Skip to content

Modern Docker Management, Designed for Everyone

fix: implement main compose spec functionality (#259)

Kyle Mendelle2fc0ac7d53d
diff --git a/src/app.css b/src/app.css
index 1d37e7a3d..8465c2e89 100644
--- a/src/app.css
+++ b/src/app.css
@@ -327,3 +327,22 @@
.dark .arcane-button-cancel:hover {
background-color: hsla(215, 27.9%, 40%, 0.15) !important;
}
+
+/* Prevent horizontal overflow globally */
+html,
+body {
+ overflow-x: hidden;
+ max-width: 100vw;
+}
+
+/* Ensure main containers respect viewport width */
+main {
+ min-width: 0;
+ max-width: 100%;
+ overflow-x: hidden;
+}
+
+/* Fix flex containers that might cause overflow */
+.flex {
+ min-width: 0;
+}
diff --git a/src/lib/services/docker/stack-custom-service.ts b/src/lib/services/docker/stack-custom-service.ts
index 5c2f167f0..97e5de418 100644
--- a/src/lib/services/docker/stack-custom-service.ts
+++ b/src/lib/services/docker/stack-custom-service.ts
@@ -1,14 +1,43 @@
import { promises as fs } from 'node:fs';
import * as path from 'node:path';
import Dockerode from 'dockerode';
-import { load as yamlLoad, dump as yamlDump } from 'js-yaml';
+import { dump as yamlDump } from 'js-yaml';
import slugify from 'slugify';
import { directoryExists } from '$lib/utils/fs.utils';
import { getDockerClient } from './core';
import { getSettings, ensureStacksDirectory } from '$lib/services/settings-service';
import type { Stack, StackService, StackUpdate } from '$lib/types/docker/stack.type';
-// Database imports
import { listStacksFromDb, getStackByIdFromDb, saveStackToDb, updateStackRuntimeInfoInDb, updateStackContentInDb, deleteStackFromDb, updateStackAutoUpdateInDb, getAutoUpdateStacksFromDb } from '$lib/services/database/compose-db-service';
+import {
+ parseEnvContent,
+ validateComposeStructure,
+ normalizeHealthcheckTest,
+ parseYamlContent,
+ prepareVolumes,
+ preparePorts,
+ prepareEnvironmentVariables,
+ prepareRestartPolicy,
+ resolveDependencyOrder,
+ prepareExtraHosts,
+ prepareUlimits,
+ prepareHealthcheck,
+ parseMemory,
+ validateComposeContent,
+ substituteVariablesInObject,
+ createVolumeDefinitions,
+ createDependencyWaitConfig,
+ parseActiveProfiles,
+ getAllDefinedProfiles,
+ createProfileDeploymentPlan,
+ applyProfileFiltering,
+ getProfileUsageStats,
+ generateProfileHelp,
+ validateAllDependencies,
+ resolveDependencyOrderWithConditions,
+ generateConfigHash,
+ prepareLogConfig,
+ DEFAULT_COMPOSE_VERSION
+} from '$lib/utils/compose.utils';
interface DockerProgressEvent {
status: string;
@@ -22,28 +51,9 @@ interface DockerProgressEvent {
let STACKS_DIR = '';
const stackCache = new Map();
-const CACHE_TTL = 30000; // 30 seconds
-
-// Helper function to parse environment file content
-export function parseEnvContent(envContent: string | null): Record<string, string> {
- const envVars: Record<string, string> = {};
- if (envContent) {
- envContent.split('\n').forEach((line) => {
- const trimmedLine = line.trim();
- if (trimmedLine && !trimmedLine.startsWith('#')) {
- const [key, ...valueParts] = trimmedLine.split('=');
- const value = valueParts.join('=');
- if (key) {
- envVars[key.trim()] = value?.trim() || '';
- }
- }
- });
- }
- return envVars;
-}
/**
- * Initialize compose service - includes database check
+ * Initialize compose service with proper validation
*/
export async function initComposeService(): Promise<void> {
try {
@@ -64,25 +74,28 @@ export async function initComposeService(): Promise<void> {
}
} catch (err) {
console.error('Error initializing compose service:', err);
+ throw new Error('Failed to initialize compose service');
}
}
/**
- * Update stacks directory
+ * Update stacks directory with validation
*/
export function updateStacksDirectory(directory: string): void {
- if (directory) {
- if (!path.isAbsolute(directory)) {
- STACKS_DIR = path.resolve(directory);
- } else {
- STACKS_DIR = directory;
- }
- console.log(`Stacks directory updated to: ${STACKS_DIR}`);
+ if (!directory || typeof directory !== 'string') {
+ throw new Error('Directory path must be a non-empty string');
+ }
+
+ if (!path.isAbsolute(directory)) {
+ STACKS_DIR = path.resolve(directory);
+ } else {
+ STACKS_DIR = directory;
}
+ console.log(`Stacks directory updated to: ${STACKS_DIR}`);
}
/**
- * Ensure stacks directory exists
+ * Ensure stacks directory exists with proper error handling
*/
export async function ensureStacksDir(): Promise<string> {
try {
@@ -96,6 +109,14 @@ export async function ensureStacksDir(): Promise<string> {
}
await fs.mkdir(STACKS_DIR, { recursive: true });
+
+ // Verify directory is writable
+ try {
+ await fs.access(STACKS_DIR, fs.constants.W_OK);
+ } catch {
+ throw new Error(`Stacks directory ${STACKS_DIR} is not writable`);
+ }
+
return STACKS_DIR;
} catch (err) {
console.error('Error creating stacks directory:', err);
@@ -104,39 +125,56 @@ export async function ensureStacksDir(): Promise<string> {
}
/**
- * Get stack directory for a given stackId
+ * Get stack directory with path sanitization
*/
export async function getStackDir(stackId: string): Promise<string> {
+ if (!stackId || typeof stackId !== 'string') {
+ throw new Error('Stack ID must be a non-empty string');
+ }
+
const stacksDirAbs = await ensureStacksDir();
const safeId = path.basename(stackId);
+
if (safeId !== stackId) {
- console.warn(`Original stackId "${stackId}" was sanitized to "${safeId}". Ensure this is expected.`);
+ console.warn(`Stack ID "${stackId}" was sanitized to "${safeId}" for security`);
}
+
+ // Additional validation to ensure safe directory name
+ if (!/^[a-z0-9][a-z0-9_-]*$/.test(safeId)) {
+ throw new Error(`Invalid stack ID: "${safeId}". Stack ID must start with a lowercase letter or digit and contain only lowercase letters, digits, hyphens, and underscores.`);
+ }
+
return path.join(stacksDirAbs, safeId);
}
/**
- * Get compose file path, prioritizing compose.yaml over docker-compose.yml
+ * Get compose file path with spec-compliant priority
*/
export async function getComposeFilePath(stackId: string): Promise<string | null> {
const stackDirAbs = await getStackDir(stackId);
- const newPath = path.join(stackDirAbs, 'compose.yaml');
- const oldPath = path.join(stackDirAbs, 'docker-compose.yml');
- try {
- await fs.access(newPath);
- return newPath;
- } catch {
+
+ // Docker Compose specification file priority
+ const composePaths = [
+ path.join(stackDirAbs, 'compose.yaml'), // Preferred format
+ path.join(stackDirAbs, 'compose.yml'), // Alternative YAML
+ path.join(stackDirAbs, 'docker-compose.yaml'), // Legacy format
+ path.join(stackDirAbs, 'docker-compose.yml') // Legacy format
+ ];
+
+ for (const composePath of composePaths) {
try {
- await fs.access(oldPath);
- return oldPath;
+ await fs.access(composePath, fs.constants.R_OK);
+ return composePath;
} catch {
- return null;
+ // Continue to next path
}
}
+
+ return null;
}
/**
- * Get .env file path
+ * Get .env file path with validation
*/
async function getEnvFilePath(stackId: string): Promise<string> {
const stackDir = await getStackDir(stackId);
@@ -144,23 +182,42 @@ async function getEnvFilePath(stackId: string): Promise<string> {
}
/**
- * Save environment variables to .env file
+ * Save environment variables to .env file with proper formatting
*/
async function saveEnvFile(stackId: string, content?: string): Promise<void> {
const envPath = await getEnvFilePath(stackId);
const fileContent = content === undefined || content === null ? '' : content;
+
+ // Validate env content format if not empty
+ if (fileContent.trim()) {
+ try {
+ parseEnvContent(fileContent);
+ } catch (error) {
+ throw new Error(`Invalid .env file format: ${error instanceof Error ? error.message : String(error)}`);
+ }
+ }
+
await fs.writeFile(envPath, fileContent, 'utf8');
console.log(`Saved .env file for stack ${stackId}`);
}
/**
- * Load environment variables from .env file
+ * Load environment variables from .env file with proper error handling
*/
export async function loadEnvFile(stackId: string): Promise<string> {
const envPath = await getEnvFilePath(stackId);
try {
- return await fs.readFile(envPath, 'utf8');
+ const content = await fs.readFile(envPath, 'utf8');
+
+ // Validate the content can be parsed
+ try {
+ parseEnvContent(content);
+ } catch (parseError) {
+ console.warn(`Warning: .env file for stack ${stackId} has parsing issues:`, parseError);
+ }
+
+ return content;
} catch (err) {
const nodeErr = err as NodeJS.ErrnoException;
if (nodeErr.code === 'ENOENT') {
@@ -173,7 +230,7 @@ export async function loadEnvFile(stackId: string): Promise<string> {
}
/**
- * Load compose stacks - FAST version (no runtime updates)
+ * Load compose stacks with enhanced caching and validation
*/
export async function loadComposeStacks(): Promise<Stack[]> {
const cacheKey = 'compose-stacks';
@@ -192,11 +249,22 @@ export async function loadComposeStacks(): Promise<Stack[]> {
const dbStacks = await listStacksFromDb();
console.log(`Loaded ${dbStacks.length} stacks from database (fast mode)`);
- // Return stacks with minimal processing
- const fastStacks = dbStacks.map((stack) => ({
- ...stack,
- services: [] // Empty services array for fast loading
- }));
+ // Return stacks with minimal processing and validation
+ const fastStacks = dbStacks
+ .map((stack) => {
+ // Basic validation of stack data
+ if (!stack.id || typeof stack.id !== 'string') {
+ console.warn('Stack missing valid ID, skipping');
+ return null;
+ }
+
+ return {
+ ...stack,
+ services: [], // Empty services array for fast loading
+ status: stack.status || 'unknown'
+ };
+ })
+ .filter(Boolean) as Stack[];
stackCache.set(cacheKey, {
data: fastStacks,
@@ -212,10 +280,9 @@ export async function loadComposeStacks(): Promise<Stack[]> {
}
/**
- * Load stacks with full runtime info (use sparingly)
+ * Load stacks with full runtime info and compose validation
*/
export async function loadComposeStacksWithRuntimeInfo(): Promise<Stack[]> {
- // This is the current heavy function - only use when needed
const dbStacks = await listStacksFromDb();
return Promise.all(
@@ -228,7 +295,15 @@ export async function loadComposeStacksWithRuntimeInfo(): Promise<Stack[]> {
const composePath = await getComposeFilePath(stack.id);
if (composePath) {
composeContent = await fs.readFile(composePath, 'utf8');
- // Don't update DB on every load - do this in background
+
+ // Validate compose content
+ const validation = validateComposeContent(composeContent);
+ if (!validation.valid) {
+ console.warn(`Compose validation errors for stack ${stack.id}:`, validation.errors);
+ }
+ if (validation.warnings.length > 0) {
+ console.warn(`Compose validation warnings for stack ${stack.id}:`, validation.warnings);
+ }
}
} catch (fileError) {
console.warn(`Could not load compose file for stack ${stack.id}`);
@@ -260,7 +335,8 @@ export async function loadComposeStacksWithRuntimeInfo(): Promise<Stack[]> {
console.error(`Error processing stack ${stack.id}:`, error);
return {
...stack,
- services: []
+ services: [],
+ status: 'unknown' as Stack['status']
};
}
})
@@ -350,17 +426,17 @@ async function loadComposeStacksFromFiles(): Promise<Stack[]> {
}
/**
- * Get stack services from containers
+ * Get stack services from containers with Docker Compose spec compliance
*/
async function getStackServices(stackId: string, composeContent: string): Promise<StackService[]> {
const docker = await getDockerClient();
const composeProjectLabel = 'com.docker.compose.project';
const composeServiceLabel = 'com.docker.compose.service';
- console.log(`Getting services for stack ${stackId}, composeContent length: ${composeContent.length}`);
+ console.log(`Getting services for stack ${stackId} (compose content length: ${composeContent.length})`);
try {
- // Load the .env file to provide environment variable values
+ // Load and parse environment variables
let envContent = '';
let envVars: Record<string, string> = {};
@@ -372,21 +448,37 @@ async function getStackServices(stackId: string, composeContent: string): Promis
}
// Create environment variable getter function
- const getEnvVar = (key: string) => {
- return envVars[key] || process.env[key] || '';
+ const getEnvVar = (key: string): string | undefined => {
+ return envVars[key] || process.env[key];
};
- // Parse compose content to get service definitions
+ // Parse and validate compose content
let composeData: Record<string, any> | null = null;
let serviceNames: string[] = [];
if (composeContent.trim()) {
+ // Validate compose content first
+ const validation = validateComposeContent(composeContent);
+ if (!validation.valid) {
+ console.warn(`Compose validation errors for stack ${stackId}:`, validation.errors);
+ }
+
+ // Parse with variable substitution
composeData = parseYamlContent(composeContent, getEnvVar);
- if (composeData && composeData.services) {
- serviceNames = Object.keys(composeData.services as Record<string, unknown>);
- console.log(`Found ${serviceNames.length} services defined in compose: [${serviceNames.join(', ')}]`);
- } else {
- console.warn(`No services found in compose content for stack ${stackId}`);
+
+ // Validate compose structure
+ if (composeData) {
+ const structureValidation = validateComposeStructure(composeData);
+ if (!structureValidation.valid) {
+ console.warn(`Compose structure validation errors for stack ${stackId}:`, structureValidation.errors);
+ }
+
+ if (composeData.services) {
+ serviceNames = Object.keys(composeData.services as Record<string, unknown>);
+ console.log(`Found ${serviceNames.length} services defined in compose: [${serviceNames.join(', ')}]`);
+ } else {
+ console.warn(`No services found in compose content for stack ${stackId}`);
+ }
}
} else {
console.warn(`Empty compose content for stack ${stackId}`);
@@ -396,13 +488,15 @@ async function getStackServices(stackId: string, composeContent: string): Promis
const containers = await docker.listContainers({ all: true });
console.log(`Total containers found: ${containers.length}`);
- // Filter containers based on labels and naming convention
+ // Filter containers based on Docker Compose labels and naming convention
const stackContainers = containers.filter((container) => {
const labels = container.Labels || {};
const names = container.Names || [];
- // Check if container belongs to this stack
+ // Primary filter: Docker Compose project label
const hasCorrectLabel = labels[composeProjectLabel] === stackId;
+
+ // Secondary filter: naming convention for backwards compatibility
const nameStartsWithPrefix = names.some((name) => name.startsWith(`/${stackId}_`));
const belongs = hasCorrectLabel || nameStartsWithPrefix;
@@ -420,6 +514,7 @@ async function getStackServices(stackId: string, composeContent: string): Promis
const services: StackService[] = [];
+ // Process existing containers
for (const containerData of stackContainers) {
const containerName = containerData.Names?.[0]?.substring(1) || '';
const labels = containerData.Labels || {};
@@ -431,6 +526,7 @@ async function getStackServices(stackId: string, composeContent: string): Promis
if (!serviceName && serviceNames.length > 0) {
console.log(`Container ${containerData.Id} missing service label, trying to parse from name`);
for (const name of serviceNames) {
+ // Docker Compose naming pattern: {project}_{service}_{replica}
const servicePrefixWithUnderscore = `${stackId}_${name}_`;
const servicePrefixExact = `${stackId}_${name}`;
if (containerName.startsWith(servicePrefixWithUnderscore) || containerName === servicePrefixExact) {
@@ -441,9 +537,9 @@ async function getStackServices(stackId: string, composeContent: string): Promis
}
}
- // Final fallback if still no match
+ // Final fallback using Docker Compose naming convention
if (!serviceName) {
- // Extract service name from container name pattern: stackId_serviceName_instance
+ // Extract service name from container name pattern: {project}_{service}_{replica}
const namePattern = new RegExp(`^${stackId}_([^_]+)(?:_\\d+)?$`);
const match = containerName.match(namePattern);
if (match) {
@@ -467,7 +563,7 @@ async function getStackServices(stackId: string, composeContent: string): Promis
console.log(`Created service: ${JSON.stringify(service)}`);
- // Avoid adding duplicates
+ // Avoid adding duplicates (handle multiple replicas)
const existingServiceIndex = services.findIndex((s) => s.name === serviceName);
if (existingServiceIndex !== -1) {
if (!services[existingServiceIndex].id) {
@@ -482,7 +578,7 @@ async function getStackServices(stackId: string, composeContent: string): Promis
}
}
- // Add placeholders for services defined in compose but not found among listed containers
+ // Add placeholders for services defined in compose but not found among containers
if (serviceNames.length > 0) {
for (const name of serviceNames) {
if (!services.some((s) => s.name === name)) {
@@ -501,13 +597,35 @@ async function getStackServices(stackId: string, composeContent: string): Promis
}
}
- // Sort services alphabetically by name for consistent order
- services.sort((a, b) => a.name.localeCompare(b.name));
+ // Sort services by dependency order if possible, otherwise alphabetically
+ let sortedServices = services;
+ if (composeData && composeData.services) {
+ try {
+ const dependencyOrder = resolveDependencyOrder(composeData.services);
+ sortedServices = services.sort((a, b) => {
+ const aIndex = dependencyOrder.indexOf(a.name);
+ const bIndex = dependencyOrder.indexOf(b.name);
+
+ // If both services are in dependency order, sort by that
+ if (aIndex !== -1 && bIndex !== -1) {
+ return aIndex - bIndex;
+ }
+
+ // Otherwise, alphabetical sort
+ return a.name.localeCompare(b.name);
+ });
+ } catch (depError) {
+ console.warn(`Could not resolve dependency order for stack ${stackId}, using alphabetical sort:`, depError);
+ sortedServices = services.sort((a, b) => a.name.localeCompare(b.name));
+ }
+ } else {
+ sortedServices = services.sort((a, b) => a.name.localeCompare(b.name));
+ }
- console.log(`Final services for stack ${stackId}: ${services.length} services`);
- services.forEach((s) => console.log(` - ${s.name}: ${s.state?.Status} (id: ${s.id || 'none'})`));
+ console.log(`Final services for stack ${stackId}: ${sortedServices.length} services`);
+ sortedServices.forEach((s) => console.log(` - ${s.name}: ${s.state?.Status} (id: ${s.id || 'none'})`));
- return services;
+ return sortedServices;
} catch (err) {
console.error(`Error getting services for stack ${stackId}:`, err);
return [];
@@ -766,7 +884,7 @@ export async function updateStack(currentStackId: string, updates: StackUpdate):
/**
* Custom stack deployment function using dockerode directly
*/
-export async function deployStack(stackId: string): Promise<boolean> {
+export async function deployStack(stackId: string, options: { profiles?: string[]; envOverrides?: Record<string, string> } = {}): Promise<boolean> {
const stackDir = await getStackDir(stackId);
const originalCwd = process.cwd();
let deploymentStarted = false;
@@ -782,13 +900,12 @@ export async function deployStack(stackId: string): Promise<boolean> {
const envContent = await loadEnvFile(stackId);
// Parse env variables and create getter
- const envVars = parseEnvContent(envContent);
+ const envVars = { ...parseEnvContent(envContent), ...options.envOverrides };
const getEnvVar = (key: string): string | undefined => envVars[key] || process.env[key];
- // Normalize content for healthchecks but don't write it back to the file
+ // Normalize content for healthchecks
const normalizedContent = normalizeHealthcheckTest(composeContent, getEnvVar);
- // Only write back if it's specifically a healthcheck normalization issue
if (composeContent !== normalizedContent) {
console.log(`Normalized compose content for stack ${stackId}. Writing to disk.`);
await fs.writeFile(composePath, normalizedContent, 'utf8');
@@ -804,19 +921,92 @@ export async function deployStack(stackId: string): Promise<boolean> {
throw new Error(`Failed to parse compose file for stack ${stackId}`);
}
- const hasExternalNetworks = composeData.networks && Object.values(composeData.networks).some((net: any) => net.external);
+ // Add comprehensive validation before deployment
+ if (composeData.services) {
+ console.log(`Validating dependencies for stack ${stackId}...`);
+ const dependencyValidation = validateAllDependencies(composeData.services);
+
+ if (!dependencyValidation.valid) {
+ console.error(`Dependency validation failed for stack ${stackId}:`, dependencyValidation.errors);
+ throw new Error(`Invalid dependencies: ${dependencyValidation.errors.join(', ')}`);
+ }
+
+ if (dependencyValidation.warnings.length > 0) {
+ console.warn(`Dependency warnings for stack ${stackId}:`, dependencyValidation.warnings);
+ }
+ }
+
+ // Handle profiles
+ const activeProfiles = options.profiles?.length ? options.profiles : parseActiveProfiles([], envVars);
+ console.log(`Active profiles for stack ${stackId}: [${activeProfiles.join(', ')}]`);
+
+ // Apply profile filtering
+ const { filteredComposeData, deploymentPlan } = applyProfileFiltering(composeData, activeProfiles);
+
+ // Log deployment plan
+ console.log(`Deployment plan for stack ${stackId}:`);
+ console.log(` Services to deploy (${deploymentPlan.plan.servicesToDeploy.length}): [${deploymentPlan.plan.servicesToDeploy.join(', ')}]`);
+
+ if (deploymentPlan.plan.servicesToSkip.length > 0) {
+ console.log(` Services to skip (${deploymentPlan.plan.servicesToSkip.length}):`);
+ for (const skipped of deploymentPlan.plan.servicesToSkip) {
+ console.log(` - ${skipped.name}: ${skipped.reason}`);
+ }
+ }
+
+ if (deploymentPlan.warnings.length > 0) {
+ console.warn(`Profile warnings for stack ${stackId}:`, deploymentPlan.warnings);
+ }
+
+ if (deploymentPlan.errors.length > 0) {
+ throw new Error(`Profile errors for stack ${stackId}: ${deploymentPlan.errors.join(', ')}`);
+ }
+
+ console.log(`Checking for existing containers for stack ${stackId}...`);
+ const docker = await getDockerClient();
+
+ try {
+ const existingContainers = await docker.listContainers({
+ all: true,
+ filters: JSON.stringify({
+ label: [`com.docker.compose.project=${stackId}`]
+ })
+ });
+
+ if (existingContainers.length > 0) {
+ console.log(`Found ${existingContainers.length} existing containers for stack ${stackId}. Stopping and removing...`);
+
+ for (const containerInfo of existingContainers) {
+ const container = docker.getContainer(containerInfo.Id);
+ try {
+ if (containerInfo.State === 'running') {
+ await container.stop({ t: 10 });
+ }
+ await container.remove({ force: true });
+ console.log(`Removed container ${containerInfo.Names?.[0]} (${containerInfo.Id})`);
+ } catch (containerErr) {
+ console.warn(`Error removing container ${containerInfo.Id}:`, containerErr);
+ }
+ }
+ }
+ } catch (cleanupErr) {
+ console.warn(`Error during container cleanup for stack ${stackId}:`, cleanupErr);
+ }
+
+ // Use filtered compose data for deployment
+ const hasExternalNetworks = filteredComposeData.networks && Object.values(filteredComposeData.networks).some((net: any) => net.external);
try {
deploymentStarted = true;
if (hasExternalNetworks) {
console.log(`Stack ${stackId} contains external networks. Using custom deployment approach.`);
- await deployStackWithExternalNetworks(stackId, composeData, stackDir);
+ await deployStackWithExternalNetworks(stackId, filteredComposeData, stackDir);
} else {
// Standard approach for stacks without external networks
const docker = await getDockerClient();
- // Pull images for all services
- const imagePullPromises = Object.entries(composeData.services || {})
+ // Pull images for deployable services only
+ const imagePullPromises = Object.entries(filteredComposeData.services || {})
.filter(([_, serviceConfig]) => (serviceConfig as any).image)
.map(async ([serviceName, serviceConfig]) => {
const serviceImage = (serviceConfig as any).image;
@@ -830,18 +1020,18 @@ export async function deployStack(stackId: string): Promise<boolean> {
await Promise.all(imagePullPromises);
- // Create networks
- await createStackNetworks(docker, stackId, composeData.networks || {});
+ // Create networks for deployable services only
+ await createStackNetworks(docker, stackId, filteredComposeData.networks || {});
- // Deploy services
- await createAndStartServices(docker, stackId, composeData, stackDir);
+ // Deploy filtered services
+ await createAndStartServices(docker, stackId, filteredComposeData, stackDir);
}
// Update database with new status
try {
await updateStackRuntimeInfoInDb(stackId, {
status: 'running',
- lastPolled: Math.floor(Date.now() / 1000) // ← Solution: Unix timestamp
+ lastPolled: Math.floor(Date.now() / 1000)
});
} catch (dbError) {
console.error(`Error updating stack ${stackId} status in database:`, dbError);
@@ -850,7 +1040,6 @@ export async function deployStack(stackId: string): Promise<boolean> {
stackCache.delete('compose-stacks');
return true;
} catch (deployErr) {
- // If deployment started but failed, clean up any containers that were created
if (deploymentStarted) {
console.log(`Deployment of stack ${stackId} failed. Cleaning up any created containers...`);
try {
@@ -1330,116 +1519,6 @@ export async function getAutoUpdateStacks(): Promise<Stack[]> {
}
}
-/**
- * Normalize healthcheck test and substitute variables
- */
-export function normalizeHealthcheckTest(composeContent: string, envGetter?: (key: string) => string | undefined): string {
- let doc: any;
- try {
- doc = yamlLoad(composeContent);
- if (!doc || typeof doc !== 'object') {
- console.warn('Could not parse compose YAML for normalization or content is not an object.');
- return composeContent;
- }
- } catch (e) {
- console.warn('Could not parse compose YAML for normalization:', e);
- return composeContent;
- }
-
- let modified = false;
-
- // Perform healthcheck normalization
- if (doc.services && typeof doc.services === 'object') {
- for (const serviceName in doc.services) {
- if (Object.prototype.hasOwnProperty.call(doc.services, serviceName)) {
- const service = doc.services[serviceName];
- if (service && service.healthcheck && typeof service.healthcheck === 'object' && service.healthcheck.test && typeof service.healthcheck.test === 'string') {
- service.healthcheck.test = service.healthcheck.test
- .trim()
- .split(/\s+/)
- .filter((s: string) => s.length > 0);
- modified = true;
- }
- }
- }
- }
-
- // Perform variable substitution if envGetter is provided
- if (envGetter) {
- const originalDocSnapshot = JSON.stringify(doc);
- doc = substituteVariablesInObject(doc, envGetter);
- if (JSON.stringify(doc) !== originalDocSnapshot) {
- modified = true;
- }
- }
-
- if (modified) {
- // Critical check: ensure container_name does not contain unresolved variables
- if (doc.services && typeof doc.services === 'object') {
- for (const serviceName in doc.services) {
- if (Object.prototype.hasOwnProperty.call(doc.services, serviceName)) {
- const service = doc.services[serviceName];
- if (service && typeof service.container_name === 'string' && service.container_name.includes('${')) {
- console.error(`CRITICAL: Unresolved variable in container_name for service '${serviceName}': ${service.container_name}. ` + `This will likely cause Docker to fail. Ensure the environment variable is defined.`);
- }
- }
- }
- }
- return yamlDump(doc, { lineWidth: -1 });
- }
- return composeContent;
-}
-
-/**
- * Parse YAML content safely
- */
-export function parseYamlContent(content: string, envGetter?: (key: string) => string | undefined): Record<string, any> | null {
- try {
- const parsedYaml = yamlLoad(content);
-
- if (!parsedYaml || typeof parsedYaml !== 'object') {
- console.warn('Parsed YAML content is not an object or is null.');
- return null;
- }
-
- if (envGetter) {
- return substituteVariablesInObject(parsedYaml, envGetter);
- }
- return parsedYaml as Record<string, any>;
- } catch (error) {
- console.error('Error parsing YAML content:', error);
- return null;
- }
-}
-
-// Helper function to recursively substitute variables in an object
-function substituteVariablesInObject(obj: any, envGetter: (key: string) => string | undefined): any {
- if (Array.isArray(obj)) {
- return obj.map((item) => substituteVariablesInObject(item, envGetter));
- } else if (typeof obj === 'object' && obj !== null) {
- const newObj: Record<string, any> = {};
- for (const key in obj) {
- if (Object.prototype.hasOwnProperty.call(obj, key)) {
- newObj[key] = substituteVariablesInObject(obj[key], envGetter);
- }
- }
- return newObj;
- } else if (typeof obj === 'string') {
- let S = obj;
- for (let i = 0; i < 10 && S.includes('${'); i++) {
- S = S.replace(/\$\{([^}]+)\}/g, (match, varName) => {
- const value = envGetter(varName);
- return value !== undefined ? value : match;
- });
- }
- if (S.includes('${')) {
- console.warn(`Unresolved variable or recursive substitution limit reached in string: "${obj}". Result: "${S}"`);
- }
- return S;
- }
- return obj;
-}
-
/**
* Creates all networks defined in the compose file
*/
@@ -1537,135 +1616,222 @@ async function pullImage(docker: Dockerode, imageTag: string): Promise<void> {
}
/**
- * Create and start all services
+ * Create and start all services with proper Docker Compose spec compliance
*/
async function createAndStartServices(docker: Dockerode, stackId: string, composeData: any, stackDir: string): Promise<void> {
- for (const [serviceName, serviceConfig] of Object.entries(composeData.services || {})) {
- const service = serviceConfig as any;
+ if (!composeData || !composeData.services) {
+ throw new Error(`No services defined in compose file for stack ${stackId}`);
+ }
- let containerName = service.container_name;
- if (!containerName || typeof containerName !== 'string') {
- containerName = `${stackId}_${serviceName}`;
+ // Note: composeData should already be filtered by profiles at this point
+ console.log(`Creating and starting ${Object.keys(composeData.services).length} services for stack ${stackId}`);
+
+ // Load environment variables for substitution
+ let envVars: Record<string, string> = {};
+ try {
+ const envContent = await loadEnvFile(stackId);
+ envVars = parseEnvContent(envContent);
+ } catch (envError) {
+ console.log(`No .env file found for stack ${stackId}, proceeding without env vars`);
+ }
+
+ const getEnvVar = (key: string): string | undefined => {
+ return envVars[key] || process.env[key];
+ };
+
+ // Substitute variables in the entire compose data
+ const processedComposeData = substituteVariablesInObject(composeData, getEnvVar);
+
+ // Resolve service dependency order for proper startup sequence
+ let serviceOrder: string[];
+ try {
+ const dependencyResolution = resolveDependencyOrderWithConditions(processedComposeData.services);
+ serviceOrder = dependencyResolution.order;
+
+ console.log(`Enhanced service startup order for stack ${stackId}: [${serviceOrder.join(', ')}]`);
+ console.log(`Service deployment batches:`, dependencyResolution.batches);
+
+ if (dependencyResolution.warnings.length > 0) {
+ console.warn(`Dependency order warnings for stack ${stackId}:`, dependencyResolution.warnings);
}
- if (containerName.includes('${')) {
- console.warn(`CRITICAL: Unresolved variable in container_name for service '${serviceName}': ${containerName}. Using default name: ${stackId}_${serviceName}`);
- containerName = `${stackId}_${serviceName}`;
+ } catch (depError) {
+ console.warn(`Could not resolve enhanced dependencies for stack ${stackId}, falling back to basic resolution:`, depError);
+ try {
+ serviceOrder = resolveDependencyOrder(processedComposeData.services);
+ } catch (basicDepError) {
+ console.warn(`Basic dependency resolution also failed, using alphabetical order:`, basicDepError);
+ serviceOrder = Object.keys(processedComposeData.services).sort();
}
+ }
- const containerConfig: any = {
- name: containerName,
- Image: service.image,
- User: service.user || '',
- Labels: {
- 'com.docker.compose.project': stackId,
- 'com.docker.compose.service': serviceName,
- ...service.labels
- },
- Env: await prepareEnvironmentVariables(service.environment, stackDir),
- HostConfig: {
- RestartPolicy: prepareRestartPolicy(service.restart),
- Binds: prepareVolumes(service.volumes),
- PortBindings: preparePorts(service.ports),
- Dns: service.dns || [],
- DnsOptions: service.dns_opt || [],
- DnsSearch: service.dns_search || []
+ // Before creating containers, create required volumes
+ const volumeDefinitions = createVolumeDefinitions(processedComposeData, stackId);
+ for (const volumeDef of volumeDefinitions) {
+ try {
+ console.log(`Creating volume: ${volumeDef.name}`);
+ await docker.createVolume({
+ Name: volumeDef.name,
+ ...volumeDef.config
+ });
+ console.log(`Successfully created volume: ${volumeDef.name}`);
+ } catch (createErr: any) {
+ if (createErr.statusCode === 409) {
+ console.log(`Volume ${volumeDef.name} already exists, reusing it.`);
+ } else {
+ console.error(`Error creating volume ${volumeDef.name}:`, createErr);
+ throw createErr;
}
- };
+ }
+ }
- const networkMode = service.network_mode || null;
- let primaryNetworkName = null;
- if (networkMode) {
- containerConfig.HostConfig.NetworkMode = networkMode;
- } else if (service.networks) {
- const serviceNetworks = Array.isArray(service.networks) ? service.networks : Object.keys(service.networks);
-
- if (serviceNetworks.length > 0) {
- const firstNetName = serviceNetworks[0];
- const networkDefinition = composeData.networks?.[firstNetName];
-
- let actualExternalNetIdentifier = firstNetName;
- if (networkDefinition?.external && networkDefinition.name) {
- if (typeof networkDefinition.name === 'string' && networkDefinition.name.includes('${') && networkDefinition.name.includes('}')) {
- console.warn(`External network key '${firstNetName}' has an unresolved variable in name attribute. Using key '${firstNetName}' as identifier.`);
- } else {
- actualExternalNetIdentifier = networkDefinition.name;
- }
- }
+ // Create and start services in dependency order
+ for (const serviceName of serviceOrder) {
+ const serviceConfig = processedComposeData.services[serviceName];
+ if (!serviceConfig) {
+ console.warn(`Service ${serviceName} not found in processed compose data, skipping`);
+ continue;
+ }
- primaryNetworkName = networkDefinition?.external ? actualExternalNetIdentifier : `${stackId}_${firstNetName}`;
- containerConfig.HostConfig.NetworkMode = primaryNetworkName;
- console.log(`Service ${serviceName} will use '${primaryNetworkName}' as primary network.`);
- }
+ console.log(`Creating service: ${serviceName}`);
+
+ // Validate image is present (required by spec)
+ if (!serviceConfig.image && !serviceConfig.build) {
+ throw new Error(`Service ${serviceName} must specify either 'image' or 'build'`);
}
- // Handle additional networks
- const networkingConfig: { EndpointsConfig?: any } = {};
- if (!networkMode && service.networks) {
- const serviceNetworks = Array.isArray(service.networks) ? service.networks : Object.keys(service.networks);
- const additionalNetworks = primaryNetworkName ? serviceNetworks.slice(1) : serviceNetworks;
+ // Enhanced dependency condition handling
+ if (serviceConfig.depends_on) {
+ const dependencyConfig = createDependencyWaitConfig(serviceName, serviceConfig);
- if (additionalNetworks.length > 0) {
- networkingConfig.EndpointsConfig = {};
+ if (dependencyConfig.warnings.length > 0) {
+ console.warn(`Dependency warnings for service ${serviceName}:`, dependencyConfig.warnings);
+ }
- for (const netName of additionalNetworks) {
- const serviceNetConfig = typeof service.networks === 'object' ? service.networks[netName] : {};
- const networkDefinition = composeData.networks?.[netName];
-
- let actualExternalNetIdentifier = netName;
- if (networkDefinition?.external && networkDefinition.name) {
- if (typeof networkDefinition.name === 'string' && networkDefinition.name.includes('${') && networkDefinition.name.includes('}')) {
- console.warn(`External network key '${netName}' in stack '${stackId}' has a 'name' attribute '${networkDefinition.name}' that appears to be an unresolved variable. Using the network key '${netName}' as the identifier for connection.`);
- } else {
- actualExternalNetIdentifier = networkDefinition.name;
- }
+ // Wait for all dependencies
+ for (const dep of dependencyConfig.dependencies) {
+ console.log(`Waiting for dependency: ${dep.service} (condition: ${dep.condition}, timeout: ${dep.timeout}ms)`);
+
+ try {
+ await waitForDependency(stackId, dep.service, dep.condition, dep.timeout, dep.restart);
+ } catch (depError) {
+ const errorMsg = `Failed to satisfy dependency '${dep.service}' for service '${serviceName}': ${depError instanceof Error ? depError.message : String(depError)}`;
+ console.error(errorMsg);
+
+ // For critical conditions, fail the deployment
+ if (dep.condition === 'service_healthy' || dep.condition === 'service_completed_successfully') {
+ throw new Error(errorMsg);
+ } else {
+ // For service_started, just warn and continue
+ console.warn(`Continuing deployment despite dependency failure: ${errorMsg}`);
}
- const fullNetworkName = networkDefinition?.external ? actualExternalNetIdentifier : `${stackId}_${netName}`;
+ }
+ }
+ }
- const endpointConfig: any = {};
+ // Continue with existing container creation logic...
+ // (Keep all the existing container configuration code from your current implementation)
- if (typeof serviceNetConfig === 'object' && serviceNetConfig.aliases) {
- endpointConfig.Aliases = serviceNetConfig.aliases;
- }
+ // Determine container name using Docker Compose convention
+ let containerName = serviceConfig.container_name;
+ if (!containerName || typeof containerName !== 'string') {
+ containerName = `${stackId}_${serviceName}_1`;
+ }
- if (typeof serviceNetConfig === 'object') {
- const ipamConfig: any = {};
+ // Validate container name doesn't have unresolved variables
+ if (containerName.includes('${')) {
+ console.warn(`CRITICAL: Unresolved variable in container_name for service '${serviceName}': ${containerName}. Using default name: ${stackId}_${serviceName}_1`);
+ containerName = `${stackId}_${serviceName}_1`;
+ }
- if (serviceNetConfig.ipv4_address) {
- ipamConfig.IPv4Address = serviceNetConfig.ipv4_address;
- }
+ // Continue with the rest of your existing container configuration...
+ // [Keep all existing containerConfig setup, networking, volume mounting, etc.]
+ // (I'm shortening this for brevity, but keep all your existing logic)
- if (serviceNetConfig.ipv6_address) {
- ipamConfig.IPv6Address = serviceNetConfig.ipv6_address;
- }
+ // Create the container configuration
+ const containerConfig: any = {
+ name: containerName,
+ Image: serviceConfig.image,
+ Labels: {
+ 'com.docker.compose.project': stackId,
+ 'com.docker.compose.service': serviceName,
+ 'com.docker.compose.config-hash': generateConfigHash(serviceConfig),
+ 'com.docker.compose.version': DEFAULT_COMPOSE_VERSION,
+ ...(serviceConfig.labels || {})
+ },
+ Env: await prepareEnvironmentVariables(serviceConfig.environment, stackDir),
+ HostConfig: {
+ RestartPolicy: prepareRestartPolicy(serviceConfig.restart),
+ Binds: prepareVolumes(serviceConfig.volumes, processedComposeData, stackId),
+ PortBindings: preparePorts(serviceConfig.ports),
+ Memory: serviceConfig.mem_limit ? parseMemory(serviceConfig.mem_limit) : undefined,
+ NanoCpus: serviceConfig.cpus ? Math.floor(parseFloat(serviceConfig.cpus) * 1_000_000_000) : undefined,
+ ExtraHosts: prepareExtraHosts(serviceConfig.extra_hosts),
+ Ulimits: prepareUlimits(serviceConfig.ulimits),
+ LogConfig: prepareLogConfig(serviceConfig.logging || {}), // Add logging configuration
+ Dns: serviceConfig.dns || [],
+ DnsOptions: serviceConfig.dns_opt || [],
+ DnsSearch: serviceConfig.dns_search || [],
+ CapAdd: serviceConfig.cap_add || [],
+ CapDrop: serviceConfig.cap_drop || [],
+ Privileged: serviceConfig.privileged || false,
+ ReadonlyRootfs: serviceConfig.read_only || false
+ }
+ };
- if (Object.keys(ipamConfig).length > 0) {
- endpointConfig.IPAMConfig = ipamConfig;
- }
- }
+ // Add command and entrypoint if specified
+ if (serviceConfig.command) {
+ containerConfig.Cmd = Array.isArray(serviceConfig.command) ? serviceConfig.command : [serviceConfig.command];
+ }
+ if (serviceConfig.entrypoint) {
+ containerConfig.Entrypoint = Array.isArray(serviceConfig.entrypoint) ? serviceConfig.entrypoint : [serviceConfig.entrypoint];
+ }
- networkingConfig.EndpointsConfig[fullNetworkName] = endpointConfig;
- }
+ // Add working directory, user, etc.
+ if (serviceConfig.working_dir) containerConfig.WorkingDir = serviceConfig.working_dir;
+ if (serviceConfig.user) containerConfig.User = serviceConfig.user;
+
+ // Handle networking
+ if (serviceConfig.network_mode) {
+ containerConfig.HostConfig.NetworkMode = serviceConfig.network_mode;
+ } else if (serviceConfig.networks) {
+ // Handle Docker Compose networks
+ const networks = Array.isArray(serviceConfig.networks) ? serviceConfig.networks : Object.keys(serviceConfig.networks);
+ if (networks.length > 0) {
+ const primaryNetwork = networks[0];
+ const networkDefinition = processedComposeData.networks?.[primaryNetwork];
+ const fullNetworkName = networkDefinition?.external ? networkDefinition.name || primaryNetwork : `${stackId}_${primaryNetwork}`;
+ containerConfig.HostConfig.NetworkMode = fullNetworkName;
}
}
+ // Add healthcheck if present
+ if (serviceConfig.healthcheck) {
+ containerConfig.Healthcheck = prepareHealthcheck(serviceConfig.healthcheck);
+ }
+
try {
+ console.log(`Creating container: ${containerName}`);
const container = await docker.createContainer(containerConfig);
console.log(`Successfully created container: ${containerName} (ID: ${container.id})`);
- if (networkingConfig.EndpointsConfig && Object.keys(networkingConfig.EndpointsConfig).length > 0) {
- for (const netNameKey of Object.keys(networkingConfig.EndpointsConfig)) {
+ // Connect to additional networks if needed
+ if (serviceConfig.networks && !serviceConfig.network_mode) {
+ const networks = Array.isArray(serviceConfig.networks) ? serviceConfig.networks : Object.keys(serviceConfig.networks);
+ const additionalNetworks = networks.slice(1); // Skip first network (already set as NetworkMode)
+
+ for (const netName of additionalNetworks) {
try {
- console.log(`Connecting container ${container.id} to network: ${netNameKey} with config:`, JSON.stringify(networkingConfig.EndpointsConfig[netNameKey]));
+ const networkDefinition = processedComposeData.networks?.[netName];
+ const fullNetworkName = networkDefinition?.external ? networkDefinition.name || netName : `${stackId}_${netName}`;
- const network = docker.getNetwork(netNameKey);
+ const network = docker.getNetwork(fullNetworkName);
await network.connect({
Container: container.id,
- EndpointConfig: networkingConfig.EndpointsConfig[netNameKey] || {}
+ EndpointConfig: {}
});
- console.log(`Successfully connected ${container.id} to network: ${netNameKey}`);
- } catch (netConnectErr) {
- console.error(`Error connecting container ${container.id} to network ${netNameKey}:`, netConnectErr);
- throw new Error(`Failed to connect container ${container.id} to network ${netNameKey}: ${netConnectErr instanceof Error ? netConnectErr.message : String(netConnectErr)}`);
+ console.log(`Connected container ${container.id} to network: ${fullNetworkName}`);
+ } catch (netErr) {
+ console.error(`Error connecting container to network ${netName}:`, netErr);
}
}
}
@@ -1674,10 +1840,12 @@ async function createAndStartServices(docker: Dockerode, stackId: string, compos
await container.start();
console.log(`Successfully started container: ${containerName}`);
} catch (createErr) {
- console.error(`Error creating/starting container for service ${serviceName} (${containerName}):`, createErr);
+ console.error(`Error creating/starting container for service ${serviceName}:`, createErr);
throw createErr;
}
}
+
+ console.log(`Successfully created and started all services for stack ${stackId}`);
}
/**
@@ -1721,7 +1889,7 @@ async function cleanupFailedDeployment(stackId: string): Promise<void> {
const containers = await docker.listContainers({
all: true,
filters: JSON.stringify({
- label: [`${composeProjectLabel}=${stackId}`]
+ label: [`com.docker.compose.project=${stackId}`]
})
});
@@ -1754,128 +1922,6 @@ async function cleanupFailedDeployment(stackId: string): Promise<void> {
}
}
-/**
- * Prepare environment variables for container creation
- */
-async function prepareEnvironmentVariables(environment: any, stackDir: string): Promise<string[]> {
- const envArray: string[] = [];
-
- if (Array.isArray(environment)) {
- // Handle array format: ['KEY=value', 'KEY2=value2']
- envArray.push(...environment);
- } else if (typeof environment === 'object' && environment !== null) {
- // Handle object format: { KEY: 'value', KEY2: 'value2' }
- for (const [key, value] of Object.entries(environment)) {
- envArray.push(`${key}=${value}`);
- }
- }
-
- // Load .env file and add variables if they don't already exist
- try {
- const envFilePath = path.join(stackDir, '.env');
- const envFileContent = await fs.readFile(envFilePath, 'utf8');
- const envVars = parseEnvContent(envFileContent);
-
- for (const [key, value] of Object.entries(envVars)) {
- // Only add if not already defined in compose environment
- const keyExists = envArray.some((env) => env.startsWith(`${key}=`));
- if (!keyExists) {
- envArray.push(`${key}=${value}`);
- }
- }
- } catch (envError) {
- // .env file doesn't exist or can't be read, that's okay
- }
-
- return envArray;
-}
-
-/**
- * Prepare restart policy for container
- */
-function prepareRestartPolicy(restart: string | undefined): any {
- if (!restart) {
- return { Name: 'no' };
- }
-
- switch (restart) {
- case 'always':
- return { Name: 'always' };
- case 'unless-stopped':
- return { Name: 'unless-stopped' };
- case 'on-failure':
- return { Name: 'on-failure', MaximumRetryCount: 0 };
- case 'no':
- return { Name: 'no' };
- default:
- // Handle on-failure:5 format
- if (restart.startsWith('on-failure:')) {
- const retryCount = parseInt(restart.split(':')[1]) || 0;
- return { Name: 'on-failure', MaximumRetryCount: retryCount };
- }
- return { Name: 'no' };
- }
-}
-
-/**
- * Prepare volumes for container
- */
-function prepareVolumes(volumes: any[]): string[] {
- if (!Array.isArray(volumes)) {
- return [];
- }
-
- return volumes
- .map((volume) => {
- if (typeof volume === 'string') {
- return volume;
- } else if (typeof volume === 'object' && volume.type === 'bind') {
- // Handle long format: { type: 'bind', source: '/host/path', target: '/container/path' }
- const readonly = volume.read_only ? ':ro' : '';
- return `${volume.source}:${volume.target}${readonly}`;
- }
- return '';
- })
- .filter((v) => v);
-}
-
-/**
- * Prepare port bindings for container
- */
-function preparePorts(ports: any[]): any {
- if (!Array.isArray(ports)) {
- return {};
- }
-
- const portBindings: any = {};
-
- for (const port of ports) {
- if (typeof port === 'string') {
- // Handle "8080:80" or "80" format
- const parts = port.split(':');
- if (parts.length === 2) {
- const [hostPort, containerPort] = parts;
- const containerPortKey = containerPort.includes('/') ? containerPort : `${containerPort}/tcp`;
- portBindings[containerPortKey] = [{ HostPort: hostPort }];
- } else if (parts.length === 1) {
- // Just container port, let Docker assign host port
- const containerPortKey = parts[0].includes('/') ? parts[0] : `${parts[0]}/tcp`;
- portBindings[containerPortKey] = [{}];
- }
- } else if (typeof port === 'object') {
- // Handle long format: { target: 80, published: 8080, protocol: 'tcp' }
- const containerPortKey = `${port.target}/${port.protocol || 'tcp'}`;
- if (port.published) {
- portBindings[containerPortKey] = [{ HostPort: port.published.toString() }];
- } else {
- portBindings[containerPortKey] = [{}];
- }
- }
- }
-
- return portBindings;
-}
-
/**
* Delete stack - removes from both database and files
*/
@@ -2031,66 +2077,6 @@ export async function getStackStats(stackId: string): Promise<any> {
}
}
-/**
- * Validate compose content
- */
-export function validateComposeContent(content: string): { valid: boolean; errors: string[] } {
- const errors: string[] = [];
-
- try {
- const parsed = yamlLoad(content);
-
- if (!parsed || typeof parsed !== 'object') {
- errors.push('Compose content must be a valid YAML object');
- return { valid: false, errors };
- }
-
- const compose = parsed as any;
-
- // Check for required version (optional but recommended)
- if (!compose.version && !compose.services) {
- errors.push('Compose file should have either a version field or services field');
- }
-
- // Check services
- if (!compose.services || typeof compose.services !== 'object') {
- errors.push('Compose file must have a services section');
- } else {
- // Validate each service
- for (const [serviceName, serviceConfig] of Object.entries(compose.services)) {
- const service = serviceConfig as any;
-
- if (!service.image && !service.build) {
- errors.push(`Service '${serviceName}' must have either an 'image' or 'build' field`);
- }
-
- // Check for common misconfigurations
- if (service.container_name && typeof service.container_name === 'string' && service.container_name.includes('${')) {
- errors.push(`Service '${serviceName}' has unresolved variables in container_name: ${service.container_name}`);
- }
- }
- }
-
- // Validate networks if present
- if (compose.networks && typeof compose.networks === 'object') {
- for (const [networkName, networkConfig] of Object.entries(compose.networks)) {
- const network = networkConfig as any;
-
- if (network.external && !network.name && typeof networkName !== 'string') {
- errors.push(`External network '${networkName}' should have a name field`);
- }
- }
- }
- } catch (parseError) {
- errors.push(`YAML parsing error: ${parseError instanceof Error ? parseError.message : String(parseError)}`);
- }
-
- return {
- valid: errors.length === 0,
- errors
- };
-}
-
/**
* Export stack configuration
*/
@@ -2332,4 +2318,392 @@ export class StackRuntimeUpdater {
}
}
+/**
+ * Enhanced dependency waiting with support for all Docker Compose conditions
+ */
+async function waitForDependency(stackId: string, depServiceName: string, condition: string = 'service_started', timeout: number = 30000, restart: boolean = false): Promise<void> {
+ const docker = await getDockerClient();
+ const pollInterval = 1000; // 1 second
+ const startTime = Date.now();
+
+ console.log(`Waiting for dependency '${depServiceName}' with condition '${condition}' for stack ${stackId} (timeout: ${timeout}ms)`);
+
+ while (Date.now() - startTime < timeout) {
+ try {
+ // Find the dependency container
+ const containers = await docker.listContainers({
+ all: true,
+ filters: JSON.stringify({
+ label: [`com.docker.compose.project=${stackId}`, `com.docker.compose.service=${depServiceName}`]
+ })
+ });
+
+ if (containers.length === 0) {
+ // If no container found, wait a bit more
+ await new Promise((resolve) => setTimeout(resolve, pollInterval));
+ continue;
+ }
+
+ const depContainer = containers[0];
+ const conditionMet = await checkDependencyCondition(docker, depContainer, condition);
+
+ if (conditionMet.satisfied) {
+ console.log(`Dependency '${depServiceName}' satisfied condition '${condition}': ${conditionMet.reason}`);
+ return;
+ }
+
+ // If condition not met and restart is enabled, check if we need to restart
+ if (restart && conditionMet.shouldRestart) {
+ console.log(`Restarting dependency '${depServiceName}' due to: ${conditionMet.reason}`);
+ try {
+ const container = docker.getContainer(depContainer.Id);
+ await container.restart();
+ console.log(`Restarted dependency container '${depServiceName}'`);
+ } catch (restartError) {
+ console.warn(`Failed to restart dependency '${depServiceName}':`, restartError);
+ }
+ }
+
+ // Wait before next poll
+ await new Promise((resolve) => setTimeout(resolve, pollInterval));
+ } catch (error) {
+ console.warn(`Error checking dependency ${depServiceName}:`, error);
+ await new Promise((resolve) => setTimeout(resolve, pollInterval));
+ }
+ }
+
+ // Timeout reached
+ const message = `Timeout waiting for dependency '${depServiceName}' with condition '${condition}' for stack ${stackId} (${timeout}ms)`;
+ console.warn(message);
+
+ // For health and completion conditions, this might be more critical
+ if (condition === 'service_healthy' || condition === 'service_completed_successfully') {
+ throw new Error(message);
+ }
+
+ // For service_started, just warn - Docker Compose is sometimes lenient
+}
+
+/**
+ * Check if a dependency condition is satisfied
+ */
+async function checkDependencyCondition(docker: Dockerode, containerInfo: any, condition: string): Promise<{ satisfied: boolean; reason: string; shouldRestart: boolean }> {
+ switch (condition) {
+ case 'service_started':
+ return {
+ satisfied: containerInfo.State === 'running',
+ reason: containerInfo.State === 'running' ? 'Container is running' : `Container state: ${containerInfo.State}`,
+ shouldRestart: false
+ };
+
+ case 'service_healthy':
+ if (containerInfo.State !== 'running') {
+ return {
+ satisfied: false,
+ reason: `Container not running (state: ${containerInfo.State})`,
+ shouldRestart: containerInfo.State === 'exited'
+ };
+ }
+
+ try {
+ const container = docker.getContainer(containerInfo.Id);
+ const details = await container.inspect();
+
+ if (!details.State.Health) {
+ // No healthcheck defined, but container is running
+ return {
+ satisfied: true,
+ reason: 'No healthcheck defined, considering running container as healthy',
+ shouldRestart: false
+ };
+ }
+
+ const healthStatus = details.State.Health.Status;
+ const isHealthy = healthStatus === 'healthy';
+
+ return {
+ satisfied: isHealthy,
+ reason: `Health status: ${healthStatus}${details.State.Health.Log ? ` (last check: ${details.State.Health.Log[details.State.Health.Log.length - 1]?.Output?.trim() || 'no output'})` : ''}`,
+ shouldRestart: healthStatus === 'unhealthy'
+ };
+ } catch (inspectError) {
+ return {
+ satisfied: false,
+ reason: `Failed to inspect container: ${inspectError instanceof Error ? inspectError.message : String(inspectError)}`,
+ shouldRestart: false
+ };
+ }
+
+ case 'service_completed_successfully':
+ if (containerInfo.State === 'exited') {
+ try {
+ const container = docker.getContainer(containerInfo.Id);
+ const details = await container.inspect();
+ const exitCode = details.State.ExitCode;
+
+ return {
+ satisfied: exitCode === 0,
+ reason: `Container exited with code ${exitCode}`,
+ shouldRestart: exitCode !== 0
+ };
+ } catch (inspectError) {
+ return {
+ satisfied: false,
+ reason: `Failed to inspect exited container: ${inspectError instanceof Error ? inspectError.message : String(inspectError)}`,
+ shouldRestart: false
+ };
+ }
+ } else if (containerInfo.State === 'running') {
+ return {
+ satisfied: false,
+ reason: 'Container is still running, waiting for completion',
+ shouldRestart: false
+ };
+ } else {
+ return {
+ satisfied: false,
+ reason: `Container in unexpected state for completion check: ${containerInfo.State}`,
+ shouldRestart: true
+ };
+ }
+
+ default:
+ return {
+ satisfied: false,
+ reason: `Unknown dependency condition: ${condition}`,
+ shouldRestart: false
+ };
+ }
+}
+
export const stackRuntimeUpdater = new StackRuntimeUpdater();
+
+/**
+ * Add new function to get profile information for a stack
+ */
+export async function getStackProfiles(stackId: string): Promise<{
+ allProfiles: string[];
+ stats: ReturnType<typeof getProfileUsageStats>;
+ help: string;
+}> {
+ try {
+ const composePath = await getComposeFilePath(stackId);
+ if (!composePath) {
+ throw new Error(`Compose file not found for stack ${stackId}`);
+ }
+
+ const composeContent = await fs.readFile(composePath, 'utf8');
+ const envContent = await loadEnvFile(stackId);
+
+ const envVars = parseEnvContent(envContent);
+ const getEnvVar = (key: string): string | undefined => envVars[key] || process.env[key];
+
+ const composeData = parseYamlContent(composeContent, getEnvVar);
+
+ if (!composeData) {
+ throw new Error(`Failed to parse compose file for stack ${stackId}`);
+ }
+
+ const allProfiles = getAllDefinedProfiles(composeData);
+ const stats = getProfileUsageStats(composeData);
+ const help = generateProfileHelp(composeData);
+
+ return {
+ allProfiles,
+ stats,
+ help
+ };
+ } catch (error) {
+ console.error(`Error getting profiles for stack ${stackId}:`, error);
+ throw error;
+ }
+}
+
+/**
+ * Add function to preview deployment with profiles
+ */
+export async function previewStackDeployment(
+ stackId: string,
+ profiles: string[] = []
+): Promise<{
+ deploymentPlan: ReturnType<typeof createProfileDeploymentPlan>;
+ profileInfo: Awaited<ReturnType<typeof getStackProfiles>>;
+}> {
+ try {
+ const composePath = await getComposeFilePath(stackId);
+ if (!composePath) {
+ throw new Error(`Compose file not found for stack ${stackId}`);
+ }
+
+ const composeContent = await fs.readFile(composePath, 'utf8');
+ const envContent = await loadEnvFile(stackId);
+
+ const envVars = parseEnvContent(envContent);
+ const getEnvVar = (key: string): string | undefined => envVars[key] || process.env[key];
+
+ const composeData = parseYamlContent(composeContent, getEnvVar);
+
+ if (!composeData) {
+ throw new Error(`Failed to parse compose file for stack ${stackId}`);
+ }
+
+ const activeProfiles = profiles.length ? profiles : parseActiveProfiles([], envVars);
+ const deploymentPlan = createProfileDeploymentPlan(composeData, activeProfiles);
+ const profileInfo = await getStackProfiles(stackId);
+
+ return {
+ deploymentPlan,
+ profileInfo
+ };
+ } catch (error) {
+ console.error(`Error previewing deployment for stack ${stackId}:`, error);
+ throw error;
+ }
+}
+
+/**
+ * Add function to detect configuration changes using hash comparison
+ */
+export async function detectStackChanges(stackId: string): Promise<{
+ hasChanges: boolean;
+ changedServices: string[];
+ newServices: string[];
+ removedServices: string[];
+}> {
+ try {
+ const composePath = await getComposeFilePath(stackId);
+ if (!composePath) {
+ throw new Error(`Compose file not found for stack ${stackId}`);
+ }
+
+ const composeContent = await fs.readFile(composePath, 'utf8');
+ const envContent = await loadEnvFile(stackId);
+
+ const envVars = parseEnvContent(envContent);
+ const getEnvVar = (key: string): string | undefined => envVars[key] || process.env[key];
+
+ const composeData = parseYamlContent(composeContent, getEnvVar);
+ if (!composeData || !composeData.services) {
+ return { hasChanges: false, changedServices: [], newServices: [], removedServices: [] };
+ }
+
+ // Get current running containers
+ const docker = await getDockerClient();
+ const containers = await docker.listContainers({
+ all: true,
+ filters: JSON.stringify({
+ label: [`com.docker.compose.project=${stackId}`]
+ })
+ });
+
+ const runningServices = new Map<string, string>(); // service -> config hash
+ for (const container of containers) {
+ const serviceName = container.Labels?.['com.docker.compose.service'];
+ const configHash = container.Labels?.['com.docker.compose.config-hash'];
+ if (serviceName && configHash) {
+ runningServices.set(serviceName, configHash);
+ }
+ }
+
+ const changedServices: string[] = [];
+ const newServices: string[] = [];
+ const currentServices = new Set<string>();
+
+ // Check each service in compose file
+ for (const [serviceName, serviceConfig] of Object.entries(composeData.services)) {
+ currentServices.add(serviceName);
+ const currentHash = generateConfigHash(serviceConfig);
+
+ if (runningServices.has(serviceName)) {
+ const runningHash = runningServices.get(serviceName);
+ if (runningHash !== currentHash) {
+ changedServices.push(serviceName);
+ }
+ } else {
+ newServices.push(serviceName);
+ }
+ }
+
+ // Find removed services
+ const removedServices = Array.from(runningServices.keys()).filter((service) => !currentServices.has(service));
+
+ const hasChanges = changedServices.length > 0 || newServices.length > 0 || removedServices.length > 0;
+
+ return {
+ hasChanges,
+ changedServices,
+ newServices,
+ removedServices
+ };
+ } catch (error) {
+ console.error(`Error detecting changes for stack ${stackId}:`, error);
+ throw error;
+ }
+}
+
+/**
+ * Add function to validate stack before deployment
+ */
+export async function validateStackConfiguration(stackId: string): Promise<{
+ valid: boolean;
+ errors: string[];
+ warnings: string[];
+}> {
+ try {
+ const composePath = await getComposeFilePath(stackId);
+ if (!composePath) {
+ return {
+ valid: false,
+ errors: ['Compose file not found'],
+ warnings: []
+ };
+ }
+
+ const composeContent = await fs.readFile(composePath, 'utf8');
+ const envContent = await loadEnvFile(stackId);
+
+ const envVars = parseEnvContent(envContent);
+ const getEnvVar = (key: string): string | undefined => envVars[key] || process.env[key];
+
+ // Validate compose content format
+ const contentValidation = validateComposeContent(composeContent);
+ if (!contentValidation.valid) {
+ return {
+ valid: false,
+ errors: contentValidation.errors,
+ warnings: contentValidation.warnings
+ };
+ }
+
+ const composeData = parseYamlContent(composeContent, getEnvVar);
+ if (!composeData) {
+ return {
+ valid: false,
+ errors: ['Failed to parse compose file'],
+ warnings: []
+ };
+ }
+
+ // Validate compose structure
+ const structureValidation = validateComposeStructure(composeData);
+
+ // Validate dependencies
+ const dependencyValidation = composeData.services ? validateAllDependencies(composeData.services) : { valid: true, errors: [], warnings: [] };
+
+ const allErrors = [...contentValidation.errors, ...structureValidation.errors, ...dependencyValidation.errors];
+
+ const allWarnings = [...contentValidation.warnings, ...structureValidation.warnings, ...dependencyValidation.warnings];
+
+ return {
+ valid: allErrors.length === 0,
+ errors: allErrors,
+ warnings: allWarnings
+ };
+ } catch (error) {
+ return {
+ valid: false,
+ errors: [`Validation failed: ${error instanceof Error ? error.message : String(error)}`],
+ warnings: []
+ };
+ }
+}
diff --git a/src/lib/utils/compose.utils.ts b/src/lib/utils/compose.utils.ts
new file mode 100644
index 000000000..a84c53ccf
--- /dev/null
+++ b/src/lib/utils/compose.utils.ts
@@ -0,0 +1,2093 @@
+import { load as yamlLoad, dump as yamlDump } from 'js-yaml';
+import { promises as fs, existsSync } from 'node:fs';
+import * as path from 'node:path';
+
+// Compose specification constants
+export const SUPPORTED_COMPOSE_VERSIONS = ['3.0', '3.1', '3.2', '3.3', '3.4', '3.5', '3.6', '3.7', '3.8', '3.9'];
+export const DEFAULT_COMPOSE_VERSION = '3.8';
+
+/**
+ * Docker Compose profile-related types
+ */
+export interface ProfileConfig {
+ description?: string;
+ depends_on?: string[];
+ conflicts?: string[];
+}
+
+export interface ServiceProfile {
+ service: string;
+ profiles: string[];
+}
+
+export interface ProfileDeploymentCheck {
+ shouldDeploy: boolean;
+ reason: string;
+}
+
+export interface ProfileServiceFiltering {
+ deployableServices: Record<string, any>;
+ skippedServices: Array<{ name: string; reason: string }>;
+ profileSummary: {
+ totalServices: number;
+ deployableServices: number;
+ skippedServices: number;
+ activeProfiles: string[];
+ };
+}
+
+export interface ProfileResolution {
+ resolvedProfiles: string[];
+ warnings: string[];
+ errors: string[];
+}
+
+export interface ProfileDeploymentPlan {
+ plan: {
+ servicesToDeploy: string[];
+ servicesToSkip: Array<{ name: string; reason: string }>;
+ volumesToCreate: string[];
+ networksToCreate: string[];
+ };
+ summary: {
+ totalServices: number;
+ deployableServices: number;
+ skippedServices: number;
+ activeProfiles: string[];
+ allDefinedProfiles: string[];
+ };
+ warnings: string[];
+ errors: string[];
+}
+
+export interface ProfileUsageStats {
+ totalProfiles: number;
+ profilesWithServices: Array<{ profile: string; serviceCount: number; services: string[] }>;
+ servicesWithoutProfiles: string[];
+ servicesWithProfiles: ServiceProfile[];
+}
+
+export interface ComposeData {
+ version?: string;
+ services?: Record<string, ServiceConfig>;
+ volumes?: Record<string, VolumeConfig>;
+ networks?: Record<string, NetworkConfig>;
+ profiles?: Record<string, ProfileConfig> | string[];
+ [key: string]: any;
+}
+
+export interface ServiceConfig {
+ image?: string;
+ build?: string | BuildConfig;
+ profiles?: string | string[];
+ depends_on?: string[] | Record<string, DependencyConfig>;
+ volumes?: VolumeMount[];
+ networks?: string[] | Record<string, NetworkServiceConfig>;
+ ports?: PortMapping[];
+ environment?: string[] | Record<string, string>;
+ healthcheck?: HealthcheckConfig;
+ restart?: string;
+ [key: string]: any;
+}
+
+export interface VolumeConfig {
+ driver?: string;
+ driver_opts?: Record<string, string>;
+ external?: boolean | { name: string };
+ labels?: Record<string, string>;
+ [key: string]: any;
+}
+
+export interface NetworkConfig {
+ driver?: string;
+ driver_opts?: Record<string, string>;
+ external?: boolean | { name: string };
+ labels?: Record<string, string>;
+ [key: string]: any;
+}
+
+export interface BuildConfig {
+ context: string;
+ dockerfile?: string;
+ args?: Record<string, string>;
+ [key: string]: any;
+}
+
+export interface DependencyConfig {
+ condition?: 'service_started' | 'service_healthy' | 'service_completed_successfully';
+ restart?: boolean;
+}
+
+export interface NetworkServiceConfig {
+ aliases?: string[];
+ ipv4_address?: string;
+ ipv6_address?: string;
+ [key: string]: any;
+}
+
+export interface VolumeMount {
+ type?: 'bind' | 'volume' | 'tmpfs';
+ source?: string;
+ target: string;
+ read_only?: boolean;
+ consistency?: 'cached' | 'delegated' | 'consistent';
+ bind?: {
+ propagation?: 'shared' | 'slave' | 'private' | 'rshared' | 'rslave' | 'rprivate';
+ create_host_path?: boolean;
+ };
+ volume?: {
+ nocopy?: boolean;
+ };
+ tmpfs?: {
+ size?: string | number;
+ mode?: string | number;
+ uid?: number;
+ gid?: number;
+ noexec?: boolean;
+ nosuid?: boolean;
+ nodev?: boolean;
+ };
+}
+
+export interface PortMapping {
+ target: number;
+ published?: number;
+ protocol?: 'tcp' | 'udp';
+ mode?: 'host' | 'ingress';
+ host_ip?: string;
+}
+
+export interface HealthcheckConfig {
+ test?: string | string[];
+ interval?: string;
+ timeout?: string;
+ retries?: number;
+ start_period?: string;
+ disable?: boolean;
+}
+
+/**
+ * Parse environment file content with proper .env spec support
+ */
+export function parseEnvContent(envContent: string | null): Record<string, string> {
+ const envVars: Record<string, string> = {};
+ if (envContent) {
+ const lines = envContent.split('\n');
+ for (let i = 0; i < lines.length; i++) {
+ const line = lines[i].trim();
+
+ // Skip empty lines and comments
+ if (!line || line.startsWith('#')) continue;
+
+ // Handle quoted values and escaping
+ const equalIndex = line.indexOf('=');
+ if (equalIndex === -1) continue;
+
+ const key = line.substring(0, equalIndex).trim();
+ let value = line.substring(equalIndex + 1);
+
+ // Handle quoted values
+ if ((value.startsWith('"') && value.endsWith('"')) || (value.startsWith("'") && value.endsWith("'"))) {
+ value = value.slice(1, -1);
+ // Handle escaped quotes within double quotes
+ if (value.includes('\\"')) {
+ value = value.replace(/\\"/g, '"');
+ }
+ if (value.includes("\\'")) {
+ value = value.replace(/\\'/g, "'");
+ }
+ }
+
+ // Handle special characters and newlines
+ value = value.replace(/\\n/g, '\n').replace(/\\t/g, '\t');
+
+ if (key) {
+ envVars[key] = value;
+ }
+ }
+ }
+ return envVars;
+}
+
+/**
+ * Validate compose file version and structure according to spec
+ */
+export function validateComposeStructure(composeData: ComposeData): { valid: boolean; errors: string[]; warnings: string[] } {
+ const errors: string[] = [];
+ const warnings: string[] = [];
+
+ if (!composeData || typeof composeData !== 'object') {
+ errors.push('Compose file must be a valid YAML object');
+ return { valid: false, errors, warnings };
+ }
+
+ // Check version
+ if (composeData.version) {
+ if (!SUPPORTED_COMPOSE_VERSIONS.includes(composeData.version)) {
+ warnings.push(`Compose version ${composeData.version} may not be fully supported. Supported versions: ${SUPPORTED_COMPOSE_VERSIONS.join(', ')}`);
+ }
+ } else {
+ warnings.push('No version specified in compose file. Consider adding a version field.');
+ }
+
+ // Services are required
+ if (!composeData.services || typeof composeData.services !== 'object') {
+ errors.push('Compose file must have a services section');
+ return { valid: false, errors, warnings };
+ }
+
+ // Validate each service
+ for (const [serviceName, serviceConfig] of Object.entries(composeData.services)) {
+ // Each service must have image or build
+ if (!serviceConfig.image && !serviceConfig.build) {
+ errors.push(`Service '${serviceName}' must have either 'image' or 'build' field`);
+ }
+
+ // Validate service name format
+ if (!/^[a-zA-Z0-9._-]+$/.test(serviceName)) {
+ errors.push(`Service name '${serviceName}' contains invalid characters. Use only letters, numbers, dots, hyphens, and underscores.`);
+ }
+
+ // Validate depends_on
+ if (serviceConfig.depends_on) {
+ if (Array.isArray(serviceConfig.depends_on)) {
+ for (const dep of serviceConfig.depends_on) {
+ if (!composeData.services[dep]) {
+ errors.push(`Service '${serviceName}' depends on '${dep}' which doesn't exist`);
+ }
+ }
+ } else if (typeof serviceConfig.depends_on === 'object') {
+ for (const dep of Object.keys(serviceConfig.depends_on)) {
+ if (!composeData.services[dep]) {
+ errors.push(`Service '${serviceName}' depends on '${dep}' which doesn't exist`);
+ }
+ }
+ }
+ }
+
+ // Validate networks
+ if (serviceConfig.networks) {
+ if (Array.isArray(serviceConfig.networks)) {
+ for (const network of serviceConfig.networks) {
+ if (typeof network === 'string' && composeData.networks && !composeData.networks[network]) {
+ warnings.push(`Service '${serviceName}' references network '${network}' which is not defined`);
+ }
+ }
+ } else if (typeof serviceConfig.networks === 'object') {
+ for (const network of Object.keys(serviceConfig.networks)) {
+ if (composeData.networks && !composeData.networks[network]) {
+ warnings.push(`Service '${serviceName}' references network '${network}' which is not defined`);
+ }
+ }
+ }
+ }
+
+ // Validate volumes
+ if (serviceConfig.volumes) {
+ for (const volume of serviceConfig.volumes) {
+ if (typeof volume === 'object' && volume.source && volume.type === 'volume') {
+ if (composeData.volumes && !composeData.volumes[volume.source]) {
+ warnings.push(`Service '${serviceName}' references volume '${volume.source}' which is not defined`);
+ }
+ }
+ }
+ }
+
+ // Validate ports format
+ if (serviceConfig.ports) {
+ for (const port of serviceConfig.ports) {
+ if (typeof port === 'string') {
+ const portRegex = /^(\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3}:)?(\d+:)?\d+(\/[a-z]+)?$/;
+ if (!portRegex.test(port)) {
+ errors.push(`Service '${serviceName}' has invalid port format: '${port}'`);
+ }
+ }
+ }
+ }
+ }
+
+ // Validate networks section
+ if (composeData.networks) {
+ for (const [networkName, networkConfig] of Object.entries(composeData.networks)) {
+ // ADD NULL CHECK HERE
+ if (!networkConfig) {
+ continue; // Skip null/undefined network configs
+ }
+
+ if (networkConfig.external && typeof networkConfig.external === 'object' && !networkConfig.external.name) {
+ warnings.push(`External network '${networkName}' should have a name specified`);
+ }
+
+ if (networkConfig.driver && !['bridge', 'host', 'overlay', 'macvlan', 'none'].includes(networkConfig.driver)) {
+ warnings.push(`Network '${networkName}' uses uncommon driver '${networkConfig.driver}'`);
+ }
+ }
+ }
+
+ // Validate volumes section
+ if (composeData.volumes) {
+ for (const [volumeName, volumeConfig] of Object.entries(composeData.volumes)) {
+ // ADD NULL CHECK HERE TOO
+ if (!volumeConfig) {
+ continue; // Skip null/undefined volume configs
+ }
+
+ if (volumeConfig.external && typeof volumeConfig.external === 'object' && !volumeConfig.external.name) {
+ warnings.push(`External volume '${volumeName}' should have a name specified`);
+ }
+ }
+ }
+
+ return {
+ valid: errors.length === 0,
+ errors,
+ warnings
+ };
+}
+
+/**
+ * Normalize healthcheck according to Compose spec
+ */
+export function normalizeHealthcheckTest(composeContent: string, envGetter?: (key: string) => string | undefined): string {
+ let doc: any;
+ try {
+ doc = yamlLoad(composeContent);
+ if (!doc || typeof doc !== 'object') {
+ return composeContent;
+ }
+ } catch (e) {
+ console.warn('Could not parse compose YAML for normalization:', e);
+ return composeContent;
+ }
+
+ let modified = false;
+
+ if (doc.services && typeof doc.services === 'object') {
+ for (const serviceName in doc.services) {
+ const service = doc.services[serviceName];
+ if (service?.healthcheck) {
+ // Normalize healthcheck test format
+ if (service.healthcheck.test) {
+ if (typeof service.healthcheck.test === 'string') {
+ if (service.healthcheck.test.startsWith('CMD-SHELL ')) {
+ service.healthcheck.test = ['CMD-SHELL', service.healthcheck.test.substring(11)];
+ } else if (service.healthcheck.test.startsWith('CMD ')) {
+ service.healthcheck.test = service.healthcheck.test.substring(4).split(' ');
+ service.healthcheck.test.unshift('CMD');
+ } else if (!service.healthcheck.test.startsWith('NONE')) {
+ service.healthcheck.test = ['CMD-SHELL', service.healthcheck.test];
+ }
+ modified = true;
+ } else if (Array.isArray(service.healthcheck.test)) {
+ if (service.healthcheck.test.length > 0 && !['CMD', 'CMD-SHELL', 'NONE'].includes(service.healthcheck.test[0])) {
+ service.healthcheck.test.unshift('CMD');
+ modified = true;
+ }
+ }
+ }
+
+ // Normalize interval, timeout, start_period, retries
+ if (service.healthcheck.interval && typeof service.healthcheck.interval === 'number') {
+ service.healthcheck.interval = `${service.healthcheck.interval}s`;
+ modified = true;
+ }
+ if (service.healthcheck.timeout && typeof service.healthcheck.timeout === 'number') {
+ service.healthcheck.timeout = `${service.healthcheck.timeout}s`;
+ modified = true;
+ }
+ if (service.healthcheck.start_period && typeof service.healthcheck.start_period === 'number') {
+ service.healthcheck.start_period = `${service.healthcheck.start_period}s`;
+ modified = true;
+ }
+ }
+ }
+ }
+
+ // Perform variable substitution if envGetter is provided
+ if (envGetter) {
+ const originalDocSnapshot = JSON.stringify(doc);
+ doc = substituteVariablesInObject(doc, envGetter);
+ if (JSON.stringify(doc) !== originalDocSnapshot) {
+ modified = true;
+ }
+ }
+
+ if (modified) {
+ return yamlDump(doc, { lineWidth: -1, quotingType: '"', forceQuotes: false });
+ }
+ return composeContent;
+}
+
+/**
+ * Parse YAML content with proper Compose spec validation
+ */
+export function parseYamlContent(content: string, envGetter?: (key: string) => string | undefined): ComposeData | null {
+ try {
+ const parsedYaml = yamlLoad(content);
+
+ if (!parsedYaml || typeof parsedYaml !== 'object') {
+ console.warn('Parsed YAML content is not an object or is null.');
+ return null;
+ }
+
+ // Validate structure
+ const validation = validateComposeStructure(parsedYaml as ComposeData);
+ if (!validation.valid) {
+ console.error('Compose validation errors:', validation.errors);
+ }
+ if (validation.warnings.length > 0) {
+ console.warn('Compose validation warnings:', validation.warnings);
+ }
+
+ let result = parsedYaml as ComposeData;
+
+ // Apply environment variable substitution
+ if (envGetter) {
+ result = substituteVariablesInObject(result, envGetter) as ComposeData;
+ }
+
+ // Ensure we have a default network if none specified
+ if (!result.networks) {
+ result.networks = {
+ default: {
+ driver: 'bridge'
+ }
+ };
+ }
+
+ return result;
+ } catch (error) {
+ console.error('Error parsing YAML content:', error);
+ return null;
+ }
+}
+
+/**
+ * Enhanced variable substitution with Compose spec compliance
+ */
+export function substituteVariablesInObject(obj: any, envGetter: (key: string) => string | undefined): any {
+ if (Array.isArray(obj)) {
+ return obj.map((item) => substituteVariablesInObject(item, envGetter));
+ } else if (typeof obj === 'object' && obj !== null) {
+ const newObj: Record<string, any> = {};
+ for (const key in obj) {
+ if (Object.prototype.hasOwnProperty.call(obj, key)) {
+ newObj[key] = substituteVariablesInObject(obj[key], envGetter);
+ }
+ }
+ return newObj;
+ } else if (typeof obj === 'string') {
+ let result = obj;
+
+ // Handle ${VAR} format
+ result = result.replace(/\$\{([^}]+)\}/g, (match, varExpression) => {
+ // Handle default values: ${VAR:-default} or ${VAR-default}
+ const colonDefaultMatch = varExpression.match(/^([^:]+):-(.*)$/);
+ const defaultMatch = varExpression.match(/^([^-]+)-(.*)$/);
+
+ if (colonDefaultMatch) {
+ const [, varName, defaultValue] = colonDefaultMatch;
+ const value = envGetter(varName);
+ return value !== undefined && value !== '' ? value : defaultValue;
+ } else if (defaultMatch) {
+ const [, varName, defaultValue] = defaultMatch;
+ const value = envGetter(varName);
+ return value !== undefined ? value : defaultValue;
+ } else {
+ // Simple variable substitution
+ const value = envGetter(varExpression);
+ return value !== undefined ? value : match; // Keep original if not found
+ }
+ });
+
+ // Handle $VAR format (without braces)
+ result = result.replace(/\$([A-Z_][A-Z0-9_]*)/g, (match, varName) => {
+ const value = envGetter(varName);
+ return value !== undefined ? value : match;
+ });
+
+ return result;
+ }
+ return obj;
+}
+
+/**
+ * Enhanced volume preparation with full Docker Compose specification support
+ * Handles short syntax, long syntax, bind mounts, named volumes, tmpfs, and all volume options
+ */
+export function prepareVolumes(volumes: any[], composeData: any, stackId: string): string[] {
+ if (!Array.isArray(volumes)) {
+ return [];
+ }
+
+ const binds: string[] = [];
+ const tmpfsMounts: string[] = [];
+
+ for (const volume of volumes) {
+ if (typeof volume === 'string') {
+ // Short syntax: "source:target" or "source:target:mode"
+ const bind = processShortVolumeString(volume, composeData, stackId);
+ if (bind) binds.push(bind);
+ } else if (typeof volume === 'object' && volume !== null) {
+ // Long syntax object
+ const result = processLongVolumeObject(volume, composeData, stackId);
+ if (result.bind) binds.push(result.bind);
+ if (result.tmpfs) tmpfsMounts.push(result.tmpfs);
+ }
+ }
+
+ // Note: tmpfs mounts need to be handled separately in container creation
+ // For now, we'll store them in a way that can be retrieved later
+ return binds.filter(Boolean);
+}
+
+/**
+ * Process short volume syntax strings
+ * Examples: "/host/path:/container/path", "volume-name:/data", "/path:/data:ro"
+ */
+function processShortVolumeString(volumeString: string, composeData: any, stackId: string): string | null {
+ const parts = volumeString.split(':');
+
+ if (parts.length < 2) {
+ console.warn(`Invalid volume syntax: ${volumeString}. Expected at least "source:target"`);
+ return null;
+ }
+
+ let source = parts[0];
+ const target = parts[1];
+ const options = parts.slice(2);
+
+ // Convert relative paths to absolute paths
+ if (source.startsWith('./') || source.startsWith('../')) {
+ source = path.resolve(process.cwd(), source);
+ }
+
+ // Check if this is a bind mount and validate source exists
+ if (source.startsWith('/') || source.includes('/')) {
+ // This is a bind mount - check if source exists
+ if (!existsSync(source)) {
+ console.warn(`Bind mount source does not exist: ${source}`);
+ console.warn(`Skipping volume mount: ${volumeString}`);
+ console.warn(`Make sure to create the file/directory before deploying the stack`);
+ return null;
+ }
+
+ // Bind mount
+ return formatBindMount(source, target, options);
+ } else {
+ // Named volume logic...
+ const isNamedVolume = composeData.volumes && composeData.volumes[source];
+
+ if (isNamedVolume || !source.includes('/')) {
+ const volumeName = `${stackId}_${source}`;
+ return formatVolumeMount(volumeName, target, options);
+ } else {
+ return formatBindMount(source, target, options);
+ }
+ }
+}
+
+/**
+ * Process long volume syntax objects
+ * Supports all Docker Compose volume options
+ */
+function processLongVolumeObject(volume: any, composeData: any, stackId: string): { bind?: string; tmpfs?: string } {
+ const { type, source, target, read_only, consistency, bind, volume: volumeOpts, tmpfs } = volume;
+
+ if (!target) {
+ console.warn(`Volume missing required 'target' field:`, volume);
+ return {};
+ }
+
+ switch (type) {
+ case 'bind':
+ return { bind: processBindMount(source, target, { read_only, consistency, bind }) };
+
+ case 'volume':
+ return { bind: processVolumeMount(source, target, stackId, composeData, { read_only, volume: volumeOpts }) };
+
+ case 'tmpfs':
+ return { tmpfs: processTmpfsMount(target, { tmpfs }) };
+
+ default:
+ console.warn(`Unsupported volume type: ${type}`);
+ return {};
+ }
+}
+
+/**
+ * Process bind mount with all options
+ */
+function processBindMount(source: string, target: string, options: any = {}): string {
+ if (!source) {
+ throw new Error('Bind mount requires a source path');
+ }
+
+ const parts = [source, target];
+ const mountOptions: string[] = [];
+
+ // Read-only option
+ if (options.read_only) {
+ mountOptions.push('ro');
+ }
+
+ // Bind-specific options
+ if (options.bind) {
+ if (options.bind.propagation) {
+ // Docker bind propagation: shared, slave, private, rshared, rslave, rprivate
+ mountOptions.push(`bind-propagation=${options.bind.propagation}`);
+ }
+
+ if (options.bind.create_host_path !== false) {
+ // Default behavior - Docker creates host path if it doesn't exist
+ mountOptions.push('bind-nonrecursive=false');
+ }
+ }
+
+ // Consistency option (mainly for Docker Desktop)
+ if (options.consistency) {
+ // cached, delegated, consistent
+ mountOptions.push(`consistency=${options.consistency}`);
+ }
+
+ if (mountOptions.length > 0) {
+ parts.push(mountOptions.join(','));
+ }
+
+ return parts.join(':');
+}
+
+/**
+ * Process named volume mount with all options
+ */
+function processVolumeMount(source: string, target: string, stackId: string, composeData: any, options: any = {}): string {
+ let volumeName = '';
+
+ if (source) {
+ // Check if it's a defined volume in the compose file
+ if (composeData.volumes && composeData.volumes[source]) {
+ volumeName = `${stackId}_${source}`;
+ } else {
+ // External volume or absolute volume name
+ volumeName = source;
+ }
+ } else {
+ // Anonymous volume - Docker will generate a name
+ volumeName = '';
+ }
+
+ const parts = [volumeName, target];
+ const mountOptions: string[] = [];
+
+ // Read-only option
+ if (options.read_only) {
+ mountOptions.push('ro');
+ }
+
+ // Volume-specific options
+ if (options.volume) {
+ if (options.volume.nocopy) {
+ mountOptions.push('nocopy');
+ }
+ }
+
+ if (mountOptions.length > 0) {
+ parts.push(mountOptions.join(','));
+ }
+
+ return parts.join(':');
+}
+
+/**
+ * Process tmpfs mount with all options
+ * Note: tmpfs mounts need special handling in container creation
+ */
+function processTmpfsMount(target: string, options: any = {}): string {
+ const mountOptions: string[] = [];
+
+ if (options.tmpfs) {
+ if (options.tmpfs.size) {
+ // Size in bytes or with suffix (100m, 1g)
+ mountOptions.push(`size=${options.tmpfs.size}`);
+ }
+
+ if (options.tmpfs.mode) {
+ // File mode in octal
+ mountOptions.push(`mode=${options.tmpfs.mode}`);
+ }
+
+ if (options.tmpfs.uid !== undefined) {
+ mountOptions.push(`uid=${options.tmpfs.uid}`);
+ }
+
+ if (options.tmpfs.gid !== undefined) {
+ mountOptions.push(`gid=${options.tmpfs.gid}`);
+ }
+
+ if (options.tmpfs.noexec) {
+ mountOptions.push('noexec');
+ }
+
+ if (options.tmpfs.nosuid) {
+ mountOptions.push('nosuid');
+ }
+
+ if (options.tmpfs.nodev) {
+ mountOptions.push('nodev');
+ }
+ }
+
+ // Return in format that can be processed later for tmpfs creation
+ return `${target}:${mountOptions.join(',')}`;
+}
+
+/**
+ * Format bind mount string
+ */
+function formatBindMount(source: string, target: string, options: string[] = []): string {
+ const parts = [source, target];
+
+ if (options.length > 0) {
+ parts.push(options.join(','));
+ }
+
+ return parts.join(':');
+}
+
+/**
+ * Format volume mount string
+ */
+function formatVolumeMount(volumeName: string, target: string, options: string[] = []): string {
+ const parts = [volumeName, target];
+
+ if (options.length > 0) {
+ parts.push(options.join(','));
+ }
+
+ return parts.join(':');
+}
+
+/**
+ * Extract tmpfs mounts from volume definitions
+ * This should be called during container creation to handle tmpfs mounts separately
+ */
+export function extractTmpfsMounts(volumes: any[]): Array<{ target: string; options: any }> {
+ if (!Array.isArray(volumes)) {
+ return [];
+ }
+
+ const tmpfsMounts: Array<{ target: string; options: any }> = [];
+
+ for (const volume of volumes) {
+ if (typeof volume === 'object' && volume !== null && volume.type === 'tmpfs') {
+ tmpfsMounts.push({
+ target: volume.target,
+ options: volume.tmpfs || {}
+ });
+ }
+ }
+
+ return tmpfsMounts;
+}
+
+/**
+ * Create Docker volume definitions for named volumes
+ * This should be called before creating containers to ensure named volumes exist
+ */
+export function createVolumeDefinitions(composeData: any, stackId: string): Array<{ name: string; config: any }> {
+ if (!composeData.volumes) {
+ return [];
+ }
+
+ const volumeDefinitions: Array<{ name: string; config: any }> = [];
+
+ for (const [volumeName, volumeConfig] of Object.entries(composeData.volumes)) {
+ // Skip external volumes
+ if (volumeConfig && typeof volumeConfig === 'object' && (volumeConfig as any).external) {
+ continue;
+ }
+
+ const config = volumeConfig || {};
+ const fullVolumeName = `${stackId}_${volumeName}`;
+
+ volumeDefinitions.push({
+ name: fullVolumeName,
+ config: {
+ Driver: (config as any).driver || 'local',
+ DriverOpts: (config as any).driver_opts || {},
+ Labels: {
+ 'com.docker.compose.project': stackId,
+ 'com.docker.compose.volume': volumeName,
+ ...((config as any).labels || {})
+ }
+ }
+ });
+ }
+
+ return volumeDefinitions;
+}
+
+/**
+ * Validate volume configuration
+ */
+export function validateVolumeConfiguration(volumes: any[]): { valid: boolean; errors: string[] } {
+ const errors: string[] = [];
+
+ if (!Array.isArray(volumes)) {
+ return { valid: true, errors: [] }; // No volumes is valid
+ }
+
+ for (let i = 0; i < volumes.length; i++) {
+ const volume = volumes[i];
+
+ if (typeof volume === 'string') {
+ // Validate short syntax
+ if (!volume.includes(':')) {
+ errors.push(`Volume ${i}: Invalid short syntax "${volume}". Expected "source:target" format.`);
+ }
+ } else if (typeof volume === 'object' && volume !== null) {
+ // Validate long syntax
+ if (!volume.target) {
+ errors.push(`Volume ${i}: Missing required 'target' field in long syntax.`);
+ }
+
+ if (volume.type && !['bind', 'volume', 'tmpfs', 'npipe'].includes(volume.type)) {
+ errors.push(`Volume ${i}: Invalid type "${volume.type}". Must be one of: bind, volume, tmpfs, npipe.`);
+ }
+
+ if (volume.type === 'bind' && !volume.source) {
+ errors.push(`Volume ${i}: Bind mount requires 'source' field.`);
+ }
+ } else {
+ errors.push(`Volume ${i}: Invalid volume definition. Must be string or object.`);
+ }
+ }
+
+ return {
+ valid: errors.length === 0,
+ errors
+ };
+}
+
+/**
+ * Enhanced port preparation with full Compose spec support
+ */
+export function preparePorts(ports: any[]): any {
+ if (!Array.isArray(ports)) {
+ return {};
+ }
+
+ const portBindings: any = {};
+
+ for (const port of ports) {
+ if (typeof port === 'string') {
+ // Handle various string formats
+ if (port.includes(':')) {
+ const parts = port.split(':');
+ let hostIP = '';
+ let hostPort = '';
+ let containerPort = '';
+
+ if (parts.length === 2) {
+ // "hostPort:containerPort"
+ hostPort = parts[0];
+ containerPort = parts[1];
+ } else if (parts.length === 3) {
+ // "hostIP:hostPort:containerPort"
+ hostIP = parts[0];
+ hostPort = parts[1];
+ containerPort = parts[2];
+ }
+
+ // Handle protocol specification
+ let protocol = 'tcp';
+ if (containerPort.includes('/')) {
+ [containerPort, protocol] = containerPort.split('/');
+ }
+
+ const containerPortKey = `${containerPort}/${protocol}`;
+ portBindings[containerPortKey] = [
+ {
+ HostIp: hostIP,
+ HostPort: hostPort
+ }
+ ];
+ } else {
+ // Just container port
+ let containerPort = port;
+ let protocol = 'tcp';
+
+ if (port.includes('/')) {
+ [containerPort, protocol] = port.split('/');
+ }
+
+ const containerPortKey = `${containerPort}/${protocol}`;
+ portBindings[containerPortKey] = [{}]; // Let Docker assign
+ }
+ } else if (typeof port === 'object') {
+ // Long syntax
+ const containerPort = port.target.toString();
+ const protocol = port.protocol || 'tcp';
+ const containerPortKey = `${containerPort}/${protocol}`;
+
+ const binding: any = {};
+ if (port.published) {
+ binding.HostPort = port.published.toString();
+ }
+ if (port.host_ip) {
+ binding.HostIp = port.host_ip;
+ }
+
+ portBindings[containerPortKey] = [binding];
+ }
+ }
+
+ return portBindings;
+}
+
+/**
+ * Enhanced environment variable preparation
+ */
+export async function prepareEnvironmentVariables(environment: any, stackDir: string): Promise<string[]> {
+ const envArray: string[] = [];
+ const envMap = new Map<string, string>();
+
+ // Load .env file first (lowest priority)
+ try {
+ const envFilePath = path.join(stackDir, '.env');
+ const envFileContent = await fs.readFile(envFilePath, 'utf8');
+ const envVars = parseEnvContent(envFileContent);
+
+ for (const [key, value] of Object.entries(envVars)) {
+ envMap.set(key, value);
+ }
+ } catch (envError) {
+ // .env file doesn't exist, that's okay
+ }
+
+ // Add process environment (medium priority)
+ for (const [key, value] of Object.entries(process.env)) {
+ if (value !== undefined) {
+ envMap.set(key, value);
+ }
+ }
+
+ // Add compose environment (highest priority)
+ if (Array.isArray(environment)) {
+ // Array format: ['KEY=value', 'KEY2=value2']
+ for (const env of environment) {
+ if (typeof env === 'string' && env.includes('=')) {
+ const [key, ...valueParts] = env.split('=');
+ envMap.set(key, valueParts.join('='));
+ }
+ }
+ } else if (typeof environment === 'object' && environment !== null) {
+ // Object format: { KEY: 'value', KEY2: 'value2' }
+ for (const [key, value] of Object.entries(environment)) {
+ if (value !== null && value !== undefined) {
+ envMap.set(key, value.toString());
+ }
+ }
+ }
+
+ // Convert map to array
+ for (const [key, value] of envMap) {
+ envArray.push(`${key}=${value}`);
+ }
+
+ return envArray;
+}
+
+/**
+ * Enhanced restart policy with full spec support
+ */
+export function prepareRestartPolicy(restart: string | undefined): any {
+ if (!restart || restart === 'no') {
+ return { Name: 'no' };
+ }
+
+ switch (restart) {
+ case 'always':
+ return { Name: 'always' };
+ case 'unless-stopped':
+ return { Name: 'unless-stopped' };
+ case 'on-failure':
+ return { Name: 'on-failure', MaximumRetryCount: 0 };
+ default:
+ // Handle on-failure:5 format
+ if (restart.startsWith('on-failure:')) {
+ const retryCount = parseInt(restart.split(':')[1]) || 0;
+ return { Name: 'on-failure', MaximumRetryCount: retryCount };
+ }
+ return { Name: 'no' };
+ }
+}
+
+/**
+ * Resolve dependency order for services
+ */
+export function resolveDependencyOrder(services: Record<string, any>): string[] {
+ const resolved: string[] = [];
+ const resolving: Set<string> = new Set();
+
+ function resolve(serviceName: string) {
+ if (resolved.includes(serviceName)) return;
+ if (resolving.has(serviceName)) {
+ throw new Error(`Circular dependency detected involving ${serviceName}`);
+ }
+
+ resolving.add(serviceName);
+
+ const service = services[serviceName];
+ if (service.depends_on) {
+ const dependencies = Array.isArray(service.depends_on) ? service.depends_on : Object.keys(service.depends_on);
+
+ for (const dep of dependencies) {
+ if (services[dep]) {
+ resolve(dep);
+ }
+ }
+ }
+
+ resolving.delete(serviceName);
+ resolved.push(serviceName);
+ }
+
+ for (const serviceName of Object.keys(services)) {
+ resolve(serviceName);
+ }
+
+ return resolved;
+}
+
+/**
+ * Generate config hash for service changes
+ */
+export function generateConfigHash(service: any): string {
+ const configString = JSON.stringify(service);
+ let hash = 0;
+ for (let i = 0; i < configString.length; i++) {
+ const char = configString.charCodeAt(i);
+ hash = (hash << 5) - hash + char;
+ hash = hash & hash; // Convert to 32bit integer
+ }
+ return Math.abs(hash).toString(16);
+}
+
+/**
+ * Prepare extra hosts
+ */
+export function prepareExtraHosts(extraHosts: any[]): string[] {
+ if (!Array.isArray(extraHosts)) return [];
+
+ return extraHosts
+ .map((host) => {
+ if (typeof host === 'string') {
+ return host;
+ } else if (typeof host === 'object') {
+ return `${host.hostname}:${host.ip}`;
+ }
+ return '';
+ })
+ .filter((h) => h);
+}
+
+/**
+ * Prepare ulimits
+ */
+export function prepareUlimits(ulimits: any): any[] {
+ // Handle null, undefined, or non-object values
+ if (!ulimits || typeof ulimits !== 'object') {
+ return [];
+ }
+
+ // Handle array format (already in Docker format)
+ if (Array.isArray(ulimits)) {
+ return ulimits;
+ }
+
+ // Handle object format (Docker Compose format)
+ return Object.entries(ulimits).map(([name, value]) => {
+ if (typeof value === 'number') {
+ return {
+ Name: name,
+ Soft: value,
+ Hard: value
+ };
+ } else if (typeof value === 'object' && value !== null) {
+ const limit = value as any;
+ return {
+ Name: name,
+ Soft: limit.soft || limit.Soft || 0,
+ Hard: limit.hard || limit.Hard || 0
+ };
+ } else {
+ return {
+ Name: name,
+ Soft: 0,
+ Hard: 0
+ };
+ }
+ });
+}
+
+/**
+ * Prepare log config
+ */
+export function prepareLogConfig(logging: any): any {
+ if (!logging || !logging.driver) {
+ return { Type: 'json-file' };
+ }
+
+ return {
+ Type: logging.driver,
+ Config: logging.options || {}
+ };
+}
+
+/**
+ * Prepare healthcheck
+ */
+export function prepareHealthcheck(healthcheck: any): any {
+ if (!healthcheck) return undefined;
+
+ const config: any = {};
+
+ if (healthcheck.test) {
+ if (Array.isArray(healthcheck.test)) {
+ config.Test = healthcheck.test;
+ } else if (typeof healthcheck.test === 'string') {
+ if (healthcheck.test === 'NONE') {
+ config.Test = ['NONE'];
+ } else {
+ config.Test = ['CMD-SHELL', healthcheck.test];
+ }
+ }
+ }
+
+ if (healthcheck.interval) {
+ config.Interval = parseTimeToNanoseconds(healthcheck.interval);
+ }
+
+ if (healthcheck.timeout) {
+ config.Timeout = parseTimeToNanoseconds(healthcheck.timeout);
+ }
+
+ if (healthcheck.start_period) {
+ config.StartPeriod = parseTimeToNanoseconds(healthcheck.start_period);
+ }
+
+ if (healthcheck.retries) {
+ config.Retries = parseInt(healthcheck.retries);
+ }
+
+ return config;
+}
+
+/**
+ * Parse memory string to bytes
+ */
+export function parseMemory(memStr: string | number): number {
+ if (typeof memStr === 'number') return memStr;
+
+ const str = memStr.toString().toLowerCase();
+ const num = parseFloat(str);
+
+ if (str.includes('k')) return Math.round(num * 1024);
+ if (str.includes('m')) return Math.round(num * 1024 * 1024);
+ if (str.includes('g')) return Math.round(num * 1024 * 1024 * 1024);
+
+ return Math.round(num);
+}
+
+/**
+ * Parse time string to nanoseconds
+ */
+export function parseTimeToNanoseconds(timeStr: string | number): number {
+ if (typeof timeStr === 'number') return timeStr * 1000000000; // assume seconds
+
+ const str = timeStr.toString().toLowerCase();
+ const num = parseFloat(str);
+
+ if (str.includes('ns')) return Math.round(num);
+ if (str.includes('us') || str.includes('μs')) return Math.round(num * 1000);
+ if (str.includes('ms')) return Math.round(num * 1000000);
+ if (str.includes('s')) return Math.round(num * 1000000000);
+ if (str.includes('m')) return Math.round(num * 60 * 1000000000);
+ if (str.includes('h')) return Math.round(num * 60 * 60 * 1000000000);
+
+ return Math.round(num * 1000000000); // assume seconds
+}
+
+/**
+ * Validate compose content
+ */
+export function validateComposeContent(content: string): { valid: boolean; errors: string[]; warnings: string[] } {
+ try {
+ const parsed = yamlLoad(content);
+ return validateComposeStructure(parsed as ComposeData);
+ } catch (parseError) {
+ return {
+ valid: false,
+ errors: [`YAML parsing error: ${parseError instanceof Error ? parseError.message : String(parseError)}`],
+ warnings: []
+ };
+ }
+}
+
+/**
+ * Parse and validate depends_on configuration
+ * Supports both short and long syntax as per Docker Compose spec
+ */
+export function parseDependsOn(dependsOn: any): Array<{ service: string; condition: string; restart?: boolean }> {
+ if (!dependsOn) {
+ return [];
+ }
+
+ const dependencies: Array<{ service: string; condition: string; restart?: boolean }> = [];
+
+ if (Array.isArray(dependsOn)) {
+ // Short syntax: depends_on: [service1, service2]
+ for (const serviceName of dependsOn) {
+ if (typeof serviceName === 'string') {
+ dependencies.push({
+ service: serviceName,
+ condition: 'service_started',
+ restart: false
+ });
+ }
+ }
+ } else if (typeof dependsOn === 'object' && dependsOn !== null) {
+ // Long syntax: depends_on: { service1: { condition: "service_healthy" } }
+ for (const [serviceName, config] of Object.entries(dependsOn)) {
+ const depConfig = config as any;
+
+ dependencies.push({
+ service: serviceName,
+ condition: depConfig?.condition || 'service_started',
+ restart: depConfig?.restart || false
+ });
+ }
+ }
+
+ return dependencies;
+}
+
+/**
+ * Validate dependency conditions according to Docker Compose spec
+ */
+export function validateDependencyConditions(dependencies: Array<{ service: string; condition: string }>): { valid: boolean; errors: string[] } {
+ const errors: string[] = [];
+ const validConditions = ['service_started', 'service_healthy', 'service_completed_successfully'];
+
+ for (const dep of dependencies) {
+ if (!dep.service || typeof dep.service !== 'string') {
+ errors.push(`Invalid service name in dependency: ${dep.service}`);
+ }
+
+ if (!validConditions.includes(dep.condition)) {
+ errors.push(`Invalid dependency condition '${dep.condition}' for service '${dep.service}'. Valid conditions: ${validConditions.join(', ')}`);
+ }
+ }
+
+ return {
+ valid: errors.length === 0,
+ errors
+ };
+}
+
+/**
+ * Check if a service has a healthcheck defined
+ */
+export function hasHealthcheck(serviceConfig: any): boolean {
+ return !!(serviceConfig?.healthcheck && serviceConfig.healthcheck !== false && serviceConfig.healthcheck.disable !== true);
+}
+
+/**
+ * Get service dependency chain for debugging
+ */
+export function getDependencyChain(services: Record<string, any>, startService: string, visited = new Set<string>()): string[] {
+ if (visited.has(startService)) {
+ return []; // Circular dependency detected
+ }
+
+ visited.add(startService);
+ const chain = [startService];
+
+ const serviceConfig = services[startService];
+ if (serviceConfig?.depends_on) {
+ const dependencies = parseDependsOn(serviceConfig.depends_on);
+
+ for (const dep of dependencies) {
+ if (services[dep.service]) {
+ const subChain = getDependencyChain(services, dep.service, new Set(visited));
+ chain.unshift(...subChain);
+ }
+ }
+ }
+
+ return [...new Set(chain)]; // Remove duplicates while preserving order
+}
+
+/**
+ * Detect circular dependencies in compose services
+ */
+export function detectCircularDependencies(services: Record<string, any>): { hasCircular: boolean; cycles: string[][] } {
+ const visited = new Set<string>();
+ const recursionStack = new Set<string>();
+ const cycles: string[][] = [];
+
+ function dfs(serviceName: string, path: string[]): boolean {
+ if (recursionStack.has(serviceName)) {
+ // Found a cycle
+ const cycleStart = path.indexOf(serviceName);
+ if (cycleStart !== -1) {
+ cycles.push([...path.slice(cycleStart), serviceName]);
+ }
+ return true;
+ }
+
+ if (visited.has(serviceName)) {
+ return false;
+ }
+
+ visited.add(serviceName);
+ recursionStack.add(serviceName);
+ path.push(serviceName);
+
+ const serviceConfig = services[serviceName];
+ if (serviceConfig?.depends_on) {
+ const dependencies = parseDependsOn(serviceConfig.depends_on);
+
+ for (const dep of dependencies) {
+ if (services[dep.service] && dfs(dep.service, [...path])) {
+ // Continue checking other dependencies to find all cycles
+ }
+ }
+ }
+
+ recursionStack.delete(serviceName);
+ path.pop();
+ return false;
+ }
+
+ for (const serviceName of Object.keys(services)) {
+ if (!visited.has(serviceName)) {
+ dfs(serviceName, []);
+ }
+ }
+
+ return {
+ hasCircular: cycles.length > 0,
+ cycles
+ };
+}
+
+/**
+ * Enhanced dependency order resolution with condition awareness
+ */
+export function resolveDependencyOrderWithConditions(services: Record<string, any>): {
+ order: string[];
+ batches: string[][];
+ warnings: string[];
+} {
+ const warnings: string[] = [];
+
+ // First check for circular dependencies
+ const circularCheck = detectCircularDependencies(services);
+ if (circularCheck.hasCircular) {
+ warnings.push(`Circular dependencies detected: ${circularCheck.cycles.map((cycle) => cycle.join(' -> ')).join(', ')}`);
+ }
+
+ // Build dependency graph
+ const graph: Record<string, Set<string>> = {};
+ const inDegree: Record<string, number> = {};
+ const healthyServices = new Set<string>();
+ const completionServices = new Set<string>();
+
+ // Initialize graph
+ for (const serviceName of Object.keys(services)) {
+ graph[serviceName] = new Set();
+ inDegree[serviceName] = 0;
+
+ // Track services that need health checks or completion
+ const serviceConfig = services[serviceName];
+ if (hasHealthcheck(serviceConfig)) {
+ healthyServices.add(serviceName);
+ }
+ }
+
+ // Build edges and track dependency types
+ for (const [serviceName, serviceConfig] of Object.entries(services)) {
+ if (serviceConfig?.depends_on) {
+ const dependencies = parseDependsOn(serviceConfig.depends_on);
+
+ for (const dep of dependencies) {
+ if (services[dep.service]) {
+ graph[dep.service].add(serviceName);
+ inDegree[serviceName]++;
+
+ // Track completion dependencies
+ if (dep.condition === 'service_completed_successfully') {
+ completionServices.add(dep.service);
+ }
+ } else {
+ warnings.push(`Service '${serviceName}' depends on undefined service '${dep.service}'`);
+ }
+ }
+ }
+ }
+
+ // Topological sort with batching
+ const result: string[] = [];
+ const batches: string[][] = [];
+ const queue: string[] = [];
+ const tempInDegree = { ...inDegree };
+
+ // Find initial services with no dependencies
+ for (const [serviceName, degree] of Object.entries(tempInDegree)) {
+ if (degree === 0) {
+ queue.push(serviceName);
+ }
+ }
+
+ while (queue.length > 0) {
+ const batch: string[] = [...queue];
+ batches.push(batch);
+ queue.length = 0;
+
+ for (const serviceName of batch) {
+ result.push(serviceName);
+
+ // Process neighbors
+ for (const neighbor of graph[serviceName]) {
+ tempInDegree[neighbor]--;
+ if (tempInDegree[neighbor] === 0) {
+ queue.push(neighbor);
+ }
+ }
+ }
+ }
+
+ // Check if all services were processed (detect remaining cycles)
+ if (result.length !== Object.keys(services).length) {
+ const remaining = Object.keys(services).filter((name) => !result.includes(name));
+ warnings.push(`Could not resolve dependencies for services: ${remaining.join(', ')} (possible circular dependencies)`);
+ // Add remaining services to the end
+ result.push(...remaining);
+ }
+
+ return {
+ order: result,
+ batches,
+ warnings
+ };
+}
+
+/**
+ * Create dependency wait configuration for a service
+ */
+export function createDependencyWaitConfig(
+ serviceName: string,
+ serviceConfig: any
+): {
+ dependencies: Array<{ service: string; condition: string; timeout: number; restart?: boolean }>;
+ warnings: string[];
+} {
+ const warnings: string[] = [];
+ const dependencies: Array<{ service: string; condition: string; timeout: number; restart?: boolean }> = [];
+
+ if (!serviceConfig?.depends_on) {
+ return { dependencies, warnings };
+ }
+
+ const parsedDeps = parseDependsOn(serviceConfig.depends_on);
+ const validation = validateDependencyConditions(parsedDeps);
+
+ if (!validation.valid) {
+ warnings.push(...validation.errors);
+ }
+
+ for (const dep of parsedDeps) {
+ let timeout = 30000; // Default 30 seconds
+
+ // Adjust timeout based on condition type
+ switch (dep.condition) {
+ case 'service_healthy':
+ timeout = 60000; // Health checks may take longer
+ break;
+ case 'service_completed_successfully':
+ timeout = 120000; // Completion may take much longer
+ break;
+ case 'service_started':
+ default:
+ timeout = 30000; // Standard startup timeout
+ break;
+ }
+
+ dependencies.push({
+ service: dep.service,
+ condition: dep.condition,
+ timeout,
+ restart: dep.restart
+ });
+ }
+
+ return { dependencies, warnings };
+}
+
+/**
+ * Check if a dependency condition can be satisfied
+ */
+export function canSatisfyDependencyCondition(condition: string, serviceConfig: any): { canSatisfy: boolean; reason?: string } {
+ switch (condition) {
+ case 'service_started':
+ return { canSatisfy: true };
+
+ case 'service_healthy':
+ if (!hasHealthcheck(serviceConfig)) {
+ return {
+ canSatisfy: false,
+ reason: 'Service has no healthcheck defined but dependency requires service_healthy condition'
+ };
+ }
+ return { canSatisfy: true };
+
+ case 'service_completed_successfully':
+ // Any service can potentially complete successfully
+ return { canSatisfy: true };
+
+ default:
+ return {
+ canSatisfy: false,
+ reason: `Unknown dependency condition: ${condition}`
+ };
+ }
+}
+
+/**
+ * Validate all dependency configurations in a compose file
+ */
+export function validateAllDependencies(services: Record<string, any>): {
+ valid: boolean;
+ errors: string[];
+ warnings: string[];
+} {
+ const errors: string[] = [];
+ const warnings: string[] = [];
+
+ // Check for circular dependencies
+ const circularCheck = detectCircularDependencies(services);
+ if (circularCheck.hasCircular) {
+ errors.push(`Circular dependencies detected: ${circularCheck.cycles.map((cycle) => cycle.join(' -> ')).join(', ')}`);
+ }
+
+ // Validate each service's dependencies
+ for (const [serviceName, serviceConfig] of Object.entries(services)) {
+ if (serviceConfig?.depends_on) {
+ const { dependencies, warnings: depWarnings } = createDependencyWaitConfig(serviceName, serviceConfig);
+ warnings.push(...depWarnings);
+
+ // Check if dependency services exist and can satisfy conditions
+ for (const dep of dependencies) {
+ if (!services[dep.service]) {
+ errors.push(`Service '${serviceName}' depends on undefined service '${dep.service}'`);
+ continue;
+ }
+
+ const dependencyServiceConfig = services[dep.service];
+ const satisfyCheck = canSatisfyDependencyCondition(dep.condition, dependencyServiceConfig);
+
+ if (!satisfyCheck.canSatisfy) {
+ warnings.push(`Service '${serviceName}' dependency on '${dep.service}' with condition '${dep.condition}': ${satisfyCheck.reason}`);
+ }
+ }
+ }
+ }
+
+ return {
+ valid: errors.length === 0,
+ errors,
+ warnings
+ };
+}
+
+/**
+ * Parse profiles from command line arguments or environment
+ * Handles Docker Compose profile specification: --profile prof1 --profile prof2
+ */
+export function parseActiveProfiles(args?: string[], env?: Record<string, string>): string[] {
+ const profiles = new Set<string>();
+
+ // Parse from command line arguments
+ if (args) {
+ for (let i = 0; i < args.length; i++) {
+ if (args[i] === '--profile' && i + 1 < args.length) {
+ profiles.add(args[i + 1]);
+ i++; // Skip the profile value
+ }
+ }
+ }
+
+ // Parse from environment variables
+ if (env) {
+ // COMPOSE_PROFILES environment variable (comma-separated)
+ const composeProfiles = env['COMPOSE_PROFILES'];
+ if (composeProfiles) {
+ composeProfiles.split(',').forEach((profile) => {
+ const trimmed = profile.trim();
+ if (trimmed) profiles.add(trimmed);
+ });
+ }
+ }
+
+ // Default profile if none specified
+ const profilesArray = Array.from(profiles);
+ return profilesArray.length > 0 ? profilesArray : ['default'];
+}
+
+/**
+ * Validate profile configuration in compose data
+ */
+export function validateProfiles(composeData: ComposeData): { valid: boolean; errors: string[]; warnings: string[] } {
+ const errors: string[] = [];
+ const warnings: string[] = [];
+
+ if (!composeData || typeof composeData !== 'object') {
+ return { valid: true, errors, warnings };
+ }
+
+ // Check if profiles are defined at top level
+ const topLevelProfiles = composeData.profiles;
+ if (topLevelProfiles && !Array.isArray(topLevelProfiles) && typeof topLevelProfiles !== 'object') {
+ errors.push('Top-level profiles must be an array or object');
+ }
+
+ // Validate service profiles
+ if (composeData.services) {
+ for (const [serviceName, serviceConfig] of Object.entries(composeData.services)) {
+ if (serviceConfig && typeof serviceConfig === 'object') {
+ if (serviceConfig.profiles) {
+ // Profiles can be string, array of strings, or not present
+ if (typeof serviceConfig.profiles === 'string') {
+ // Single profile as string is valid
+ continue;
+ } else if (Array.isArray(serviceConfig.profiles)) {
+ // Array of profiles
+ for (const profile of serviceConfig.profiles) {
+ if (typeof profile !== 'string') {
+ errors.push(`Service '${serviceName}' has invalid profile type. Profiles must be strings.`);
+ }
+ if (!profile.trim()) {
+ errors.push(`Service '${serviceName}' has empty profile name.`);
+ }
+ }
+ } else {
+ errors.push(`Service '${serviceName}' profiles must be a string or array of strings.`);
+ }
+ }
+ }
+ }
+ }
+
+ return {
+ valid: errors.length === 0,
+ errors,
+ warnings
+ };
+}
+
+/**
+ * Get all profiles defined in the compose file
+ */
+export function getAllDefinedProfiles(composeData: ComposeData): string[] {
+ const allProfiles = new Set<string>();
+
+ if (!composeData || typeof composeData !== 'object') {
+ return [];
+ }
+
+ // Add top-level defined profiles
+ if (composeData.profiles) {
+ if (Array.isArray(composeData.profiles)) {
+ composeData.profiles.forEach((profile) => {
+ if (typeof profile === 'string') {
+ allProfiles.add(profile);
+ }
+ });
+ } else if (typeof composeData.profiles === 'object') {
+ Object.keys(composeData.profiles).forEach((profile) => {
+ allProfiles.add(profile);
+ });
+ }
+ }
+
+ // Extract profiles from services
+ if (composeData.services) {
+ for (const serviceConfig of Object.values(composeData.services)) {
+ if (serviceConfig && typeof serviceConfig === 'object') {
+ if (serviceConfig.profiles) {
+ if (typeof serviceConfig.profiles === 'string') {
+ allProfiles.add(serviceConfig.profiles);
+ } else if (Array.isArray(serviceConfig.profiles)) {
+ serviceConfig.profiles.forEach((profile: string) => {
+ if (typeof profile === 'string') {
+ allProfiles.add(profile);
+ }
+ });
+ }
+ }
+ }
+ }
+ }
+
+ return Array.from(allProfiles).sort();
+}
+
+/**
+ * Check if a service should be deployed based on active profiles
+ */
+export function shouldDeployService(serviceConfig: ServiceConfig, activeProfiles: string[], defaultBehavior: 'include' | 'exclude' = 'include'): ProfileDeploymentCheck {
+ // If no profiles are specified on the service, use default behavior
+ if (!serviceConfig.profiles) {
+ return {
+ shouldDeploy: defaultBehavior === 'include',
+ reason: defaultBehavior === 'include' ? 'No profiles specified, included by default' : 'No profiles specified, excluded by default'
+ };
+ }
+
+ // Normalize service profiles to array
+ const serviceProfiles = Array.isArray(serviceConfig.profiles) ? serviceConfig.profiles : [serviceConfig.profiles];
+
+ // Check if any of the service's profiles are in the active profiles
+ const matchingProfiles = serviceProfiles.filter((profile) => activeProfiles.includes(profile));
+
+ if (matchingProfiles.length > 0) {
+ return {
+ shouldDeploy: true,
+ reason: `Service profiles [${serviceProfiles.join(', ')}] match active profiles [${matchingProfiles.join(', ')}]`
+ };
+ }
+
+ return {
+ shouldDeploy: false,
+ reason: `Service profiles [${serviceProfiles.join(', ')}] do not match active profiles [${activeProfiles.join(', ')}]`
+ };
+}
+
+/**
+ * Filter services based on profiles
+ */
+export function filterServicesByProfiles(services: Record<string, ServiceConfig>, activeProfiles: string[]): ProfileServiceFiltering {
+ const deployableServices: Record<string, ServiceConfig> = {};
+ const skippedServices: Array<{ name: string; reason: string }> = [];
+
+ for (const [serviceName, serviceConfig] of Object.entries(services)) {
+ const deploymentCheck = shouldDeployService(serviceConfig, activeProfiles);
+
+ if (deploymentCheck.shouldDeploy) {
+ deployableServices[serviceName] = serviceConfig;
+ } else {
+ skippedServices.push({
+ name: serviceName,
+ reason: deploymentCheck.reason
+ });
+ }
+ }
+
+ return {
+ deployableServices,
+ skippedServices,
+ profileSummary: {
+ totalServices: Object.keys(services).length,
+ deployableServices: Object.keys(deployableServices).length,
+ skippedServices: skippedServices.length,
+ activeProfiles
+ }
+ };
+}
+
+/**
+ * Resolve profile dependencies and conflicts
+ */
+export function resolveProfileDependencies(composeData: ComposeData, requestedProfiles: string[]): ProfileResolution {
+ const warnings: string[] = [];
+ const errors: string[] = [];
+ const resolvedProfiles = new Set(requestedProfiles);
+
+ // If no profiles requested, use default
+ if (requestedProfiles.length === 0) {
+ resolvedProfiles.add('default');
+ }
+
+ // Check for profile definitions and dependencies
+ if (composeData.profiles && typeof composeData.profiles === 'object' && !Array.isArray(composeData.profiles)) {
+ for (const [profileName, profileConfig] of Object.entries(composeData.profiles)) {
+ if (resolvedProfiles.has(profileName) && profileConfig && typeof profileConfig === 'object') {
+ // Handle profile dependencies
+ if (profileConfig.depends_on && Array.isArray(profileConfig.depends_on)) {
+ for (const dependency of profileConfig.depends_on) {
+ if (typeof dependency === 'string') {
+ resolvedProfiles.add(dependency);
+ warnings.push(`Profile '${profileName}' requires profile '${dependency}' - added automatically`);
+ }
+ }
+ }
+
+ // Handle profile conflicts
+ if (profileConfig.conflicts && Array.isArray(profileConfig.conflicts)) {
+ for (const conflict of profileConfig.conflicts) {
+ if (typeof conflict === 'string' && resolvedProfiles.has(conflict)) {
+ errors.push(`Profile '${profileName}' conflicts with profile '${conflict}'`);
+ }
+ }
+ }
+ }
+ }
+ }
+
+ // Validate that all resolved profiles exist
+ const definedProfiles = getAllDefinedProfiles(composeData);
+ for (const profile of resolvedProfiles) {
+ if (profile !== 'default' && !definedProfiles.includes(profile)) {
+ warnings.push(`Profile '${profile}' is not defined in the compose file`);
+ }
+ }
+
+ return {
+ resolvedProfiles: Array.from(resolvedProfiles).sort(),
+ warnings,
+ errors
+ };
+}
+
+/**
+ * Create deployment plan based on profiles
+ */
+export function createProfileDeploymentPlan(composeData: ComposeData, activeProfiles: string[]): ProfileDeploymentPlan {
+ const warnings: string[] = [];
+ const errors: string[] = [];
+
+ // Validate profiles
+ const profileValidation = validateProfiles(composeData);
+ warnings.push(...profileValidation.warnings);
+ errors.push(...profileValidation.errors);
+
+ // Resolve profile dependencies
+ const resolution = resolveProfileDependencies(composeData, activeProfiles);
+ warnings.push(...resolution.warnings);
+ errors.push(...resolution.errors);
+
+ const finalActiveProfiles = resolution.resolvedProfiles;
+
+ // Filter services by profiles
+ const serviceFiltering = filterServicesByProfiles(composeData.services || {}, finalActiveProfiles);
+
+ // Determine volumes and networks needed for deployable services
+ const volumesToCreate = new Set<string>();
+ const networksToCreate = new Set<string>();
+
+ // Add volumes used by deployable services
+ for (const serviceName of Object.keys(serviceFiltering.deployableServices)) {
+ const serviceConfig = serviceFiltering.deployableServices[serviceName];
+
+ // Collect volume references
+ if (serviceConfig.volumes) {
+ const volumes = Array.isArray(serviceConfig.volumes) ? serviceConfig.volumes : [];
+ for (const volume of volumes) {
+ if (typeof volume === 'string') {
+ // Short syntax: extract volume name
+ const parts = volume.split(':');
+ const source = parts[0];
+ if (!source.startsWith('/') && !source.startsWith('./') && !source.startsWith('../')) {
+ // It's a named volume
+ volumesToCreate.add(source);
+ }
+ } else if (typeof volume === 'object' && volume.source && volume.type === 'volume') {
+ // Long syntax: volume mount
+ volumesToCreate.add(volume.source);
+ }
+ }
+ }
+
+ // Collect network references
+ if (serviceConfig.networks) {
+ if (Array.isArray(serviceConfig.networks)) {
+ serviceConfig.networks.forEach((network: string) => networksToCreate.add(network));
+ } else if (typeof serviceConfig.networks === 'object') {
+ Object.keys(serviceConfig.networks).forEach((network) => networksToCreate.add(network));
+ }
+ }
+ }
+
+ // Only include volumes that are actually defined in the compose file
+ const definedVolumes = composeData.volumes ? Object.keys(composeData.volumes) : [];
+ const filteredVolumes = Array.from(volumesToCreate).filter((vol) => definedVolumes.includes(vol));
+
+ // Only include networks that are actually defined in the compose file
+ const definedNetworks = composeData.networks ? Object.keys(composeData.networks) : [];
+ const filteredNetworks = Array.from(networksToCreate).filter((net) => definedNetworks.includes(net));
+
+ return {
+ plan: {
+ servicesToDeploy: Object.keys(serviceFiltering.deployableServices),
+ servicesToSkip: serviceFiltering.skippedServices,
+ volumesToCreate: filteredVolumes,
+ networksToCreate: filteredNetworks
+ },
+ summary: {
+ totalServices: serviceFiltering.profileSummary.totalServices,
+ deployableServices: serviceFiltering.profileSummary.deployableServices,
+ skippedServices: serviceFiltering.profileSummary.skippedServices,
+ activeProfiles: finalActiveProfiles,
+ allDefinedProfiles: getAllDefinedProfiles(composeData)
+ },
+ warnings,
+ errors
+ };
+}
+
+/**
+ * Apply profile filtering to compose data
+ * Returns a new compose data object with only the services that should be deployed
+ */
+export function applyProfileFiltering(
+ composeData: ComposeData,
+ activeProfiles: string[]
+): {
+ filteredComposeData: ComposeData;
+ deploymentPlan: ProfileDeploymentPlan;
+} {
+ const deploymentPlan = createProfileDeploymentPlan(composeData, activeProfiles);
+
+ // Create filtered compose data
+ const filteredComposeData: ComposeData = {
+ ...composeData,
+ services: {},
+ volumes: {},
+ networks: {}
+ };
+
+ // Add deployable services
+ for (const serviceName of deploymentPlan.plan.servicesToDeploy) {
+ if (composeData.services && composeData.services[serviceName]) {
+ filteredComposeData.services![serviceName] = composeData.services[serviceName];
+ }
+ }
+
+ // Add required volumes
+ for (const volumeName of deploymentPlan.plan.volumesToCreate) {
+ if (composeData.volumes && composeData.volumes[volumeName]) {
+ filteredComposeData.volumes![volumeName] = composeData.volumes[volumeName];
+ }
+ }
+
+ // Add required networks
+ for (const networkName of deploymentPlan.plan.networksToCreate) {
+ if (composeData.networks && composeData.networks[networkName]) {
+ filteredComposeData.networks![networkName] = composeData.networks[networkName];
+ }
+ }
+
+ // Always ensure default network exists if no networks specified
+ if (Object.keys(filteredComposeData.networks!).length === 0 && Object.keys(filteredComposeData.services!).length > 0) {
+ filteredComposeData.networks!.default = {
+ driver: 'bridge'
+ };
+ }
+
+ return {
+ filteredComposeData,
+ deploymentPlan
+ };
+}
+
+/**
+ * Get profile usage statistics from a compose file
+ */
+export function getProfileUsageStats(composeData: ComposeData): ProfileUsageStats {
+ const allProfiles = getAllDefinedProfiles(composeData);
+ const profileServiceMap = new Map<string, string[]>();
+ const servicesWithoutProfiles: string[] = [];
+ const servicesWithProfiles: ServiceProfile[] = [];
+
+ // Initialize profile map
+ allProfiles.forEach((profile) => {
+ profileServiceMap.set(profile, []);
+ });
+
+ // Process services
+ if (composeData.services) {
+ for (const [serviceName, serviceConfig] of Object.entries(composeData.services)) {
+ if (serviceConfig && typeof serviceConfig === 'object') {
+ if (serviceConfig.profiles) {
+ const serviceProfiles = Array.isArray(serviceConfig.profiles) ? serviceConfig.profiles : [serviceConfig.profiles];
+
+ servicesWithProfiles.push({
+ service: serviceName,
+ profiles: serviceProfiles
+ });
+
+ // Add service to each of its profiles
+ serviceProfiles.forEach((profile) => {
+ if (!profileServiceMap.has(profile)) {
+ profileServiceMap.set(profile, []);
+ }
+ profileServiceMap.get(profile)!.push(serviceName);
+ });
+ } else {
+ servicesWithoutProfiles.push(serviceName);
+ }
+ }
+ }
+ }
+
+ const profilesWithServices = Array.from(profileServiceMap.entries()).map(([profile, services]) => ({
+ profile,
+ serviceCount: services.length,
+ services: services.sort()
+ }));
+
+ return {
+ totalProfiles: allProfiles.length,
+ profilesWithServices,
+ servicesWithoutProfiles: servicesWithoutProfiles.sort(),
+ servicesWithProfiles
+ };
+}
+
+/**
+ * Generate profile documentation/help text
+ */
+export function generateProfileHelp(composeData: ComposeData): string {
+ const stats = getProfileUsageStats(composeData);
+ const allProfiles = getAllDefinedProfiles(composeData);
+
+ let help = 'Docker Compose Profiles Available:\n\n';
+
+ if (allProfiles.length === 0) {
+ help += 'No profiles are defined in this compose file.\n';
+ help += 'All services will be deployed by default.\n';
+ return help;
+ }
+
+ help += `Total profiles defined: ${stats.totalProfiles}\n\n`;
+
+ // List profiles with their services
+ for (const profileInfo of stats.profilesWithServices) {
+ help += `Profile: ${profileInfo.profile}\n`;
+ help += ` Services (${profileInfo.serviceCount}): ${profileInfo.services.join(', ')}\n\n`;
+ }
+
+ // Show services without profiles
+ if (stats.servicesWithoutProfiles.length > 0) {
+ help += `Services without profiles (always deployed): ${stats.servicesWithoutProfiles.join(', ')}\n\n`;
+ }
+
+ help += 'Usage:\n';
+ help += ' Deploy specific profile: --profile <profile-name>\n';
+ help += ' Deploy multiple profiles: --profile prof1 --profile prof2\n';
+ help += ' Environment variable: COMPOSE_PROFILES=prof1,prof2\n';
+
+ return help;
+}
diff --git a/src/routes/api/stacks/[stackId]/changes/+server.ts b/src/routes/api/stacks/[stackId]/changes/+server.ts
new file mode 100644
index 000000000..f7f70d136
--- /dev/null
+++ b/src/routes/api/stacks/[stackId]/changes/+server.ts
@@ -0,0 +1,15 @@
+import { json } from '@sveltejs/kit';
+import { detectStackChanges } from '$lib/services/docker/stack-custom-service';
+import { tryCatch } from '$lib/utils/try-catch';
+
+export async function GET({ params }) {
+ const { stackId } = params;
+
+ const result = await tryCatch(detectStackChanges(stackId));
+
+ if (result.error) {
+ return json({ error: result.error.message }, { status: 500 });
+ }
+
+ return json(result.data);
+}
diff --git a/src/routes/api/stacks/[stackId]/deploy/+server.ts b/src/routes/api/stacks/[stackId]/deploy/+server.ts
index 5c6a69a4c..c6f076973 100644
--- a/src/routes/api/stacks/[stackId]/deploy/+server.ts
+++ b/src/routes/api/stacks/[stackId]/deploy/+server.ts
@@ -1,27 +1,90 @@
import { deployStack } from '$lib/services/docker/stack-custom-service';
-import type { RequestHandler } from './$types';
import { json } from '@sveltejs/kit';
-import { ApiErrorCode, type ApiErrorResponse } from '$lib/types/errors.type';
import { tryCatch } from '$lib/utils/try-catch';
-export const POST: RequestHandler = async ({ params }) => {
- const id = params.stackId;
+export async function POST({ params, request }) {
+ const { stackId } = params;
- const result = await tryCatch(deployStack(id));
+ try {
+ // Handle empty or missing request body
+ let body: { profiles?: string[]; envOverrides?: Record<string, string> } = {};
- if (result.error) {
- console.error(`API Error starting stack ${id}:`, result.error);
- const response: ApiErrorResponse = {
- success: false,
- error: result.error.message || 'Failed to start stack',
- code: ApiErrorCode.INTERNAL_SERVER_ERROR,
- details: result.error
- };
- return json(response, { status: 500 });
+ try {
+ const contentType = request.headers.get('content-type');
+
+ if (contentType && contentType.includes('application/json')) {
+ const text = await request.text();
+ if (text.trim()) {
+ body = JSON.parse(text);
+ }
+ }
+ } catch (parseError) {
+ console.warn('Failed to parse request body, using empty object:', parseError);
+ // Continue with empty body object
+ }
+
+ const { profiles, envOverrides } = body;
+
+ console.log(`Deploying stack ${stackId} with options:`, {
+ profiles: profiles || [],
+ envOverrides: envOverrides || {}
+ });
+
+ const result = await tryCatch(
+ deployStack(stackId, {
+ profiles: profiles || [],
+ envOverrides: envOverrides || {}
+ })
+ );
+
+ if (result.error) {
+ console.error(`API Error deploying stack ${stackId}:`, result.error);
+ return json({ error: result.error.message }, { status: 500 });
+ }
+
+ return json({ success: true, message: `Stack ${stackId} deployed successfully` });
+ } catch (error) {
+ console.error('Deploy endpoint error:', error);
+ const errorMessage = error instanceof Error ? error.message : 'Unknown error occurred';
+ return json(
+ {
+ error: errorMessage,
+ details: 'Failed to deploy stack'
+ },
+ { status: 500 }
+ );
}
+}
- return json({
- success: true,
- message: `Stack started successfully`
- });
-};
+// Add GET endpoint for simple deployments without body
+export async function GET({ params }) {
+ const { stackId } = params;
+
+ try {
+ console.log(`Deploying stack ${stackId} (GET request - no options)`);
+
+ const result = await tryCatch(
+ deployStack(stackId, {
+ profiles: [],
+ envOverrides: {}
+ })
+ );
+
+ if (result.error) {
+ console.error(`API Error deploying stack ${stackId}:`, result.error);
+ return json({ error: result.error.message }, { status: 500 });
+ }
+
+ return json({ success: true, message: `Stack ${stackId} deployed successfully` });
+ } catch (error) {
+ console.error('Deploy endpoint error (GET):', error);
+ const errorMessage = error instanceof Error ? error.message : 'Unknown error occurred';
+ return json(
+ {
+ error: errorMessage,
+ details: 'Failed to deploy stack'
+ },
+ { status: 500 }
+ );
+ }
+}
diff --git a/src/routes/api/stacks/[stackId]/deployment-preview/+server.ts b/src/routes/api/stacks/[stackId]/deployment-preview/+server.ts
new file mode 100644
index 000000000..d6c05b315
--- /dev/null
+++ b/src/routes/api/stacks/[stackId]/deployment-preview/+server.ts
@@ -0,0 +1,22 @@
+import { json } from '@sveltejs/kit';
+import { previewStackDeployment } from '$lib/services/docker/stack-custom-service';
+import { tryCatch } from '$lib/utils/try-catch';
+
+export async function POST({ params, request }) {
+ const { stackId } = params;
+
+ try {
+ const body = await request.json();
+ const { profiles } = body;
+
+ const result = await tryCatch(previewStackDeployment(stackId, profiles || []));
+
+ if (result.error) {
+ return json({ error: result.error.message }, { status: 500 });
+ }
+
+ return json(result.data);
+ } catch (error) {
+ return json({ error: error instanceof Error ? error.message : 'Invalid request' }, { status: 400 });
+ }
+}
diff --git a/src/routes/api/stacks/[stackId]/profiles/+server.ts b/src/routes/api/stacks/[stackId]/profiles/+server.ts
new file mode 100644
index 000000000..d13791a5f
--- /dev/null
+++ b/src/routes/api/stacks/[stackId]/profiles/+server.ts
@@ -0,0 +1,15 @@
+import { json } from '@sveltejs/kit';
+import { getStackProfiles } from '$lib/services/docker/stack-custom-service';
+import { tryCatch } from '$lib/utils/try-catch';
+
+export async function GET({ params }) {
+ const { stackId } = params;
+
+ const result = await tryCatch(getStackProfiles(stackId));
+
+ if (result.error) {
+ return json({ error: result.error.message }, { status: 500 });
+ }
+
+ return json(result.data);
+}
diff --git a/src/routes/api/stacks/[stackId]/validate/+server.ts b/src/routes/api/stacks/[stackId]/validate/+server.ts
new file mode 100644
index 000000000..97612c71f
--- /dev/null
+++ b/src/routes/api/stacks/[stackId]/validate/+server.ts
@@ -0,0 +1,15 @@
+import { json } from '@sveltejs/kit';
+import { validateStackConfiguration } from '$lib/services/docker/stack-custom-service';
+import { tryCatch } from '$lib/utils/try-catch';
+
+export async function GET({ params }) {
+ const { stackId } = params;
+
+ const result = await tryCatch(validateStackConfiguration(stackId));
+
+ if (result.error) {
+ return json({ error: result.error.message }, { status: 500 });
+ }
+
+ return json(result.data);
+}