@geekmidas/cli 10.0.0-alpha.124 → 10.0.0-alpha.125

package/dist/{engine-esxTxcIx.cjs → engine-CuZUGbEh.cjs}

@@ -1,14 +1,14 @@
 const require_errors = require("./errors-DMC4Umsb.cjs");
 const require_credentials = require("./credentials-D7XJypNd.cjs");
-const require_workspace = require("./workspace-C82GLPnf.cjs");
+const require_workspace = require("./workspace-Du4Afb03.cjs");
 const require_schemas = require("./schemas-BQ_v0lEX.cjs");
-const require_seeds = require("./seeds-DOfxmDRO.cjs");
+const require_seeds = require("./seeds-CPEcmoPn.cjs");
 const require_derive = require("./derive-DAbo49sm.cjs");
 const require_identity = require("./identity-CbLfgQNT.cjs");
-const require_discover = require("./discover-ojkcbxHw.cjs");
+const require_discover = require("./discover-DL6h-J97.cjs");
 const require_sandbox = require("./sandbox-CHv3OYXg.cjs");
 const require_local = require("./local-OPC9BCZt.cjs");
-const require_sniffer = require("./sniffer-C7O9Pna_.cjs");
+const require_sniffer = require("./sniffer-DdX_WN_-.cjs");
 const require_databases = require("./databases-fOaoBInm.cjs");
 let node_path = require("node:path");
 let node_fs_promises = require("node:fs/promises");
@@ -1837,6 +1837,24 @@ var BackendDeployFailed = class extends Error {
 	}
 };
 /**
+* A file server's processors on a Dokploy stage nothing can reach: Dokploy
+* serves a file server on MinIO itself, path-style, with no host of its own
+* to route a pattern on, so only the CDN in front of an S3 bucket reaches a
+* processor unit — and that CDN's deploy records the secret it sends.
+*/
+var ProcessorsNeedCdn = class extends Error {
+	fileServer;
+	secretKey;
+	stage;
+	constructor(fileServer, secretKey, stage) {
+		super(`'${fileServer}' has processors, and on Dokploy only the CDN in front of an S3 bucket can reach them: the stage '${stage}' has no domain, or no ${secretKey}, which the s3 provider writes when it puts a CDN in front of the bucket. Give the stage a domain and deploy.objects.${stage}: { provider: 's3' }, then deploy again.`);
+		this.fileServer = fileServer;
+		this.secretKey = secretKey;
+		this.stage = stage;
+		this.name = "ProcessorsNeedCdn";
+	}
+};
+/**
 * Sites failed to release or to answer. Every site is attempted before this
 * is thrown, so one broken site does not keep the others back — but the run
 * fails, and what failed is rolled back.
@@ -1952,10 +1970,13 @@ async function validateDokploy(phase) {
 	const background = phase.background ?? {};
 	const workers = require_seeds.workerUnits(workspace, phase.manifest, background).filter((worker) => appsToDeployNames.includes(worker.app));
 	if (workers.length > 0) logger.log(`   Deploying workers: ${workers.map((w) => `${w.name} (from ${w.app})`).join(", ")}`);
+	const processors = require_seeds.processorUnits(workspace, phase.manifest).filter((unit) => appsToDeployNames.includes(unit.app));
+	if (processors.length > 0) logger.log(`   Deploying processors: ${processors.map((p) => `${p.name} (from ${p.app})`).join(", ")}`);
 	return {
 		...run,
 		devServices: devServices.map((use) => use.service),
 		workers,
+		processors,
 		runnables,
 		preflight: await preflight(run),
 		verify: verifySettings(workspace.deploy.dokploy?.verify),
@@ -2290,7 +2311,7 @@ async function releaseDokploy(run) {
 	* attach its domain, and wait for Dokploy to finish — then record the
 	* release, with what ran before it as the one a rollback restores.
 	*/
-	const release = async (appName, applicationId, image, envVars, host) => {
+	const release = async (appName, applicationId, image, envVars, host, port = workspace.apps[appName]?.port) => {
 		released.applicationIds.set(appName, applicationId);
 		const since = await api.latestDeploymentAt(applicationId);
 		const before = state.releases?.[appName]?.current;
@@ -2303,7 +2324,7 @@ async function releaseDokploy(run) {
 		logger.log(`      Deploying to Dokploy...`);
 		await api.deployApplication(applicationId);
 		if (host) {
-			const domainId = await ensureDomain(api, journal, host, workspace.apps[appName].port, applicationId, applied);
+			const domainId = await ensureDomain(api, journal, host, port, applicationId, applied);
 			appHostnames.set(appName, host);
 			if (domainId) appDomainIds.set(appName, domainId);
 		}
@@ -2482,6 +2503,79 @@ async function releaseDokploy(run) {
 			}
 		}
 	}
+	if (run.processors.length > 0) {
+		logger.log("\n🖼️  Deploying processors...");
+		for (const unit of run.processors) {
+			ctx.signal?.throwIfAborted();
+			logger.log(`\n   🖼️  Deploying ${unit.name} (processors of ${unit.id})...`);
+			const domain = workspace.domains?.[stage];
+			const secretKey = require_seeds.originSecretKey(unit.id);
+			const secret = stageSecrets.custom?.[secretKey];
+			if (!domain || !secret) throw new ProcessorsNeedCdn(unit.id, secretKey, stage);
+			try {
+				const application = await ensureApplication(api, journal, unit.name, require_identity.applicationName(identity, unit.name), project.projectId, environmentId, applied);
+				const keys = [...require_seeds.processorEnvKeys(run.manifest, unit.id, run.runnables) ?? []].sort();
+				const secrets = prepareSecretsForApp(stageSecrets, {
+					appName: unit.name,
+					requiredEnvVars: keys,
+					optionalEnvVars: []
+				});
+				const credentials = secrets.secretCount > 0 ? {
+					encrypted: secrets.payload.encrypted,
+					iv: secrets.payload.iv
+				} : void 0;
+				const imageRef$3 = require_identity.imageRef(identity, unit.name, registry, imageTag);
+				logger.log(`      Building Docker image: ${imageRef$3}`);
+				const image = await deployDocker({
+					stage,
+					tag: imageTag,
+					skipPush: false,
+					config: {
+						registry,
+						imageName: require_identity.imageName(identity, unit.name),
+						appName: unit.name
+					},
+					credentials,
+					cwd: workspace.root,
+					dockerfile: require_seeds.workerDockerfileOf(unit.name),
+					...ctx.signal ? { signal: ctx.signal } : {},
+					...ctx.stdio ? { stdio: ctx.stdio } : {}
+				});
+				built(unit.name, image, imageRef$3);
+				const env = {
+					...require_seeds.scopeTelemetryEnv(Object.fromEntries(Object.entries(declaredEnv).filter(([key]) => keys.includes(key))), {
+						uses: require_seeds.telemetryOf(run.manifest, unit.id) !== void 0,
+						serviceName: unit.name,
+						...telemetryValues ? { telemetry: telemetryValues } : {}
+					}),
+					...credentials ? { GKM_MASTER_KEY: secrets.masterKey } : {},
+					[require_seeds.PROCESSOR_ORIGIN_SECRET_ENV]: secret,
+					NODE_ENV: "production",
+					PORT: String(require_seeds.PROCESSOR_PORT),
+					STAGE: stage
+				};
+				const host = require_seeds.processorOriginHost(unit.id, domain);
+				await release(unit.name, application.applicationId, {
+					ref: image.imageRef ?? imageRef$3,
+					...image.digest ? { digest: image.digest } : {}
+				}, Object.entries(env).map(([key, value]) => `${key}=${value}`), host, require_seeds.PROCESSOR_PORT);
+				await checkHealth(run, unit.name);
+				results.push({
+					appName: unit.name,
+					type: "backend",
+					success: true,
+					applicationId: application.applicationId,
+					imageRef: imageRef$3,
+					...image.digest ? { digest: image.digest } : {}
+				});
+				logger.log(`      ✓ ${unit.name} deployed at https://${host}`);
+			} catch (error) {
+				if (ctx.signal?.aborted) throw ctx.signal.reason;
+				failed(run, unit.name, error);
+				throw new BackendDeployFailed(unit.name, error);
+			}
+		}
+	}
 	let frontendFailure;
 	if (frontendApps.length > 0) {
 		logger.log("\n🌐 PHASE 2: Deploying frontend applications...");
@@ -2519,8 +2613,8 @@ async function releaseDokploy(run) {
 					}
 				}
 				if (buildArgs.length > 0) logger.log(`      Build args: ${publicUrlArgNames.join(", ")}`);
-				const imageRef$3 = require_identity.imageRef(identity, appName, registry, imageTag);
-				logger.log(`      Building Docker image: ${imageRef$3}`);
+				const imageRef$4 = require_identity.imageRef(identity, appName, registry, imageTag);
+				logger.log(`      Building Docker image: ${imageRef$4}`);
 				const image = await deployDocker({
 					stage,
 					tag: imageTag,
@@ -2534,7 +2628,7 @@ async function releaseDokploy(run) {
 					publicUrlArgs: publicUrlArgNames,
 					...dockerRun(workspace, app, ctx)
 				});
-				built(appName, image, imageRef$3);
+				built(appName, image, imageRef$4);
 				const envVars = [
 					`NODE_ENV=production`,
 					`PORT=${app.port}`,
@@ -2542,14 +2636,14 @@ async function releaseDokploy(run) {
 				];
 				for (const [key, value] of Object.entries(resolved)) envVars.push(`${key}=${value}`);
 				await release(appName, application.applicationId, {
-					ref: image.imageRef ?? imageRef$3,
+					ref: image.imageRef ?? imageRef$4,
 					...image.digest ? { digest: image.digest } : {}
 				}, envVars, frontendHost);
 				deployed(appName, {
 					appName,
 					type: app.type,
 					applicationId: application.applicationId,
-					imageRef: imageRef$3,
+					imageRef: imageRef$4,
 					...image.digest ? { digest: image.digest } : {}
 				}, frontendHost);
 				logger.log(`      ✓ ${appName} deployed successfully`);
@@ -2696,7 +2790,7 @@ async function checkHealth(run, appName) {
 		logger.log(`   ✓ ${appName}: no domain, so its finished deployment is its check`);
 		return;
 	}
-	const url = `https://${host}${workspace.apps[appName].type === "web" ? "/" : verify.healthCheckPath}`;
+	const url = `https://${host}${workspace.apps[appName]?.type === "web" ? "/" : verify.healthCheckPath}`;
 	logger.log(`\n🩺 Checking ${appName} at ${url}...`);
 	await verifyHealth({
 		app: appName,
@@ -3063,6 +3157,37 @@ async function planDokploy(run) {
 			...existing ? { applicationId: existing.applicationId } : {}
 		});
 	}
+	for (const unit of run.processors) {
+		const dokployAppName = require_identity.applicationName(identity, unit.name);
+		const recordedId = state?.applications?.[unit.name];
+		const existing = project && environment ? (recordedId ? await api.getApplication(recordedId).catch(() => null) : null) ?? await api.findApplicationByName(project.projectId, dokployAppName, environment.environmentId) : null;
+		const domain = workspace.domains?.[stage];
+		const host = domain ? require_seeds.processorOriginHost(unit.id, domain) : void 0;
+		plan(existing ? {
+			key: `application:${unit.name}`,
+			resourceType: "application",
+			action: "reuse",
+			id: existing.applicationId
+		} : {
+			key: `application:${unit.name}`,
+			resourceType: "application",
+			action: "create"
+		}, `${dokployAppName}, processors of ${unit.id}${host ? ` at https://${host}` : ""}`);
+		const ref = require_identity.imageRef(identity, unit.name, workspace.deploy.registry, imageTag);
+		plan({
+			key: `image:${unit.name}`,
+			resourceType: "image",
+			action: "build"
+		}, ref);
+		apps.push({
+			appName: unit.name,
+			type: "backend",
+			success: true,
+			imageRef: ref,
+			...host ? { url: `https://${host}` } : {},
+			...existing ? { applicationId: existing.applicationId } : {}
+		});
+	}
 	const creates = changes.filter((c) => c.action !== "reuse").length;
 	logger.log(`\n✅ Dry run complete: ${creates} to create or build, ${changes.length - creates} to reuse.`);
 	run.result = {
@@ -3198,4 +3323,4 @@ Object.defineProperty(exports, "verifySettings", {
 	}
 });
 
-//# sourceMappingURL=engine-esxTxcIx.cjs.map
+//# sourceMappingURL=engine-CuZUGbEh.cjs.map