@pulumix/core 0.1.0

package/dist/orchestrator/index.js

@@ -0,0 +1,722 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createOrchestrator = exports.Orchestrator = exports.resolveStackConfig = exports.sortByDependencies = exports.discoverPublishedServices = exports.discoverServices = void 0;
+const path = __importStar(require("path"));
+const fs = __importStar(require("fs"));
+const child_process_1 = require("child_process");
+const fast_glob_1 = __importDefault(require("fast-glob"));
+const EitherAsync_1 = require("purify-ts/EitherAsync");
+const Either_1 = require("purify-ts/Either");
+const Maybe_1 = require("purify-ts/Maybe");
+const jiti_1 = require("jiti");
+const yaml = __importStar(require("yaml"));
+const errors_1 = require("../types/errors");
+const manifest_1 = require("../validation/manifest");
+const events_1 = require("./events");
+const automation_1 = require("@pulumi/pulumi/automation");
+const docker_1 = require("../docker");
+const jiti = (0, jiti_1.createJiti)(__filename, {
+    interopDefault: true
+});
+const DEFAULT_BACKEND = {
+    type: 'file',
+    path: 'dist/'
+};
+const resolveBackendUrl = (rootPath, projectConfig, stackName) => {
+    const stackConfig = projectConfig.stacks?.[stackName];
+    const backend = stackConfig?.backend ?? projectConfig.backend ?? DEFAULT_BACKEND;
+    switch (backend.type) {
+        case 'file': {
+            const backendPath = backend.path ?? 'dist/';
+            const absolutePath = path.isAbsolute(backendPath)
+                ? backendPath
+                : path.join(rootPath, backendPath);
+            return `file://${absolutePath}`;
+        }
+        case 's3': {
+            const prefix = backend.prefix ? `/${backend.prefix.replace(/^\//, '')}` : '';
+            const region = backend.region ? `?region=${backend.region}` : '';
+            return `s3://${backend.bucket}${prefix}${region}`;
+        }
+        case 'gcs': {
+            const prefix = backend.prefix ? `/${backend.prefix.replace(/^\//, '')}` : '';
+            return `gs://${backend.bucket}${prefix}`;
+        }
+        case 'azblob': {
+            const prefix = backend.prefix ? `/${backend.prefix.replace(/^\//, '')}` : '';
+            return `azblob://${backend.container}${prefix}`;
+        }
+        case 'pulumi': {
+            if (backend.org) {
+                return `https://app.pulumi.com/${backend.org}`;
+            }
+            return 'https://app.pulumi.com';
+        }
+        default: {
+            const defaultPath = path.join(rootPath, 'dist/');
+            return `file://${defaultPath}`;
+        }
+    }
+};
+const resolveWorkDir = (rootPath, projectConfig, stackName) => {
+    const stackConfig = projectConfig.stacks?.[stackName];
+    const backend = stackConfig?.backend ?? projectConfig.backend ?? DEFAULT_BACKEND;
+    if (backend.type === 'file') {
+        const backendPath = backend.path ?? 'dist/';
+        return path.isAbsolute(backendPath)
+            ? backendPath
+            : path.join(rootPath, backendPath);
+    }
+    return path.join(rootPath, 'dist/');
+};
+const isValidShellArg = (value) => /^[a-zA-Z0-9_\-.:]+$/.test(value);
+const parseYamlFile = (filePath) => {
+    try {
+        if (!fs.existsSync(filePath)) {
+            return (0, Either_1.Right)({});
+        }
+        const content = fs.readFileSync(filePath, 'utf-8');
+        const parsed = yaml.parse(content);
+        return (0, Either_1.Right)(parsed ?? {});
+    }
+    catch (err) {
+        const message = err instanceof Error ? err.message : 'Unknown error';
+        return (0, Either_1.Left)((0, errors_1.createDiscoveryError)('InvalidYaml', `Failed to parse YAML file ${filePath}: ${message}`, filePath, { filePath, parseError: message }, err instanceof Error ? err : undefined));
+    }
+};
+const getConfigValue = (config, key) => config[key] !== undefined ? (0, Maybe_1.Just)(config[key]) : Maybe_1.Nothing;
+const parseServiceMetadata = (rawConfig, serviceName) => {
+    const metadata = rawConfig.metadata ?? {};
+    return {
+        name: metadata.name ?? serviceName,
+        version: metadata.version ?? '0.0.0',
+        description: metadata.description,
+        team: metadata.team,
+        owner: metadata.owner,
+        repository: metadata.repository,
+        documentation: metadata.documentation,
+        tags: metadata.tags,
+        sla: metadata.sla,
+        support: metadata.support,
+        contract: metadata.contract
+    };
+};
+const extractDependenciesFromPackageJson = (packageJsonPath, allServiceNames) => {
+    if (!fs.existsSync(packageJsonPath)) {
+        return [];
+    }
+    try {
+        const content = fs.readFileSync(packageJsonPath, 'utf-8');
+        const pkg = JSON.parse(content);
+        const deps = { ...pkg.dependencies, ...pkg.devDependencies };
+        return Object.keys(deps).filter(dep => {
+            const serviceName = dep.includes('/') ? dep.split('/').pop() : dep;
+            return serviceName && allServiceNames.has(serviceName);
+        }).map(dep => {
+            const serviceName = dep.includes('/') ? dep.split('/').pop() : dep;
+            return serviceName;
+        });
+    }
+    catch {
+        return [];
+    }
+};
+const discoverServices = async (rootPath) => {
+    try {
+        const yamlFiles = await (0, fast_glob_1.default)('**/pulumix.yaml', {
+            cwd: rootPath,
+            ignore: ['node_modules/**', '.git/**', '**/dist/**', '**/build/**', '**/.pulumi/**'],
+            absolute: false
+        });
+        const services = [];
+        const serviceNames = new Set();
+        for (const yamlFile of yamlFiles) {
+            const servicePath = path.join(rootPath, path.dirname(yamlFile));
+            const deployPath = path.join(servicePath, 'pulumix.ts');
+            if (!fs.existsSync(deployPath)) {
+                continue;
+            }
+            const configPath = path.join(servicePath, 'pulumix.yaml');
+            const configResult = parseYamlFile(configPath);
+            if (configResult.isLeft()) {
+                return configResult;
+            }
+            const rawConfig = configResult.unsafeCoerce();
+            const validationResult = (0, manifest_1.validateServiceManifest)(rawConfig, configPath);
+            if (validationResult.isLeft()) {
+                return validationResult;
+            }
+            const metadata = parseServiceMetadata(rawConfig, path.basename(servicePath));
+            serviceNames.add(metadata.name);
+        }
+        for (const yamlFile of yamlFiles) {
+            const servicePath = path.join(rootPath, path.dirname(yamlFile));
+            const deployPath = path.join(servicePath, 'pulumix.ts');
+            if (!fs.existsSync(deployPath)) {
+                continue;
+            }
+            const configPath = path.join(servicePath, 'pulumix.yaml');
+            const dockerPath = path.join(servicePath, 'Dockerfile');
+            const packageJsonPath = path.join(servicePath, 'package.json');
+            const configResult = parseYamlFile(configPath);
+            if (configResult.isLeft()) {
+                return configResult;
+            }
+            const rawConfig = configResult.unsafeCoerce();
+            const metadata = parseServiceMetadata(rawConfig, path.basename(servicePath));
+            const observability = rawConfig.observability;
+            const security = rawConfig.security;
+            const dependencies = extractDependenciesFromPackageJson(packageJsonPath, serviceNames);
+            services.push({
+                name: metadata.name,
+                path: servicePath,
+                deployPath,
+                configPath,
+                dependencies,
+                hasDockerfile: fs.existsSync(dockerPath),
+                rawConfig,
+                metadata,
+                observability,
+                security
+            });
+        }
+        return (0, Either_1.Right)(services);
+    }
+    catch (err) {
+        const message = err instanceof Error ? err.message : 'Unknown error';
+        return (0, Either_1.Left)((0, errors_1.createDiscoveryError)('InvalidGlobPattern', `Failed to discover services: ${message}`, rootPath, { rootPath }, err instanceof Error ? err : undefined));
+    }
+};
+exports.discoverServices = discoverServices;
+const matchesAllowlist = (packageName, allowlist) => {
+    return allowlist.some(pattern => {
+        const regexPattern = pattern
+            .replace(/\*/g, '.*')
+            .replace(/\?/g, '.')
+            .replace(/\//g, '\\/');
+        const regex = new RegExp(`^${regexPattern}$`);
+        return regex.test(packageName);
+    });
+};
+const discoverPublishedServices = async (rootPath, allowlist) => {
+    try {
+        const nodeModulesPath = path.join(rootPath, 'node_modules');
+        if (!fs.existsSync(nodeModulesPath)) {
+            return (0, Either_1.Right)([]);
+        }
+        const yamlFiles = await (0, fast_glob_1.default)('**/pulumix.yaml', {
+            cwd: nodeModulesPath,
+            ignore: ['**/node_modules/**'],
+            absolute: false
+        });
+        const services = [];
+        const serviceNames = new Set();
+        for (const yamlFile of yamlFiles) {
+            const servicePath = path.join(nodeModulesPath, path.dirname(yamlFile));
+            const deployPath = path.join(servicePath, 'pulumix.ts');
+            if (!fs.existsSync(deployPath)) {
+                continue;
+            }
+            const packageName = path.dirname(yamlFile).replace(/\\/g, '/');
+            if (!matchesAllowlist(packageName, allowlist)) {
+                continue;
+            }
+            const configPath = path.join(servicePath, 'pulumix.yaml');
+            const configResult = parseYamlFile(configPath);
+            if (configResult.isLeft()) {
+                return configResult;
+            }
+            const rawConfig = configResult.unsafeCoerce();
+            const validationResult = (0, manifest_1.validateServiceManifest)(rawConfig, configPath);
+            if (validationResult.isLeft()) {
+                return validationResult;
+            }
+            const metadata = parseServiceMetadata(rawConfig, path.basename(servicePath));
+            serviceNames.add(metadata.name);
+        }
+        for (const yamlFile of yamlFiles) {
+            const servicePath = path.join(nodeModulesPath, path.dirname(yamlFile));
+            const deployPath = path.join(servicePath, 'pulumix.ts');
+            if (!fs.existsSync(deployPath)) {
+                continue;
+            }
+            const packageName = path.dirname(yamlFile).replace(/\\/g, '/');
+            if (!matchesAllowlist(packageName, allowlist)) {
+                continue;
+            }
+            const configPath = path.join(servicePath, 'pulumix.yaml');
+            const dockerPath = path.join(servicePath, 'Dockerfile');
+            const packageJsonPath = path.join(servicePath, 'package.json');
+            const configResult = parseYamlFile(configPath);
+            if (configResult.isLeft()) {
+                return configResult;
+            }
+            const rawConfig = configResult.unsafeCoerce();
+            const metadata = parseServiceMetadata(rawConfig, path.basename(servicePath));
+            const observability = rawConfig.observability;
+            const security = rawConfig.security;
+            const dependencies = extractDependenciesFromPackageJson(packageJsonPath, serviceNames);
+            services.push({
+                name: metadata.name,
+                path: servicePath,
+                deployPath,
+                configPath,
+                dependencies,
+                hasDockerfile: fs.existsSync(dockerPath),
+                rawConfig,
+                metadata,
+                observability,
+                security
+            });
+        }
+        return (0, Either_1.Right)(services);
+    }
+    catch (err) {
+        const message = err instanceof Error ? err.message : 'Unknown error';
+        return (0, Either_1.Left)((0, errors_1.createDiscoveryError)('InvalidGlobPattern', `Failed to discover published services: ${message}`, rootPath, { rootPath, allowlist }, err instanceof Error ? err : undefined));
+    }
+};
+exports.discoverPublishedServices = discoverPublishedServices;
+const sortByDependencies = (services) => {
+    const sorted = [];
+    const visited = new Set();
+    const serviceMap = new Map(services.map(s => [s.name, s]));
+    const visit = (name) => {
+        if (visited.has(name))
+            return;
+        visited.add(name);
+        const service = serviceMap.get(name);
+        if (!service)
+            return;
+        for (const dep of service.dependencies) {
+            visit(dep);
+        }
+        sorted.push(service);
+    };
+    for (const service of services) {
+        visit(service.name);
+    }
+    return sorted;
+};
+exports.sortByDependencies = sortByDependencies;
+const resolveStackConfig = (service, stackName) => {
+    const stacks = getConfigValue(service.rawConfig, 'stacks');
+    const stackConfig = stacks
+        .chain(s => getConfigValue(s, stackName))
+        .orDefault({});
+    return {
+        ...service,
+        stackConfig
+    };
+};
+exports.resolveStackConfig = resolveStackConfig;
+const filterServices = (services, names) => names?.length
+    ? services.filter(s => names.includes(s.name))
+    : services;
+const runCommandWithProgress = (command, args, onProgress, options) => {
+    return new Promise((resolve) => {
+        const { spawn } = require('child_process');
+        const proc = spawn(command, args, {
+            cwd: options?.cwd,
+            stdio: ['ignore', 'pipe', 'pipe']
+        });
+        let stdout = '';
+        let stderr = '';
+        proc.stdout.on('data', (data) => {
+            const text = data.toString();
+            stdout += text;
+            const lines = text.split('\n');
+            for (const line of lines) {
+                if (line.trim()) {
+                    onProgress(line.trim());
+                }
+            }
+        });
+        proc.stderr.on('data', (data) => {
+            stderr += data.toString();
+        });
+        proc.on('close', (code) => {
+            if (code !== 0) {
+                resolve((0, Either_1.Left)((0, errors_1.createDeploymentError)('PulumiFailed', `Command failed: ${command} ${args.join(' ')}\n${stderr || stdout}`, undefined, { exitCode: code })));
+            }
+            else {
+                resolve((0, Either_1.Right)(stdout));
+            }
+        });
+        proc.on('error', (err) => {
+            resolve((0, Either_1.Left)((0, errors_1.createDeploymentError)('PulumiFailed', `Command error: ${command} ${args.join(' ')}\n${err.message}`, undefined, { error: err })));
+        });
+    });
+};
+const clusterExists = (clusterName) => {
+    if (!isValidShellArg(clusterName)) {
+        return false;
+    }
+    const result = (0, child_process_1.spawnSync)('k3d', ['cluster', 'list', '-o', 'json'], {
+        encoding: 'utf-8',
+        stdio: 'pipe'
+    });
+    if (result.status !== 0) {
+        return false;
+    }
+    try {
+        const clusters = JSON.parse(result.stdout);
+        return clusters.some((c) => c.name === clusterName);
+    }
+    catch {
+        return false;
+    }
+};
+const createK3dCluster = async (clusterName, registryPort, port, eventEmitter) => {
+    if (!isValidShellArg(clusterName)) {
+        return (0, Either_1.Left)((0, errors_1.createDeploymentError)('ValidationFailed', `Invalid cluster name: ${clusterName}. Must contain only alphanumeric characters, hyphens, underscores, and periods.`));
+    }
+    if (registryPort < 1 || registryPort > 65535) {
+        return (0, Either_1.Left)((0, errors_1.createDeploymentError)('ValidationFailed', `Invalid registry port: ${registryPort}`));
+    }
+    const args = [
+        'cluster', 'create', clusterName,
+        '--registry-create', `${clusterName}-registry:0.0.0.0:${registryPort}`,
+        '--port', `${port}:80@loadbalancer`,
+        '--agents', '2',
+        '--wait'
+    ];
+    const result = await runCommandWithProgress('k3d', args, (line) => {
+        if (line.includes('Creating') || line.includes('Starting') || line.includes('Waiting') || line.includes('Successfully')) {
+            eventEmitter.emitTaskUpdate(clusterName, line);
+        }
+    }, { cwd: undefined });
+    return result.map(() => undefined);
+};
+const buildAndPushImage = async (service, registry, eventEmitter) => {
+    if (!service.hasDockerfile) {
+        return (0, Either_1.Right)(undefined);
+    }
+    const contentHash = await (0, docker_1.hashBuildContext)(service.path);
+    const imageTag = `${registry}/${service.name}:${contentHash}`;
+    const exists = await (0, docker_1.imageExistsInRegistry)(registry, service.name, contentHash);
+    if (exists) {
+        const digest = await (0, docker_1.getImageDigestFromRegistry)(registry, service.name, contentHash);
+        if (digest) {
+            eventEmitter.emitTaskUpdate(service.name, `unchanged (${contentHash})`);
+            return (0, Either_1.Right)({
+                imageRef: `${registry}/${service.name}@${digest}`,
+                skipped: true,
+                contentHash
+            });
+        }
+        eventEmitter.emitTaskUpdate(service.name, `unchanged (${contentHash})`);
+        return (0, Either_1.Right)({
+            imageRef: imageTag,
+            skipped: true,
+            contentHash
+        });
+    }
+    eventEmitter.emitTaskUpdate(service.name, `building (${contentHash})`);
+    const buildResult = await (0, docker_1.buildImage)({
+        contextPath: service.path,
+        tag: imageTag,
+        onProgress: (progress) => {
+            if (progress.current && progress.total) {
+                eventEmitter.emitTaskUpdate(service.name, progress.message, (progress.current / progress.total) * 100);
+            }
+            else {
+                eventEmitter.emitTaskUpdate(service.name, progress.message);
+            }
+        }
+    });
+    if (buildResult.isLeft()) {
+        return buildResult;
+    }
+    const pushResult = await (0, docker_1.pushImage)({
+        tag: imageTag,
+        onProgress: (progress) => {
+            const msg = progress.id
+                ? `${progress.status} ${progress.id}${progress.progress ? ` (${progress.progress}%)` : ''}`
+                : progress.status;
+            eventEmitter.emitTaskUpdate(service.name, msg);
+        }
+    });
+    if (pushResult.isLeft()) {
+        return pushResult;
+    }
+    const push = pushResult.extract();
+    if (push.digest) {
+        return (0, Either_1.Right)({
+            imageRef: `${registry}/${service.name}@${push.digest}`,
+            skipped: false,
+            contentHash
+        });
+    }
+    return (0, Either_1.Right)({
+        imageRef: imageTag,
+        skipped: false,
+        contentHash
+    });
+};
+const loadDeployFunction = async (service) => {
+    try {
+        const deployModule = await jiti.import(service.deployPath);
+        const deployFn = deployModule.default ?? deployModule;
+        if (typeof deployFn !== 'function') {
+            return (0, Either_1.Left)((0, errors_1.createConfigError)('InvalidConfigFormat', `${service.deployPath} must export a default function`, undefined, 'default', { serviceName: service.name, deployPath: service.deployPath }));
+        }
+        return (0, Either_1.Right)(deployFn);
+    }
+    catch (err) {
+        const message = err instanceof Error ? err.message : 'Unknown error';
+        return (0, Either_1.Left)((0, errors_1.createConfigError)('InvalidConfigFormat', `Failed to load deploy function from ${service.name}: ${message}`, undefined, 'deployPath', { serviceName: service.name, deployPath: service.deployPath }, err instanceof Error ? err : undefined));
+    }
+};
+class Orchestrator {
+    eventEmitter;
+    constructor(eventEmitter) {
+        this.eventEmitter = eventEmitter ?? (0, events_1.createEventEmitter)();
+    }
+    getEventEmitter() {
+        return this.eventEmitter;
+    }
+    validateEnvironment(stackName) {
+        if (stackName === 'production' && !process.env.PULUMI_CONFIG_PASSPHRASE) {
+            return (0, Either_1.Left)((0, errors_1.createConfigError)('MissingRequiredField', 'PULUMI_CONFIG_PASSPHRASE environment variable is required for production deployments', stackName, 'PULUMI_CONFIG_PASSPHRASE', { stackName, envVar: 'PULUMI_CONFIG_PASSPHRASE' }));
+        }
+        if (!process.env.PULUMI_CONFIG_PASSPHRASE) {
+            process.env.PULUMI_CONFIG_PASSPHRASE = '';
+        }
+        return (0, Either_1.Right)(undefined);
+    }
+    deploy(config) {
+        const startTime = Date.now();
+        return (0, EitherAsync_1.EitherAsync)(async ({ liftEither, throwE }) => {
+            await liftEither(this.validateEnvironment(config.stackName));
+            this.eventEmitter.emitPhaseStart('configuration');
+            const rootConfigPath = path.join(config.rootPath, 'pulumix.yaml');
+            const rootConfig = await liftEither(parseYamlFile(rootConfigPath));
+            const stacks = rootConfig.stacks ?? {};
+            const globalConfig = stacks[config.stackName] ?? {};
+            this.eventEmitter.emitPhaseComplete('configuration');
+            this.eventEmitter.emitPhaseStart('discovery');
+            const localServices = await liftEither(await (0, exports.discoverServices)(config.rootPath));
+            const allowlist = rootConfig.services?.allowed ?? [];
+            const publishedServices = await liftEither(await (0, exports.discoverPublishedServices)(config.rootPath, allowlist));
+            const localServiceNames = new Set(localServices.map(s => s.name));
+            const mergedServices = [
+                ...localServices,
+                ...publishedServices.filter(s => !localServiceNames.has(s.name))
+            ];
+            const services = filterServices(mergedServices, config.servicesToDeploy);
+            for (let i = 0; i < services.length; i++) {
+                const service = services[i];
+                const isLast = i === services.length - 1;
+                const prefix = isLast ? '└─' : '├─';
+                const source = localServiceNames.has(service.name) ? 'local' : 'published';
+                this.eventEmitter.emitLog('info', `${prefix} ${service.name} (${source})`, undefined, 'Discovery');
+            }
+            this.eventEmitter.emitPhaseComplete('discovery');
+            this.eventEmitter.emitPhaseStart('dependency-analysis');
+            const sorted = (0, exports.sortByDependencies)(services);
+            for (let i = 0; i < sorted.length; i++) {
+                const service = sorted[i];
+                const isLast = i === sorted.length - 1;
+                const prefix = isLast ? '└─' : '├─';
+                const deps = service.dependencies.length > 0
+                    ? ` (requires: ${service.dependencies.join(', ')})`
+                    : '';
+                this.eventEmitter.emitLog('info', `${prefix} ${service.name}${deps}`, undefined, 'DependencyGraph');
+            }
+            this.eventEmitter.emitPhaseComplete('dependency-analysis');
+            const providerService = sorted.find(s => s.name === 'provider');
+            const providerConfig = providerService
+                ? (0, exports.resolveStackConfig)(providerService, config.stackName).stackConfig
+                : {};
+            const k3dConfig = getConfigValue(providerConfig, 'k3d').orDefault({});
+            const hostRegistry = getConfigValue(globalConfig, 'hostRegistry').orDefault('') ||
+                k3dConfig.hostRegistry ||
+                (k3dConfig.registryPort ? `localhost:${k3dConfig.registryPort}` : 'localhost:5001');
+            const clusterRegistry = getConfigValue(globalConfig, 'clusterRegistry').orDefault('') ||
+                k3dConfig.clusterRegistry ||
+                hostRegistry;
+            const servicesToBuild = sorted.filter(s => s.hasDockerfile);
+            if (servicesToBuild.length > 0 && k3dConfig.enabled) {
+                this.eventEmitter.emitPhaseStart('bootstrap');
+                const clusterName = k3dConfig.clusterName ?? 'pulumix-dev';
+                const port = k3dConfig.port ?? 80;
+                const registryPort = k3dConfig.registryPort ?? 5001;
+                if (clusterExists(clusterName)) {
+                    this.eventEmitter.emitTaskStart(clusterName);
+                    this.eventEmitter.emitTaskComplete(clusterName, true, true);
+                }
+                else {
+                    this.eventEmitter.emitTaskStart(clusterName);
+                    const createResult = await createK3dCluster(clusterName, registryPort, port, this.eventEmitter);
+                    const success = createResult.isRight();
+                    this.eventEmitter.emitTaskComplete(clusterName, success);
+                    if (createResult.isLeft()) {
+                        throw throwE(createResult.extract());
+                    }
+                }
+                this.eventEmitter.emitPhaseComplete('bootstrap');
+            }
+            const builtImages = {};
+            if (servicesToBuild.length > 0) {
+                this.eventEmitter.emitPhaseStart('image-build');
+                for (const service of servicesToBuild) {
+                    this.eventEmitter.emitTaskStart(service.name);
+                    const buildResult = await buildAndPushImage(service, hostRegistry, this.eventEmitter);
+                    if (buildResult.isLeft()) {
+                        const error = buildResult.extract();
+                        this.eventEmitter.emitTaskComplete(service.name, false);
+                        this.eventEmitter.emitLog('warn', error.message, undefined, 'Build');
+                    }
+                    else {
+                        const result = buildResult.unsafeCoerce();
+                        if (result) {
+                            const imageWithoutRegistry = result.imageRef.replace(`${hostRegistry}/`, '');
+                            builtImages[service.name] = `${clusterRegistry}/${imageWithoutRegistry}`;
+                            this.eventEmitter.emitTaskComplete(service.name, true, result.skipped, result.contentHash);
+                        }
+                    }
+                }
+                this.eventEmitter.emitPhaseComplete('image-build');
+            }
+            this.eventEmitter.emitPhaseStart('deployment');
+            const namespace = getConfigValue(globalConfig, 'namespace').orDefault(config.stackName);
+            const outputs = {};
+            const program = async () => {
+                for (const service of sorted) {
+                    const resolved = (0, exports.resolveStackConfig)(service, config.stackName);
+                    const ctx = {
+                        stackName: config.stackName,
+                        serviceName: service.name,
+                        metadata: service.metadata,
+                        observability: service.observability,
+                        security: service.security,
+                        config: resolved.stackConfig,
+                        globalConfig,
+                        namespace,
+                        dependencies: outputs,
+                        image: builtImages[service.name]
+                    };
+                    const deployFnResult = await loadDeployFunction(service);
+                    if (deployFnResult.isLeft()) {
+                        throw deployFnResult.extract();
+                    }
+                    const deployFn = deployFnResult.unsafeCoerce();
+                    const result = await deployFn(ctx);
+                    if (result?.outputs) {
+                        outputs[service.name] = result.outputs;
+                    }
+                }
+            };
+            const backendUrl = resolveBackendUrl(config.rootPath, rootConfig, config.stackName);
+            const workDir = resolveWorkDir(config.rootPath, rootConfig, config.stackName);
+            if (!fs.existsSync(workDir)) {
+                fs.mkdirSync(workDir, { recursive: true });
+            }
+            const projectName = rootConfig.name ?? 'pulumix-project';
+            const stack = await automation_1.LocalWorkspace.createOrSelectStack({
+                stackName: config.stackName,
+                projectName,
+                program
+            }, {
+                workDir,
+                projectSettings: {
+                    name: projectName,
+                    runtime: 'nodejs',
+                    backend: { url: backendUrl }
+                }
+            });
+            await stack.up({
+                onOutput: config.onOutput || ((msg) => this.eventEmitter.emitLog('info', msg, undefined, 'Deploy')),
+            });
+            this.eventEmitter.emitPhaseComplete('deployment');
+            const stackOutputs = await stack.outputs();
+            const allOutputs = {
+                ...outputs,
+                _stack: Object.fromEntries(Object.entries(stackOutputs).map(([k, v]) => [k, v.value]))
+            };
+            return {
+                success: true,
+                stack: config.stackName,
+                servicesDeployed: sorted.length,
+                duration: Date.now() - startTime,
+                outputs: allOutputs
+            };
+        });
+    }
+    destroy(config) {
+        const startTime = Date.now();
+        return (0, EitherAsync_1.EitherAsync)(async ({ liftEither }) => {
+            await liftEither(this.validateEnvironment(config.stackName));
+            const rootConfigPath = path.join(config.rootPath, 'pulumix.yaml');
+            const rootConfig = await liftEither(parseYamlFile(rootConfigPath));
+            const backendUrl = resolveBackendUrl(config.rootPath, rootConfig, config.stackName);
+            const workDir = resolveWorkDir(config.rootPath, rootConfig, config.stackName);
+            const projectName = rootConfig.name ?? 'pulumix-project';
+            const program = async () => {
+            };
+            const stack = await automation_1.LocalWorkspace.createOrSelectStack({
+                stackName: config.stackName,
+                projectName,
+                program
+            }, {
+                workDir,
+                projectSettings: {
+                    name: projectName,
+                    runtime: 'nodejs',
+                    backend: { url: backendUrl }
+                }
+            });
+            await stack.destroy({
+                onOutput: config.onOutput || ((msg) => this.eventEmitter.emitLog('info', msg, undefined, 'Deploy')),
+            });
+            return {
+                success: true,
+                stack: config.stackName,
+                servicesDeployed: 0,
+                duration: Date.now() - startTime,
+                outputs: {}
+            };
+        });
+    }
+}
+exports.Orchestrator = Orchestrator;
+const createOrchestrator = (eventEmitter) => new Orchestrator(eventEmitter);
+exports.createOrchestrator = createOrchestrator;
+//# sourceMappingURL=index.js.map