@base44-preview/cli 0.0.21-pr.126.43cda65 → 0.0.22-pr.134.259538d

package/dist/index.js

@@ -5818,6 +5818,97 @@ function handleTupleResult(result, final, index) {
 	if (result.issues.length) final.issues.push(...prefixIssues(index, result.issues));
 	final.value[index] = result.value;
 }
+const $ZodRecord = /* @__PURE__ */ $constructor("$ZodRecord", (inst, def) => {
+	$ZodType.init(inst, def);
+	inst._zod.parse = (payload, ctx) => {
+		const input = payload.value;
+		if (!isPlainObject$1(input)) {
+			payload.issues.push({
+				expected: "record",
+				code: "invalid_type",
+				input,
+				inst
+			});
+			return payload;
+		}
+		const proms = [];
+		const values = def.keyType._zod.values;
+		if (values) {
+			payload.value = {};
+			const recordKeys = /* @__PURE__ */ new Set();
+			for (const key of values) if (typeof key === "string" || typeof key === "number" || typeof key === "symbol") {
+				recordKeys.add(typeof key === "number" ? key.toString() : key);
+				const result = def.valueType._zod.run({
+					value: input[key],
+					issues: []
+				}, ctx);
+				if (result instanceof Promise) proms.push(result.then((result$1) => {
+					if (result$1.issues.length) payload.issues.push(...prefixIssues(key, result$1.issues));
+					payload.value[key] = result$1.value;
+				}));
+				else {
+					if (result.issues.length) payload.issues.push(...prefixIssues(key, result.issues));
+					payload.value[key] = result.value;
+				}
+			}
+			let unrecognized;
+			for (const key in input) if (!recordKeys.has(key)) {
+				unrecognized = unrecognized ?? [];
+				unrecognized.push(key);
+			}
+			if (unrecognized && unrecognized.length > 0) payload.issues.push({
+				code: "unrecognized_keys",
+				input,
+				inst,
+				keys: unrecognized
+			});
+		} else {
+			payload.value = {};
+			for (const key of Reflect.ownKeys(input)) {
+				if (key === "__proto__") continue;
+				let keyResult = def.keyType._zod.run({
+					value: key,
+					issues: []
+				}, ctx);
+				if (keyResult instanceof Promise) throw new Error("Async schemas not supported in object keys currently");
+				if (typeof key === "string" && number$1.test(key) && keyResult.issues.length && keyResult.issues.some((iss) => iss.code === "invalid_type" && iss.expected === "number")) {
+					const retryResult = def.keyType._zod.run({
+						value: Number(key),
+						issues: []
+					}, ctx);
+					if (retryResult instanceof Promise) throw new Error("Async schemas not supported in object keys currently");
+					if (retryResult.issues.length === 0) keyResult = retryResult;
+				}
+				if (keyResult.issues.length) {
+					if (def.mode === "loose") payload.value[key] = input[key];
+					else payload.issues.push({
+						code: "invalid_key",
+						origin: "record",
+						issues: keyResult.issues.map((iss) => finalizeIssue(iss, ctx, config())),
+						input: key,
+						path: [key],
+						inst
+					});
+					continue;
+				}
+				const result = def.valueType._zod.run({
+					value: input[key],
+					issues: []
+				}, ctx);
+				if (result instanceof Promise) proms.push(result.then((result$1) => {
+					if (result$1.issues.length) payload.issues.push(...prefixIssues(key, result$1.issues));
+					payload.value[keyResult.value] = result$1.value;
+				}));
+				else {
+					if (result.issues.length) payload.issues.push(...prefixIssues(key, result.issues));
+					payload.value[keyResult.value] = result.value;
+				}
+			}
+		}
+		if (proms.length) return Promise.all(proms).then(() => payload);
+		return payload;
+	};
+});
 const $ZodEnum = /* @__PURE__ */ $constructor("$ZodEnum", (inst, def) => {
 	$ZodType.init(inst, def);
 	const values = getEnumValues(def.entries);
@@ -7108,6 +7199,39 @@ const tupleProcessor = (schema, ctx, _json, params) => {
 	if (typeof minimum === "number") json.minItems = minimum;
 	if (typeof maximum === "number") json.maxItems = maximum;
 };
+const recordProcessor = (schema, ctx, _json, params) => {
+	const json = _json;
+	const def = schema._zod.def;
+	json.type = "object";
+	const keyType = def.keyType;
+	const patterns = keyType._zod.bag?.patterns;
+	if (def.mode === "loose" && patterns && patterns.size > 0) {
+		const valueSchema = process$3(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$3(def.keyType, ctx, {
+			...params,
+			path: [...params.path, "propertyNames"]
+		});
+		json.additionalProperties = process$3(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$3(def.innerType, ctx, params);
@@ -7637,6 +7761,21 @@ function tuple(items, _paramsOrRest, _params) {
 		...normalizeParams(params)
 	});
 }
+const ZodRecord = /* @__PURE__ */ $constructor("ZodRecord", (inst, def) => {
+	$ZodRecord.init(inst, def);
+	ZodType.init(inst, def);
+	inst._zod.processJSONSchema = (ctx, json, params) => recordProcessor(inst, ctx, json, params);
+	inst.keyType = def.keyType;
+	inst.valueType = def.valueType;
+});
+function record(keyType, valueType, params) {
+	return new ZodRecord({
+		type: "record",
+		keyType,
+		valueType,
+		...normalizeParams(params)
+	});
+}
 const ZodEnum = /* @__PURE__ */ $constructor("ZodEnum", (inst, def) => {
 	$ZodEnum.init(inst, def);
 	ZodType.init(inst, def);
@@ -7903,6 +8042,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}`;
@@ -16537,9 +16677,7 @@ const SyncEntitiesResponseSchema = object({
 //#region src/core/resources/entity/config.ts
 async function readEntityFile(entityPath) {
 	const parsed = await readJsonFile(entityPath);
-	const result = EntitySchema.safeParse(parsed);
-	if (!result.success) throw new Error(`Invalid entity configuration in ${entityPath}: ${result.error.issues.map((e$1) => e$1.message).join(", ")}`);
-	return result.data;
+	return EntitySchema.parse(parsed);
 }
 async function readAllEntities(entitiesDir) {
 	if (!await pathExists(entitiesDir)) return [];
@@ -16561,8 +16699,8 @@ async function syncEntities(entities) {
 	});
 	if (!response.ok) {
 		const errorJson = await response.json();
-		if (response.status === 428) throw new Error(`Failed to delete entity: ${errorJson.message}`);
-		throw new Error(`Error occurred while syncing entities ${errorJson.message}`);
+		if (response.status === 428) throw new Error(`Failed to delete entity: ${formatApiError(errorJson)}`);
+		throw new Error(`Error occurred while syncing entities: ${formatApiError(errorJson)}`);
 	}
 	return SyncEntitiesResponseSchema.parse(await response.json());
 }
@@ -16684,6 +16822,87 @@ const functionResource = {
 	push: pushFunctions
 };
 
+//#endregion
+//#region src/core/resources/agent/schema.ts
+const AgentConfigSchema = looseObject({ name: string().regex(/^[a-z0-9_]+$/, "Agent name must be lowercase alphanumeric with underscores").min(1).max(100) });
+const SyncAgentsResponseSchema = object({
+	created: array(string()),
+	updated: array(string()),
+	deleted: array(string())
+});
+const AgentConfigApiResponseSchema = looseObject({ name: string() });
+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);
+	return AgentConfigSchema.parse(parsed);
+}
+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, remoteAgents) {
+	const existingAgents = await readAllAgents(agentsDir);
+	const newNames = new Set(remoteAgents.map((a$1) => a$1.name));
+	const toDelete = existingAgents.filter((a$1) => !newNames.has(a$1.name));
+	for (const agent of toDelete) {
+		const files = await globby(`${agent.name}.${CONFIG_FILE_EXTENSION_GLOB}`, {
+			cwd: agentsDir,
+			absolute: true
+		});
+		for (const filePath of files) await deleteFile(filePath);
+	}
+	for (const agent of remoteAgents) await writeJsonFile(join(agentsDir, `${agent.name}.${CONFIG_FILE_EXTENSION}`), agent);
+	return {
+		written: remoteAgents.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 response = await getAppClient().put("agent-configs", {
+		json: agents,
+		throwHttpErrors: false
+	});
+	if (!response.ok) {
+		const errorJson = await response.json();
+		throw new Error(`Error occurred while syncing agents: ${formatApiError(errorJson)}`);
+	}
+	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();
+		throw new Error(`Error occurred while fetching agents: ${formatApiError(errorJson)}`);
+	}
+	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({
@@ -16704,7 +16923,8 @@ const ProjectConfigSchema = object({
 	description: string().optional(),
 	site: SiteConfigSchema.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() });
@@ -16776,7 +16996,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,
@@ -16784,7 +17008,8 @@ async function readProjectConfig(projectRoot) {
 			configPath
 		},
 		entities,
-		functions
+		functions,
+		agents
 	};
 }
 
@@ -30469,6 +30694,11 @@ async function readAppConfig(projectRoot) {
 * Authenticated HTTP client for Base44 API.
 * Automatically handles token refresh and retry on 401 responses.
 */
+function formatApiError(errorJson) {
+	const error = errorJson;
+	const content = error?.message ?? error?.detail ?? errorJson;
+	return typeof content === "string" ? content : JSON.stringify(content, null, 2);
+}
 const retriedRequests = /* @__PURE__ */ new WeakSet();
 /**
 * Handles 401 responses by refreshing the token and retrying the request.
@@ -30522,6 +30752,19 @@ function getAppClient() {
 	return base44Client.extend({ prefixUrl: new URL(`/api/apps/${id}/`, getBase44ApiUrl()).href });
 }
 
+//#endregion
+//#region src/core/clients/schemas.ts
+const ApiErrorSchema = object({
+	error_type: string().optional(),
+	message: union([string(), record(string(), unknown())]).optional(),
+	detail: union([
+		string(),
+		record(string(), unknown()),
+		array(unknown())
+	]).optional(),
+	traceback: string().optional()
+});
+
 //#endregion
 //#region src/core/auth/api.ts
 async function generateDeviceCode() {
@@ -31349,12 +31592,62 @@ async function pushEntitiesAction() {
 	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 {};
+	return { outroMessage: "Entities pushed to Base44" };
 }
 const entitiesPushCommand = new Command("entities").description("Manage project entities").addCommand(new Command("push").description("Push local entities to Base44").action(async () => {
 	await runCommand(pushEntitiesAction, { 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 { outroMessage: "Agents pushed to Base44" };
+}
+const agentsPushCommand = new Command("push").description("Push local agents to Base44 (replaces all remote agent configs)").action(async () => {
+	await runCommand(pushAgentsAction, { 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 remoteAgents = await runTask("Fetching agents from Base44", async () => {
+		return await fetchAgents();
+	}, {
+		successMessage: "Agents fetched successfully",
+		errorMessage: "Failed to fetch agents"
+	});
+	if (remoteAgents.items.length === 0) return { outroMessage: "No agents found on Base44" };
+	const { written, deleted } = await runTask("Writing agent files", async () => {
+		return await writeAgents(agentsDir, remoteAgents.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 ${remoteAgents.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/index.ts
+const agentsCommand = new Command("agents").description("Manage project agents").addCommand(agentsPushCommand).addCommand(agentsPullCommand);
+
 //#endregion
 //#region src/cli/commands/functions/deploy.ts
 async function deployFunctionsAction() {
@@ -31373,7 +31666,7 @@ async function deployFunctionsAction() {
 		const errorMessages = result.errors.map((e$1) => `'${e$1.name}' function: ${e$1.message}`).join("\n");
 		throw new Error(`Function deployment errors:\n${errorMessages}`);
 	}
-	return {};
+	return { outroMessage: "Functions deployed to Base44" };
 }
 const functionsDeployCommand = new Command("functions").description("Manage project functions").addCommand(new Command("deploy").description("Deploy local functions to Base44").action(async () => {
 	await runCommand(deployFunctionsAction, { requireAuth: true });
@@ -38931,7 +39224,7 @@ const siteDeployCommand = new Command("site").description("Manage site deploymen
 
 //#endregion
 //#region package.json
-var version = "0.0.21";
+var version = "0.0.22";
 
 //#endregion
 //#region src/cli/program.ts
@@ -38946,6 +39239,7 @@ program.addCommand(dashboardCommand);
 program.addCommand(deployCommand);
 program.addCommand(linkCommand);
 program.addCommand(entitiesPushCommand);
+program.addCommand(agentsCommand);
 program.addCommand(functionsDeployCommand);
 program.addCommand(siteDeployCommand);
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@base44-preview/cli",
-  "version": "0.0.21-pr.126.43cda65",
+  "version": "0.0.22-pr.134.259538d",
   "description": "Base44 CLI - Unified interface for managing Base44 applications",
   "type": "module",
   "bin": {