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

package/dist/{engine-BuinpJfS.mjs → engine-_0pjyCd_.mjs}

@@ -1,15 +1,15 @@
 import { t as GkmError } from "./errors-D8Gwp5kU.mjs";
 import { c as runOutput, s as run, t as MissingCredential } from "./credentials-DpfnUvIR.mjs";
-import { I as otlpTelemetryEnv, L as resolveStageTelemetry, ht as isReservedStageKey, u as getAppBuildOrder, v as getPublicEnvPrefix, y as stripPublicPrefix } from "./workspace-DUnnVjqC.mjs";
+import { I as otlpTelemetryEnv, L as resolveStageTelemetry, ht as isReservedStageKey, u as getAppBuildOrder, v as getPublicEnvPrefix, y as stripPublicPrefix } from "./workspace-DBHF9Gba.mjs";
 import { a as discriminatedUnion, c as literal, d as object, l as looseObject, n as array, p as string } from "./schemas-BCwKKA42.mjs";
-import { Bn as usesTelemetry, Bt as initStageSecrets, C as recordRollback, Cn as withGeneratedSecrets, D as setPostgresBackupId, Dt as storageBackendFor, E as setGeneratedSecret, Et as providerOf, F as DockerBuildFailed, Fn as appTelemetry, I as DockerPushFailed, Jt as WORKER_PORT, Ln as scopeTelemetryEnv, N as stageProviderNotes, Pn as resourceName, Q as STORAGE_KEY_PAIR, R as dockerCommand, S as recordRelease, T as setBackupState, Tt as eventsBackendFor, Ut as toEmbeddableSecrets, V as workerDockerfileOf, Z as ExternalServicesNotConfigured, _ as asDokployState, ar as isMainFrontendApp, b as getBackupState, c as currentActor, d as DeployJournal, et as devServicesUsed, ft as constructGlobs, g as verifyDnsRecords, h as orchestrateDns, it as stageServiceDeclarations, lt as workerEnvKeys, n as reportDatabaseRuns, on as applyPostgres, or as resolveHost, ot as appEnvKeys, q as validateImageRef, r as reportPlannedSeeds, st as dockerfileOf, t as DeploySeedsFailed, tn as workerUnits, tt as externalServices, w as setApplicationId, wt as cacheBackendFor, x as getGeneratedSecret, y as createEmptyState, zn as telemetryOf } from "./seeds-rG-Evfz9.mjs";
+import { $n as telemetryOf, C as recordRollback, Ct as backendsOf, D as setPostgresBackupId, E as setGeneratedSecret, F as DockerBuildFailed, I as DockerPushFailed, It as cacheBackendFor, Jn as resourceName, Ln as withGeneratedSecrets, Lt as eventsBackendFor, N as stageProviderNotes, Qt as initStageSecrets, R as dockerCommand, Rt as providerOf, S as recordRelease, T as setBackupState, U as workerDockerfileOf, Yn as appTelemetry, Zn as scopeTelemetryEnv, _ as asDokployState, _t as appEnvKeys, an as PROCESSOR_PORT, b as getBackupState, bn as applyPostgres, br as resolveHost, bt as processorEnvKeys, c as currentActor, ct as ExternalServicesNotConfigured, d as DeployJournal, dt as devServicesUsed, er as usesTelemetry, et as PROCESSOR_ORIGIN_SECRET_ENV, ft as externalServices, g as verifyDnsRecords, h as orchestrateDns, hn as workerUnits, ht as stageServiceDeclarations, it as validateImageRef, lt as STORAGE_KEY_PAIR, mn as processorUnits, n as reportDatabaseRuns, nt as originSecretKey, r as reportPlannedSeeds, rt as processorOriginHost, sn as WORKER_PORT, t as DeploySeedsFailed, tn as toEmbeddableSecrets, vt as dockerfileOf, w as setApplicationId, wt as constructGlobs, x as getGeneratedSecret, xt as workerEnvKeys, y as createEmptyState, yr as isMainFrontendApp, zt as storageBackendFor } from "./seeds-Cfejy8wj.mjs";
 import { t as appKey } from "./derive-B4vDpzgP.mjs";
 import { a as imageRef, c as ownershipMarker, i as imageName, l as projectName, o as isOwnedBy, s as markerOf, t as applicationName } from "./identity-CBXr4wNi.mjs";
-import { f as output, i as discover, l as runWorker } from "./discover-BvJOVsYG.mjs";
+import { f as output, i as discover, l as runWorker } from "./discover-CzGM5P3p.mjs";
 import { i as activeSandbox } from "./sandbox-CbVB7uOD.mjs";
 import { t as LocalSandbox } from "./local-B7Zv1NoA.mjs";
-import { D as encryptSecrets, E as eventError, g as StateVersionConflict, k as keyFingerprint, m as StateStoreBusy, o as DokployApi, s as DokployApiError, t as sniffAllApps } from "./sniffer-DVPgfyHr.mjs";
-import { _ as migrationFiles, f as plannedSeeds } from "./databases-BPOgTn1u.mjs";
+import { D as encryptSecrets, E as eventError, g as StateVersionConflict, k as keyFingerprint, m as StateStoreBusy, o as DokployApi, s as DokployApiError, t as sniffAllApps } from "./sniffer-CCkdzjiU.mjs";
+import { f as plannedSeeds, y as migrationFiles } from "./databases-6GD0tI2F.mjs";
 import { join, relative } from "node:path";
 import { chmod, mkdtemp, rm, writeFile } from "node:fs/promises";
 import { tmpdir } from "node:os";
@@ -1611,7 +1611,8 @@ async function runMigrations(options) {
 			root: options.root,
 			stage: options.stage,
 			manifest: options.manifest,
-			patterns: options.patterns
+			patterns: options.patterns,
+			backends: options.backends
 		})],
 		cwd: options.root,
 		timeoutMs: options.timeoutMs ?? 9e5,
@@ -1837,6 +1838,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 +1971,13 @@ async function validateDokploy(phase) {
 	const background = phase.background ?? {};
 	const workers = 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 = 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 +2312,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 +2325,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 +2504,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 = 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, applicationName(identity, unit.name), project.projectId, environmentId, applied);
+				const keys = [...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 = 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: imageName(identity, unit.name),
+						appName: unit.name
+					},
+					credentials,
+					cwd: workspace.root,
+					dockerfile: workerDockerfileOf(unit.name),
+					...ctx.signal ? { signal: ctx.signal } : {},
+					...ctx.stdio ? { stdio: ctx.stdio } : {}
+				});
+				built(unit.name, image, imageRef$3);
+				const env = {
+					...scopeTelemetryEnv(Object.fromEntries(Object.entries(declaredEnv).filter(([key]) => keys.includes(key))), {
+						uses: telemetryOf(run.manifest, unit.id) !== void 0,
+						serviceName: unit.name,
+						...telemetryValues ? { telemetry: telemetryValues } : {}
+					}),
+					...credentials ? { GKM_MASTER_KEY: secrets.masterKey } : {},
+					[PROCESSOR_ORIGIN_SECRET_ENV]: secret,
+					NODE_ENV: "production",
+					PORT: String(PROCESSOR_PORT),
+					STAGE: stage
+				};
+				const host = 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, 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 +2614,8 @@ async function releaseDokploy(run) {
 					}
 				}
 				if (buildArgs.length > 0) logger.log(`      Build args: ${publicUrlArgNames.join(", ")}`);
-				const imageRef$3 = imageRef(identity, appName, registry, imageTag);
-				logger.log(`      Building Docker image: ${imageRef$3}`);
+				const imageRef$4 = imageRef(identity, appName, registry, imageTag);
+				logger.log(`      Building Docker image: ${imageRef$4}`);
 				const image = await deployDocker({
 					stage,
 					tag: imageTag,
@@ -2534,7 +2629,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 +2637,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`);
@@ -2635,6 +2730,7 @@ async function migrate(run) {
 		stage,
 		manifest,
 		patterns: constructGlobs(workspace),
+		backends: backendsOf(workspace),
 		urls,
 		signal: ctx.signal
 	});
@@ -2696,7 +2792,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 +3159,37 @@ async function planDokploy(run) {
 			...existing ? { applicationId: existing.applicationId } : {}
 		});
 	}
+	for (const unit of run.processors) {
+		const dokployAppName = 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 ? 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 = 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 = {
@@ -3085,4 +3212,4 @@ const MOBILE_SKIP_REASON = "deploys via its framework toolchain";
 //#endregion
 export { RegistryNotConfigured as _, dokployResult as a, releaseDokploy as c, validateDokploy as d, verifyDokploy as f, RegistryAmbiguous as g, HealthCheckTimedOut as h, dokployApi as i, restoreImage as l, DeployMigrationsFailed as m, FrontendDeployFailed as n, planDokploy as o, verifySettings as p, MissingEnvVars as r, provisionDokploy as s, BackendDeployFailed as t, rollbackDokploy as u, RegistryNotFound as v, ProjectNotOwned as y };
 
-//# sourceMappingURL=engine-BuinpJfS.mjs.map
+//# sourceMappingURL=engine-_0pjyCd_.mjs.map