@geekmidas/cli 10.0.0-alpha.88 → 10.0.0-alpha.89

package/dist/{engine-Bt5k_UMq.cjs → engine-DgHoFBMw.cjs}

@@ -1,12 +1,12 @@
-const require_credentials = require("./credentials-tr26-KML.cjs");
+const require_credentials = require("./credentials-BKfIugu2.cjs");
 const require_schemas = require("./schemas-BObwxB_t.cjs");
 const require_discover = require("./discover-D1It5r_h.cjs");
 const require_sandbox = require("./sandbox-CL--ZDui.cjs");
 const require_derive = require("./derive-DAbo49sm.cjs");
-const require_workspace = require("./workspace-CT0JM3Y8.cjs");
-const require_seeds = require("./seeds-CsI0A_Ef.cjs");
-const require_local = require("./local-Cq8qdgNX.cjs");
-const require_sniffer = require("./sniffer-DJYupBeK.cjs");
+const require_workspace = require("./workspace-CwW3Gkru.cjs");
+const require_seeds = require("./seeds-CN6tB-va.cjs");
+const require_local = require("./local-BjxDfPvy.cjs");
+const require_sniffer = require("./sniffer-IAQEpsQb.cjs");
 const require_databases = require("./databases-BY-pEImp.cjs");
 const require_credentialSchemas = require("./credentialSchemas-DCR4Wd1W.cjs");
 let node_path = require("node:path");
@@ -17,9 +17,8 @@ let node_crypto = require("node:crypto");
 let _geekmidas_db_pg_roles = require("@geekmidas/db/pg/roles");
 let pg = require("pg");
 let _geekmidas_cache_postgres = require("@geekmidas/cache/postgres");
-let node_dns_promises = require("node:dns/promises");
 //#region src/deploy/docker.ts
-const logger$3 = require_discover.output;
+const logger$2 = require_discover.output;
 /**
 * The id the Dockerfile templates mount the encrypted credentials under:
 * `RUN --mount=type=secret,id=gkm_credentials`.
@@ -95,8 +94,8 @@ async function writeCredentialsFile(credentials) {
 * @param credentials - Encrypted credentials, passed as a build secret
 */
 async function buildImage(imageRef, buildArgs, credentials, { cwd, dockerfile, signal, stdio, stage }) {
-	logger$3.log(`\n🔨 Building Docker image: ${imageRef}`);
-	logger$3.log("   Generating Dockerfile...");
+	logger$2.log(`\n🔨 Building Docker image: ${imageRef}`);
+	logger$2.log("   Generating Dockerfile...");
 	const { buildRoot } = await require_seeds.dockerCommand({
 		cwd,
 		...stage ? { stage } : {}
@@ -118,7 +117,7 @@ async function buildImage(imageRef, buildArgs, credentials, { cwd, dockerfile, s
 			...signal ? { signal } : {},
 			...stdio ? { stdio } : {}
 		});
-		logger$3.log(`✅ Image built: ${imageRef}`);
+		logger$2.log(`✅ Image built: ${imageRef}`);
 	} catch (error) {
 		throw new require_seeds.DockerBuildFailed(imageRef, error);
 	} finally {
@@ -129,14 +128,14 @@ async function buildImage(imageRef, buildArgs, credentials, { cwd, dockerfile, s
 * Push Docker image to registry
 */
 async function pushImage(imageRef, { cwd, signal, stdio }) {
-	logger$3.log(`\n☁️  Pushing image: ${imageRef}`);
+	logger$2.log(`\n☁️  Pushing image: ${imageRef}`);
 	try {
 		await require_credentials.run("docker", ["push", imageRef], {
 			cwd,
 			...signal ? { signal } : {},
 			...stdio ? { stdio } : {}
 		});
-		logger$3.log(`✅ Image pushed: ${imageRef}`);
+		logger$2.log(`✅ Image pushed: ${imageRef}`);
 	} catch (error) {
 		throw new require_seeds.DockerPushFailed(imageRef, error);
 	}
@@ -189,17 +188,17 @@ async function deployDocker(options) {
 	await buildImage(imageRef, buildArgs, credentials, docker);
 	let digest;
 	if (!skipPush) {
-		if (!config.registry) logger$3.warn("\n⚠️  No registry configured. Use --skip-push or configure docker.registry in gkm.config.ts");
+		if (!config.registry) logger$2.warn("\n⚠️  No registry configured. Use --skip-push or configure docker.registry in gkm.config.ts");
 		else {
 			await pushImage(imageRef, docker);
 			digest = await pushedDigest(imageRef, docker);
 		}
 	}
-	logger$3.log("\n✅ Docker deployment ready!");
-	logger$3.log(`\n📋 Deployment details:`);
-	logger$3.log(`   Image: ${imageRef}`);
-	logger$3.log(`   Stage: ${stage}`);
-	if (masterKey) logger$3.log(`\n🔐 Run the container with GKM_MASTER_KEY set to the key with fingerprint ${require_sniffer.keyFingerprint(masterKey)}.`);
+	logger$2.log("\n✅ Docker deployment ready!");
+	logger$2.log(`\n📋 Deployment details:`);
+	logger$2.log(`   Image: ${imageRef}`);
+	logger$2.log(`   Stage: ${stage}`);
+	if (masterKey) logger$2.log(`\n🔐 Run the container with GKM_MASTER_KEY set to the key with fingerprint ${require_sniffer.keyFingerprint(masterKey)}.`);
 	return {
 		imageRef,
 		...digest ? { digest } : {},
@@ -1286,7 +1285,7 @@ async function provisionDeclared(options) {
 		events: require_seeds.eventsBackendFor(require_seeds.providerOf(workspace)),
 		storage: require_seeds.storageBackendFor(require_seeds.providerOf(workspace)),
 		...options.devServices ? { devServices: options.devServices } : {},
-		...workspace.deploy?.domains?.[options.stage] ? { domain: workspace.deploy.domains[options.stage] } : {},
+		...workspace.domains?.[options.stage] ? { domain: workspace.domains[options.stage] } : {},
 		addresses: surfaceAddresses(manifest, options.appUrls),
 		seed: options.seed,
 		...options.supplied ? { supplied: options.supplied } : {},
@@ -1366,387 +1365,6 @@ function surfaceAddresses(manifest, appUrls) {
 	return addresses;
 }
 //#endregion
-//#region src/target/dokploy/dns/DnsProvider.ts
-/**
-* Check if value is a DnsProvider implementation.
-*/
-function isDnsProvider(value) {
-	return typeof value === "object" && value !== null && typeof value.name === "string" && typeof value.getRecords === "function" && typeof value.upsertRecords === "function" && typeof value.deleteRecords === "function";
-}
-/**
-* Create a DNS provider based on configuration.
-*
-* - 'hostinger': HostingerProvider
-* - 'route53': Route53Provider
-* - 'manual': Returns null (user handles DNS)
-* - Custom: Use provided DnsProvider implementation
-*/
-async function createDnsProvider(options) {
-	const { config } = options;
-	if (config.provider === "manual") return null;
-	if (isDnsProvider(config.provider)) return config.provider;
-	const provider = config.provider;
-	if (provider === "hostinger") {
-		const { HostingerProvider } = await Promise.resolve().then(() => require("./HostingerProvider-BCB1QJj1.cjs"));
-		return new HostingerProvider();
-	}
-	if (provider === "route53") {
-		const { Route53Provider } = await Promise.resolve().then(() => require("./Route53Provider-Bllus2NR.cjs"));
-		const route53Config = config;
-		return new Route53Provider({
-			region: route53Config.region,
-			profile: route53Config.profile,
-			hostedZoneId: route53Config.hostedZoneId
-		});
-	}
-	if (provider === "cloudflare") throw new Error("Cloudflare DNS provider not yet implemented");
-	throw new Error(`Unknown DNS provider: ${JSON.stringify(config)}`);
-}
-//#endregion
-//#region src/target/dokploy/dns/index.ts
-/**
-* DNS orchestration for deployments
-*
-* Handles automatic DNS record creation for deployed applications.
-*/
-const logger$2 = require_discover.output;
-/**
-* Check if DNS config is legacy format (single domain with `domain` property)
-*/
-function isLegacyDnsConfig(config) {
-	return typeof config === "object" && config !== null && "provider" in config && "domain" in config;
-}
-/**
-* Normalize DNS config to new multi-domain format
-*/
-function normalizeDnsConfig(config) {
-	if (isLegacyDnsConfig(config)) {
-		const { domain, ...providerConfig } = config;
-		return { [domain]: providerConfig };
-	}
-	return config;
-}
-/**
-* Find the root domain for a hostname from available DNS configs
-*
-* @example
-* findRootDomain('api.geekmidas.com', { 'geekmidas.com': {...}, 'geekmidas.dev': {...} })
-* // Returns 'geekmidas.com'
-*/
-function findRootDomain(hostname, dnsConfig) {
-	const domains = Object.keys(dnsConfig).sort((a, b) => b.length - a.length);
-	for (const domain of domains) if (hostname === domain || hostname.endsWith(`.${domain}`)) return domain;
-	return null;
-}
-/**
-* Group hostnames by their root domain
-*/
-function groupHostnamesByDomain(appHostnames, dnsConfig) {
-	const grouped = /* @__PURE__ */ new Map();
-	for (const [appName, hostname] of appHostnames) {
-		const rootDomain = findRootDomain(hostname, dnsConfig);
-		if (!rootDomain) {
-			logger$2.log(`   ⚠ No DNS config found for hostname: ${hostname}`);
-			continue;
-		}
-		if (!grouped.has(rootDomain)) grouped.set(rootDomain, /* @__PURE__ */ new Map());
-		grouped.get(rootDomain).set(appName, hostname);
-	}
-	return grouped;
-}
-/**
-* Resolve IP address from a hostname
-*/
-async function resolveHostnameToIp(hostname) {
-	try {
-		return (await (0, node_dns_promises.lookup)(hostname, { family: 4 })).address;
-	} catch (error) {
-		throw new Error(`Failed to resolve IP for ${hostname}: ${error instanceof Error ? error.message : "Unknown error"}`);
-	}
-}
-/**
-* Extract subdomain from full hostname relative to root domain
-*
-* @example
-* extractSubdomain('api.joemoer.traflabs.io', 'traflabs.io') => 'api.joemoer'
-* extractSubdomain('joemoer.traflabs.io', 'traflabs.io') => 'joemoer'
-*/
-function extractSubdomain(hostname, rootDomain) {
-	if (!hostname.endsWith(rootDomain)) throw new Error(`Hostname ${hostname} is not under root domain ${rootDomain}`);
-	return hostname.slice(0, -(rootDomain.length + 1)) || "@";
-}
-/**
-* Generate required DNS records for a deployment
-*/
-function generateRequiredRecords(appHostnames, rootDomain, serverIp) {
-	const records = [];
-	for (const [appName, hostname] of appHostnames) {
-		const subdomain = extractSubdomain(hostname, rootDomain);
-		records.push({
-			hostname,
-			subdomain,
-			type: "A",
-			value: serverIp,
-			appName
-		});
-	}
-	return records;
-}
-/**
-* Print DNS records table
-*/
-function printDnsRecordsTable(records, rootDomain) {
-	logger$2.log(`\n   📋 DNS Records for ${rootDomain}:`);
-	logger$2.log("   ┌─────────────────────────────────────┬──────┬─────────────────┬────────┐");
-	logger$2.log("   │ Subdomain                           │ Type │ Value           │ Status │");
-	logger$2.log("   ├─────────────────────────────────────┼──────┼─────────────────┼────────┤");
-	for (const record of records) {
-		const subdomain = record.subdomain.padEnd(35);
-		const type = record.type.padEnd(4);
-		const value = record.value.padEnd(15);
-		let status;
-		if (record.error) status = "✗";
-		else if (record.created) status = "✓ new";
-		else if (record.existed) status = "✓";
-		else status = "?";
-		logger$2.log(`   │ ${subdomain} │ ${type} │ ${value} │ ${status.padEnd(6)} │`);
-	}
-	logger$2.log("   └─────────────────────────────────────┴──────┴─────────────────┴────────┘");
-}
-/**
-* Print DNS records in a simple format for manual setup
-*/
-function printDnsRecordsSimple(records, rootDomain) {
-	logger$2.log("\n   📋 Required DNS Records:");
-	logger$2.log(`   Add these A records to your DNS provider (${rootDomain}):\n`);
-	for (const record of records) logger$2.log(`   ${record.subdomain}  →  ${record.value}  (A record)`);
-	logger$2.log("");
-}
-/**
-* Create DNS records for a single domain using its configured provider
-*/
-async function createDnsRecordsForDomain(records, rootDomain, providerConfig) {
-	const ttl = "ttl" in providerConfig && providerConfig.ttl ? providerConfig.ttl : 300;
-	let provider;
-	try {
-		provider = await createDnsProvider({ config: providerConfig });
-	} catch (error) {
-		const message = error instanceof Error ? error.message : "Unknown error";
-		logger$2.log(`   ⚠ Failed to create DNS provider for ${rootDomain}: ${message}`);
-		return records.map((r) => ({
-			...r,
-			error: message
-		}));
-	}
-	if (!provider) return records.map((r) => ({
-		...r,
-		created: false,
-		existed: false
-	}));
-	const results = [];
-	const upsertRecords = records.map((r) => ({
-		name: r.subdomain,
-		type: r.type,
-		ttl,
-		value: r.value
-	}));
-	try {
-		const upsertResults = await provider.upsertRecords(rootDomain, upsertRecords);
-		for (const [i, record] of records.entries()) {
-			const result = upsertResults[i];
-			if (!result) {
-				results.push({
-					hostname: record.hostname,
-					subdomain: record.subdomain,
-					type: record.type,
-					value: record.value,
-					appName: record.appName,
-					error: "No result returned from provider"
-				});
-				continue;
-			}
-			if (result.unchanged) results.push({
-				hostname: record.hostname,
-				subdomain: record.subdomain,
-				type: record.type,
-				value: record.value,
-				appName: record.appName,
-				existed: true,
-				created: false
-			});
-			else results.push({
-				hostname: record.hostname,
-				subdomain: record.subdomain,
-				type: record.type,
-				value: record.value,
-				appName: record.appName,
-				created: result.created,
-				existed: !result.created
-			});
-		}
-	} catch (error) {
-		const message = error instanceof Error ? error.message : "Unknown error";
-		logger$2.log(`   ⚠ Failed to create DNS records for ${rootDomain}: ${message}`);
-		return records.map((r) => ({
-			hostname: r.hostname,
-			subdomain: r.subdomain,
-			type: r.type,
-			value: r.value,
-			appName: r.appName,
-			error: message
-		}));
-	}
-	return results;
-}
-/**
-* Main DNS orchestration function for deployments
-*
-* Supports both legacy single-domain format and new multi-domain format:
-* - Legacy: { provider: 'hostinger', domain: 'example.com' }
-* - Multi:  { 'example.com': { provider: 'hostinger' }, 'example.dev': { provider: 'route53' } }
-*
-* @param appHostnames - Map of app names to hostnames
-* @param dnsConfig - DNS configuration (legacy or multi-domain)
-* @param dokployEndpoint - Dokploy server endpoint to resolve IP from
-* @param state - Optional state to save created records for later deletion
-*/
-async function orchestrateDns(appHostnames, dnsConfig, dokployEndpoint, state) {
-	if (!dnsConfig) return null;
-	const normalizedConfig = normalizeDnsConfig(dnsConfig);
-	logger$2.log("\n🌐 Setting up DNS records...");
-	let serverIp;
-	try {
-		const endpointUrl = new URL(dokployEndpoint);
-		serverIp = await resolveHostnameToIp(endpointUrl.hostname);
-		logger$2.log(`   Server IP: ${serverIp} (from ${endpointUrl.hostname})`);
-	} catch (error) {
-		const message = error instanceof Error ? error.message : "Unknown error";
-		logger$2.log(`   ⚠ Failed to resolve server IP: ${message}`);
-		return null;
-	}
-	const groupedHostnames = groupHostnamesByDomain(appHostnames, normalizedConfig);
-	if (groupedHostnames.size === 0) {
-		logger$2.log("   No DNS records needed (no hostnames match configured domains)");
-		return {
-			records: [],
-			success: true,
-			serverIp
-		};
-	}
-	const allRecords = [];
-	let hasFailures = false;
-	for (const [rootDomain, domainHostnames] of groupedHostnames) {
-		const providerConfig = normalizedConfig[rootDomain];
-		if (!providerConfig) {
-			logger$2.log(`   ⚠ No provider config for ${rootDomain}`);
-			continue;
-		}
-		const providerName = typeof providerConfig.provider === "string" ? providerConfig.provider : "custom";
-		const requiredRecords = generateRequiredRecords(domainHostnames, rootDomain, serverIp);
-		if (requiredRecords.length === 0) continue;
-		logger$2.log(`   Creating DNS records for ${rootDomain} (${providerName})...`);
-		const domainRecords = await createDnsRecordsForDomain(requiredRecords, rootDomain, providerConfig);
-		allRecords.push(...domainRecords);
-		const created = domainRecords.filter((r) => r.created).length;
-		const existed = domainRecords.filter((r) => r.existed).length;
-		const failed = domainRecords.filter((r) => r.error).length;
-		if (created > 0) logger$2.log(`   ✓ Created ${created} DNS record(s) for ${rootDomain}`);
-		if (existed > 0) logger$2.log(`   ✓ ${existed} record(s) already exist for ${rootDomain}`);
-		if (failed > 0) {
-			logger$2.log(`   ⚠ ${failed} record(s) failed for ${rootDomain}`);
-			hasFailures = true;
-		}
-		if (state) {
-			for (const record of domainRecords) if (record.created || record.existed) require_seeds.setDnsRecord(state, {
-				domain: rootDomain,
-				name: record.subdomain,
-				type: record.type,
-				value: record.value,
-				ttl: "ttl" in providerConfig && providerConfig.ttl ? providerConfig.ttl : 300
-			});
-		}
-		printDnsRecordsTable(domainRecords, rootDomain);
-		if (providerConfig.provider === "manual" || failed > 0) printDnsRecordsSimple(domainRecords.filter((r) => !r.created && !r.existed), rootDomain);
-	}
-	return {
-		records: allRecords,
-		success: !hasFailures,
-		serverIp
-	};
-}
-/**
-* Verify DNS records resolve correctly after deployment.
-*
-* This function:
-* 1. Checks state for previously verified hostnames (skips if already verified with same IP)
-* 2. Attempts to resolve each hostname to an IP
-* 3. Compares resolved IP with expected server IP
-* 4. Updates state with verification results
-*
-* @param appHostnames - Map of app names to hostnames
-* @param serverIp - Expected IP address the hostnames should resolve to
-* @param state - Deploy state for caching verification results
-* @returns Array of verification results
-*/
-async function verifyDnsRecords(appHostnames, serverIp, state) {
-	const results = [];
-	logger$2.log("\n🔍 Verifying DNS records...");
-	for (const [appName, hostname] of appHostnames) {
-		if (require_seeds.isDnsVerified(state, hostname, serverIp)) {
-			logger$2.log(`   ✓ ${hostname} (previously verified)`);
-			results.push({
-				hostname,
-				appName,
-				verified: true,
-				expectedIp: serverIp,
-				skipped: true
-			});
-			continue;
-		}
-		try {
-			const resolvedIp = await resolveHostnameToIp(hostname);
-			if (resolvedIp === serverIp) {
-				require_seeds.setDnsVerification(state, hostname, serverIp);
-				logger$2.log(`   ✓ ${hostname} → ${resolvedIp}`);
-				results.push({
-					hostname,
-					appName,
-					verified: true,
-					resolvedIp,
-					expectedIp: serverIp
-				});
-			} else {
-				logger$2.log(`   ⚠ ${hostname} resolves to ${resolvedIp}, expected ${serverIp}`);
-				results.push({
-					hostname,
-					appName,
-					verified: false,
-					resolvedIp,
-					expectedIp: serverIp
-				});
-			}
-		} catch (error) {
-			const message = error instanceof Error ? error.message : "Unknown error";
-			logger$2.log(`   ⚠ ${hostname} DNS not propagated (${message})`);
-			results.push({
-				hostname,
-				appName,
-				verified: false,
-				expectedIp: serverIp,
-				error: message
-			});
-		}
-	}
-	const verified = results.filter((r) => r.verified).length;
-	const skipped = results.filter((r) => r.skipped).length;
-	const pending = results.filter((r) => !r.verified).length;
-	if (pending > 0) {
-		logger$2.log(`\n   ${verified} verified, ${pending} pending propagation`);
-		logger$2.log("   DNS changes may take 5-30 minutes to propagate");
-	} else if (skipped > 0) logger$2.log(`   ${verified} verified (${skipped} from cache)`);
-	return results;
-}
-//#endregion
 //#region src/target/dokploy/env-resolver.ts
 /**
 * Environment Variable Resolution for Dokploy Deployments
@@ -1777,6 +1395,7 @@ function getOrGenerateSecret(state, appName, secretName) {
 * Resolve a single environment variable
 */
 function resolveEnvVar(varName, context) {
+	if (require_workspace.isReservedStageKey(varName)) return void 0;
 	switch (varName) {
 		case "PORT": return String(context.app.port);
 		case "NODE_ENV": return "production";
@@ -2305,7 +1924,7 @@ async function validateDokploy(phase) {
 		declarations: require_seeds.manifestServiceDeclarations(phase.manifest),
 		supplied: stored?.custom ?? {},
 		allow: phase.allowDevServices,
-		...workspace.deploy?.domains?.[stage] ? { domain: workspace.deploy.domains[stage] } : {},
+		...workspace.domains?.[stage] ? { domain: workspace.domains[stage] } : {},
 		providers: require_seeds.stageProviderNotes(workspace, stage)
 	});
 	const devServices = require_seeds.devServicesUsed(services);
@@ -3036,11 +2655,11 @@ async function settleDns(run, apps) {
 	const { workspace } = run;
 	const { api, endpoint, journal, state } = run.provisioned;
 	const appHostnames = new Map([...run.released.appHostnames].filter(([app]) => apps.includes(app)));
-	const dnsConfig = workspace.deploy.dns;
+	const dnsConfig = workspace.dns;
 	if (!dnsConfig || appHostnames.size === 0) return;
-	const dnsResult = await orchestrateDns(appHostnames, dnsConfig, endpoint);
+	const dnsResult = await require_seeds.orchestrateDns(appHostnames, dnsConfig, endpoint);
 	if (dnsResult?.serverIp) {
-		await verifyDnsRecords(appHostnames, dnsResult.serverIp, state);
+		await require_seeds.verifyDnsRecords(appHostnames, dnsResult.serverIp, state);
 		await journal.save();
 	}
 	if (dnsResult?.success) {
@@ -3284,7 +2903,7 @@ async function dokployApi(workspace, ctx) {
 /** Each app's public host, the same way the deploy resolves it. */
 function hostOf(workspace, appName, stage) {
 	const app = workspace.apps[appName];
-	return require_seeds.resolveHost(appName, app, stage, workspace.deploy?.domains, app.type === "web" && require_seeds.isMainFrontendApp(appName, app, workspace.apps));
+	return require_seeds.resolveHost(appName, app, stage, workspace.domains, app.type === "web" && require_seeds.isMainFrontendApp(appName, app, workspace.apps));
 }
 /**
 * What a deploy would do, from the same lookups it starts with — and nothing
@@ -3576,4 +3195,4 @@ Object.defineProperty(exports, "verifySettings", {
 	}
 });
 
-//# sourceMappingURL=engine-Bt5k_UMq.cjs.map
+//# sourceMappingURL=engine-DgHoFBMw.cjs.map