@lakutata/docker 3.0.0-beta.0

package/dist/esm/client/DockerClient.js

@@ -0,0 +1,307 @@
+import { DockerConnection } from './DockerConnection.js';
+import { DockerRequestError } from './DockerRequestError.js';
+import { DockerContainerNotFoundException } from '../docker/exceptions/DockerContainerNotFoundException.js';
+import { DockerImageNotFoundException } from '../docker/exceptions/DockerImageNotFoundException.js';
+import { DockerNetworkNotFoundException } from '../docker/exceptions/DockerNetworkNotFoundException.js';
+import { DockerRequestException } from '../docker/exceptions/DockerRequestException.js';
+/**
+ * The status codes of the requests: the successes, and the reasons of the failures
+ */
+const SERVER_ERROR = { 500: 'server error' };
+const OK = { 200: true, 204: true };
+const NO_SUCH_IMAGE = { 404: 'no such image' };
+const NO_SUCH_CONTAINER = { 404: 'no such container' };
+const NO_SUCH_EXEC = { 404: 'no such exec' };
+const NO_SUCH_NETWORK = { 404: 'no such network' };
+/**
+ * The exception of a request the daemon refused: the not found exception of the resource missing (told by the daemon's
+ * message, else by the meaning of the status for the request), a DockerRequestException otherwise. The other errors
+ * (the network errors, the aborts) are given as they are
+ * @param error
+ */
+export function dockerException(error) {
+    if (!(error instanceof DockerRequestError))
+        return error;
+    if (error.statusCode === 404) {
+        //"No such container: x", "No such image: x", "network x not found" (also in the failure of a start)
+        const kind = /no such container/i.test(error.detail) ? 'container'
+            : /no such image/i.test(error.detail) ? 'image'
+                : /no such network|network \S+ not found/i.test(error.detail) ? 'network'
+                    : error.reason.replace(/^no such /, '');
+        if (kind === 'container')
+            return new DockerContainerNotFoundException(error.detail);
+        if (kind === 'image')
+            return new DockerImageNotFoundException(error.detail);
+        if (kind === 'network')
+            return new DockerNetworkNotFoundException(error.detail);
+    }
+    return new DockerRequestException(error.statusCode, error.detail || error.message);
+}
+/**
+ * The client of the Docker Engine API
+ */
+export class DockerClient {
+    constructor(options = {}) {
+        this.connection = new DockerConnection(options);
+    }
+    /**
+     * A request whose response is JSON, its failure as the exception of the component
+     * @param request
+     */
+    async #request(request) {
+        try {
+            return await this.connection.request(request);
+        }
+        catch (e) {
+            throw dockerException(e);
+        }
+    }
+    /**
+     * A request whose response is a stream, its failure as the exception of the component
+     * @param request
+     */
+    async #stream(request) {
+        try {
+            return await this.connection.stream(request);
+        }
+        catch (e) {
+            throw dockerException(e);
+        }
+    }
+    /**
+     * A request upgraded to a raw stream, its failure as the exception of the component
+     * @param request
+     */
+    async #hijack(request) {
+        try {
+            return await this.connection.hijack(request);
+        }
+        catch (e) {
+            throw dockerException(e);
+        }
+    }
+    /**
+     * Whether the daemon answers
+     * @param signal
+     */
+    async ping(signal) {
+        return await this.#request({ method: 'GET', path: '/_ping', statusCodes: { 200: true, ...SERVER_ERROR }, signal: signal });
+    }
+    /**
+     * The versions of the daemon
+     */
+    async version() {
+        return await this.#request({ method: 'GET', path: '/version', statusCodes: { 200: true, ...SERVER_ERROR } });
+    }
+    /**
+     * Check registry credentials (docker login)
+     * @param auth
+     */
+    async checkAuth(auth) {
+        return await this.#request({ method: 'POST', path: '/auth', body: auth, statusCodes: { ...OK, ...SERVER_ERROR } });
+    }
+    /** Images **/
+    async listImages(query, signal) {
+        return await this.#request({ method: 'GET', path: '/images/json', query: query, statusCodes: { 200: true, 400: 'bad parameter', ...SERVER_ERROR }, signal: signal });
+    }
+    async inspectImage(name, signal) {
+        return await this.#request({ method: 'GET', path: `/images/${name}/json`, statusCodes: { 200: true, ...NO_SUCH_IMAGE, ...SERVER_ERROR }, signal: signal });
+    }
+    /**
+     * Pull an image: the stream of the progress (docker pull)
+     * @param query fromImage, tag, platform
+     * @param auth
+     * @param signal
+     */
+    async pullImage(query, auth, signal) {
+        return await this.#stream({ method: 'POST', path: '/images/create', query: query, auth: auth, statusCodes: { 200: true, ...SERVER_ERROR }, signal: signal });
+    }
+    /**
+     * Build an image: the stream of the progress
+     * @param context the gzipped tar archive of the context
+     * @param query dockerfile, t, platform, version...
+     * @param registryConfig the credentials of the registries, by server
+     * @param signal
+     */
+    async buildImage(context, query, registryConfig, signal) {
+        return await this.#stream({ method: 'POST', path: '/build', query: query, body: context, registryConfig: registryConfig, statusCodes: { 200: true, ...SERVER_ERROR }, signal: signal });
+    }
+    /**
+     * Load the images of a tar archive (docker load): the stream of the progress
+     * @param archive
+     * @param query quiet
+     */
+    async loadImage(archive, query) {
+        return await this.#stream({ method: 'POST', path: '/images/load', query: query, body: archive, statusCodes: { 200: true, ...SERVER_ERROR } });
+    }
+    /**
+     * The tar archive of an image (docker save)
+     * @param name
+     */
+    async exportImage(name) {
+        return await this.#stream({ method: 'GET', path: `/images/${name}/get`, statusCodes: { 200: true, ...SERVER_ERROR } });
+    }
+    async tagImage(name, query) {
+        await this.#request({ method: 'POST', path: `/images/${name}/tag`, query: query, statusCodes: { 200: true, 201: true, 400: 'bad parameter', ...NO_SUCH_IMAGE, 409: 'conflict', ...SERVER_ERROR } });
+    }
+    /**
+     * Push an image: the stream of the progress
+     * @param name
+     * @param query tag, platform
+     * @param auth
+     */
+    async pushImage(name, query, auth) {
+        return await this.#stream({ method: 'POST', path: `/images/${name}/push`, query: query, auth: (auth ?? {}), statusCodes: { 200: true, ...NO_SUCH_IMAGE, ...SERVER_ERROR } });
+    }
+    async removeImage(name, query) {
+        return await this.#request({ method: 'DELETE', path: `/images/${name}`, query: query, statusCodes: { 200: true, ...NO_SUCH_IMAGE, 409: 'conflict', ...SERVER_ERROR } });
+    }
+    async pruneImages(query) {
+        return await this.#request({ method: 'POST', path: '/images/prune', query: query, statusCodes: { 200: true, ...SERVER_ERROR } });
+    }
+    /** Containers **/
+    async listContainers(query, signal) {
+        return await this.#request({ method: 'GET', path: '/containers/json', query: query, statusCodes: { 200: true, 400: 'bad parameter', ...SERVER_ERROR }, signal: signal });
+    }
+    /**
+     * Create a container
+     * @param body its configuration
+     * @param query name, platform
+     */
+    async createContainer(body, query) {
+        return await this.#request({ method: 'POST', path: '/containers/create', query: query, body: body, statusCodes: { 200: true, 201: true, 400: 'bad parameter', ...NO_SUCH_IMAGE, 409: 'conflict', ...SERVER_ERROR } });
+    }
+    async inspectContainer(id, signal) {
+        return await this.#request({ method: 'GET', path: `/containers/${id}/json`, statusCodes: { 200: true, ...NO_SUCH_CONTAINER, ...SERVER_ERROR }, signal: signal });
+    }
+    /**
+     * Start a container: one already started is done (HTTP 304), as the Docker CLI does
+     * @param id
+     * @param signal
+     */
+    async startContainer(id, signal) {
+        await this.#request({ method: 'POST', path: `/containers/${id}/start`, statusCodes: { ...OK, 304: true, ...NO_SUCH_CONTAINER, ...SERVER_ERROR }, signal: signal });
+    }
+    /**
+     * Stop a container: one already stopped is done (HTTP 304), as the Docker CLI does
+     * @param id
+     * @param query
+     * @param signal
+     */
+    async stopContainer(id, query, signal) {
+        await this.#request({ method: 'POST', path: `/containers/${id}/stop`, query: query, statusCodes: { ...OK, 304: true, ...NO_SUCH_CONTAINER, ...SERVER_ERROR }, signal: signal });
+    }
+    async restartContainer(id, query, signal) {
+        await this.#request({ method: 'POST', path: `/containers/${id}/restart`, query: query, statusCodes: { ...OK, ...NO_SUCH_CONTAINER, ...SERVER_ERROR }, signal: signal });
+    }
+    async pauseContainer(id) {
+        await this.#request({ method: 'POST', path: `/containers/${id}/pause`, statusCodes: { ...OK, ...NO_SUCH_CONTAINER, ...SERVER_ERROR } });
+    }
+    async unpauseContainer(id) {
+        await this.#request({ method: 'POST', path: `/containers/${id}/unpause`, statusCodes: { ...OK, ...NO_SUCH_CONTAINER, ...SERVER_ERROR } });
+    }
+    async killContainer(id, query) {
+        await this.#request({ method: 'POST', path: `/containers/${id}/kill`, query: query, statusCodes: { ...OK, ...NO_SUCH_CONTAINER, ...SERVER_ERROR } });
+    }
+    async removeContainer(id, query) {
+        await this.#request({ method: 'DELETE', path: `/containers/${id}`, query: query, statusCodes: { ...OK, 400: 'bad parameter', ...NO_SUCH_CONTAINER, ...SERVER_ERROR } });
+    }
+    /**
+     * Rename a container
+     * @param id
+     * @param name
+     */
+    async renameContainer(id, name) {
+        await this.#request({ method: 'POST', path: `/containers/${id}/rename`, query: { name: name }, statusCodes: { ...OK, ...NO_SUCH_CONTAINER, 409: 'name already in use', ...SERVER_ERROR } });
+    }
+    /**
+     * Update the resources and the restart policy of a container, live (docker update)
+     * @param id
+     * @param body
+     */
+    async updateContainer(id, body) {
+        return await this.#request({ method: 'POST', path: `/containers/${id}/update`, body: body, statusCodes: { ...OK, 400: 'bad parameter', ...NO_SUCH_CONTAINER, ...SERVER_ERROR } });
+    }
+    /**
+     * Create an image of a container (docker commit)
+     * @param id
+     * @param query repo, tag, comment, author, pause, changes
+     */
+    async commitContainer(id, query) {
+        return await this.#request({ method: 'POST', path: '/commit', query: { ...query, container: id }, statusCodes: { 200: true, 201: true, ...NO_SUCH_CONTAINER, ...SERVER_ERROR } });
+    }
+    /**
+     * The logs of a container: multiplexed when it has no TTY
+     * @param id
+     * @param query follow, stdout, stderr, since, until, timestamps, tail
+     */
+    async containerLogs(id, query) {
+        return await this.#stream({ method: 'GET', path: `/containers/${id}/logs`, query: query, statusCodes: { 200: true, ...NO_SUCH_CONTAINER, ...SERVER_ERROR } });
+    }
+    /**
+     * The statistics of a container, once
+     * @param id
+     */
+    async containerStats(id) {
+        return await this.#request({ method: 'GET', path: `/containers/${id}/stats`, query: { 'stream': false, 'one-shot': true }, statusCodes: { 200: true, ...NO_SUCH_CONTAINER, ...SERVER_ERROR } });
+    }
+    /**
+     * The tar archive of a path of a container
+     * @param id
+     * @param query path
+     */
+    async getArchive(id, query) {
+        return await this.#stream({ method: 'GET', path: `/containers/${id}/archive`, query: query, statusCodes: { 200: true, 400: 'client error, bad parameters', ...NO_SUCH_CONTAINER, ...SERVER_ERROR } });
+    }
+    /**
+     * Create an execution in a container
+     * @param id
+     * @param body Cmd, AttachStdin, AttachStdout, AttachStderr, Tty, ConsoleSize...
+     */
+    async createExec(id, body) {
+        return await this.#request({ method: 'POST', path: `/containers/${id}/exec`, body: body, statusCodes: { 200: true, 201: true, ...NO_SUCH_CONTAINER, 409: 'container stopped/paused', ...SERVER_ERROR } });
+    }
+    /**
+     * Start an execution, attached: its stream, read (its output, multiplexed without TTY) and written (its input)
+     * @param execId
+     * @param body Detach, Tty
+     */
+    async startExec(execId, body) {
+        return await this.#hijack({ method: 'POST', path: `/exec/${execId}/start`, body: body, statusCodes: { ...OK, ...NO_SUCH_EXEC, 409: 'container stopped/paused', 500: 'container not running' } });
+    }
+    async resizeExec(execId, query) {
+        await this.#request({ method: 'POST', path: `/exec/${execId}/resize`, query: query, statusCodes: { ...OK, ...NO_SUCH_EXEC, 500: 'container not running' } });
+    }
+    async inspectExec(execId) {
+        return await this.#request({ method: 'GET', path: `/exec/${execId}/json`, statusCodes: { 200: true, ...NO_SUCH_EXEC, ...SERVER_ERROR } });
+    }
+    async pruneContainers(query) {
+        return await this.#request({ method: 'POST', path: '/containers/prune', query: query, statusCodes: { 200: true, ...SERVER_ERROR } });
+    }
+    /** Networks **/
+    async listNetworks(query, signal) {
+        return await this.#request({ method: 'GET', path: '/networks', query: query, statusCodes: { 200: true, 400: 'bad parameter', ...SERVER_ERROR }, signal: signal });
+    }
+    async createNetwork(body) {
+        return await this.#request({ method: 'POST', path: '/networks/create', body: body, statusCodes: { 200: true, 201: true, 404: 'driver not found', ...SERVER_ERROR } });
+    }
+    async inspectNetwork(id) {
+        return await this.#request({ method: 'GET', path: `/networks/${id}`, statusCodes: { 200: true, ...NO_SUCH_NETWORK, ...SERVER_ERROR } });
+    }
+    async removeNetwork(id) {
+        await this.#request({ method: 'DELETE', path: `/networks/${id}`, statusCodes: { ...OK, ...NO_SUCH_NETWORK, 409: 'conflict', ...SERVER_ERROR } });
+    }
+    async pruneNetworks(query) {
+        return await this.#request({ method: 'POST', path: '/networks/prune', query: query, statusCodes: { 200: true, ...SERVER_ERROR } });
+    }
+    /** Volumes **/
+    async pruneVolumes(query) {
+        return await this.#request({ method: 'POST', path: '/volumes/prune', query: query, statusCodes: { 200: true, ...SERVER_ERROR } });
+    }
+    /**
+     * Close the connections kept alive
+     */
+    close() {
+        this.connection.close();
+    }
+}

package/dist/esm/client/DockerConnection.js

@@ -0,0 +1,355 @@
+/*
+ * The connection to the Docker Engine API, rewritten from docker-modem (Copyright Pedro Dias, Apache License 2.0,
+ * see THIRD_PARTY_NOTICES.md), modified: the requests are promises, the API version is negotiated, and the requests
+ * streaming a body close their connection (see Request)
+ */
+import { existsSync, readFileSync } from 'node:fs';
+import http from 'node:http';
+import https from 'node:https';
+import { homedir, platform } from 'node:os';
+import path from 'node:path';
+import { Duplex, Writable } from 'node:stream';
+import { DockerRequestError } from './DockerRequestError.js';
+/**
+ * The newest API version this client is tested with (Docker 29.8): the one negotiated when the daemon supports it, so that
+ * a newer daemon answers as the tested one. An older daemon answers with its version: the fields a version does not have
+ * are missing or null
+ */
+export const DOCKER_API_VERSION = '1.56';
+/**
+ * The oldest API version this client works with
+ */
+export const DOCKER_MIN_API_VERSION = '1.41';
+/**
+ * Compare two API versions
+ * @param a
+ * @param b
+ */
+export function compareAPIVersions(a, b) {
+    const [x, y] = [a, b].map((version) => version.replace(/^v/, '').split('.').map(Number));
+    return (x[0] - y[0]) || ((x[1] ?? 0) - (y[1] ?? 0));
+}
+/**
+ * The certificates of a CA file, split (a file may have several)
+ * @param file
+ */
+function splitCA(file) {
+    return readFileSync(file, 'utf8').split(/(?<=-----END CERTIFICATE-----)\s*/).map((certificate) => certificate.trim()).filter(Boolean);
+}
+/**
+ * The connection options given by the environment (DOCKER_HOST, DOCKER_TLS_VERIFY, DOCKER_CERT_PATH,
+ * DOCKER_CLIENT_TIMEOUT), else the socket of the platform: the named pipe on Windows, the socket of the user (Docker
+ * Desktop) or /var/run/docker.sock
+ */
+export function defaultConnectionOptions() {
+    const dockerHost = process.env.DOCKER_HOST;
+    if (!dockerHost) {
+        if (platform() === 'win32')
+            return { socketPath: '//./pipe/docker_engine' };
+        const userSocket = path.join(homedir(), '.docker', 'run', 'docker.sock');
+        return { socketPath: existsSync(userSocket) ? userSocket : '/var/run/docker.sock' };
+    }
+    if (dockerHost.startsWith('unix://'))
+        return { socketPath: dockerHost.slice(7) || '/var/run/docker.sock' };
+    if (dockerHost.startsWith('npipe://'))
+        return { socketPath: dockerHost.slice(8) || '//./pipe/docker_engine' };
+    let url;
+    try {
+        url = new URL(dockerHost.includes('//') ? dockerHost : `tcp://${dockerHost}`);
+    }
+    catch {
+        throw new Error('DOCKER_HOST should be something like tcp://localhost:2375');
+    }
+    const options = { host: url.hostname, port: url.port };
+    if (url.protocol === 'ssh:') {
+        options.protocol = 'ssh';
+        options.username = url.username || undefined;
+    }
+    else {
+        options.protocol = process.env.DOCKER_TLS_VERIFY === '1' || url.port === '2376' ? 'https' : 'http';
+    }
+    const certPath = process.env.DOCKER_CERT_PATH;
+    if (certPath) {
+        options.ca = splitCA(path.join(certPath, 'ca.pem'));
+        options.cert = readFileSync(path.join(certPath, 'cert.pem'));
+        options.key = readFileSync(path.join(certPath, 'key.pem'));
+    }
+    if (process.env.DOCKER_CLIENT_TIMEOUT)
+        options.timeout = Number.parseInt(process.env.DOCKER_CLIENT_TIMEOUT, 10);
+    return options;
+}
+/**
+ * The query string of the parameters of a request
+ * @param query
+ */
+function queryString(query = {}) {
+    const parameters = new URLSearchParams();
+    for (const [key, value] of Object.entries(query)) {
+        if (value === undefined || value === null)
+            continue;
+        if (Array.isArray(value)) {
+            value.forEach((item) => parameters.append(key, String(item)));
+        }
+        else if (typeof value === 'object') {
+            parameters.append(key, JSON.stringify(value));
+        }
+        else {
+            parameters.append(key, String(value));
+        }
+    }
+    const text = parameters.toString();
+    return text ? `?${text}` : '';
+}
+/**
+ * Whether a body is a stream
+ * @param body
+ */
+function isStream(body) {
+    return !!body && typeof body.pipe === 'function';
+}
+/**
+ * The connection to a Docker daemon
+ */
+export class DockerConnection {
+    #options;
+    #protocol;
+    /**
+     * The agent of the requests: the connections are kept alive
+     */
+    #agent;
+    /**
+     * The agent of the requests streaming their body: their connections are closed after them. Docker answers a build
+     * while it reads its context: on a kept alive connection, its HTTP server discards a part of the unread body when it
+     * answers, which corrupts the context ("unpigz: corrupted -- invalid deflate data")
+     */
+    #closingAgent;
+    /**
+     * The negotiated API version
+     */
+    #version;
+    #sshAgent;
+    constructor(options = {}) {
+        //The options given (a timeout, headers…) apply over the ones of the environment, the ones not given keep them
+        const given = Object.fromEntries(Object.entries(options).filter(([, value]) => value !== undefined));
+        this.#options = given.socketPath || given.host ? given : { ...defaultConnectionOptions(), ...given };
+        this.#protocol = this.#options.protocol ?? (this.#options.key && this.#options.cert && this.#options.ca ? 'https' : 'http');
+        if (this.#options.version)
+            this.#version = this.#options.version.replace(/^v/, '');
+        if (this.#protocol !== 'ssh') {
+            const module = this.#protocol === 'https' ? https : http;
+            this.#agent = new module.Agent({ keepAlive: true });
+            this.#closingAgent = new module.Agent({ keepAlive: false });
+        }
+    }
+    /**
+     * The API version of the requests, once negotiated
+     */
+    get version() {
+        return this.#version;
+    }
+    /**
+     * Negotiate the API version with the daemon: the newest one both support
+     */
+    async negotiate() {
+        if (this.#version)
+            return this.#version;
+        const version = await this.request({ method: 'GET', path: '/version', statusCodes: { 200: true, 500: 'server error' } });
+        const daemon = version.ApiVersion ?? DOCKER_MIN_API_VERSION;
+        let negotiated = compareAPIVersions(daemon, DOCKER_API_VERSION) < 0 ? daemon : DOCKER_API_VERSION;
+        //The daemon no longer supports the version of the client
+        if (version.MinAPIVersion && compareAPIVersions(negotiated, version.MinAPIVersion) < 0)
+            negotiated = version.MinAPIVersion;
+        this.#version = negotiated;
+        return negotiated;
+    }
+    /**
+     * The agent of an SSH connection: the requests are sent to "docker system dial-stdio" (ssh2, an optional dependency)
+     */
+    sshAgent() {
+        return this.#sshAgent ??= (async () => {
+            let ssh2;
+            try {
+                //An optional dependency, loaded where it is installed
+                const ssh2Module = 'ssh2';
+                ssh2 = await import(ssh2Module);
+            }
+            catch {
+                throw new Error('The SSH connections to Docker need the package ssh2: npm install ssh2');
+            }
+            const Client = ssh2.Client ?? ssh2.default?.Client;
+            const agent = new http.Agent();
+            const options = this.#options;
+            agent.createConnection = ((_, callback) => {
+                const client = new Client();
+                const fail = (error) => {
+                    client.end();
+                    callback(error);
+                };
+                client.once('ready', () => {
+                    client.exec('docker system dial-stdio', (error, stream) => {
+                        if (error)
+                            return fail(error);
+                        callback(null, stream);
+                        stream.once('close', () => client.end());
+                    });
+                }).once('error', fail).connect({
+                    host: options.host,
+                    port: Number(options.port ?? 22),
+                    username: options.username,
+                    password: options.password,
+                    agent: options.sshAuthAgent ?? process.env.SSH_AUTH_SOCK
+                });
+            });
+            return agent;
+        })();
+    }
+    /**
+     * The options of a request
+     * @param request
+     * @param streamingBody
+     */
+    async requestOptions(request, streamingBody) {
+        const headers = { ...this.#options.headers, ...request.headers };
+        if (request.auth)
+            headers['X-Registry-Auth'] = Buffer.from(JSON.stringify(request.auth)).toString('base64url');
+        if (request.registryConfig)
+            headers['X-Registry-Config'] = Buffer.from(JSON.stringify(request.registryConfig)).toString('base64');
+        const versioned = this.#version ? `/v${this.#version}${request.path}` : request.path;
+        const options = {
+            method: request.method,
+            path: `${versioned}${queryString(request.query)}`,
+            headers: headers,
+            signal: request.signal,
+            timeout: this.#options.timeout
+        };
+        if (this.#protocol === 'ssh') {
+            options.agent = await this.sshAgent();
+            options.host = 'localhost';
+        }
+        else {
+            options.agent = streamingBody ? this.#closingAgent : this.#agent;
+            if (this.#options.socketPath) {
+                options.socketPath = this.#options.socketPath;
+            }
+            else {
+                options.host = this.#options.host;
+                options.port = this.#options.port;
+            }
+            if (this.#protocol === 'https')
+                Object.assign(options, { ca: this.#options.ca, cert: this.#options.cert, key: this.#options.key });
+        }
+        return options;
+    }
+    /**
+     * Send a request: the response, once its status is known
+     * @param request
+     * @param hijack upgrade the connection to a raw stream (the TTYs, the attached executions)
+     */
+    async send(request, hijack = false) {
+        const streamingBody = isStream(request.body);
+        const options = await this.requestOptions(request, streamingBody);
+        const headers = options.headers;
+        let payload;
+        if (request.body !== undefined && !streamingBody) {
+            payload = JSON.stringify(request.body);
+            headers['Content-Type'] = 'application/json';
+            headers['Content-Length'] = String(Buffer.byteLength(payload));
+        }
+        else if (streamingBody) {
+            headers['Content-Type'] = 'application/x-tar';
+        }
+        if (hijack) {
+            headers.Connection = 'Upgrade';
+            headers.Upgrade = 'tcp';
+        }
+        const module = this.#protocol === 'https' ? https : http;
+        return new Promise((resolve, reject) => {
+            const req = module.request(options);
+            req.once('error', reject);
+            req.once('timeout', () => req.destroy(new Error(`Timeout of ${this.#options.timeout} ms exceeded`)));
+            if (hijack) {
+                req.once('upgrade', (response, socket, head) => {
+                    if (head.length)
+                        socket.unshift(head);
+                    resolve({ response: response, socket: socket, request: req });
+                });
+            }
+            req.once('response', (response) => resolve({ response: response, request: req }));
+            if (streamingBody) {
+                const body = request.body;
+                //An error of the body (the packing of a build context) fails the request, instead of ending its stream
+                body.once('error', (error) => req.destroy(error));
+                body.pipe(req);
+            }
+            else {
+                req.end(payload);
+            }
+        });
+    }
+    /**
+     * The error of a failed response
+     * @param request
+     * @param response
+     */
+    async failure(request, response) {
+        const text = Buffer.concat(await response.toArray()).toString();
+        let json;
+        try {
+            json = JSON.parse(text);
+        }
+        catch {
+            json = undefined;
+        }
+        const reason = typeof request.statusCodes[response.statusCode] === 'string' ? request.statusCodes[response.statusCode] : 'unexpected';
+        return new DockerRequestError(response.statusCode, reason, json?.message ?? text.trim(), json);
+    }
+    /**
+     * A request whose response is JSON (or nothing)
+     * @param request
+     */
+    async request(request) {
+        const { response } = await this.send(request);
+        if (request.statusCodes[response.statusCode] !== true)
+            throw await this.failure(request, response);
+        const text = Buffer.concat(await response.toArray()).toString();
+        if (!text)
+            return undefined;
+        try {
+            return JSON.parse(text);
+        }
+        catch {
+            return text;
+        }
+    }
+    /**
+     * A request whose response is a stream (the progress of a pull, the logs, an archive)
+     * @param request
+     */
+    async stream(request) {
+        const { response } = await this.send(request);
+        if (request.statusCodes[response.statusCode] !== true)
+            throw await this.failure(request, response);
+        return response;
+    }
+    /**
+     * A request upgraded to a raw stream, read and written (the TTYs, the attached executions)
+     * @param request
+     */
+    async hijack(request) {
+        const { response, socket } = await this.send(request, true);
+        if (socket)
+            return socket;
+        if (request.statusCodes[response.statusCode] !== true)
+            throw await this.failure(request, response);
+        //A daemon answering without upgrading: its response is the output, what is written is discarded
+        return Duplex.from({ readable: response, writable: new Writable({ write: (_chunk, _encoding, callback) => callback() }) });
+    }
+    /**
+     * Close the kept alive connections
+     */
+    close() {
+        this.#agent?.destroy();
+        this.#closingAgent?.destroy();
+        this.#sshAgent?.then((agent) => agent.destroy()).catch(() => undefined);
+    }
+}