iobroker.docker-manager 0.1.3 → 0.1.5

package/build/lib/DockerCommands.js

@@ -1,1042 +0,0 @@
-"use strict";
-// This class implements docker commands using CLI and
-// it monitors periodically the docker daemon status.
-// It manages containers defined in adapter.config.containers and monitors other containers
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-const node_util_1 = require("node:util");
-const node_child_process_1 = require("node:child_process");
-const node_os_1 = require("node:os");
-const promises_1 = require("node:dns/promises");
-const node_http_1 = __importDefault(require("node:http"));
-const range_check_1 = require("range_check");
-const execPromise = (0, node_util_1.promisify)(node_child_process_1.exec);
-function isHttpResponse(url, timeout = 1000) {
-    return new Promise(resolve => {
-        try {
-            const req = node_http_1.default.request(url, { method: 'HEAD', timeout }, res => {
-                resolve(typeof res.statusCode === 'number');
-                req.destroy();
-            });
-            req.on('error', error => {
-                if (error.toString().toUpperCase().includes('TIMEDOUT') ||
-                    error.toString().toUpperCase().includes('TIMEOUT')) {
-                    resolve('timeout');
-                }
-                else {
-                    resolve(false);
-                }
-            });
-            req.end();
-        }
-        catch {
-            resolve(false);
-        }
-    });
-}
-function findOwnIpFor(ipToAccess) {
-    if (!(0, range_check_1.isIP)(ipToAccess)) {
-        return null;
-    }
-    const interfaces = (0, node_os_1.networkInterfaces)();
-    for (const iface of Object.values(interfaces)) {
-        if (iface) {
-            for (const alias of iface) {
-                if (alias.family === 'IPv4' && !alias.internal && alias.cidr) {
-                    if ((0, range_check_1.inRange)(ipToAccess, alias.cidr)) {
-                        return alias.address;
-                    }
-                }
-            }
-        }
-    }
-    return null;
-}
-async function getIpForDomain(domain) {
-    try {
-        const result = await (0, promises_1.lookup)(domain);
-        return result.address;
-    }
-    catch {
-        return false;
-    }
-}
-class DockerCommands {
-    #installed = false;
-    #dockerVersion = '';
-    #needSudo = false;
-    #waitReady;
-    #adapter;
-    #ownContainers = [];
-    #timers = {
-        container: {},
-    };
-    #runningCommands = {};
-    checkedURLs = {};
-    #ownIps = [];
-    #domain2ip = {};
-    constructor(adapter) {
-        this.#adapter = adapter;
-        this.#ownContainers = adapter.config.containers || [];
-        this.#waitReady = new Promise(resolve => this.init().then(() => resolve()));
-    }
-    isReady() {
-        return this.#waitReady;
-    }
-    async init() {
-        const version = await this.#isDockerInstalled();
-        this.#installed = !!version;
-        if (version) {
-            this.#dockerVersion = version;
-        }
-        else {
-            const daemonRunning = await this.#isDockerDaemonRunning();
-            if (daemonRunning) {
-                // Docker daemon is running, but docker command not found
-                this.#adapter.log.warn('Docker daemon is running, but docker command not found. May be "iobroker" user has no access to Docker. Run "iob fix" command to fix it.');
-            }
-            else {
-                this.#adapter.log.warn('Docker is not installed. Please install Docker.');
-            }
-        }
-        if (this.#installed) {
-            this.#needSudo = await this.#isNeedSudo();
-            await this.#checkOwnContainers();
-        }
-    }
-    async #isDockerDaemonRunning() {
-        try {
-            const { stdout, stderr } = await execPromise('systemctl status docker');
-            // ● docker.service - Docker Application Container Engine
-            //      Loaded: loaded (/lib/systemd/system/docker.service; enabled; preset: enabled)
-            //      Active: active (running) since Fri 2025-08-15 08:37:22 CEST; 3 weeks 2 days ago
-            // TriggeredBy: ● docker.socket
-            //        Docs: https://docs.docker.com
-            //    Main PID: 785 (dockerd)
-            //       Tasks: 30
-            //         CPU: 4min 17.003s
-            //      CGroup: /system.slice/docker.service
-            //              ├─  785 /usr/bin/dockerd -H fd:// --containerd=/run/containerd/containerd.sock
-            //              ├─97032 /usr/bin/docker-proxy -proto tcp -host-ip 0.0.0.0 -host-port 5000 -container-ip 172.17.0.2 -container-port 5000 -use-listen-fd
-            //              └─97039 /usr/bin/docker-proxy -proto tcp -host-ip :: -host-port 5000 -container-ip 172.17.0.2 -container-port 5000 -use-listen-fd
-            if (stderr?.includes('could not be found') || stderr.includes('not-found')) {
-                this.#adapter.log.error(`Docker is not installed: ${stderr}`);
-                return false;
-            }
-            this.#adapter.log.error(`Docker daemon is not running`);
-            return stdout.includes('(running)');
-        }
-        catch {
-            return false;
-        }
-    }
-    async #checkOwnContainers() {
-        if (!this.#ownContainers.length) {
-            return;
-        }
-        const status = await this.containerList(true);
-        let images = await this.imageList();
-        for (let c = 0; c < this.#ownContainers.length; c++) {
-            const container = this.#ownContainers[c];
-            if (container.enabled !== false) {
-                // Check if container is running
-                const containerInfo = status.find(it => it.names === container.name);
-                if (containerInfo) {
-                    if (containerInfo.status !== 'running' && containerInfo.status !== 'restarting') {
-                        // Start the container
-                        this.#adapter.log.info(`Starting own container ${container.name}`);
-                        try {
-                            const result = await this.containerStart(containerInfo.id);
-                            if (result.stderr) {
-                                this.#adapter.log.warn(`Cannot start own container ${container.name}: ${result.stderr}`);
-                            }
-                        }
-                        catch (e) {
-                            this.#adapter.log.warn(`Cannot start own container ${container.name}: ${e.message}`);
-                        }
-                    }
-                    else {
-                        this.#adapter.log.debug(`Own container ${container.name} is already running`);
-                    }
-                }
-                else {
-                    // Create and start the container
-                    this.#adapter.log.info(`Creating and starting own container ${container.name}`);
-                    if (!images.find(it => `${it.repository}:${it.tag}` === container.image)) {
-                        this.#adapter.log.info(`Pulling image ${container.image} for own container ${container.name}`);
-                        try {
-                            const result = await this.imagePull(container.image);
-                            if (result.stderr) {
-                                this.#adapter.log.warn(`Cannot pull image ${container.image}: ${result.stderr}`);
-                                continue;
-                            }
-                        }
-                        catch (e) {
-                            this.#adapter.log.warn(`Cannot pull image ${container.image}: ${e.message}`);
-                            continue;
-                        }
-                        // Check that image is available now
-                        images = await this.imageList();
-                        if (!images.find(it => `${it.repository}:${it.tag}` === container.image)) {
-                            this.#adapter.log.warn(`Image ${container.image} for own container ${container.name} not found after pull`);
-                            continue;
-                        }
-                    }
-                    try {
-                        const result = await this.containerRun(container.image, container);
-                        if (result.stderr) {
-                            this.#adapter.log.warn(`Cannot start own container ${container.name}: ${result.stderr}`);
-                        }
-                    }
-                    catch (e) {
-                        this.#adapter.log.warn(`Cannot start own container ${container.name}: ${e.message}`);
-                    }
-                }
-            }
-        }
-    }
-    #exec(command) {
-        if (!this.#installed) {
-            return Promise.reject(new Error('Docker is not installed'));
-        }
-        const finalCommand = this.#needSudo ? `sudo docker ${command}` : `docker ${command}`;
-        return execPromise(finalCommand);
-    }
-    async #isDockerInstalled() {
-        try {
-            const result = await execPromise('docker --version');
-            if (!result.stderr && result.stdout) {
-                // "Docker version 28.3.2, build 578ccf6\n"
-                return result.stdout.split('\n')[0].trim();
-            }
-            this.#adapter.log.debug(`Docker not installed: ${result.stderr}`);
-        }
-        catch (e) {
-            this.#adapter.log.debug(`Docker not installed: ${e.message}`);
-        }
-        return false;
-    }
-    async #isNeedSudo() {
-        try {
-            await execPromise('docker ps');
-            return false;
-        }
-        catch {
-            return true;
-        }
-    }
-    async discUsage() {
-        const { stdout } = await this.#exec(`system df`);
-        const result = { total: { size: 0, reclaimable: 0 } };
-        // parse the output
-        // TYPE            TOTAL     ACTIVE    SIZE      RECLAIMABLE
-        // Images          2         1         2.715GB   2.715GB (99%)
-        // Containers      1         1         26.22MB   0B (0%)
-        // Local Volumes   0         0         0B        0B
-        // Build Cache     0         0         0B        0B
-        const lines = stdout.split('\n');
-        for (const line of lines) {
-            const parts = line.trim().split(/\s+/);
-            if (parts.length >= 5 && parts[0] !== 'TYPE') {
-                let size;
-                let reclaimable;
-                if (parts[0] === 'Images') {
-                    const sizeStr = parts[3];
-                    const reclaimableStr = parts[4].split(' ')[0];
-                    size = this.#parseSize(sizeStr);
-                    reclaimable = this.#parseSize(reclaimableStr);
-                    result.images = {
-                        total: parseInt(parts[1], 10),
-                        active: parseInt(parts[2], 10),
-                        size,
-                        reclaimable: reclaimable,
-                    };
-                }
-                else if (parts[0] === 'Containers') {
-                    const sizeStr = parts[3];
-                    const reclaimableStr = parts[4].split(' ')[0];
-                    size = this.#parseSize(sizeStr);
-                    reclaimable = this.#parseSize(reclaimableStr);
-                    result.containers = {
-                        total: parseInt(parts[1], 10),
-                        active: parseInt(parts[2], 10),
-                        size,
-                        reclaimable: reclaimable,
-                    };
-                }
-                else if (parts[0] === 'Local' && parts[1] === 'Volumes') {
-                    const sizeStr = parts[4];
-                    const reclaimableStr = parts[5].split(' ')[0];
-                    size = this.#parseSize(sizeStr);
-                    reclaimable = this.#parseSize(reclaimableStr);
-                    result.volumes = {
-                        total: parseInt(parts[2], 10),
-                        active: parseInt(parts[3], 10),
-                        size,
-                        reclaimable: reclaimable,
-                    };
-                }
-                else if (parts[0] === 'Build' && parts[1] === 'Cache') {
-                    const sizeStr = parts[4];
-                    const reclaimableStr = parts[5].split(' ')[0];
-                    size = this.#parseSize(sizeStr);
-                    reclaimable = this.#parseSize(reclaimableStr);
-                    result.buildCache = {
-                        total: parseInt(parts[2], 10),
-                        active: parseInt(parts[3], 10),
-                        size,
-                        reclaimable: reclaimable,
-                    };
-                }
-                result.total.size += size;
-                result.total.reclaimable += reclaimable;
-            }
-        }
-        return result;
-    }
-    async imagePull(image) {
-        try {
-            const result = await this.#exec(`pull ${image}`);
-            const images = await this.imageList();
-            if (!images.find(it => `${it.repository}:${it.tag}` === image)) {
-                throw new Error(`Image ${image} not found after pull`);
-            }
-            await this.#adapter.sendToGui({
-                command: 'images',
-                data: images,
-            });
-            return result;
-        }
-        catch (e) {
-            return { stdout: '', stderr: e.message.toString() };
-        }
-    }
-    async imageNameAutocomplete(partialName) {
-        try {
-            // Read stars and descriptions
-            const { stdout } = await this.#exec(`search ${partialName} --format "{{.Name}};{{.Description}};{{.IsOfficial}};{{.StarCount}}" --limit 50`);
-            return stdout
-                .split('\n')
-                .filter(line => line.trim() !== '')
-                .map(line => {
-                const [name, description, isOfficial, starCount] = line.split(';');
-                return {
-                    name,
-                    description,
-                    isOfficial: isOfficial === 'true',
-                    starCount: parseInt(starCount, 10) || 0,
-                };
-            });
-        }
-        catch (e) {
-            this.#adapter.log.debug(`Cannot search images: ${e.message}`);
-            return [];
-        }
-    }
-    async containerRun(image, config) {
-        try {
-            const result = await this.#exec(`run ${this.#toDockerRun({ ...config, image })}`);
-            const containers = await this.containerList();
-            await this.#adapter.sendToGui({
-                command: 'containers',
-                data: containers,
-            });
-            return result;
-        }
-        catch (e) {
-            return { stdout: '', stderr: e.message.toString() };
-        }
-    }
-    async containerCreate(image, config) {
-        try {
-            const result = await this.#exec(`create ${this.#toDockerRun({ ...config, image })}`);
-            const containers = await this.containerList();
-            await this.#adapter.sendToGui({
-                command: 'containers',
-                data: containers,
-            });
-            return result;
-        }
-        catch (e) {
-            return { stdout: '', stderr: e.message.toString() };
-        }
-    }
-    async imageList() {
-        try {
-            const { stdout } = await this.#exec('images --format "{{.Repository}}:{{.Tag}};{{.ID}};{{.CreatedAt}};{{.Size}}"');
-            return stdout
-                .split('\n')
-                .filter(line => line.trim() !== '')
-                .map(line => {
-                const [repositoryTag, id, createdSince, size] = line.split(';');
-                const [repository, tag] = repositoryTag.split(':');
-                return {
-                    repository,
-                    tag,
-                    id,
-                    createdSince,
-                    size: this.#parseSize(size),
-                };
-            });
-        }
-        catch (e) {
-            this.#adapter.log.debug(`Cannot list images: ${e.message}`);
-            return [];
-        }
-    }
-    async imageBuild(dockerfilePath, tag) {
-        try {
-            const result = await this.#exec(`build -t ${tag} -f ${dockerfilePath} .`);
-            const images = await this.imageList();
-            await this.#adapter.sendToGui({
-                command: 'images',
-                data: images,
-            });
-            return result;
-        }
-        catch (e) {
-            return { stdout: '', stderr: e.message.toString() };
-        }
-    }
-    async imageTag(imageId, newTag) {
-        try {
-            const result = await this.#exec(`tag ${imageId} ${newTag}`);
-            const images = await this.imageList();
-            await this.#adapter.sendToGui({
-                command: 'images',
-                data: images,
-            });
-            return result;
-        }
-        catch (e) {
-            return { stdout: '', stderr: e.message.toString() };
-        }
-    }
-    async imageRemove(imageId) {
-        try {
-            const result = await this.#exec(`rmi ${imageId}`);
-            const images = await this.imageList();
-            if (images.find(it => `${it.repository}:${it.tag}` === imageId)) {
-                return { stdout: '', stderr: `Image ${imageId} still found after deletion` };
-            }
-            await this.#adapter.sendToGui({
-                command: 'images',
-                data: images,
-            });
-            return result;
-        }
-        catch (e) {
-            return { stdout: '', stderr: e.message.toString() };
-        }
-    }
-    async imageInspect(imageId) {
-        try {
-            const { stdout } = await this.#exec(`inspect ${imageId}`);
-            return JSON.parse(stdout)[0];
-        }
-        catch (e) {
-            this.#adapter.log.debug(`Cannot inspect image: ${e.message.toString()}`);
-            return null;
-        }
-    }
-    #parseSize(sizeStr) {
-        const units = {
-            B: 1,
-            KB: 1024,
-            MB: 1024 * 1024,
-            GB: 1024 * 1024 * 1024,
-            TB: 1024 * 1024 * 1024 * 1024,
-        };
-        const match = sizeStr.match(/^([\d.]+)([KMGTP]?B)$/);
-        if (match) {
-            const value = parseFloat(match[1]);
-            const unit = match[2];
-            return value * (units[unit] || 1);
-        }
-        return 0;
-    }
-    async containerStop(container) {
-        try {
-            let containers = await this.containerList();
-            // find ID of container
-            const containerInfo = containers.find(it => it.names === container || it.id === container);
-            if (!containerInfo) {
-                throw new Error(`Container ${container} not found`);
-            }
-            const result = await this.#exec(`stop ${containerInfo.id}`);
-            containers = await this.containerList();
-            if (containers.find(it => it.id === containerInfo.id && it.status === 'running')) {
-                throw new Error(`Container ${container} still running after stop`);
-            }
-            await this.#adapter.sendToGui({
-                command: 'containers',
-                data: containers,
-            });
-            return result;
-        }
-        catch (e) {
-            return { stdout: '', stderr: e.message.toString() };
-        }
-    }
-    async containerStart(container) {
-        try {
-            let containers = await this.containerList();
-            // find ID of container
-            const containerInfo = containers.find(it => it.names === container || it.id === container);
-            if (!containerInfo) {
-                throw new Error(`Container ${container} not found`);
-            }
-            const result = await this.#exec(`start ${containerInfo.id}`);
-            containers = await this.containerList();
-            if (containers.find(it => it.id === containerInfo.id && it.status !== 'running' && it.status !== 'restarting')) {
-                throw new Error(`Container ${container} still running after stop`);
-            }
-            await this.#adapter.sendToGui({
-                command: 'containers',
-                data: containers,
-            });
-            return result;
-        }
-        catch (e) {
-            return { stdout: '', stderr: e.message.toString() };
-        }
-    }
-    async containerRestart(container, timeoutSeconds) {
-        try {
-            let containers = await this.containerList();
-            // find ID of container
-            const containerInfo = containers.find(it => it.names === container || it.id === container);
-            if (!containerInfo) {
-                throw new Error(`Container ${container} not found`);
-            }
-            const result = await this.#exec(`restart -t ${timeoutSeconds || 5} ${containerInfo.id}`);
-            containers = await this.containerList();
-            await this.#adapter.sendToGui({
-                command: 'containers',
-                data: containers,
-            });
-            return result;
-        }
-        catch (e) {
-            return { stdout: '', stderr: e.message.toString() };
-        }
-    }
-    async containerRemove(container) {
-        try {
-            let containers = await this.containerList();
-            // find ID of container
-            const containerInfo = containers.find(it => it.names === container || it.id === container);
-            if (!containerInfo) {
-                throw new Error(`Container ${container} not found`);
-            }
-            const result = await this.#exec(`rm ${container}`);
-            containers = await this.containerList();
-            if (containers.find(it => it.id === containerInfo.id)) {
-                throw new Error(`Container ${container} still found after stop`);
-            }
-            await this.#adapter.sendToGui({
-                command: 'containers',
-                data: containers,
-            });
-            return result;
-        }
-        catch (e) {
-            return { stdout: '', stderr: e.message.toString() };
-        }
-    }
-    async containerList(all = true, ownIps) {
-        try {
-            const { stdout } = await this.#exec(`ps ${all ? '-a' : ''} --format  "{{.Names}};{{.Status}};{{.ID}};{{.Image}};{{.Command}};{{.CreatedAt}};{{.Ports}}"`);
-            const containers = stdout
-                .split('\n')
-                .filter(line => line.trim() !== '')
-                .map(line => {
-                const [names, statusInfo, id, image, command, createdAt, ports] = line.split(';');
-                const [status, ...uptime] = statusInfo.split(' ');
-                let statusKey = status.toLowerCase();
-                if (statusKey === 'up') {
-                    statusKey = 'running';
-                }
-                return { id, image, command, createdAt, status: statusKey, uptime: uptime.join(' '), ports, names };
-            });
-            if (ownIps) {
-                // Try to define if the provided ports are HTTP server
-                for (const container of containers) {
-                    if (!container.ports || container.status !== 'running') {
-                        continue;
-                    }
-                    const ports = container.ports?.split(',').map(p => p.trim()) || [];
-                    // We have something like '127.0.0.1:8086->8086/tcp'
-                    for (const port of ports) {
-                        const parts = port.split('->');
-                        if (parts.length === 2) {
-                            const [hostIp, hostPort] = parts[0].split(':');
-                            const [, protocol] = parts[1].split('/');
-                            if (protocol === 'tcp') {
-                                // request to the port and check if we get HTTP response
-                                // create url
-                                const url = `http://${hostIp === '127.0.0.1' ? 'localhost' : hostIp}:${hostPort}`;
-                                if (this.checkedURLs[url] === undefined || this.checkedURLs[url] === 'timeout') {
-                                    this.checkedURLs[url] = await isHttpResponse(url);
-                                }
-                                if (this.checkedURLs[url] === true) {
-                                    if (hostIp === '0.0.0.0') {
-                                        // find the local network interface IP that suits to ownIp
-                                        for (const ownIp of ownIps) {
-                                            const realIp = this.#domain2ip[ownIp] || ownIp;
-                                            if ((0, range_check_1.isIP)(realIp)) {
-                                                const hostIp = findOwnIpFor(this.#domain2ip[ownIp] || ownIp);
-                                                container.httpLinks ||= {};
-                                                container.httpLinks[ownIp] ||= [];
-                                                if (hostIp) {
-                                                    container.httpLinks[ownIp].push(url.replace('0.0.0.0', ownIp));
-                                                }
-                                                else {
-                                                    container.httpLinks[ownIp].push(url);
-                                                }
-                                            }
-                                        }
-                                    }
-                                    else {
-                                        for (const ownIp of ownIps) {
-                                            container.httpLinks ||= {};
-                                            container.httpLinks[ownIp] ||= [];
-                                            container.httpLinks[ownIp].push(url);
-                                        }
-                                    }
-                                }
-                            }
-                        }
-                    }
-                }
-            }
-            return containers;
-        }
-        catch (e) {
-            this.#adapter.log.debug(`Cannot list containers: ${e.message}`);
-            return [];
-        }
-    }
-    async containerLogs(containerNameOrId, options = {}) {
-        try {
-            const args = [];
-            if (options.tail !== undefined) {
-                args.push(`--tail ${options.tail}`);
-            }
-            if (options.follow) {
-                args.push(`--follow`);
-            }
-            const result = await this.#exec(`logs${args.length ? ` ${args.join(' ')}` : ''} ${containerNameOrId}`);
-            return (result.stdout || result.stderr).split('\n').filter(line => line.trim() !== '');
-        }
-        catch (e) {
-            return e
-                .toString()
-                .split('\n')
-                .map((line) => line.trim());
-        }
-    }
-    containerExecTerminate(sid, force, onUnsubscribe) {
-        if (this.#runningCommands[sid]) {
-            this.#runningCommands[sid].onUnsubscribe = onUnsubscribe;
-            if (force) {
-                this.#runningCommands[sid].p.kill('SIGKILL');
-            }
-            else {
-                this.#runningCommands[sid].p.kill('SIGTERM');
-                this.#runningCommands[sid].killTimeout ||= setTimeout(() => {
-                    if (this.#runningCommands[sid]) {
-                        this.#runningCommands[sid].killTimeout = null;
-                        this.#runningCommands[sid].p.kill('SIGKILL');
-                    }
-                }, 2000);
-            }
-            return true;
-        }
-        return false;
-    }
-    containerExec(container, command, sid) {
-        const hasTTY = process.stdin.isTTY && process.stdout.isTTY;
-        const args = ['exec'];
-        if (!command) {
-            this.#adapter.log.error('No command specified for exec');
-            return;
-        }
-        if (hasTTY) {
-            args.push('-t');
-        } // add TTY only when available
-        args.push(container);
-        command.split(' ').forEach(part => args.push(part));
-        let p;
-        try {
-            if (this.#needSudo) {
-                this.#adapter.log.debug(`Executing: sudo docker ${args.join(' ')}`);
-                p = (0, node_child_process_1.spawn)('sudo', ['docker', ...args], { stdio: ['pipe', 'pipe', 'pipe'] });
-            }
-            else {
-                this.#adapter.log.debug(`Executing: docker ${args.join(' ')}`);
-                p = (0, node_child_process_1.spawn)('docker', args, { stdio: ['pipe', 'pipe', 'pipe'] });
-            }
-        }
-        catch (e) {
-            void this.#adapter.sendToGui({
-                command: 'exec',
-                data: { stdout: '', stderr: e.message.toString(), containerId: container, code: 1 },
-            }, sid);
-            return;
-        }
-        this.#runningCommands[sid] = { p, killTimeout: null };
-        let stdout = '';
-        let stderr = '';
-        p.stdout.on('data', d => {
-            if (this.#runningCommands[sid] && !this.#runningCommands[sid].onUnsubscribe) {
-                stdout += d;
-                void this.#adapter.sendToGui({ command: 'exec', data: { stdout, stderr, containerId: container } }, sid);
-            }
-        });
-        p.stderr.on('data', d => {
-            if (this.#runningCommands[sid] && !this.#runningCommands[sid].onUnsubscribe) {
-                stderr += d;
-                void this.#adapter.sendToGui({ command: 'exec', data: { stdout, stderr, containerId: container } }, sid);
-            }
-        });
-        p.on('close', code => {
-            this.#adapter.log.debug(`Command finished with code ${code}`);
-            const killTimeout = this.#runningCommands[sid]?.killTimeout;
-            if (killTimeout) {
-                clearTimeout(killTimeout);
-            }
-            if (this.#runningCommands[sid] && !this.#runningCommands[sid].onUnsubscribe) {
-                void this.#adapter.sendToGui({ command: 'exec', data: { stdout, stderr, containerId: container, code } }, sid);
-            }
-            delete this.#runningCommands[sid];
-        });
-    }
-    async containerInspect(containerNameOrId) {
-        try {
-            const { stdout } = await this.#exec(`inspect ${containerNameOrId}`);
-            return JSON.parse(stdout)[0];
-        }
-        catch (e) {
-            this.#adapter.log.debug(`Cannot inspect container: ${e.message.toString()}`);
-            return null;
-        }
-    }
-    /**
-     * Build a docker run command string from ContainerConfig
-     */
-    #toDockerRun(config) {
-        const args = [];
-        // detach / interactive
-        if (config.detach !== false) {
-            // default is true
-            args.push('-d');
-        }
-        if (config.tty) {
-            args.push('-t');
-        }
-        if (config.stdinOpen) {
-            args.push('-i');
-        }
-        if (config.removeOnExit) {
-            args.push('--rm');
-        }
-        // name
-        if (config.name) {
-            args.push('--name', config.name);
-        }
-        // hostname / domain
-        if (config.hostname) {
-            args.push('--hostname', config.hostname);
-        }
-        if (config.domainname) {
-            args.push('--domainname', config.domainname);
-        }
-        // environment
-        if (config.environment) {
-            for (const [key, value] of Object.entries(config.environment)) {
-                args.push('-e', `${key}=${value}`);
-            }
-        }
-        if (config.envFile) {
-            for (const file of config.envFile) {
-                args.push('--env-file', file);
-            }
-        }
-        // labels
-        if (config.labels) {
-            for (const [key, value] of Object.entries(config.labels)) {
-                args.push('--label', `${key}=${value}`);
-            }
-        }
-        // ports
-        if (config.publishAllPorts) {
-            args.push('-P');
-        }
-        if (config.ports) {
-            for (const p of config.ports) {
-                if (!p.containerPort) {
-                    continue;
-                }
-                const mapping = (p.hostIP ? `${p.hostIP}:` : '') +
-                    (p.hostPort ? `${p.hostPort}:` : '') +
-                    p.containerPort +
-                    (p.protocol ? `/${p.protocol}` : '');
-                args.push('-p', mapping);
-            }
-        }
-        // volumes / mounts
-        if (config.volumes) {
-            for (const v of config.volumes) {
-                args.push('-v', v);
-            }
-        }
-        if (config.mounts) {
-            for (const m of config.mounts) {
-                let mount = `type=${m.type},target=${m.target}`;
-                if (m.source) {
-                    mount += `,source=${m.source}`;
-                }
-                if (m.readOnly) {
-                    mount += `,readonly`;
-                }
-                args.push('--mount', mount);
-            }
-        }
-        // restart policy
-        if (config.restart?.policy) {
-            const val = config.restart.policy === 'on-failure' && config.restart.maxRetries
-                ? `on-failure:${config.restart.maxRetries}`
-                : config.restart.policy;
-            args.push('--restart', val);
-        }
-        // user & workdir
-        if (config.user) {
-            args.push('--user', String(config.user));
-        }
-        if (config.workdir) {
-            args.push('--workdir', config.workdir);
-        }
-        // logging
-        if (config.logging?.driver) {
-            args.push('--log-driver', config.logging.driver);
-            if (config.logging.options) {
-                for (const [k, v] of Object.entries(config.logging.options)) {
-                    args.push('--log-opt', `${k}=${v}`);
-                }
-            }
-        }
-        // security
-        if (config.security?.privileged) {
-            args.push('--privileged');
-        }
-        if (config.security?.capAdd) {
-            for (const cap of config.security.capAdd) {
-                args.push('--cap-add', cap);
-            }
-        }
-        if (config.security?.capDrop) {
-            for (const cap of config.security.capDrop) {
-                args.push('--cap-drop', cap);
-            }
-        }
-        if (config.security?.noNewPrivileges) {
-            args.push('--security-opt', 'no-new-privileges');
-        }
-        if (config.security?.apparmor) {
-            args.push('--security-opt', `apparmor=${config.security.apparmor}`);
-        }
-        // network
-        if (config.networkMode) {
-            args.push('--network', config.networkMode);
-        }
-        // extra hosts
-        if (config.extraHosts) {
-            for (const host of config.extraHosts) {
-                if (typeof host === 'string') {
-                    args.push('--add-host', host);
-                }
-                else {
-                    args.push('--add-host', `${host.host}:${host.ip}`);
-                }
-            }
-        }
-        // sysctls
-        if (config.sysctls) {
-            for (const [k, v] of Object.entries(config.sysctls)) {
-                args.push('--sysctl', `${k}=${v}`);
-            }
-        }
-        // stop signal / timeout
-        if (config.stop?.signal) {
-            args.push('--stop-signal', config.stop.signal);
-        }
-        if (config.stop?.gracePeriodSec !== undefined) {
-            args.push('--stop-timeout', String(config.stop.gracePeriodSec));
-        }
-        // resources
-        if (config.resources?.cpus) {
-            args.push('--cpus', String(config.resources.cpus));
-        }
-        if (config.resources?.memory) {
-            args.push('--memory', String(config.resources.memory));
-        }
-        // image
-        if (!config.image) {
-            throw new Error('ContainerConfig.image is required for docker run');
-        }
-        args.push(config.image);
-        // command override
-        if (config.command) {
-            if (Array.isArray(config.command)) {
-                args.push(...config.command);
-            }
-            else {
-                args.push(config.command);
-            }
-        }
-        return args.join(' ');
-    }
-    async #pollingInfo() {
-        await this.isReady();
-        if (!this.#installed) {
-            await this.#adapter.sendToGui({
-                command: 'info',
-                error: 'not installed',
-            });
-            return;
-        }
-        const data = await this.discUsage();
-        await this.#adapter.sendToGui({
-            command: 'info',
-            data,
-            version: this.#dockerVersion,
-        });
-    }
-    async #pollingImages() {
-        await this.isReady();
-        if (!this.#installed) {
-            await this.#adapter.sendToGui({
-                command: 'info',
-                error: 'not installed',
-            });
-            return;
-        }
-        const data = await this.imageList();
-        await this.#adapter.sendToGui({
-            command: 'images',
-            data,
-        });
-    }
-    async #pollingContainers() {
-        await this.isReady();
-        if (!this.#installed) {
-            await this.#adapter.sendToGui({
-                command: 'info',
-                error: 'not installed',
-            });
-            return;
-        }
-        const data = await this.containerList(true, this.#ownIps?.length ? this.#ownIps : undefined);
-        await this.#adapter.sendToGui({
-            command: 'containers',
-            data,
-        });
-    }
-    async #pollingContainer(container) {
-        await this.isReady();
-        if (!this.#installed) {
-            await this.#adapter.sendToGui({
-                command: 'info',
-                error: 'not installed',
-            });
-            return;
-        }
-        const data = await this.containerInspect(container);
-        await this.#adapter.sendToGui({
-            command: 'container',
-            container,
-            data,
-        });
-    }
-    async pollingUpdate(scan) {
-        if (scan.info) {
-            this.#timers.info ||= setInterval(async () => this.#pollingInfo(), 10_000);
-            setTimeout(() => void this.#pollingInfo(), 50); // do it immediately, too
-        }
-        else if (this.#timers.info) {
-            clearInterval(this.#timers.info);
-            this.#timers.info = undefined;
-        }
-        if (scan.images) {
-            this.#timers.images ||= setInterval(async () => {
-                await this.#pollingImages();
-            }, 10_000);
-            setTimeout(() => void this.#pollingImages(), 50); // do it immediately, too
-        }
-        else if (this.#timers.images) {
-            clearInterval(this.#timers.images);
-            this.#timers.images = undefined;
-        }
-        if (scan.containers) {
-            this.#ownIps = scan.containers;
-            // try to find for all domain names the own IP
-            for (const ipOrDomain of scan.containers) {
-                if (this.#domain2ip[ipOrDomain] === undefined && !(0, range_check_1.isIP)(ipOrDomain)) {
-                    const ip = await getIpForDomain(ipOrDomain);
-                    if (ip) {
-                        this.#domain2ip[ipOrDomain] = ip;
-                    }
-                    else {
-                        this.#domain2ip[ipOrDomain] = false;
-                    }
-                }
-            }
-            this.#timers.containers ||= setInterval(async () => this.#pollingContainers(), 10_000);
-            setTimeout(() => void this.#pollingContainers(), 50); // do it immediately, too
-        }
-        else if (this.#timers.containers) {
-            clearInterval(this.#timers.containers);
-            this.#timers.containers = undefined;
-        }
-        scan.container.forEach(container => {
-            if (container) {
-                this.#timers.container[container] ||= setInterval(async (_container) => this.#pollingContainer(_container), 10_000, container);
-                setTimeout(_container => void this.#pollingContainer(_container), 50, container); // do it immediately, too
-            }
-        });
-        // Check deleted containers
-        Object.keys(this.#timers.container).forEach(container => {
-            if (container && !scan.container.includes(container)) {
-                clearInterval(this.#timers.container[container]);
-                delete this.#timers.container[container];
-            }
-        });
-    }
-    destroy() {
-        // Destroy all running commands
-        Object.keys(this.#runningCommands).forEach(sid => {
-            this.containerExecTerminate(sid, true);
-        });
-        // destroy all timers
-        Object.keys(this.#timers.container).forEach((id) => {
-            clearTimeout(this.#timers.container[id]);
-        });
-        if (this.#timers.images) {
-            clearInterval(this.#timers.images);
-            delete this.#timers.images;
-        }
-        if (this.#timers.containers) {
-            clearInterval(this.#timers.containers);
-            delete this.#timers.containers;
-        }
-        if (this.#timers.info) {
-            clearInterval(this.#timers.info);
-            delete this.#timers.info;
-        }
-    }
-}
-exports.default = DockerCommands;
-//# sourceMappingURL=DockerCommands.js.map