iobroker.docker-manager 0.1.0 → 0.1.3

package/build/lib/DockerManager.js

@@ -2,10 +2,15 @@
 // 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 };
+};
 var _a;
 Object.defineProperty(exports, "__esModule", { value: true });
 const node_util_1 = require("node:util");
 const node_child_process_1 = require("node:child_process");
+const node_net_1 = require("node:net");
+const dockerode_1 = __importDefault(require("dockerode"));
 const execPromise = (0, node_util_1.promisify)(node_child_process_1.exec);
 const dockerDefaults = {
     tty: false,
@@ -50,11 +55,12 @@ function deepCompare(object1, object2) {
         return true;
     }
     const keys1 = Object.keys(object1);
-    const keys2 = Object.keys(object2);
-    if (keys1.length !== keys2.length) {
-        return false;
-    }
     for (const key of keys1) {
+        // ignore iob* properties as they belong to ioBroker configuration
+        // ignore hostname
+        if (key.startsWith('iob') || key === 'hostname') {
+            continue;
+        }
         if (!deepCompare(object1[key], object2[key])) {
             return false;
         }
@@ -67,11 +73,8 @@ function compareConfigs(desired, existing) {
     // We only compare keys that are in the desired config
     for (const key of keys) {
         // ignore iob* properties as they belong to ioBroker configuration
-        if (key.startsWith('iob')) {
-            continue;
-        }
         // ignore hostname
-        if (key === 'hostname') {
+        if (key.startsWith('iob') || key === 'hostname') {
             continue;
         }
         if (typeof desired[key] === 'object' && desired[key] !== null) {
@@ -128,7 +131,7 @@ function removeUndefined(obj) {
     }
     return obj;
 }
-function cleanContainerConfig(obj) {
+function cleanContainerConfig(obj, mayChange) {
     obj = removeUndefined(obj);
     Object.keys(obj).forEach(name => {
         if (isDefault(obj[name], dockerDefaults[name])) {
@@ -141,6 +144,11 @@ function cleanContainerConfig(obj) {
             }
             obj.mounts = obj.mounts.map((mount) => {
                 const m = { ...mount };
+                // /var/lib/docker/volumes/influxdb_0_flux_config/_data
+                if (mayChange && m.source.includes('/docker/volumes') && m.source.endsWith('/_data')) {
+                    const parts = m.source.split('/');
+                    m.source = parts[parts.length - 2];
+                }
                 delete m.readOnly;
                 return m;
             });
@@ -195,24 +203,82 @@ function cleanContainerConfig(obj) {
             else {
                 delete obj.environment;
             }
+            if (!Object.keys(env).length) {
+                delete obj.environment;
+            }
+        }
+        if (name === 'labels') {
+            if (!obj.labels) {
+                delete obj.labels;
+                return;
+            }
+            const labels = obj.labels;
+            if (Object.keys(labels).length) {
+                obj.labels = {};
+                Object.keys(labels)
+                    .sort()
+                    .forEach(key => {
+                    if (key && labels[key]) {
+                        obj.labels[key] = labels[key];
+                    }
+                });
+            }
+            else {
+                delete obj.labels;
+            }
+            if (!Object.keys(labels).length) {
+                delete obj.labels;
+            }
+        }
+        if (name === 'volumes') {
+            if (!obj.volumes?.length) {
+                delete obj.volumes;
+                return;
+            }
+            obj.volumes = obj.volumes.map(v => v.trim()).filter(v => v);
+            obj.volumes.sort();
+            if (!obj.volumes?.length) {
+                delete obj.volumes;
+            }
         }
     });
     obj.volumes?.sort();
     return obj;
 }
+function size2string(size) {
+    if (size < 1024) {
+        return `${size} B`;
+    }
+    if (size < 1024 * 1024) {
+        return `${(size / 1024).toFixed(2)} KB`;
+    }
+    if (size < 1024 * 1024 * 1024) {
+        return `${(size / (1024 * 1024)).toFixed(2)} MB`;
+    }
+    return `${(size / (1024 * 1024 * 1024)).toFixed(2)} GB`;
+}
 class DockerManager {
     installed = false;
     dockerVersion = '';
     needSudo = false;
     #waitReady;
+    #waitAllChecked;
+    #waitAllCheckedResolve;
     adapter;
     #ownContainers = [];
     #monitoringInterval = null;
     #ownContainersStats = {};
-    constructor(adapter, containers) {
+    #driver = 'cli';
+    #dockerode = null;
+    #cliAvailable = false;
+    options;
+    #tarPack = null;
+    constructor(adapter, options, containers) {
         this.adapter = adapter;
+        this.options = options || {};
         this.#ownContainers = containers || [];
         this.#waitReady = new Promise(resolve => this.#init().then(() => resolve()));
+        this.#waitAllChecked = new Promise(resolve => (this.#waitAllCheckedResolve = resolve));
     }
     /** Wait till the check if docker is installed and the daemon is running is ready */
     isReady() {
@@ -307,7 +373,8 @@ class DockerManager {
                 ipc: inspect.HostConfig.IpcMode,
                 pid: inspect.HostConfig.PidMode,
                 seccomp: inspect.HostConfig.SecurityOpt?.find(opt => opt.startsWith('seccomp='))?.split('=')[1] ?? undefined,
-                apparmor: inspect.AppArmorProfile,
+                apparmor: inspect.HostConfig.SecurityOpt?.find(opt => opt.startsWith('apparmor='))?.split('=')[1] ??
+                    undefined,
                 groupAdd: inspect.HostConfig.GroupAdd ?? undefined,
                 noNewPrivileges: undefined, // Nicht direkt verfügbar
             },
@@ -321,7 +388,7 @@ class DockerManager {
             timezone: undefined, // Nicht direkt verfügbar
             __meta: undefined, // Eigene Metadaten
         };
-        return cleanContainerConfig(obj);
+        return cleanContainerConfig(obj, true);
     }
     /**
      * Get information about the Docker daemon: is it running and which version
@@ -334,9 +401,77 @@ class DockerManager {
         return {
             version: this.dockerVersion,
             daemonRunning,
+            removeSupported: !this.#dockerode || this.#cliAvailable,
+            driver: this.#driver,
         };
     }
+    static checkDockerSocket() {
+        return new Promise(resolve => {
+            const socket = (0, node_net_1.createConnection)({ path: '/var/run/docker.sock' }, () => {
+                socket.end();
+                resolve(true);
+            });
+            socket.on('error', e => {
+                console.error(`Cannot connect to docker socket: ${e.message}`);
+                resolve(false);
+            });
+        });
+    }
+    static async isDockerApiRunningOnPort(port, host = 'localhost') {
+        return new Promise(resolve => {
+            const socket = (0, node_net_1.createConnection)({ port, host }, () => {
+                socket.write('GET /version HTTP/1.0\r\nHost: localhost\r\n\r\n');
+            });
+            let data = '';
+            socket.on('data', chunk => (data += chunk.toString()));
+            socket.on('end', () => {
+                resolve(data.includes('Docker') || data.includes('Api-Version'));
+            });
+            socket.on('error', () => resolve(false));
+        });
+    }
     async #init() {
+        // first of all detects which way is available:
+        // - '/var/run/docker.sock',
+        // - http://localhost:2375,
+        // - https://localhost:2376 or
+        // - CLI
+        // Probe the socket
+        if (this.options?.dockerApi && this.options.dockerApiHost && this.options.dockerApiPort) {
+            this.#driver = this.options.dockerApiProtocol || 'http';
+            this.#dockerode = new dockerode_1.default({
+                host: this.options.dockerApiHost,
+                port: this.options.dockerApiPort,
+                protocol: this.options.dockerApiProtocol || 'http',
+            });
+        }
+        else if (await _a.checkDockerSocket()) {
+            this.#driver = 'socket';
+            this.#dockerode = new dockerode_1.default({ socketPath: '/var/run/docker.sock' });
+        }
+        else if (await _a.isDockerApiRunningOnPort(2375)) {
+            this.#driver = 'http';
+            this.#dockerode = new dockerode_1.default({ protocol: 'http', host: '127.0.0.1', port: 2375 });
+        }
+        else if (await _a.isDockerApiRunningOnPort(2376)) {
+            this.#driver = 'http';
+            this.#dockerode = new dockerode_1.default({ protocol: 'http', host: '127.0.0.1', port: 2376 });
+        }
+        else {
+            this.#driver = 'cli';
+            this.#cliAvailable = true;
+        }
+        if (!this.#cliAvailable) {
+            try {
+                const result = await execPromise('docker --version');
+                if (!result.stderr && result.stdout) {
+                    this.#cliAvailable = true;
+                }
+            }
+            catch {
+                // ignore
+            }
+        }
         const version = await this.#isDockerInstalled();
         this.installed = !!version;
         if (version) {
@@ -353,11 +488,18 @@ class DockerManager {
             }
         }
         if (this.installed) {
+            // we still must check the sudo as autocompletion works only via CLI
             this.needSudo = await this.#isNeedSudo();
             await this.#checkOwnContainers();
         }
+        else {
+            this.#waitAllCheckedResolve?.();
+        }
     }
     async #isDockerDaemonRunning() {
+        if (this.#dockerode) {
+            return true;
+        }
         try {
             const { stdout, stderr } = await execPromise('systemctl status docker');
             // ● docker.service - Docker Application Container Engine
@@ -388,6 +530,9 @@ class DockerManager {
      * @param container Container configuration
      */
     async #ensureActualConfiguration(container) {
+        if (!container.name) {
+            throw new Error(`Container name must be a string, but got boolean true`);
+        }
         // Check the configuration of the container
         const inspect = await this.containerInspect(container.name);
         if (inspect) {
@@ -402,8 +547,10 @@ class DockerManager {
                     this.adapter.log.warn(`Cannot recreate own container ${container.name}: ${result.stderr}`);
                 }
             }
+            else {
+                this.adapter.log.debug(`Configuration of own container ${container.name} is up to date`);
+            }
             // Check if container is running
-            this.adapter.log.debug(`Configuration of own container ${container.name} is up to date`);
             const status = await this.containerList(true);
             const containerInfo = status.find(it => it.names === container.name);
             if (containerInfo) {
@@ -429,20 +576,34 @@ class DockerManager {
             }
         }
     }
+    getDefaultContainerName() {
+        return `iob_${this.adapter.namespace.replace(/[-.]/g, '_')}`;
+    }
     async #checkOwnContainers() {
         if (!this.#ownContainers.length) {
+            this.#waitAllCheckedResolve?.();
             return;
         }
         const status = await this.containerList(true);
         let images = await this.imageList();
         let anyStartedOrRunning = false;
         const networkChecked = [];
+        const prefix = this.getDefaultContainerName();
         for (let c = 0; c < this.#ownContainers.length; c++) {
             const container = this.#ownContainers[c];
             if (container.iobEnabled !== false) {
                 if (!container.image.includes(':')) {
                     container.image += ':latest';
                 }
+                if (container.labels?.iobroker !== this.adapter.namespace) {
+                    container.labels = { ...container.labels, iobroker: this.adapter.namespace };
+                }
+                container.name ||= prefix;
+                // Name of the container, name of the network and name of the volume must start with iob_<Adaptername>_<instance>_
+                if (container.name !== prefix && !container.name.startsWith(`${prefix}_`)) {
+                    this.adapter.log.debug(`Renaming container ${container.name} to be prefixed with iob_${prefix}_`);
+                    container.name = `${prefix}_${container.name}`;
+                }
                 try {
                     // create iobroker network if necessary
                     if (container.networkMode &&
@@ -450,6 +611,13 @@ class DockerManager {
                         container.networkMode !== 'host' &&
                         container.networkMode !== 'bridge' &&
                         container.networkMode !== 'none') {
+                        if (container.networkMode === true) {
+                            container.networkMode = prefix;
+                        }
+                        if (container.networkMode !== prefix && !container.networkMode.startsWith(`${prefix}_`)) {
+                            this.adapter.log.debug(`Renaming network ${container.networkMode} to be prefixed with ${prefix}_`);
+                            container.networkMode = `${prefix}_${container.networkMode}`;
+                        }
                         if (!networkChecked.includes(container.networkMode)) {
                             // check if the network exists
                             const networks = await this.networkList();
@@ -460,6 +628,54 @@ class DockerManager {
                             networkChecked.push(container.networkMode);
                         }
                     }
+                    // create all volumes ourselves, to have a static name
+                    if (container.mounts?.find(m => m.type === 'volume')) {
+                        // check if the volume exists
+                        const volumes = await this.volumeList();
+                        for (const mount of container.mounts) {
+                            if (mount.type === 'volume' && mount.source) {
+                                if (mount.source === true) {
+                                    mount.source = prefix;
+                                }
+                                if (mount.source !== prefix && !mount.source.startsWith(`${prefix}_`)) {
+                                    this.adapter.log.debug(`Renaming volume ${mount.source} to be prefixed with ${prefix}_`);
+                                    mount.source = `${prefix}_${mount.source}`;
+                                }
+                                if (mount.iobBackup) {
+                                    if (!container.labels.iob_backup) {
+                                        container.labels = { ...container.labels, iob_backup: mount.source };
+                                    }
+                                    else {
+                                        const volumes = container.labels.iob_backup
+                                            .split(',')
+                                            .map(v => v.trim())
+                                            .filter(v => v);
+                                        if (!volumes.includes(mount.source)) {
+                                            volumes.push(mount.source);
+                                            container.labels = { ...container.labels, iob_backup: volumes.join(',') };
+                                        }
+                                    }
+                                }
+                                const volume = volumes.find(v => v.name === mount.source);
+                                if (!volume) {
+                                    this.adapter.log.info(`Creating docker volume ${mount.source}`);
+                                    const result = await this.volumeCreate(mount.source);
+                                    if (result.stderr) {
+                                        this.adapter.log.warn(`Cannot create volume ${mount.source}: ${result.stderr}`);
+                                        continue;
+                                    }
+                                    // Copy data from host to volume
+                                    if (mount.iobAutoCopyFrom) {
+                                        await this.volumeCopyTo(mount.source, mount.iobAutoCopyFrom);
+                                    }
+                                }
+                                else if (mount.iobAutoCopyFromForce && mount.iobAutoCopyFrom) {
+                                    // Copy data from host to volume
+                                    await this.volumeCopyTo(mount.source, mount.iobAutoCopyFrom);
+                                }
+                            }
+                        }
+                    }
                     let containerInfo = status.find(it => it.names === container.name);
                     let image = images.find(it => `${it.repository}:${it.tag}` === container.image);
                     if (container.iobAutoImageUpdate) {
@@ -525,6 +741,10 @@ class DockerManager {
         if (anyStartedOrRunning) {
             this.#monitoringInterval ||= setInterval(() => this.#monitorOwnContainers(), 60000);
         }
+        this.#waitAllCheckedResolve?.();
+    }
+    allOwnContainersChecked() {
+        return this.#waitAllChecked;
     }
     async #monitorOwnContainers() {
         // get the status of containers
@@ -532,7 +752,7 @@ class DockerManager {
         // Check the status of own containers
         for (let c = 0; c < this.#ownContainers.length; c++) {
             const container = this.#ownContainers[c];
-            if (container.iobEnabled !== false && container.iobMonitoringEnabled) {
+            if (container.iobEnabled !== false && container.iobMonitoringEnabled && container.name) {
                 // Check if container is running
                 const running = containers.find(it => it.names === container.name);
                 if (!running || (running.status !== 'running' && running.status !== 'restarting')) {
@@ -634,16 +854,29 @@ class DockerManager {
         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();
+        if (this.#driver === 'cli') {
+            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}`);
             }
-            this.adapter.log.debug(`Docker not installed: ${result.stderr}`);
         }
-        catch (e) {
-            this.adapter.log.debug(`Docker not installed: ${e.message}`);
+        else if (this.#dockerode) {
+            try {
+                const info = await this.#dockerode.version();
+                if (info?.Version) {
+                    return `Docker version ${info.Version}, api version: ${info.ApiVersion}`;
+                }
+            }
+            catch (e) {
+                this.adapter.log.debug(`Docker not installed: ${e.message}`);
+            }
         }
         return false;
     }
@@ -658,6 +891,57 @@ class DockerManager {
     }
     /** Get disk usage information */
     async discUsage() {
+        if (this.#dockerode) {
+            const info = await this.#dockerode.df();
+            const result = { total: { size: 0, reclaimable: 0 } };
+            if (info.Images) {
+                let size = 0;
+                let reclaimable = 0;
+                for (const image of info.Images) {
+                    size += image.Size;
+                    reclaimable += image.SharedSize + image.VirtualSize;
+                }
+                result.images = {
+                    total: info.Images.length,
+                    // @ts-expect-error todo
+                    active: info.Images.filter(img => img.Containers > 0).length,
+                    size,
+                    reclaimable,
+                };
+                result.total.size += size;
+                result.total.reclaimable += reclaimable;
+            }
+            if (info.Containers) {
+                let size = 0;
+                for (const container of info.Containers) {
+                    size += container.SizeRootFs || 0;
+                }
+                result.containers = {
+                    total: info.Containers.length,
+                    // @ts-expect-error todo
+                    active: info.Containers.filter(cont => cont.State === 'running').length,
+                    size,
+                    reclaimable: 0, // Not available
+                };
+                result.total.size += size;
+            }
+            if (info.Volumes) {
+                let size = 0;
+                for (const volume of info.Volumes) {
+                    size += volume.UsageData?.Size || 0;
+                }
+                result.volumes = {
+                    total: info.Volumes.length,
+                    // @ts-expect-error todo
+                    active: info.Volumes.filter(vol => vol.UsageData?.RefCount && vol.UsageData.RefCount > 0).length,
+                    size,
+                    reclaimable: 0, // Not available
+                };
+                result.total.size += size;
+            }
+            // Build cache not available
+            return result;
+        }
         const { stdout } = await this.#exec(`system df`);
         const result = { total: { size: 0, reclaimable: 0 } };
         // parse the output
@@ -728,10 +1012,49 @@ class DockerManager {
     }
     /** Pull an image from the registry */
     async imagePull(image) {
-        try {
-            if (!image.includes(':')) {
-                image += ':latest';
+        if (!image.includes(':')) {
+            image += ':latest';
+        }
+        if (this.#dockerode) {
+            const stream = await this.#dockerode.pull(image);
+            if (!stream) {
+                throw new Error('No stream returned');
             }
+            return new Promise((resolve, reject) => {
+                const onFinished = (err) => {
+                    if (err) {
+                        return reject(err);
+                    }
+                    this.imageList()
+                        .then(images => resolve({ stdout: `Image ${image} pulled`, stderr: '', images }))
+                        .catch(reject);
+                };
+                const lastShownProgress = {};
+                const onProgress = (event) => {
+                    // {"status":"Downloading","progressDetail":{"current":109494080,"total":689664036},"progress":"[=======> ]  109.5MB/689.7MB","id":"29bce3058cea"}
+                    // {"status":"Download complete","progressDetail":{},"id":"6859c690a072"}
+                    // {"status":"Verifying Checksum","progressDetail":{},"id":"6859c690a072"}
+                    // {"status":"Extracting","progressDetail":{"current":32,"total":32},"progress":"[======>] 32B/32B","id":"4f4fb700ef54"}
+                    // {"status":"Pull complete","progressDetail":{},"id":"4f4fb700ef54"}
+                    if (!lastShownProgress || Date.now() - lastShownProgress[event.id] > 4000) {
+                        if (event.status === 'Download complete' ||
+                            event.status === 'Pull complete' ||
+                            event.status === 'Verifying Checksum') {
+                            this.adapter.log.debug(`Image ${image}/${event.id}: ${event.status}`);
+                        }
+                        else if (event.status === 'Downloading' || event.status === 'Extracting') {
+                            this.adapter.log.debug(`Pulling image ${image}/${event.id}: ${event.status} ${Math.round((event.progressDetail.current / event.progressDetail.total) * 1000) / 10}% of ${size2string(event.progressDetail.total)}`);
+                        }
+                        else {
+                            this.adapter.log.debug(`Pulling image ${image}/${event.id}: ${JSON.stringify(event)}`);
+                        }
+                        lastShownProgress[event.id] = Date.now();
+                    }
+                };
+                this.#dockerode.modem.followProgress(stream, onFinished, onProgress);
+            });
+        }
+        try {
             const result = await this.#exec(`pull ${image}`);
             const images = await this.imageList();
             if (!images.find(it => `${it.repository}:${it.tag}` === image)) {
@@ -766,12 +1089,154 @@ class DockerManager {
             return [];
         }
     }
+    static getDockerodeConfig(config) {
+        let mounts;
+        if (config.mounts) {
+            for (const mount of config.mounts) {
+                let volumeOptions;
+                if (mount.volumeOptions) {
+                    if (mount.volumeOptions.nocopy !== undefined) {
+                        volumeOptions ||= {};
+                        volumeOptions.NoCopy = mount.volumeOptions.nocopy;
+                    }
+                    if (mount.volumeOptions.labels) {
+                        volumeOptions ||= {};
+                        volumeOptions.Labels = mount.volumeOptions.labels;
+                    }
+                }
+                let bindOptions;
+                if (mount.bindOptions) {
+                    if (mount.bindOptions.propagation) {
+                        bindOptions ||= {};
+                        bindOptions.Propagation = mount.bindOptions.propagation;
+                    }
+                }
+                let tmpfsOptions;
+                if (mount.tmpfsOptions) {
+                    if (mount.tmpfsOptions.size !== undefined) {
+                        tmpfsOptions ||= {};
+                        tmpfsOptions.SizeBytes = mount.tmpfsOptions.size;
+                    }
+                    if (mount.tmpfsOptions.mode !== undefined) {
+                        tmpfsOptions ||= {};
+                        tmpfsOptions.Mode = mount.tmpfsOptions.mode;
+                    }
+                }
+                if (mount.source === true) {
+                    throw new Error(`Mount source must be a string, but got boolean true`);
+                }
+                const m = {
+                    Target: mount.target,
+                    Source: mount.source || '',
+                    Type: mount.type,
+                    ReadOnly: mount.readOnly,
+                    Consistency: mount.consistency,
+                    VolumeOptions: volumeOptions,
+                    BindOptions: bindOptions,
+                    TmpfsOptions: tmpfsOptions,
+                };
+                mounts ||= [];
+                mounts.push(m);
+            }
+        }
+        if (!config.name) {
+            throw new Error(`Container name must be a string, but got boolean true`);
+        }
+        return {
+            name: config.name,
+            Image: config.image,
+            Cmd: Array.isArray(config.command)
+                ? config.command
+                : typeof config.command === 'string'
+                    ? [config.command]
+                    : undefined,
+            Entrypoint: config.entrypoint,
+            Env: config.environment
+                ? Object.keys(config.environment).map(key => `${key}=${config.environment[key]}`)
+                : undefined,
+            // WorkingDir: config.workingDir,
+            // { '/data': {} }
+            Volumes: config.volumes?.reduce((acc, vol) => (acc[vol] = {}), {}),
+            Labels: config.labels,
+            ExposedPorts: config.ports
+                ? config.ports.reduce((acc, port) => {
+                    acc[`${port.containerPort}/${port.protocol || 'tcp'}`] = {};
+                    return acc;
+                }, {})
+                : undefined,
+            HostConfig: {
+                // Binds: config.binds,
+                PortBindings: config.ports
+                    ? config.ports.reduce((acc, port) => {
+                        acc[`${port.containerPort}/${port.protocol || 'tcp'}`] = [
+                            {
+                                HostPort: port.hostPort ? port.hostPort.toString() : undefined,
+                                HostIp: port.hostIP || undefined,
+                            },
+                        ];
+                        return acc;
+                    }, {})
+                    : undefined,
+                Mounts: mounts,
+                NetworkMode: config.networkMode === true ? '' : config.networkMode || undefined,
+                // Links: config.links,
+                // Dns: config.dns,
+                // DnsOptions: config.dnsOptions,
+                // DnsSearch: config.dnsSearch,
+                ExtraHosts: config.extraHosts,
+                // VolumesFrom: config.volumesFrom,
+                Privileged: config.security?.privileged,
+                CapAdd: config.security?.capAdd,
+                CapDrop: config.security?.capDrop,
+                UsernsMode: config.security?.usernsMode,
+                IpcMode: config.security?.ipc,
+                PidMode: config.security?.pid,
+                GroupAdd: config.security?.groupAdd?.map(g => g.toString()),
+                ReadonlyRootfs: config.readOnly,
+                RestartPolicy: {
+                    Name: config.restart?.policy || 'no',
+                    MaximumRetryCount: config.restart?.maxRetries || 0,
+                },
+                CpuShares: config.resources?.cpuShares,
+                CpuPeriod: config.resources?.cpuPeriod,
+                CpuQuota: config.resources?.cpuQuota,
+                CpusetCpus: config.resources?.cpus?.toString(),
+                Memory: config.resources?.memory,
+                MemorySwap: config.resources?.memorySwap,
+                MemoryReservation: config.resources?.memoryReservation,
+                // OomKillDisable: config.resources?.oomKillDisable,
+                // OomScoreAdj: config.resources?.oomScoreAdj,
+                LogConfig: config.logging
+                    ? {
+                        Type: config.logging.driver || 'json-file',
+                        Config: config.logging.options || {},
+                    }
+                    : undefined,
+                SecurityOpt: [
+                    ...(config.security?.seccomp ? [`seccomp=${config.security.seccomp}`] : []),
+                    ...(config.security?.apparmor ? [`apparmor=${config.security.apparmor}`] : []),
+                    ...(config.security?.noNewPrivileges ? ['no-new-privileges:true'] : []),
+                ],
+                Sysctls: config.sysctls,
+                Init: config.init,
+            },
+            StopSignal: config.stop?.signal,
+            StopTimeout: config.stop?.gracePeriodSec,
+            Tty: config.tty,
+            OpenStdin: config.openStdin,
+        };
+    }
     /**
      * Create and start a container with the given configuration. No checks are done.
      */
     async containerRun(config) {
+        if (this.#dockerode) {
+            const container = await this.#dockerode.createContainer(_a.getDockerodeConfig(config));
+            await container.start();
+            return { stdout: `Container ${config.name} started`, stderr: '' };
+        }
         try {
-            return await this.#exec(`run ${this.#toDockerRun(config)}`);
+            return await this.#exec(`run ${_a.toDockerRun(config)}`);
         }
         catch (e) {
             return { stdout: '', stderr: e.message.toString() };
@@ -781,8 +1246,12 @@ class DockerManager {
      * Create a container with the given configuration without starting it. No checks are done.
      */
     async containerCreate(config) {
+        if (this.#dockerode) {
+            const container = await this.#dockerode.createContainer(_a.getDockerodeConfig(config));
+            return { stdout: `Container ${container.id} created`, stderr: '' };
+        }
         try {
-            return await this.#exec(`create ${this.#toDockerRun(config, true)}`);
+            return await this.#exec(`create ${_a.toDockerRun(config, true)}`);
         }
         catch (e) {
             return { stdout: '', stderr: e.message.toString() };
@@ -793,11 +1262,38 @@ class DockerManager {
      *
      * This function checks if a container is running, stops it if necessary,
      * removes it and creates a new one with the given configuration.
+     * The container is not started after creation.
      *
      * @param config new configuration
      * @returns stdout and stderr of the create command
      */
     async containerReCreate(config) {
+        if (this.#dockerode) {
+            // Get if the container is running
+            let containers = await this.containerList();
+            // find ID of container
+            const containerInfo = containers.find(it => it.names === config.name);
+            if (containerInfo) {
+                const container = this.#dockerode.getContainer(containerInfo.id);
+                if (containerInfo.status === 'running' || containerInfo.status === 'restarting') {
+                    await container.stop();
+                    containers = await this.containerList();
+                    if (containers.find(it => it.id === containerInfo.id && it.status === 'running')) {
+                        this.adapter.log.warn(`Cannot remove container: still running`);
+                        throw new Error(`Container ${containerInfo.id} still running after stop`);
+                    }
+                }
+                // Remove container
+                await container.remove();
+                containers = await this.containerList();
+                if (containers.find(it => it.id === containerInfo.id)) {
+                    this.adapter.log.warn(`Cannot remove container: still existing`);
+                    throw new Error(`Container ${containerInfo.id} still found after remove`);
+                }
+            }
+            const newContainer = await this.#dockerode.createContainer(_a.getDockerodeConfig(config));
+            return { stdout: `Container ${newContainer.id} created`, stderr: '' };
+        }
         try {
             // Get if the container is running
             let containers = await this.containerList();
@@ -817,10 +1313,18 @@ class DockerManager {
                 containers = await this.containerList();
                 if (containers.find(it => it.id === containerInfo.id)) {
                     this.adapter.log.warn(`Cannot remove container: ${rmResult.stderr || rmResult.stdout}`);
-                    throw new Error(`Container ${containerInfo.id} still found after stop`);
+                    throw new Error(`Container ${containerInfo.id} still found after remove`);
                 }
             }
-            return await this.#exec(`create ${this.#toDockerRun(config, true)}`);
+            return await this.#exec(`create ${_a.toDockerRun(config, true)}`);
+        }
+        catch (e) {
+            return { stdout: '', stderr: e.message.toString() };
+        }
+    }
+    async containerCreateCompose(compose) {
+        try {
+            return await this.#exec(`compose -f ${compose} create`);
         }
         catch (e) {
             return { stdout: '', stderr: e.message.toString() };
@@ -828,6 +1332,20 @@ class DockerManager {
     }
     /** List all images */
     async imageList() {
+        if (this.#dockerode) {
+            const images = await this.#dockerode.listImages();
+            return images.map(img => {
+                const repoTag = img.RepoTags && img.RepoTags.length ? img.RepoTags[0] : '<none>:<none>';
+                const [repository, tag] = repoTag.split(':');
+                return {
+                    repository,
+                    tag,
+                    id: img.Id.startsWith('sha256:') ? img.Id.substring(7, 19) : img.Id.substring(0, 12),
+                    createdSince: new Date(img.Created * 1000).toISOString(),
+                    size: img.Size,
+                };
+            });
+        }
         try {
             const { stdout } = await this.#exec('images --format "{{.Repository}}:{{.Tag}};{{.ID}};{{.CreatedAt}};{{.Size}}"');
             return stdout
@@ -852,6 +1370,37 @@ class DockerManager {
     }
     /** Build an image from a Dockerfile */
     async imageBuild(dockerfilePath, tag) {
+        if (this.#dockerode) {
+            try {
+                const stream = await this.#dockerode.buildImage(dockerfilePath, {
+                    t: tag,
+                    dockerfile: dockerfilePath,
+                });
+                return new Promise((resolve, reject) => {
+                    let stdout = '';
+                    let stderr = '';
+                    const onFinished = (err) => {
+                        if (err) {
+                            return reject(err);
+                        }
+                        resolve({ stdout, stderr });
+                    };
+                    const onProgress = (event) => {
+                        if (event.stream) {
+                            stdout += event.stream;
+                        }
+                        if (event.error) {
+                            stderr += event.error;
+                        }
+                        this.adapter.log.debug(JSON.stringify(event));
+                    };
+                    this.#dockerode.modem.followProgress(stream, onFinished, onProgress);
+                });
+            }
+            catch (e) {
+                return { stdout: '', stderr: e.message.toString() };
+            }
+        }
         try {
             return await this.#exec(`build -t ${tag} -f ${dockerfilePath} .`);
         }
@@ -882,8 +1431,41 @@ class DockerManager {
             return { stdout: '', stderr: e.message.toString() };
         }
     }
+    static rodeInspect2DockerImageInspect(data) {
+        return {
+            Id: data.Id.startsWith('sha256:') ? data.Id.substring(7, 19) : data.Id.substring(0, 12),
+            RepoTags: data.RepoTags,
+            RepoDigests: data.RepoDigests,
+            Parent: data.Parent,
+            Comment: data.Comment,
+            Created: data.Created,
+            DockerVersion: data.DockerVersion,
+            Author: data.Author,
+            Architecture: data.Architecture,
+            Os: data.Os,
+            Size: data.Size,
+            GraphDriver: {
+                Data: data.GraphDriver.Data,
+                Name: data.GraphDriver.Name,
+            },
+            RootFS: data.RootFS,
+            Config: {
+                ...data.Config,
+                Entrypoint: Array.isArray(data.Config.Entrypoint)
+                    ? data.Config.Entrypoint
+                    : typeof data.Config.Entrypoint === 'string'
+                        ? [data.Config.Entrypoint]
+                        : [],
+            },
+        };
+    }
     /** Inspect an image */
     async imageInspect(imageId) {
+        if (this.#dockerode) {
+            const image = this.#dockerode.getImage(imageId);
+            const data = await image.inspect();
+            return _a.rodeInspect2DockerImageInspect(data);
+        }
         try {
             const { stdout } = await this.#exec(`inspect ${imageId}`);
             return JSON.parse(stdout)[0];
@@ -893,6 +1475,23 @@ class DockerManager {
             return null;
         }
     }
+    async imagePrune() {
+        if (this.#dockerode) {
+            try {
+                await this.#dockerode.pruneImages();
+                return { stdout: 'Unused images pruned', stderr: '' };
+            }
+            catch (e) {
+                return { stdout: '', stderr: e.message.toString() };
+            }
+        }
+        try {
+            return await this.#exec(`image prune -f`);
+        }
+        catch (e) {
+            return { stdout: '', stderr: e.message.toString() };
+        }
+    }
     #parseSize(sizeStr) {
         const units = {
             B: 1,
@@ -915,6 +1514,21 @@ class DockerManager {
      * @param container Container name or ID
      */
     async containerStop(container) {
+        if (this.#dockerode) {
+            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 dockerContainer = this.#dockerode.getContainer(containerInfo.id);
+            await dockerContainer.stop();
+            containers = await this.containerList();
+            if (containers.find(it => it.id === containerInfo.id && it.status === 'running')) {
+                throw new Error(`Container ${container} still running after stop`);
+            }
+            return { stdout: `Contained ${containerInfo.id} stopped`, stderr: '', containers };
+        }
         try {
             let containers = await this.containerList();
             // find ID of container
@@ -939,6 +1553,21 @@ class DockerManager {
      * @param container Container name or ID
      */
     async containerStart(container) {
+        if (this.#dockerode) {
+            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 dockerContainer = this.#dockerode.getContainer(containerInfo.id);
+            await dockerContainer.start();
+            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`);
+            }
+            return { stdout: `Container ${containerInfo.id} started`, stderr: '', containers };
+        }
         try {
             let containers = await this.containerList();
             // find ID of container
@@ -967,6 +1596,18 @@ class DockerManager {
      * @param timeoutSeconds Timeout in seconds to wait before killing the container (default: 5)
      */
     async containerRestart(container, timeoutSeconds) {
+        container ||= this.getDefaultContainerName();
+        if (this.#dockerode) {
+            const 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 dockerContainer = this.#dockerode.getContainer(containerInfo.id);
+            await dockerContainer.restart({ t: timeoutSeconds || 5 });
+            return { stdout: `Container ${containerInfo.id} restarted`, stderr: '' };
+        }
         try {
             const containers = await this.containerList();
             // find ID of container
@@ -980,6 +1621,20 @@ class DockerManager {
             return { stdout: '', stderr: e.message.toString() };
         }
     }
+    /** Find the IP address of a container, via which it can be reached from the host */
+    async getIpOfContainer(containerName) {
+        containerName ||= this.getDefaultContainerName();
+        const data = await this.containerInspect(containerName);
+        if (!data?.NetworkSettings?.Networks) {
+            throw new Error(`No network settings found for container ${containerName}`);
+        }
+        for (const n in data.NetworkSettings.Networks) {
+            if (data.NetworkSettings.Networks[n].IPAddress) {
+                return data.NetworkSettings.Networks[n].IPAddress;
+            }
+        }
+        throw new Error(`No IP address found for container ${containerName}`);
+    }
     /**
      * Remove the container and if necessary, stop it first
      *
@@ -1018,19 +1673,90 @@ class DockerManager {
      * @param all If true, list all containers. If false, list only running containers. Default is true.
      */
     async containerList(all = true) {
+        if (this.#dockerode) {
+            const containers = await this.#dockerode.listContainers({ all });
+            return containers.map(cont => {
+                const statusKey = cont.State.toLowerCase();
+                let status;
+                if (statusKey === 'up') {
+                    status = 'running';
+                }
+                else if (statusKey === 'exited') {
+                    status = 'exited';
+                }
+                else if (statusKey === 'created') {
+                    status = 'created';
+                }
+                else if (statusKey === 'paused') {
+                    status = 'paused';
+                }
+                else if (statusKey === 'restarting') {
+                    status = 'restarting';
+                }
+                else {
+                    status = statusKey;
+                }
+                // Try to convert: Up 6 minutes, Up 6 hours, Up 6 days to minutes
+                const uptimeMatch = cont.Status.match(/Up (\d+) (seconds?|minutes?|hours?|days?)/);
+                let minutes = 0;
+                if (uptimeMatch) {
+                    const value = parseInt(uptimeMatch[1], 10);
+                    const unit = uptimeMatch[2];
+                    if (unit.startsWith('hour')) {
+                        minutes = value * 60;
+                    }
+                    else if (unit.startsWith('day')) {
+                        minutes = value * 60 * 24;
+                    }
+                    else if (unit.startsWith('second')) {
+                        minutes = Math.ceil(value / 60);
+                    }
+                }
+                else if (cont.Status === 'Up About a minute') {
+                    minutes = 1;
+                }
+                return {
+                    id: cont.Id.substring(0, 12),
+                    image: cont.Image,
+                    command: cont.Command,
+                    createdAt: new Date(cont.Created * 1000).toISOString(),
+                    status,
+                    uptime: minutes.toString(),
+                    ports: cont.Ports.map(p => `${p.IP ? `${p.IP}:` : ''}${p.PublicPort ? `${p.PublicPort}->` : ''}${p.PrivatePort}/${p.Type}`).join(', '),
+                    names: cont.Names.map(n => (n.startsWith('/') ? n.substring(1) : n)).join(', '),
+                    labels: cont.Labels || {},
+                };
+            });
+        }
         try {
-            const { stdout } = await this.#exec(`ps ${all ? '-a' : ''} --format  "{{.Names}};{{.Status}};{{.ID}};{{.Image}};{{.Command}};{{.CreatedAt}};{{.Ports}}"`);
+            const { stdout } = await this.#exec(`ps ${all ? '-a' : ''} --format  "{{.Names}};{{.Status}};{{.ID}};{{.Image}};{{.Command}};{{.CreatedAt}};{{.Ports}};{{.Labels}}"`);
             return stdout
                 .split('\n')
                 .filter(line => line.trim() !== '')
                 .map(line => {
-                const [names, statusInfo, id, image, command, createdAt, ports] = line.split(';');
+                const [names, statusInfo, id, image, command, createdAt, ports, labels] = 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 };
+                return {
+                    id,
+                    image,
+                    command,
+                    createdAt,
+                    status: statusKey,
+                    uptime: uptime.join(' '),
+                    ports,
+                    names,
+                    labels: labels?.split(',').reduce((acc, label) => {
+                        const [key, value] = label.split('=');
+                        if (key && value) {
+                            acc[key] = value;
+                        }
+                        return acc;
+                    }, {}) || {},
+                };
             });
         }
         catch (e) {
@@ -1047,6 +1773,27 @@ class DockerManager {
      * @param options.follow If true, follow the logs (not implemented yet)
      */
     async containerLogs(containerNameOrId, options = {}) {
+        if (this.#dockerode) {
+            try {
+                const container = this.#dockerode.getContainer(containerNameOrId);
+                const data = await container.logs({
+                    stdout: true,
+                    stderr: true,
+                    follow: false,
+                    tail: options.tail || undefined,
+                });
+                return data
+                    .toString()
+                    .split('\n')
+                    .filter(line => line.trim() !== '');
+            }
+            catch (e) {
+                return e
+                    .toString()
+                    .split('\n')
+                    .map((line) => line.trim());
+            }
+        }
         try {
             const args = [];
             if (options.tail !== undefined) {
@@ -1066,8 +1813,28 @@ class DockerManager {
                 .map((line) => line.trim());
         }
     }
+    static dockerodeInspect2DockerContainerInspect(data) {
+        return {
+            ...data,
+        };
+    }
     /** Inspect a container */
     async containerInspect(containerNameOrId) {
+        if (this.#dockerode) {
+            try {
+                const container = this.#dockerode.getContainer(containerNameOrId);
+                const dResult = await container.inspect();
+                const result = _a.dockerodeInspect2DockerContainerInspect(dResult);
+                if (result.State.Running) {
+                    result.Stats = (await this.containerGetRamAndCpuUsage(containerNameOrId)) || undefined;
+                }
+                return result;
+            }
+            catch (e) {
+                this.adapter.log.debug(`Cannot inspect container: ${e.message.toString()}`);
+                return null;
+            }
+        }
         try {
             const { stdout } = await this.#exec(`inspect ${containerNameOrId}`);
             const result = JSON.parse(stdout)[0];
@@ -1081,10 +1848,27 @@ class DockerManager {
             return null;
         }
     }
+    async containerPrune() {
+        if (this.#dockerode) {
+            try {
+                const result = await this.#dockerode.pruneContainers();
+                return { stdout: `Containers pruned: ${result.ContainersDeleted?.join(', ') || 'none'}`, stderr: '' };
+            }
+            catch (e) {
+                return { stdout: '', stderr: e.message.toString() };
+            }
+        }
+        try {
+            return await this.#exec(`container prune -f`);
+        }
+        catch (e) {
+            return { stdout: '', stderr: e.message.toString() };
+        }
+    }
     /**
      * Build a docker run command string from ContainerConfig
      */
-    #toDockerRun(config, create) {
+    static toDockerRun(config, create) {
         const args = [];
         // detach / interactive
         if (config.detach !== false && !create) {
@@ -1208,7 +1992,7 @@ class DockerManager {
             args.push('--security-opt', `apparmor=${config.security.apparmor}`);
         }
         // network
-        if (config.networkMode) {
+        if (config.networkMode && typeof config.networkMode === 'string') {
             args.push('--network', config.networkMode);
         }
         // extra hosts
@@ -1259,6 +2043,15 @@ class DockerManager {
         return args.join(' ');
     }
     async networkList() {
+        if (this.#dockerode) {
+            const networks = await this.#dockerode.listNetworks();
+            return networks.map(net => ({
+                name: net.Name,
+                id: net.Id,
+                driver: net.Driver,
+                scope: net.Scope,
+            }));
+        }
         // docker network ls
         try {
             const { stdout } = await this.#exec(`network ls --format "{{.Name}};{{.ID}};{{.Driver}};{{.Scope}}"`);
@@ -1276,6 +2069,14 @@ class DockerManager {
         }
     }
     async networkCreate(name, driver) {
+        if (this.#dockerode) {
+            const net = await this.#dockerode.createNetwork({ Name: name, Driver: driver || 'bridge' });
+            const networks = await this.networkList();
+            if (!networks.find(it => it.name === name)) {
+                throw new Error(`Network ${name} not found after creation`);
+            }
+            return { stdout: `Network ${net.id} created`, stderr: '', networks };
+        }
         const result = await this.#exec(`network create ${driver ? `--driver ${driver}` : ''} ${name}`);
         const networks = await this.networkList();
         if (!networks.find(it => it.name === name)) {
@@ -1291,6 +2092,167 @@ class DockerManager {
         }
         return { ...result, networks };
     }
+    async networkPrune() {
+        if (this.#dockerode) {
+            const result = await this.#dockerode.pruneNetworks();
+            const networks = await this.networkList();
+            return { stdout: `Networks pruned`, stderr: JSON.stringify(result), networks };
+        }
+        const result = await this.#exec(`network prune -f`);
+        const networks = await this.networkList();
+        return { ...result, networks };
+    }
+    /** List all volumes */
+    async volumeList() {
+        if (this.#dockerode) {
+            const volumesData = await this.#dockerode.listVolumes();
+            return (volumesData.Volumes || []).map(vol => ({
+                name: vol.Name,
+                driver: vol.Driver,
+                volume: vol.Mountpoint,
+            }));
+        }
+        // docker network ls
+        try {
+            const { stdout } = await this.#exec(`volume ls --format "{{.Name}};{{.Driver}};{{.Mountpoint}}"`);
+            return stdout
+                .split('\n')
+                .filter(line => line.trim() !== '')
+                .map(line => {
+                const [name, driver, volume] = line.split(';');
+                return { name, driver: driver, volume };
+            });
+        }
+        catch (e) {
+            this.adapter.log.debug(`Cannot list networks: ${e.message.toString()}`);
+            return [];
+        }
+    }
+    async volumeCopyTo(volumeName, sourcePath) {
+        const tempContainerName = `iobroker_temp_copy_${Date.now()}`;
+        if (this.#dockerode) {
+            // Check if alpine image is there
+            const images = await this.imageList();
+            if (!images.find(img => img.repository === 'alpine')) {
+                const pullResult = await this.imagePull('alpine');
+                if (pullResult.stderr) {
+                    return { stdout: '', stderr: `Cannot pull alpine image: ${pullResult.stderr}` };
+                }
+            }
+            // create a temporary container with volume mounted
+            const container = await this.#dockerode.createContainer({
+                Image: 'alpine',
+                name: tempContainerName,
+                Cmd: ['sleep', '30'],
+                HostConfig: {
+                    Binds: [`${volumeName}:/data`],
+                },
+            });
+            try {
+                await container.start();
+                // Lazy loading tar-fs
+                if (!this.#tarPack) {
+                    await import('tar-fs')
+                        .then(tarFs => (this.#tarPack = tarFs.default.pack))
+                        .catch(e => this.adapter.log.error(`Cannot import tar-fs package: ${e.message}`));
+                }
+                if (!this.#tarPack) {
+                    throw new Error('Cannot load tar-fs package');
+                }
+                // use dockerode to copy files
+                const pack = this.#tarPack(sourcePath);
+                await container.putArchive(pack, { path: '/data' });
+                return { stdout: 'Data copied to volume', stderr: '' };
+            }
+            catch (e) {
+                return { stdout: '', stderr: `Cannot copy data to volume: ${e.message}` };
+            }
+            finally {
+                // remove temporary container
+                try {
+                    await container.stop();
+                    await container.remove({ force: true });
+                }
+                catch (e) {
+                    this.adapter.log.warn(`Cannot remove temporary container ${tempContainerName}: ${e.message}`);
+                }
+            }
+        }
+        // create a temporary container with volume mounted
+        const createResult = await this.#exec(`create -v ${volumeName}:/data --name ${tempContainerName} alpine sleep 60`);
+        if (createResult.stderr) {
+            return { stdout: '', stderr: `Cannot create temporary container: ${createResult.stderr}` };
+        }
+        try {
+            const copyResult = await this.#exec(`cp ${sourcePath} ${tempContainerName}:/data/`);
+            if (copyResult.stderr) {
+                return { stdout: '', stderr: `Cannot copy data to volume: ${copyResult.stderr}` };
+            }
+            return { stdout: 'Data copied to volume', stderr: '' };
+        }
+        finally {
+            // remove temporary container
+            await this.#exec(`rm -f ${tempContainerName}`);
+        }
+    }
+    /**
+     * Create a volume
+     *
+     * @param name Volume name
+     * @param driver Volume driver
+     * @param volume Volume options (depends on driver)
+     */
+    async volumeCreate(name, driver, volume) {
+        if (this.#dockerode) {
+            const vol = await this.#dockerode.createVolume({
+                Name: name,
+                Driver: driver || 'local',
+                DriverOpts: volume ? { device: volume, o: 'bind', type: 'none' } : {},
+            });
+            const volumes = await this.volumeList();
+            if (!volumes.find(it => it.name === name)) {
+                throw new Error(`Network ${name} not found after creation`);
+            }
+            return { stdout: `Volume ${vol.Name} created`, stderr: '', volumes };
+        }
+        let result;
+        if (driver === 'local' || !driver) {
+            if (volume) {
+                result = await this.#exec(`volume create local --opt type=none --opt device=${volume} --opt o=bind ${name}`);
+            }
+            else {
+                result = await this.#exec(`volume create ${name}`);
+            }
+        }
+        else {
+            throw new Error('not implemented');
+        }
+        const volumes = await this.volumeList();
+        if (!volumes.find(it => it.name === name)) {
+            throw new Error(`Network ${name} not found after creation`);
+        }
+        return { ...result, volumes };
+    }
+    /** Remove a volume */
+    async volumeRemove(volumeName) {
+        const result = await this.#exec(`volume remove ${volumeName}`);
+        const volumes = await this.volumeList();
+        if (volumes.find(it => it.name === volumeName)) {
+            throw new Error(`Volume ${volumeName} still found after deletion`);
+        }
+        return { ...result, volumes };
+    }
+    /** Prune unused volumes */
+    async volumePrune() {
+        if (this.#dockerode) {
+            const result = await this.#dockerode.pruneVolumes();
+            const volumes = await this.volumeList();
+            return { stdout: `Volumes pruned`, stderr: JSON.stringify(result), volumes };
+        }
+        const result = await this.#exec(`volume prune -f`);
+        const volumes = await this.volumeList();
+        return { ...result, volumes };
+    }
     /** Stop own containers if necessary */
     async destroy() {
         if (this.#monitoringInterval) {
@@ -1298,7 +2260,7 @@ class DockerManager {
             this.#monitoringInterval = null;
         }
         for (const container of this.#ownContainers) {
-            if (container.iobEnabled !== false && container.iobStopOnUnload) {
+            if (container.iobEnabled !== false && container.iobStopOnUnload && container.name) {
                 this.adapter.log.info(`Stopping own container ${container.name} on destroy`);
                 try {
                     await this.containerStop(container.name);