devchain-cli 0.9.2 → 0.10.0

package/dist/server/modules/orchestrator/docker/services/docker.service.js

@@ -0,0 +1,745 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+var __param = (this && this.__param) || function (paramIndex, decorator) {
+    return function (target, key) { decorator(target, key, paramIndex); }
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OrchestratorDockerService = void 0;
+const common_1 = require("@nestjs/common");
+const child_process_1 = require("child_process");
+const Dockerode = require("dockerode");
+const fs_1 = require("fs");
+const os_1 = require("os");
+const path_1 = require("path");
+const logger_1 = require("../../../../common/logging/logger");
+const templates_directory_1 = require("../../../../common/templates-directory");
+const logger = (0, logger_1.createLogger)('OrchestratorDockerService');
+const DOCKER_SOCKET_PATH = '/var/run/docker.sock';
+const DEFAULT_CONTAINER_PORT = 3000;
+const DEFAULT_CONTAINER_HOME_PATH = '/home/node';
+const DEFAULT_CONTAINER_PROJECT_PATH = '/project';
+const DEFAULT_CONTAINER_DATA_PATH = `${DEFAULT_CONTAINER_HOME_PATH}/.devchain`;
+const DEFAULT_CONTAINER_SKILLS_SEED_PATH = '/seed-skills';
+const DEFAULT_CONTAINER_TEMPLATES_PATH = '/app/apps/local-app/dist/templates';
+const DEFAULT_CONTAINER_REGISTRY_CACHE_PATH = `${DEFAULT_CONTAINER_HOME_PATH}/.devchain/registry-cache`;
+const WORKTREE_NETWORK_PREFIX = 'devchain-wt-';
+const WORKTREE_NETWORK_SUFFIX = '-net';
+const WORKTREE_CONTAINER_PREFIX = 'devchain-wt-';
+const COMPOSE_PROJECT_LABEL = 'com.docker.compose.project';
+const COMPOSE_DEFAULT_NETWORK_SUFFIX = '_default';
+const HEALTH_POLL_INTERVAL_MS = 1000;
+const HEALTH_REQUEST_TIMEOUT_MS = 1500;
+function readGitConfig(worktreePath, key) {
+    try {
+        return ((0, child_process_1.execFileSync)('git', ['-C', worktreePath, 'config', key], { encoding: 'utf-8' }).trim() || null);
+    }
+    catch {
+        return null;
+    }
+}
+let OrchestratorDockerService = class OrchestratorDockerService {
+    constructor(docker = new Dockerode({ socketPath: DOCKER_SOCKET_PATH })) {
+        this.docker = docker;
+    }
+    async createContainer(config) {
+        const containerPort = config.containerPort ?? DEFAULT_CONTAINER_PORT;
+        const image = this.resolveContainerImage(config.image);
+        const worktreeName = this.resolveWorktreeName(config);
+        await this.ensureImageAvailable(image);
+        const networkName = await this.ensureWorktreeNetwork(worktreeName);
+        const envMap = this.buildEnvMap(config.env, worktreeName);
+        const gitUserName = readGitConfig(config.worktreePath, 'user.name');
+        const gitUserEmail = readGitConfig(config.worktreePath, 'user.email');
+        if (gitUserName) {
+            envMap.GIT_AUTHOR_NAME ??= gitUserName;
+            envMap.GIT_COMMITTER_NAME ??= gitUserName;
+        }
+        if (gitUserEmail) {
+            envMap.GIT_AUTHOR_EMAIL ??= gitUserEmail;
+            envMap.GIT_COMMITTER_EMAIL ??= gitUserEmail;
+        }
+        const authMounts = this.discoverProviderAuthMounts();
+        if (!envMap.ENABLED_PROVIDERS) {
+            envMap.ENABLED_PROVIDERS = authMounts.map((mount) => mount.provider).join(',');
+        }
+        const binds = this.buildBindMounts(config, authMounts);
+        const labels = this.buildLabels(config, worktreeName);
+        logger.info({
+            name: config.name,
+            worktreeName,
+            networkName,
+            image,
+            bindCount: binds.length,
+            providers: envMap.ENABLED_PROVIDERS,
+        }, 'Creating orchestrator worktree container');
+        const container = await this.docker.createContainer({
+            name: config.name,
+            Image: image,
+            Env: Object.entries(envMap).map(([key, value]) => `${key}=${value}`),
+            Cmd: config.command,
+            Entrypoint: config.entrypoint,
+            Labels: labels,
+            ExposedPorts: {
+                [`${containerPort}/tcp`]: {},
+            },
+            HostConfig: {
+                Binds: binds,
+                CapAdd: ['SYS_PTRACE'],
+                NetworkMode: networkName,
+                PortBindings: {
+                    [`${containerPort}/tcp`]: [{ HostIp: '127.0.0.1', HostPort: '' }],
+                },
+            },
+        });
+        await container.start();
+        await this.ensureWorktreeOnComposeNetwork(worktreeName, container.id).catch((error) => {
+            logger.warn({ error, worktreeName, containerId: container.id }, 'Failed attaching worktree container to compose default network');
+        });
+        const inspect = await container.inspect();
+        return {
+            id: container.id,
+            name: inspect.Name.replace(/^\//, ''),
+            image,
+            hostPort: this.extractHostPort(inspect, containerPort),
+            state: inspect.State?.Status ?? 'unknown',
+        };
+    }
+    async startContainer(containerId) {
+        await this.docker.getContainer(containerId).start();
+    }
+    async getContainerHostPort(containerId, containerPort = DEFAULT_CONTAINER_PORT) {
+        const inspect = await this.docker.getContainer(containerId).inspect();
+        return this.extractHostPort(inspect, containerPort);
+    }
+    async stopContainer(containerId) {
+        await this.docker.getContainer(containerId).stop({ t: 30 });
+    }
+    async removeContainer(containerId, force = false) {
+        await this.docker.getContainer(containerId).remove({ force });
+    }
+    async inspectContainer(containerId) {
+        return this.docker.getContainer(containerId).inspect();
+    }
+    async getContainerLogs(containerId, tail = 200) {
+        const logs = await this.docker.getContainer(containerId).logs({
+            stdout: true,
+            stderr: true,
+            timestamps: false,
+            tail,
+        });
+        if (Buffer.isBuffer(logs)) {
+            return this.decodeDockerMultiplexStream(logs);
+        }
+        const output = await this.readStreamFully(logs);
+        return this.decodeDockerMultiplexStream(output);
+    }
+    async waitForHealthy(containerId, timeoutMs) {
+        if (timeoutMs <= 0) {
+            return false;
+        }
+        const deadline = Date.now() + timeoutMs;
+        while (Date.now() < deadline) {
+            const inspect = await this.inspectContainer(containerId);
+            const hostPort = this.extractHostPort(inspect, DEFAULT_CONTAINER_PORT);
+            if (hostPort) {
+                const isHealthy = await this.checkReadyEndpoint(hostPort);
+                if (isHealthy) {
+                    return true;
+                }
+            }
+            await this.sleep(HEALTH_POLL_INTERVAL_MS);
+        }
+        return false;
+    }
+    async execInContainer(containerId, cmd, options) {
+        const exec = await this.docker.getContainer(containerId).exec({
+            Cmd: cmd,
+            AttachStdout: true,
+            AttachStderr: true,
+            Tty: false,
+            WorkingDir: options?.workingDir,
+        });
+        const stream = await exec.start({ hijack: false, stdin: false });
+        const outputBuffer = await this.readStreamFully(stream);
+        const inspect = await exec.inspect();
+        return {
+            exitCode: inspect.ExitCode ?? 1,
+            output: this.decodeDockerMultiplexStream(outputBuffer),
+        };
+    }
+    async subscribeToContainerEvents(onEvent) {
+        const filters = JSON.stringify({ type: ['container'] });
+        const stream = await this.docker.getEvents({ filters });
+        let buffered = '';
+        const onData = (chunk) => {
+            buffered += Buffer.isBuffer(chunk) ? chunk.toString('utf8') : chunk;
+            const lines = buffered.split('\n');
+            buffered = lines.pop() ?? '';
+            for (const line of lines) {
+                if (!line.trim()) {
+                    continue;
+                }
+                try {
+                    const parsed = JSON.parse(line);
+                    onEvent(parsed);
+                }
+                catch (error) {
+                    logger.warn({ error, line }, 'Failed parsing docker event line');
+                }
+            }
+        };
+        const onError = (error) => {
+            logger.warn({ error }, 'Docker events stream error');
+        };
+        stream.on('data', onData);
+        stream.on('error', onError);
+        return () => {
+            stream.off('data', onData);
+            stream.off('error', onError);
+            if ('destroy' in stream && typeof stream.destroy === 'function') {
+                stream.destroy();
+            }
+        };
+    }
+    async ping() {
+        try {
+            await this.docker.ping();
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    async cleanupWorktreeProjectContainers(worktreeName, worktreeContainerId) {
+        const normalizedWorktreeName = worktreeName.trim();
+        if (!normalizedWorktreeName) {
+            return;
+        }
+        const networkName = this.getWorktreeNetworkName(normalizedWorktreeName);
+        const worktreeContainerName = this.getWorktreeContainerName(normalizedWorktreeName);
+        if (worktreeContainerId) {
+            await this.tryComposeDown(normalizedWorktreeName, worktreeContainerId);
+        }
+        await this.cleanupComposeProjectContainers({
+            composeProjectName: normalizedWorktreeName,
+            worktreeContainerId: worktreeContainerId ?? undefined,
+            worktreeContainerName,
+        });
+        await this.cleanupComposeProjectNetworks(normalizedWorktreeName);
+        await this.cleanupContainersAttachedToNetwork({
+            networkName,
+            worktreeContainerId: worktreeContainerId ?? undefined,
+            worktreeContainerName,
+        });
+    }
+    async ensureWorktreeOnComposeNetwork(worktreeName, containerId) {
+        const normalizedWorktreeName = worktreeName.trim();
+        const normalizedContainerId = containerId.trim();
+        if (!normalizedWorktreeName || !normalizedContainerId) {
+            return;
+        }
+        const composeNetworkName = this.getComposeDefaultNetworkName(normalizedWorktreeName);
+        const network = this.docker.getNetwork(composeNetworkName);
+        let inspect;
+        try {
+            inspect = await network.inspect();
+        }
+        catch (error) {
+            if (this.isDockerNotFoundError(error)) {
+                return;
+            }
+            logger.warn({ error, worktreeName: normalizedWorktreeName, networkName: composeNetworkName }, 'Failed inspecting compose network for worktree attachment');
+            return;
+        }
+        const attached = Object.keys(inspect.Containers ?? {}).some((id) => this.matchesContainerId(normalizedContainerId, id));
+        if (attached) {
+            return;
+        }
+        if (typeof network.connect !== 'function') {
+            return;
+        }
+        try {
+            await network.connect({ Container: normalizedContainerId });
+        }
+        catch (error) {
+            if (this.isDockerNotFoundError(error) || this.isAlreadyConnectedError(error)) {
+                return;
+            }
+            logger.warn({
+                error,
+                worktreeName: normalizedWorktreeName,
+                containerId: normalizedContainerId,
+                networkName: composeNetworkName,
+            }, 'Failed connecting worktree container to compose network');
+        }
+    }
+    async removeWorktreeNetwork(worktreeName) {
+        const normalizedWorktreeName = worktreeName.trim();
+        if (!normalizedWorktreeName) {
+            return;
+        }
+        await this.removeNetworkByName(this.getWorktreeNetworkName(normalizedWorktreeName));
+        await this.removeNetworkByName(this.getComposeDefaultNetworkName(normalizedWorktreeName));
+    }
+    buildEnvMap(userEnv, worktreeName) {
+        const envMap = {
+            HOST: '0.0.0.0',
+            NODE_ENV: 'production',
+            ...(userEnv ?? {}),
+        };
+        if (!envMap.COMPOSE_PROJECT_NAME) {
+            envMap.COMPOSE_PROJECT_NAME = worktreeName;
+        }
+        return envMap;
+    }
+    buildLabels(config, worktreeName) {
+        return {
+            'devchain.worktree': worktreeName,
+            ...(config.labels ?? {}),
+        };
+    }
+    buildBindMounts(config, authMounts) {
+        const containerProjectPath = config.containerProjectPath ?? DEFAULT_CONTAINER_PROJECT_PATH;
+        const containerDataPath = config.containerDataPath ?? DEFAULT_CONTAINER_DATA_PATH;
+        const binds = [
+            `${config.worktreePath}:${containerProjectPath}:rw`,
+            `${config.dataPath}:${containerDataPath}:rw`,
+            ...authMounts.map((mount) => mount.bind),
+            ...(config.additionalBinds ?? []),
+            `${DOCKER_SOCKET_PATH}:${DOCKER_SOCKET_PATH}:rw`,
+        ];
+        const gitCommonDirMount = this.discoverGitCommonDirMount(config.worktreePath);
+        if (gitCommonDirMount) {
+            binds.push(gitCommonDirMount);
+        }
+        const skillsSeedMount = this.discoverSkillsSeedMount();
+        if (skillsSeedMount) {
+            binds.push(skillsSeedMount);
+        }
+        const templatesMounts = this.discoverTemplatesMounts();
+        binds.push(...templatesMounts);
+        return binds;
+    }
+    discoverGitCommonDirMount(worktreePath) {
+        const gitPath = (0, path_1.join)(worktreePath, '.git');
+        if (!(0, fs_1.existsSync)(gitPath)) {
+            return null;
+        }
+        let gitPathStats;
+        try {
+            gitPathStats = (0, fs_1.statSync)(gitPath);
+        }
+        catch (error) {
+            logger.warn({ error, gitPath }, 'Failed to stat .git path while resolving bind mounts');
+            return null;
+        }
+        if (gitPathStats.isDirectory()) {
+            return null;
+        }
+        if (!gitPathStats.isFile()) {
+            logger.warn({ gitPath }, 'Skipping git metadata mount: .git is not a file or directory');
+            return null;
+        }
+        let gitdirPath = null;
+        try {
+            const gitFileContents = (0, fs_1.readFileSync)(gitPath, 'utf8');
+            const gitdirLine = gitFileContents
+                .split(/\r?\n/)
+                .find((line) => line.trimStart().toLowerCase().startsWith('gitdir:'));
+            if (gitdirLine) {
+                gitdirPath = gitdirLine.slice(gitdirLine.indexOf(':') + 1).trim();
+            }
+        }
+        catch (error) {
+            logger.warn({ error, gitPath }, 'Failed to read .git file while resolving bind mounts');
+            return null;
+        }
+        if (!gitdirPath) {
+            logger.warn({ gitPath }, 'Skipping git metadata mount: .git file missing gitdir entry');
+            return null;
+        }
+        if (!path_1.posix.isAbsolute(gitdirPath)) {
+            logger.warn({ gitPath, gitdirPath }, 'Skipping git metadata mount: gitdir path is not POSIX-absolute');
+            return null;
+        }
+        const repoGitCommonDir = (0, path_1.dirname)((0, path_1.dirname)(gitdirPath));
+        try {
+            const commonDirStats = (0, fs_1.statSync)(repoGitCommonDir);
+            if (!commonDirStats.isDirectory()) {
+                logger.warn({ gitPath, gitdirPath, repoGitCommonDir }, 'Skipping git metadata mount: computed git common dir is not a directory');
+                return null;
+            }
+        }
+        catch (error) {
+            logger.warn({ error, gitPath, gitdirPath, repoGitCommonDir }, 'Skipping git metadata mount: computed git common dir does not exist');
+            return null;
+        }
+        return `${repoGitCommonDir}:${repoGitCommonDir}:rw`;
+    }
+    discoverProviderAuthMounts() {
+        const home = this.getHostHomeDir();
+        const providers = [
+            {
+                provider: 'claude',
+                source: (0, path_1.join)(home, '.claude', '.credentials.json'),
+                target: `${DEFAULT_CONTAINER_HOME_PATH}/.claude/.credentials.json`,
+            },
+            {
+                provider: 'codex',
+                source: (0, path_1.join)(home, '.codex', 'auth.json'),
+                target: `${DEFAULT_CONTAINER_HOME_PATH}/.codex/auth.json`,
+            },
+            {
+                provider: 'gemini',
+                source: (0, path_1.join)(home, '.gemini', 'oauth_creds.json'),
+                target: `${DEFAULT_CONTAINER_HOME_PATH}/.gemini/oauth_creds.json`,
+            },
+        ];
+        return providers
+            .filter((provider) => (0, fs_1.existsSync)(provider.source))
+            .map((provider) => ({
+            provider: provider.provider,
+            bind: `${provider.source}:${provider.target}:ro`,
+        }));
+    }
+    discoverSkillsSeedMount() {
+        const hostSkillsPath = (0, path_1.join)(this.getHostHomeDir(), '.devchain', 'skills');
+        if (!(0, fs_1.existsSync)(hostSkillsPath)) {
+            return null;
+        }
+        return `${hostSkillsPath}:${DEFAULT_CONTAINER_SKILLS_SEED_PATH}:ro`;
+    }
+    discoverTemplatesMounts() {
+        const mounts = [];
+        const hostTemplatesDir = (0, templates_directory_1.resolveTemplatesDirectory)(__dirname);
+        if (hostTemplatesDir) {
+            mounts.push(`${hostTemplatesDir}:${DEFAULT_CONTAINER_TEMPLATES_PATH}:ro`);
+        }
+        const hostRegistryCache = (0, path_1.join)(this.getHostHomeDir(), '.devchain', 'registry-cache');
+        if ((0, fs_1.existsSync)(hostRegistryCache)) {
+            mounts.push(`${hostRegistryCache}:${DEFAULT_CONTAINER_REGISTRY_CACHE_PATH}:ro`);
+        }
+        return mounts;
+    }
+    getHostHomeDir() {
+        return process.env.HOME?.trim() || (0, os_1.homedir)();
+    }
+    resolveWorktreeName(config) {
+        const explicit = config.worktreeName?.trim();
+        if (explicit) {
+            return explicit;
+        }
+        const derived = config.name.replace(/^devchain-wt-/, '').trim();
+        return derived || config.name.trim();
+    }
+    resolveContainerImage(explicitImage) {
+        const imageFromConfig = explicitImage?.trim();
+        if (imageFromConfig) {
+            return imageFromConfig;
+        }
+        const imageFromEnv = process.env.ORCHESTRATOR_CONTAINER_IMAGE?.trim();
+        if (imageFromEnv) {
+            return imageFromEnv;
+        }
+        const mode = process.env.DEVCHAIN_MODE?.trim();
+        if (mode === 'orchestrator' || mode === 'main') {
+            throw new Error('ORCHESTRATOR_CONTAINER_IMAGE is required in container mode. Set it to a versioned GHCR image reference.');
+        }
+        throw new Error('Container image is required. Provide config.image or set ORCHESTRATOR_CONTAINER_IMAGE.');
+    }
+    getWorktreeNetworkName(worktreeName) {
+        return `${WORKTREE_NETWORK_PREFIX}${worktreeName}${WORKTREE_NETWORK_SUFFIX}`;
+    }
+    getWorktreeContainerName(worktreeName) {
+        return `${WORKTREE_CONTAINER_PREFIX}${worktreeName}`;
+    }
+    getComposeDefaultNetworkName(worktreeName) {
+        return `${worktreeName}${COMPOSE_DEFAULT_NETWORK_SUFFIX}`;
+    }
+    async ensureWorktreeNetwork(worktreeName) {
+        const networkName = this.getWorktreeNetworkName(worktreeName);
+        try {
+            await this.docker.getNetwork(networkName).inspect();
+            return networkName;
+        }
+        catch {
+        }
+        try {
+            await this.docker.createNetwork({
+                Name: networkName,
+                CheckDuplicate: true,
+                Labels: {
+                    'devchain.worktree': worktreeName,
+                    'devchain.managed': 'true',
+                },
+            });
+            return networkName;
+        }
+        catch {
+            await this.docker.getNetwork(networkName).inspect();
+            return networkName;
+        }
+    }
+    async tryComposeDown(worktreeName, containerId) {
+        try {
+            const result = await this.execInContainer(containerId, ['docker', 'compose', '-p', worktreeName, 'down', '--remove-orphans'], { workingDir: DEFAULT_CONTAINER_PROJECT_PATH });
+            if (result.exitCode !== 0) {
+                logger.warn({
+                    worktreeName,
+                    containerId,
+                    exitCode: result.exitCode,
+                    output: result.output,
+                }, 'docker compose down returned non-zero exit code; continuing with fallback cleanup');
+            }
+        }
+        catch (error) {
+            logger.warn({ error, worktreeName, containerId }, 'docker compose down failed; continuing with fallback cleanup');
+        }
+    }
+    async cleanupContainersAttachedToNetwork(input) {
+        const network = this.docker.getNetwork(input.networkName);
+        let inspect;
+        try {
+            inspect = await network.inspect();
+        }
+        catch (error) {
+            if (this.isDockerNotFoundError(error)) {
+                return;
+            }
+            logger.warn({ error, networkName: input.networkName }, 'Failed inspecting worktree network for fallback cleanup');
+            return;
+        }
+        const containers = inspect.Containers ?? {};
+        for (const [containerId, containerInfo] of Object.entries(containers)) {
+            const containerName = containerInfo?.Name;
+            if ((input.worktreeContainerId &&
+                this.matchesContainerId(input.worktreeContainerId, containerId)) ||
+                containerName === input.worktreeContainerName) {
+                continue;
+            }
+            try {
+                await this.stopContainer(containerId);
+            }
+            catch {
+            }
+            try {
+                await this.removeContainer(containerId, true);
+            }
+            catch (error) {
+                if (this.isDockerNotFoundError(error)) {
+                    continue;
+                }
+                logger.warn({ error, containerId, networkName: input.networkName }, 'Failed removing project sub-container during fallback cleanup');
+            }
+        }
+    }
+    async cleanupComposeProjectContainers(input) {
+        let containers = [];
+        try {
+            containers = await this.docker.listContainers({
+                all: true,
+                filters: {
+                    label: [`${COMPOSE_PROJECT_LABEL}=${input.composeProjectName}`],
+                },
+            });
+        }
+        catch (error) {
+            logger.warn({ error, composeProjectName: input.composeProjectName }, 'Failed listing compose project containers for cleanup');
+            return;
+        }
+        for (const container of containers) {
+            const containerId = container.Id;
+            if (!containerId) {
+                continue;
+            }
+            const names = container.Names ?? [];
+            const normalizedNames = names.map((name) => name.replace(/^\//, ''));
+            if ((input.worktreeContainerId &&
+                this.matchesContainerId(input.worktreeContainerId, containerId)) ||
+                normalizedNames.includes(input.worktreeContainerName)) {
+                continue;
+            }
+            try {
+                await this.stopContainer(containerId);
+            }
+            catch {
+            }
+            try {
+                await this.removeContainer(containerId, true);
+            }
+            catch (error) {
+                if (this.isDockerNotFoundError(error)) {
+                    continue;
+                }
+                logger.warn({ error, containerId, composeProjectName: input.composeProjectName }, 'Failed removing compose project container during cleanup');
+            }
+        }
+    }
+    async cleanupComposeProjectNetworks(composeProjectName) {
+        let networks = [];
+        try {
+            networks = await this.docker.listNetworks({
+                filters: {
+                    label: [`${COMPOSE_PROJECT_LABEL}=${composeProjectName}`],
+                },
+            });
+        }
+        catch (error) {
+            logger.warn({ error, composeProjectName }, 'Failed listing compose project networks for cleanup');
+            return;
+        }
+        for (const networkInfo of networks) {
+            const networkId = networkInfo.Id;
+            const networkName = networkInfo.Name;
+            if (!networkId) {
+                continue;
+            }
+            try {
+                await this.docker.getNetwork(networkId).remove();
+            }
+            catch (error) {
+                if (this.isDockerNotFoundError(error) || this.isNetworkInUseError(error)) {
+                    continue;
+                }
+                logger.warn({ error, composeProjectName, networkId, networkName }, 'Failed removing compose project network during cleanup');
+            }
+        }
+    }
+    matchesContainerId(expected, actual) {
+        return expected === actual || expected.startsWith(actual) || actual.startsWith(expected);
+    }
+    isDockerNotFoundError(error) {
+        if (!error || typeof error !== 'object') {
+            return false;
+        }
+        const maybeError = error;
+        if (maybeError.statusCode === 404) {
+            return true;
+        }
+        const message = `${maybeError.reason ?? ''} ${maybeError.message ?? ''}`.toLowerCase();
+        return message.includes('not found') || message.includes('no such');
+    }
+    isAlreadyConnectedError(error) {
+        if (!error || typeof error !== 'object') {
+            return false;
+        }
+        const maybeError = error;
+        if (maybeError.statusCode === 409) {
+            return true;
+        }
+        const message = `${maybeError.reason ?? ''} ${maybeError.message ?? ''}`.toLowerCase();
+        return (message.includes('already exists') ||
+            message.includes('already connected') ||
+            message.includes('endpoint with name'));
+    }
+    isNetworkInUseError(error) {
+        if (!error || typeof error !== 'object') {
+            return false;
+        }
+        const maybeError = error;
+        if (maybeError.statusCode === 409) {
+            return true;
+        }
+        const message = `${maybeError.reason ?? ''} ${maybeError.message ?? ''}`.toLowerCase();
+        return message.includes('active endpoints') || message.includes('resource is still in use');
+    }
+    async removeNetworkByName(networkName) {
+        try {
+            await this.docker.getNetwork(networkName).remove();
+        }
+        catch (error) {
+            if (this.isDockerNotFoundError(error)) {
+                return;
+            }
+            logger.warn({ error, networkName }, 'Failed to remove docker network');
+        }
+    }
+    async ensureImageAvailable(image) {
+        try {
+            await this.docker.getImage(image).inspect();
+            return;
+        }
+        catch {
+            logger.info({ image }, 'Docker image not found locally; pulling');
+        }
+        const pullStream = await this.docker.pull(image);
+        await new Promise((resolve, reject) => {
+            this.docker.modem.followProgress(pullStream, (error) => error ? reject(error) : resolve());
+        });
+    }
+    extractHostPort(inspect, containerPort) {
+        const key = `${containerPort}/tcp`;
+        const bindings = inspect.NetworkSettings?.Ports?.[key];
+        const hostPortRaw = bindings?.[0]?.HostPort;
+        if (!hostPortRaw) {
+            return null;
+        }
+        const parsed = Number.parseInt(hostPortRaw, 10);
+        return Number.isNaN(parsed) ? null : parsed;
+    }
+    async checkReadyEndpoint(hostPort) {
+        const controller = new AbortController();
+        const timeoutId = setTimeout(() => controller.abort(), HEALTH_REQUEST_TIMEOUT_MS);
+        try {
+            const response = await fetch(`http://127.0.0.1:${hostPort}/health/ready`, {
+                signal: controller.signal,
+            });
+            return response.status === 200;
+        }
+        catch {
+            return false;
+        }
+        finally {
+            clearTimeout(timeoutId);
+        }
+    }
+    async readStreamFully(stream) {
+        return new Promise((resolve, reject) => {
+            const chunks = [];
+            stream.on('data', (chunk) => {
+                chunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk));
+            });
+            stream.on('end', () => resolve(Buffer.concat(chunks)));
+            stream.on('error', reject);
+        });
+    }
+    decodeDockerMultiplexStream(buffer) {
+        if (buffer.length < 8) {
+            return buffer.toString('utf8');
+        }
+        const chunks = [];
+        let offset = 0;
+        while (offset + 8 <= buffer.length) {
+            const payloadLength = buffer.readUInt32BE(offset + 4);
+            const payloadStart = offset + 8;
+            const payloadEnd = payloadStart + payloadLength;
+            if (payloadLength < 0 || payloadEnd > buffer.length) {
+                return buffer.toString('utf8');
+            }
+            chunks.push(buffer.subarray(payloadStart, payloadEnd).toString('utf8'));
+            offset = payloadEnd;
+        }
+        if (offset !== buffer.length) {
+            return buffer.toString('utf8');
+        }
+        return chunks.join('');
+    }
+    sleep(ms) {
+        return new Promise((resolve) => setTimeout(resolve, ms));
+    }
+};
+exports.OrchestratorDockerService = OrchestratorDockerService;
+exports.OrchestratorDockerService = OrchestratorDockerService = __decorate([
+    (0, common_1.Injectable)(),
+    __param(0, (0, common_1.Optional)()),
+    __metadata("design:paramtypes", [Dockerode])
+], OrchestratorDockerService);
+//# sourceMappingURL=docker.service.js.map