@mastra/factory 0.21.1-alpha.2 → 0.22.0-alpha.4

package/dist/routes/projects.js

@@ -1,7 +1,11 @@
+import { redactCredentials } from "../environment/build.js";
+import { ensureSchedule, invalidCronMessage, readSchedule, scheduleIdFor } from "../environment/build-schedule.js";
 import { ACTIVE_RUN_BINDING_STAGES } from "../storage/domains/work-items/base.js";
 import { Route } from "./route.js";
 import { FACTORY_ROUTE_CONTRACTS } from "./contracts.js";
 import { registerApiRoute } from "@mastra/core/server";
+import { describeFactorySandbox, normalizeFactorySandboxSettings } from "@mastra/core/workspace";
+import { MastraError } from "@mastra/core/error";
 //#region src/routes/projects.ts
 const UUID_RE = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
 const MAX_NAME_LENGTH = 200;
@@ -107,12 +111,66 @@ function parseRepositoryUpdateInput(value) {
 	if (teardownCommand !== void 0) patch.teardownCommand = teardownCommand;
 	return Object.keys(patch).length > 0 ? patch : null;
 }
+/** Provider output is shown to the user; strip any clone credential from it first. */
+function redactBuild(build) {
+	return {
+		...build,
+		...build.error !== void 0 ? { error: redactCredentials(build.error) } : {},
+		...build.logs ? { logs: build.logs.map(redactCredentials) } : {}
+	};
+}
+/** What the environment reports when the factory has no sandbox configured. */
+const NO_SANDBOX = {
+	provider: "none",
+	settingsSchema: {
+		type: "object",
+		properties: {},
+		additionalProperties: false
+	},
+	capabilities: {
+		template: false,
+		builds: {
+			available: false,
+			history: false
+		}
+	}
+};
 var ProjectRoutes = class extends Route {
 	#versionControlIntegrationIds;
+	#sandboxDescription;
+	#settingsSchema;
 	constructor(deps) {
 		super(deps);
 		this.#versionControlIntegrationIds = new Set(deps.versionControlIntegrationIds ?? []);
 	}
+	#describeSandbox() {
+		if (!this.deps.sandbox) return NO_SANDBOX;
+		this.#sandboxDescription ??= describeFactorySandbox(this.deps.sandbox);
+		return this.#sandboxDescription;
+	}
+	/**
+	* Merge a settings patch onto the stored document (null removes a key) and
+	* validate the result through the sandbox's schema. Returns the issues when
+	* the merged document is rejected.
+	*
+	* A stored key the current schema does not declare is left over from another
+	* provider or an older schema. When the merged document fails validation, the
+	* merge retries without those keys so one stale value cannot lock every later
+	* update; keys the patch itself sets are never pruned.
+	*/
+	async #mergeSettings(stored, patch) {
+		const merged = { ...stored };
+		for (const [key, value] of Object.entries(patch)) if (value === null) delete merged[key];
+		else merged[key] = value;
+		this.#settingsSchema ??= normalizeFactorySandboxSettings(this.deps.sandbox);
+		const result = await this.#settingsSchema["~standard"].validate(merged);
+		if (!result.issues) return { merged: Object.keys(merged).length > 0 ? merged : null };
+		const declared = this.#describeSandbox().settingsSchema.properties ?? {};
+		const pruned = Object.fromEntries(Object.entries(merged).filter(([key]) => key in patch || Object.hasOwn(declared, key)));
+		if (Object.keys(pruned).length === Object.keys(merged).length) return { issues: result.issues };
+		if ((await this.#settingsSchema["~standard"].validate(pruned)).issues) return { issues: result.issues };
+		return { merged: Object.keys(pruned).length > 0 ? pruned : null };
+	}
 	async #projects() {
 		await this.deps.projects.ensureReady();
 		return this.deps.projects;
@@ -173,6 +231,166 @@ var ProjectRoutes = class extends Route {
 			repository
 		};
 	}
+	/** Every link of the project across every handle, with the handle that owns it, in position order. */
+	async #environmentLinks(orgId, projectId) {
+		const links = [];
+		for (const handle of await this.#handles()) for (const projectRepository of await handle.projectRepositories.listByProject({
+			orgId,
+			factoryProjectId: projectId
+		})) links.push({
+			handle,
+			projectRepository
+		});
+		return links.sort((a, b) => a.projectRepository.position - b.projectRepository.position || a.projectRepository.createdAt.getTime() - b.projectRepository.createdAt.getTime());
+	}
+	async #environmentPayload(orgId, project) {
+		const repositories = [];
+		for (const { handle, projectRepository } of await this.#environmentLinks(orgId, project.id)) {
+			const repository = await handle.repositories.get({
+				orgId,
+				id: projectRepository.repositoryId
+			});
+			repositories.push({
+				projectRepositoryId: projectRepository.id,
+				connectionId: projectRepository.connectionId,
+				repositoryId: projectRepository.repositoryId,
+				slug: repository?.slug ?? null,
+				defaultBranch: repository?.defaultBranch ?? null,
+				position: projectRepository.position,
+				inEnvironment: projectRepository.inEnvironment,
+				setupCommand: projectRepository.setupCommand,
+				teardownCommand: projectRepository.teardownCommand,
+				lastBuildStatus: projectRepository.lastBuildStatus,
+				lastBuildError: projectRepository.lastBuildError,
+				lastBuiltAt: projectRepository.lastBuiltAt
+			});
+		}
+		return { environment: {
+			sandbox: this.#describeSandbox(),
+			settings: project.sandboxSettings ?? {},
+			sandboxWorkingDirectory: project.sandboxWorkingDirectory,
+			workspaceSetupCommand: project.workspaceSetupCommand,
+			activeTemplateId: project.activeTemplateId,
+			activeTemplateHeads: project.activeTemplateHeads,
+			repositories,
+			...await this.#buildPayload(project)
+		} };
+	}
+	/**
+	* The build keys of the environment payload, present only when the
+	* sandbox can build. Reads the project row and the schedule row; never
+	* the provider (live status is the builds routes' job).
+	*/
+	async #buildPayload(project) {
+		const builds = this.deps.environmentBuilds;
+		if (!builds) return {};
+		const schedules = builds.scheduleAvailable ? builds.schedules() : void 0;
+		return {
+			buildTriggers: {
+				schedule: {
+					...schedules ? await readSchedule(schedules, project.id) : {
+						enabled: false,
+						cron: null,
+						timezone: null
+					},
+					scheduleAvailable: builds.scheduleAvailable
+				},
+				push: {
+					enabled: project.buildOnPushEnabled,
+					debounceMinutes: project.buildPushDebounceMinutes
+				}
+			},
+			build: project.lastBuildId ? {
+				buildId: project.lastBuildId,
+				attemptedAt: project.lastBuildAttemptedAt?.toISOString() ?? null
+			} : null
+		};
+	}
+	/** The builds capability behind the routes, or the 404 to answer with. */
+	#builds(context) {
+		const builds = this.deps.sandbox?.builds;
+		const runner = this.deps.environmentBuilds;
+		if (!builds || !runner) return { response: context.json({ error: "no_builds" }, 404) };
+		return {
+			builds,
+			runner
+		};
+	}
+	#buildRoutes() {
+		return [
+			registerApiRoute(FACTORY_ROUTE_CONTRACTS.projectEnvironmentBuild.path, {
+				method: FACTORY_ROUTE_CONTRACTS.projectEnvironmentBuild.method,
+				requiresAuth: false,
+				handler: async (routeContext) => {
+					const context = loose(routeContext);
+					const tenant = await this.#resolveTenant(context);
+					if ("response" in tenant) return tenant.response;
+					const projectId = context.req.param("id");
+					if (!projectId || !UUID_RE.test(projectId)) return context.json({ error: "Project not found" }, 404);
+					const project = await this.#project(tenant.orgId, projectId);
+					if (!project) return context.json({ error: "Project not found" }, 404);
+					const capability = this.#builds(context);
+					if ("response" in capability) return capability.response;
+					const { heads: _heads, ...outcome } = await capability.runner.start(project.id, "manual");
+					return context.json(outcome);
+				}
+			}),
+			registerApiRoute(FACTORY_ROUTE_CONTRACTS.projectEnvironmentBuilds.path, {
+				method: FACTORY_ROUTE_CONTRACTS.projectEnvironmentBuilds.method,
+				requiresAuth: false,
+				handler: async (routeContext) => {
+					const context = loose(routeContext);
+					const tenant = await this.#resolveTenant(context);
+					if ("response" in tenant) return tenant.response;
+					const projectId = context.req.param("id");
+					if (!projectId || !UUID_RE.test(projectId)) return context.json({ error: "Project not found" }, 404);
+					const project = await this.#project(tenant.orgId, projectId);
+					if (!project) return context.json({ error: "Project not found" }, 404);
+					const capability = this.#builds(context);
+					if ("response" in capability) return capability.response;
+					if (!capability.builds.list) return context.json({ error: "no_history" }, 404);
+					const read = await capability.runner.readContext(project.id);
+					if (!read) return context.json({ error: "no_environment" }, 404);
+					const builds = await capability.builds.list(read.ctx, read.settings);
+					return context.json({ builds: builds.map(redactBuild) });
+				}
+			}),
+			registerApiRoute(FACTORY_ROUTE_CONTRACTS.projectEnvironmentBuildGet.path, {
+				method: FACTORY_ROUTE_CONTRACTS.projectEnvironmentBuildGet.method,
+				requiresAuth: false,
+				handler: async (routeContext) => {
+					const context = loose(routeContext);
+					const tenant = await this.#resolveTenant(context);
+					if ("response" in tenant) return tenant.response;
+					const projectId = context.req.param("id");
+					if (!projectId || !UUID_RE.test(projectId)) return context.json({ error: "Project not found" }, 404);
+					const project = await this.#project(tenant.orgId, projectId);
+					if (!project) return context.json({ error: "Project not found" }, 404);
+					const capability = this.#builds(context);
+					if ("response" in capability) return capability.response;
+					const buildId = context.req.param("buildId") ?? "";
+					if (!buildId) return context.json({ error: "Build not found" }, 404);
+					const read = await capability.runner.readContext(project.id);
+					if (!read) return context.json({ error: "no_environment" }, 404);
+					if (buildId !== project.lastBuildId) {
+						if (!(capability.builds.list ? await capability.builds.list(read.ctx, read.settings) : []).some((build) => build.buildId === buildId)) return context.json({ error: "Build not found" }, 404);
+					}
+					return context.json({ build: redactBuild(await capability.builds.get(read.ctx, read.settings, buildId)) });
+				}
+			})
+		];
+	}
+	/** Best effort: a deleted project's cron schedule must not keep firing. */
+	async #dropSchedule(projectId) {
+		const runner = this.deps.environmentBuilds;
+		if (!runner?.scheduleAvailable) return;
+		try {
+			await runner.schedules().delete(scheduleIdFor(projectId));
+		} catch (error) {
+			if (error instanceof MastraError && error.id === "SCHEDULES_NOT_FOUND") return;
+			console.warn("[factory] could not delete the environment build schedule of a deleted project:", error);
+		}
+	}
 	async #retireProjectRepositorySessions(handle, orgId, projectRepositoryId) {
 		if ((await handle.sessions.listByProjectRepository({ projectRepositoryId })).length === 0) return true;
 		if (!this.deps.sessionRetirement) return false;
@@ -372,6 +590,7 @@ var ProjectRoutes = class extends Route {
 						orgId: tenant.orgId,
 						id
 					});
+					await this.#dropSchedule(id);
 					return context.body(null, 204);
 				}
 			}),
@@ -508,6 +727,129 @@ var ProjectRoutes = class extends Route {
 					return context.json({ projectRepository: await this.#repositoryPayload(found.handle, tenant.orgId, projectRepository) }, 201);
 				}
 			}),
+			registerApiRoute(FACTORY_ROUTE_CONTRACTS.projectEnvironmentGet.path, {
+				method: FACTORY_ROUTE_CONTRACTS.projectEnvironmentGet.method,
+				requiresAuth: false,
+				handler: async (routeContext) => {
+					const context = loose(routeContext);
+					const tenant = await this.#resolveTenant(context);
+					if ("response" in tenant) return tenant.response;
+					const projectId = context.req.param("id");
+					if (!projectId || !UUID_RE.test(projectId)) return context.json({ error: "Project not found" }, 404);
+					const project = await this.#project(tenant.orgId, projectId);
+					if (!project) return context.json({ error: "Project not found" }, 404);
+					return context.json(await this.#environmentPayload(tenant.orgId, project));
+				}
+			}),
+			registerApiRoute(FACTORY_ROUTE_CONTRACTS.projectEnvironmentUpdate.path, {
+				method: FACTORY_ROUTE_CONTRACTS.projectEnvironmentUpdate.method,
+				requiresAuth: false,
+				handler: async (routeContext) => {
+					const context = loose(routeContext);
+					const tenant = await this.#resolveTenant(context);
+					if ("response" in tenant) return tenant.response;
+					const projectId = context.req.param("id");
+					if (!projectId || !UUID_RE.test(projectId)) return context.json({ error: "Project not found" }, 404);
+					const project = await this.#project(tenant.orgId, projectId);
+					if (!project) return context.json({ error: "Project not found" }, 404);
+					const parsed = FACTORY_ROUTE_CONTRACTS.projectEnvironmentUpdate.bodySchema.safeParse(await readJson(context));
+					if (!parsed.success) return context.json({ error: "invalid_environment" }, 400);
+					const { repositories: repositoryPatches, settings: settingsPatch, buildTriggers, ...projectInput } = parsed.data;
+					const input = projectInput;
+					const runner = this.deps.environmentBuilds;
+					if (buildTriggers !== void 0) {
+						if (!runner) return context.json({ error: "no_builds" }, 400);
+						if (buildTriggers.push?.enabled !== void 0) input.buildOnPushEnabled = buildTriggers.push.enabled;
+						if (buildTriggers.push?.debounceMinutes !== void 0) input.buildPushDebounceMinutes = buildTriggers.push.debounceMinutes;
+						if (buildTriggers.schedule) if (!runner.scheduleAvailable) {
+							if (buildTriggers.schedule.enabled) return context.json({ error: "schedules_unavailable" }, 400);
+						} else {
+							const { cron, timezone } = buildTriggers.schedule;
+							const stored = await readSchedule(runner.schedules(), project.id);
+							const nextCron = cron ?? stored.cron;
+							if (!nextCron && buildTriggers.schedule.enabled) return context.json({
+								error: "invalid_environment",
+								issues: [{
+									message: "cron is required",
+									path: [
+										"buildTriggers",
+										"schedule",
+										"cron"
+									]
+								}]
+							}, 400);
+							const nextTimezone = timezone ?? stored.timezone ?? void 0;
+							const message = nextCron ? invalidCronMessage(nextCron, nextTimezone) : void 0;
+							if (message) return context.json({
+								error: "invalid_environment",
+								issues: [{
+									message,
+									path: [
+										"buildTriggers",
+										"schedule",
+										"cron"
+									]
+								}]
+							}, 400);
+						}
+					}
+					if (settingsPatch !== void 0 && !this.deps.sandbox) return context.json({ error: "no_sandbox" }, 400);
+					let updated = project;
+					if (Object.keys(input).length > 0 || settingsPatch !== void 0 || repositoryPatches !== void 0) {
+						let issues;
+						let repositoryOutcome;
+						const sourceControl = await this.#sourceControl();
+						const result = await (await this.#projects()).update({
+							orgId: tenant.orgId,
+							id: projectId,
+							input: async (current, ops) => {
+								let sandboxSettings;
+								if (settingsPatch !== void 0) {
+									const settings = await this.#mergeSettings(current.sandboxSettings ?? {}, settingsPatch);
+									if ("issues" in settings) {
+										issues = settings.issues;
+										return null;
+									}
+									sandboxSettings = settings.merged;
+								}
+								if (repositoryPatches !== void 0) {
+									repositoryOutcome = await sourceControl.updateEnvironmentRepositories(ops, {
+										factoryProjectId: current.id,
+										integrationIds: [...this.#versionControlIntegrationIds],
+										patches: repositoryPatches
+									});
+									if (repositoryOutcome !== "updated") return null;
+								}
+								return {
+									...input,
+									...sandboxSettings !== void 0 ? { sandboxSettings } : {}
+								};
+							}
+						});
+						if (repositoryOutcome === "not_found") return context.json({ error: "Project repository not found" }, 404);
+						if (repositoryOutcome === "incomplete_reorder") return context.json({ error: "invalid_environment" }, 400);
+						if (issues) return context.json({
+							error: "invalid_environment",
+							issues: issues.map((issue) => ({
+								message: issue.message,
+								path: Array.isArray(issue.path) ? issue.path.map((segment) => typeof segment === "object" && segment !== null && "key" in segment ? segment.key : segment) : []
+							}))
+						}, 400);
+						if (!result) return context.json({ error: "Project not found" }, 404);
+						updated = result;
+					}
+					if (buildTriggers?.schedule && runner?.scheduleAvailable) {
+						const stored = await readSchedule(runner.schedules(), project.id);
+						const cron = buildTriggers.schedule.cron ?? stored.cron;
+						if (cron) await ensureSchedule(runner.schedules(), project.id, {
+							enabled: buildTriggers.schedule.enabled,
+							cron,
+							...buildTriggers.schedule.timezone ?? stored.timezone ? { timezone: buildTriggers.schedule.timezone ?? stored.timezone } : {}
+						});
+					}
+					return context.json(await this.#environmentPayload(tenant.orgId, updated));
+				}
+			}),
 			registerApiRoute("/web/factory/projects/:id/repositories/:projectRepositoryId", {
 				method: "PATCH",
 				requiresAuth: false,
@@ -557,7 +899,8 @@ var ProjectRoutes = class extends Route {
 					});
 					return context.body(null, 204);
 				}
-			})
+			}),
+			...this.#buildRoutes()
 		];
 	}
 };