@wpelevator/tug 0.3.0 → 0.4.0

package/dist/container-spec.js

@@ -0,0 +1,359 @@
+// Turns the desired state for one node into Engine API container definitions. Pure: no Docker, no
+// filesystem. The config hash decides whether a running container already matches its definition.
+import crypto from 'node:crypto';
+import { bindPorts, crossNodeHosts } from "./compose.js";
+import { sentinelNames, substituteSentinels } from "./normalize.js";
+export const LABEL_PROJECT = 'tug.project';
+export const LABEL_SERVICE = 'tug.service';
+export const LABEL_REVISION = 'tug.revision';
+export const LABEL_HASH = 'tug.config-hash';
+/** The project network every container of the project joins; service names are its aliases. */
+export const networkName = (project) => `tug_${project}`;
+/** Docker volume name for a Compose volume; `external` volumes keep their own name. */
+export const volumeName = (project, volume) => `tug_${project}_${volume}`;
+export const containerName = (project, service, hash) => `tug-${project}-${service}-${hash.slice(0, 8)}`;
+const SECOND_NS = 1_000_000_000;
+const UNITS = {
+    ns: 1e-6,
+    us: 1e-3,
+    µs: 1e-3,
+    ms: 1,
+    s: 1000,
+    m: 60000,
+    h: 3600000,
+};
+/** Compose durations (`30s`, `1m30s`, `500ms`) or a number of seconds, in milliseconds. */
+export function composeDurationMs(value) {
+    if (typeof value === 'number')
+        return value * 1000;
+    if (typeof value !== 'string' || !value)
+        return undefined;
+    let total = 0;
+    let rest = value;
+    while (rest) {
+        const m = rest.match(/^(\d+(?:\.\d+)?)(ns|us|µs|ms|s|m|h)/);
+        if (!m)
+            return undefined;
+        total += Number(m[1]) * UNITS[m[2]];
+        rest = rest.slice(m[0].length);
+    }
+    return total;
+}
+const toNs = (value) => {
+    const ms = composeDurationMs(value);
+    return ms === undefined ? undefined : Math.round(ms * 1e6);
+};
+/** Compose sizes: bytes as a number, or `64m` / `1g` style strings. */
+export function sizeBytes(value) {
+    if (typeof value === 'number')
+        return value;
+    if (typeof value !== 'string')
+        return undefined;
+    const m = value
+        .trim()
+        .toLowerCase()
+        .match(/^(\d+(?:\.\d+)?)\s*([kmgt]?)b?$/);
+    if (!m)
+        return undefined;
+    const power = { '': 0, k: 1, m: 2, g: 3, t: 4 }[m[2]];
+    return Math.round(Number(m[1]) * 1024 ** power);
+}
+const asList = (value) => Array.isArray(value) ? value.map(String) : value == null ? [] : [String(value)];
+function extraHosts(value) {
+    if (!value)
+        return [];
+    return Array.isArray(value)
+        ? value.map((entry) => String(entry).replace('=', ':'))
+        : Object.entries(value).map(([name, ip]) => `${name}:${ip}`);
+}
+function restartPolicy(value) {
+    if (typeof value !== 'string' || !value)
+        return undefined;
+    const [name, max] = value.split(':');
+    return name === 'on-failure' && max
+        ? { Name: name, MaximumRetryCount: Number(max) }
+        : { Name: name === 'no' ? '' : name };
+}
+function healthcheck(value) {
+    if (!value || typeof value !== 'object')
+        return undefined;
+    const hc = value;
+    if (hc.disable === true)
+        return { Test: ['NONE'] };
+    const test = typeof hc.test === 'string' ? ['CMD-SHELL', hc.test] : hc.test;
+    return {
+        ...(test ? { Test: test } : {}),
+        ...(toNs(hc.interval) !== undefined ? { Interval: toNs(hc.interval) } : {}),
+        ...(toNs(hc.timeout) !== undefined ? { Timeout: toNs(hc.timeout) } : {}),
+        ...(toNs(hc.start_period) !== undefined ? { StartPeriod: toNs(hc.start_period) } : {}),
+        ...(toNs(hc.start_interval) !== undefined ? { StartInterval: toNs(hc.start_interval) } : {}),
+        ...(hc.retries !== undefined ? { Retries: Number(hc.retries) } : {}),
+    };
+}
+function portMaps(svc, ports) {
+    const exposed = {};
+    const bindings = {};
+    for (const entry of ports) {
+        const key = `${Number(entry.target)}/${entry.protocol || 'tcp'}`;
+        exposed[key] = {};
+        (bindings[key] ||= []).push({
+            HostIp: entry.host_ip || '',
+            HostPort: entry.published === undefined ? '' : String(entry.published),
+        });
+    }
+    for (const port of asList(svc.expose))
+        exposed[`${port.split('/')[0]}/${port.split('/')[1] || 'tcp'}`] = {};
+    return { exposed, bindings };
+}
+/** Volume definitions this node needs, with NFS volumes mounted from the exporter's directory or address. */
+function volumeSpecs(desired, node, used, nodeAddresses) {
+    const out = [];
+    for (const key of [...used].sort()) {
+        const def = desired.compose.volumes?.[key] || {};
+        const xe = def['x-tug'] || {};
+        const labels = {
+            [LABEL_PROJECT]: desired.project,
+            'tug.volume': key,
+            ...(def.labels || {}),
+        };
+        if (def.external) {
+            out.push({
+                name: String(def.name || key),
+                driver: 'local',
+                opts: {},
+                labels,
+                external: true,
+            });
+            continue;
+        }
+        const name = volumeName(desired.project, key);
+        const nodes = xe.placement?.nodes || [];
+        const isNfs = xe.type === 'nfs' || xe.driver === 'nfs' || (xe.type === 'shared' && xe.driver === 'nfs');
+        const plain = () => ({
+            name,
+            driver: String(def.driver || 'local'),
+            opts: def.driver_opts || {},
+            labels,
+            external: false,
+        });
+        if (isNfs) {
+            const exporter = nodes[0];
+            const exportPath = xe.export || `/srv/tug/${key}`;
+            if (!exporter)
+                out.push(plain());
+            else if (nodes.includes(node))
+                // The exporter mounts the exported directory directly; an NFS server on this node must export it.
+                out.push({
+                    name,
+                    driver: 'local',
+                    opts: { type: 'none', o: 'bind', device: exportPath },
+                    labels,
+                    external: false,
+                });
+            else {
+                const addr = xe.address || nodeAddresses[exporter] || exporter;
+                out.push({
+                    name,
+                    driver: 'local',
+                    opts: { type: 'nfs', o: `addr=${addr},rw,nolock,soft`, device: `:${exportPath}` },
+                    labels,
+                    external: false,
+                });
+            }
+            continue;
+        }
+        if (!nodes.length || nodes.includes(node))
+            out.push(plain());
+    }
+    return out;
+}
+function walkStrings(value, fn) {
+    if (typeof value === 'string')
+        return fn(value);
+    if (Array.isArray(value))
+        return value.map((v) => walkStrings(v, fn));
+    if (value && typeof value === 'object')
+        return Object.fromEntries(Object.entries(value).map(([k, v]) => [k, walkStrings(v, fn)]));
+    return value;
+}
+export function containerSpecs(desired, node, { secrets = {}, secretVersions = {}, endpoints = {}, nodeAddresses = {}, bind, } = {}) {
+    const { project } = desired;
+    const network = networkName(project);
+    const placed = new Set();
+    for (const service of Object.keys(desired.compose.services || {})) {
+        const nodes = desired.services[service].placement?.nodes || [];
+        if (!nodes.length || nodes.includes(node))
+            placed.add(service);
+    }
+    const hosts = crossNodeHosts(project, endpoints, placed);
+    const usedVolumes = new Set();
+    const specs = {};
+    for (const service of [...placed].sort()) {
+        const src = desired.compose.services[service];
+        const state = desired.services[service];
+        const identity = state.artifact?.imageId ?? state.image;
+        const image = state.artifact?.imageRef ?? state.image ?? '';
+        const ports = (bind && src.ports
+            ? bindPorts(src.ports, bind.address, bind.loopback?.has(service) ? src['x-tug']?.ingress?.port : undefined)
+            : src.ports || []);
+        const { exposed, bindings } = portMaps(src, ports);
+        const binds = [];
+        const tmpfs = {};
+        for (const mount of src.volumes || []) {
+            if (typeof mount === 'string')
+                continue;
+            const m = mount;
+            const ro = m.read_only ? ':ro' : '';
+            if (m.type === 'volume') {
+                const key = String(m.source);
+                usedVolumes.add(key);
+                const def = desired.compose.volumes?.[key];
+                binds.push(`${def?.external ? (def.name ?? key) : volumeName(project, key)}:${m.target}${ro}`);
+            }
+            else if (m.type === 'bind')
+                binds.push(`${m.source}:${m.target}${ro}`);
+            else if (m.type === 'tmpfs') {
+                const size = m.tmpfs?.size;
+                tmpfs[String(m.target)] = size ? `size=${size}` : '';
+            }
+        }
+        for (const target of asList(src.tmpfs))
+            tmpfs[target] = tmpfs[target] ?? '';
+        const env = Object.entries(src.environment || {})
+            .filter(([, v]) => v !== null && v !== undefined)
+            .map(([k, v]) => `${k}=${v}`);
+        const memory = sizeBytes(src.mem_limit);
+        const reservation = sizeBytes(src.mem_reservation);
+        const shm = sizeBytes(src.shm_size);
+        const ulimits = Object.entries(src.ulimits || {}).map(([Name, v]) => typeof v === 'number'
+            ? { Name, Soft: v, Hard: v }
+            : {
+                Name,
+                Soft: Number(v.soft),
+                Hard: Number(v.hard),
+            });
+        const logging = src.logging;
+        const extra = [...extraHosts(src.extra_hosts)];
+        const taken = new Set(extra.map((h) => h.split(':')[0]));
+        for (const host of hosts)
+            if (!taken.has(host.split(':')[0]))
+                extra.push(host);
+        const stopTimeout = composeDurationMs(src.stop_grace_period);
+        const hostConfig = {
+            NetworkMode: network,
+            ...(binds.length ? { Binds: binds } : {}),
+            ...(Object.keys(tmpfs).length ? { Tmpfs: tmpfs } : {}),
+            ...(Object.keys(bindings).length ? { PortBindings: bindings } : {}),
+            ...(restartPolicy(src.restart) ? { RestartPolicy: restartPolicy(src.restart) } : {}),
+            ...(memory !== undefined ? { Memory: memory } : {}),
+            ...(reservation !== undefined ? { MemoryReservation: reservation } : {}),
+            ...(src.cpus !== undefined ? { NanoCpus: Math.round(Number(src.cpus) * SECOND_NS) } : {}),
+            ...(src.pids_limit !== undefined ? { PidsLimit: Number(src.pids_limit) } : {}),
+            ...(shm !== undefined ? { ShmSize: shm } : {}),
+            ...(src.init !== undefined ? { Init: Boolean(src.init) } : {}),
+            ...(src.read_only ? { ReadonlyRootfs: true } : {}),
+            ...(extra.length ? { ExtraHosts: extra } : {}),
+            ...(asList(src.cap_add).length ? { CapAdd: asList(src.cap_add) } : {}),
+            ...(asList(src.cap_drop).length ? { CapDrop: asList(src.cap_drop) } : {}),
+            ...(ulimits.length ? { Ulimits: ulimits } : {}),
+            ...(logging?.driver
+                ? { LogConfig: { Type: logging.driver, Config: logging.options || {} } }
+                : {}),
+        };
+        const hc = healthcheck(src.healthcheck);
+        const definition = {
+            Image: image,
+            ...(env.length ? { Env: env } : {}),
+            ...(src.command != null ? { Cmd: asList(src.command) } : {}),
+            ...(src.entrypoint != null ? { Entrypoint: asList(src.entrypoint) } : {}),
+            ...(src.user ? { User: String(src.user) } : {}),
+            ...(src.working_dir ? { WorkingDir: String(src.working_dir) } : {}),
+            ...(src.hostname ? { Hostname: String(src.hostname) } : {}),
+            Labels: Object.fromEntries(Object.entries(src.labels || {}).map(([k, v]) => [
+                k,
+                String(v),
+            ])),
+            ...(Object.keys(exposed).length ? { ExposedPorts: exposed } : {}),
+            ...(src.stop_signal ? { StopSignal: String(src.stop_signal) } : {}),
+            ...(stopTimeout !== undefined ? { StopTimeout: Math.ceil(stopTimeout / 1000) } : {}),
+            ...(hc ? { Healthcheck: hc } : {}),
+            HostConfig: hostConfig,
+            NetworkingConfig: { EndpointsConfig: { [network]: { Aliases: [service] } } },
+        };
+        const used = [...new Set(sentinelNames(definition))].sort();
+        const versions = Object.fromEntries(used
+            .filter((name) => secretVersions[name] != null)
+            .map((name) => [name, secretVersions[name]]));
+        const hash = crypto
+            .createHash('sha256')
+            .update(JSON.stringify({ definition: { ...definition, Image: identity }, versions }))
+            .digest('hex')
+            .slice(0, 16);
+        const body = walkStrings(definition, (s) => substituteSentinels(s, secrets));
+        body.Labels = {
+            ...body.Labels,
+            [LABEL_PROJECT]: project,
+            [LABEL_SERVICE]: service,
+            [LABEL_HASH]: hash,
+            ...(desired.revision || desired.version
+                ? { [LABEL_REVISION]: desired.revision || desired.version }
+                : {}),
+        };
+        const dependsOn = {};
+        const deps = src.depends_on;
+        if (Array.isArray(deps)) {
+            for (const dep of deps)
+                if (placed.has(String(dep)))
+                    dependsOn[String(dep)] = 'service_started';
+        }
+        else if (deps && typeof deps === 'object') {
+            for (const [dep, spec] of Object.entries(deps))
+                if (placed.has(dep))
+                    dependsOn[dep] =
+                        spec?.condition === 'service_healthy'
+                            ? 'service_healthy'
+                            : 'service_started';
+        }
+        specs[service] = {
+            service,
+            name: containerName(project, service, hash),
+            hash,
+            body,
+            dependsOn,
+        };
+    }
+    return { network, volumes: volumeSpecs(desired, node, usedVolumes, nodeAddresses), specs };
+}
+/** Start order: dependencies first, ties by service name; a cycle is an error. */
+export function startOrder(specs) {
+    const order = [];
+    const state = new Map();
+    const visit = (service, path) => {
+        if (state.get(service) === 'done')
+            return;
+        if (state.get(service) === 'visiting')
+            throw new Error(`depends_on cycle: ${[...path, service].join(' -> ')}`);
+        state.set(service, 'visiting');
+        for (const dep of Object.keys(specs[service].dependsOn).sort())
+            visit(dep, [...path, service]);
+        state.set(service, 'done');
+        order.push(service);
+    };
+    for (const service of Object.keys(specs).sort())
+        visit(service, []);
+    return order;
+}
+/** `body` with the host side of its (single) published port replaced; used for rolling revisions. */
+export function withHostPort(body, port) {
+    const bindings = (body.HostConfig?.PortBindings || {});
+    return {
+        ...body,
+        HostConfig: {
+            ...body.HostConfig,
+            PortBindings: Object.fromEntries(Object.entries(bindings).map(([key, list]) => [
+                key,
+                list.map((b) => ({ ...b, HostPort: String(port) })),
+            ])),
+        },
+    };
+}

package/dist/control.js

@@ -17,6 +17,7 @@ import { openDb } from "./db.js";
 import { encrypt, decrypt, loadOrCreateMasterKey } from "./secrets.js";
 import { buildDesiredState, loopbackIngressServices, serviceSecretNames, validateCompose, } from "./compose.js";
 import { buildAndPush, unpackContext, run as runCommand } from "./build.js";
+import { sentinelNames } from "./normalize.js";
 import { ensureDir, errMessage, hashToken, id, now, token } from "./util.js";
 import { DEFAULT_MESH_CIDR, DEFAULT_WG_PORT, WG_INTERFACE, WG_KEEPALIVE, allocateOverlayIp, isWgKey, parseCidr, wgEndpoint, } from "./mesh.js";
 import { buildIngressWork, resolveServiceEndpoints } from "./ingress.js";
@@ -1280,6 +1281,14 @@ export async function createApp(options = {}) {
             catch (e) {
                 throw httpError(400, errMessage(e));
             }
+            // The CLI interpolates control secrets as sentinels; a reference to a secret that is gone would deploy an empty value.
+            const referenced = sentinelNames(compose);
+            if (referenced.length) {
+                const known = new Set((await db.all('SELECT name FROM secrets WHERE project_id=?', project)).map((row) => row.name));
+                const missing = referenced.filter((name) => !known.has(name));
+                if (missing.length)
+                    throw httpError(400, `secrets not found in project ${project}: ${missing.join(', ')}; create them with tug secret-set`);
+            }
             const builtServices = Object.entries(compose.services)
                 .filter(([, service]) => service.build)
                 .map(([name]) => name);

package/dist/docker-api.d.ts

@@ -0,0 +1,232 @@
+import { EventEmitter } from 'node:events';
+import type { Readable, Writable } from 'node:stream';
+/** Oldest Engine API the agent speaks (Docker 20.10+, which the nested daemons in the integration tests run). */
+export declare const API_VERSION = "v1.41";
+export declare const DEFAULT_SOCKET = "/var/run/docker.sock";
+/** An Engine API error; `status` is the HTTP status and `message` the daemon's own text. */
+export declare class DockerError extends Error {
+    status: number;
+    constructor(status: number, message: string);
+}
+export declare const isNotFound: (error: unknown) => boolean;
+export interface ContainerSummary {
+    Id: string;
+    Names: string[];
+    Image: string;
+    ImageID?: string;
+    State: string;
+    Status?: string;
+    Created?: number;
+    Labels: Record<string, string>;
+    Ports?: {
+        IP?: string;
+        PrivatePort: number;
+        PublicPort?: number;
+        Type: string;
+    }[];
+}
+export interface ContainerInspect {
+    Id: string;
+    Name: string;
+    Image?: string;
+    Config?: {
+        Image?: string;
+        Labels?: Record<string, string>;
+        Env?: string[];
+    };
+    State?: {
+        Status?: string;
+        Running?: boolean;
+        ExitCode?: number;
+        Health?: {
+            Status?: string;
+        };
+    };
+    NetworkSettings?: {
+        Networks?: Record<string, {
+            IPAddress?: string;
+            GlobalIPv6Address?: string;
+        }>;
+    };
+    [key: string]: unknown;
+}
+export interface ContainerFilter {
+    /** `key` or `key=value` label filters, all of which must match. */
+    label?: string[];
+    /** Containers created from this image reference or ID. */
+    ancestor?: string;
+    name?: string;
+}
+export interface ImageInspect {
+    Id: string;
+    Os?: string;
+    Architecture?: string;
+    RepoTags?: string[];
+    RepoDigests?: string[];
+}
+export interface NetworkInspect {
+    Name: string;
+    Id: string;
+    Labels?: Record<string, string>;
+    Containers?: Record<string, unknown>;
+}
+export interface VolumeInspect {
+    Name: string;
+    Driver?: string;
+    Labels?: Record<string, string> | null;
+    Options?: Record<string, string> | null;
+}
+export interface DaemonInfo {
+    OSType?: string;
+    Architecture?: string;
+    ServerVersion?: string;
+    [key: string]: unknown;
+}
+export interface DaemonVersion {
+    Version?: string;
+    ApiVersion?: string;
+    MinAPIVersion?: string;
+    [key: string]: unknown;
+}
+/** `POST /containers/create` body; the agent builds these in `containerSpecs`. */
+export interface CreateContainerBody {
+    Image: string;
+    Env?: string[];
+    Cmd?: string[] | null;
+    Entrypoint?: string[] | null;
+    User?: string;
+    WorkingDir?: string;
+    Hostname?: string;
+    Labels?: Record<string, string>;
+    ExposedPorts?: Record<string, object>;
+    StopSignal?: string;
+    StopTimeout?: number;
+    Healthcheck?: Record<string, unknown>;
+    HostConfig?: Record<string, unknown>;
+    NetworkingConfig?: {
+        EndpointsConfig: Record<string, {
+            Aliases?: string[];
+            [key: string]: unknown;
+        }>;
+    };
+}
+/** A process attached to a container: exec or logs. Shaped like a child process so `live.ts` treats both alike. */
+export interface AttachedProcess extends EventEmitter {
+    stdin: Writable | null;
+    stdout: Readable;
+    stderr: Readable;
+    kill(signal?: NodeJS.Signals): boolean;
+    resize?(columns: number, rows: number): void;
+}
+export interface ExecOptions {
+    cmd: string[];
+    stdin?: boolean;
+    tty?: boolean;
+    columns?: number;
+    rows?: number;
+}
+export interface LogsOptions {
+    follow?: boolean;
+    tail?: number;
+    timestamps?: boolean;
+}
+export interface DockerApi {
+    version(): Promise<DaemonVersion>;
+    info(): Promise<DaemonInfo>;
+    listContainers(filter?: ContainerFilter, all?: boolean): Promise<ContainerSummary[]>;
+    inspectContainer(id: string): Promise<ContainerInspect>;
+    createContainer(name: string, body: CreateContainerBody): Promise<string>;
+    startContainer(id: string): Promise<void>;
+    stopContainer(id: string, timeoutSeconds?: number): Promise<void>;
+    restartContainer(id: string): Promise<void>;
+    /** Removes a container even when running; a missing container is not an error. */
+    removeContainer(id: string): Promise<void>;
+    /** Connects a running container to a network, optionally under service aliases. */
+    connectNetwork(network: string, container: string, aliases?: string[]): Promise<void>;
+    /** Container output as demultiplexed, ended streams (a TTY container's output is all stdout). */
+    logs(id: string, options?: LogsOptions): Promise<AttachedProcess>;
+    /** Copies the tar stream into the container directory `dir`. */
+    putArchive(id: string, dir: string, tar: Readable | Buffer): Promise<void>;
+    /** Runs a command to completion and returns its output; a non-zero exit is reported in `code`. */
+    execRun(id: string, cmd: string[]): Promise<{
+        code: number;
+        out: string;
+        err: string;
+    }>;
+    /** Starts an interactive or streaming exec; `close` carries the exit code. */
+    execStart(id: string, options: ExecOptions): Promise<AttachedProcess>;
+    inspectNetwork(name: string): Promise<NetworkInspect | null>;
+    createNetwork(name: string, labels: Record<string, string>): Promise<void>;
+    inspectVolume(name: string): Promise<VolumeInspect | null>;
+    createVolume(name: string, options: {
+        driver?: string;
+        opts?: Record<string, string>;
+        labels?: Record<string, string>;
+    }): Promise<void>;
+    removeVolume(name: string): Promise<void>;
+    inspectImage(ref: string): Promise<ImageInspect | null>;
+    /** Pulls `ref`; `auth` becomes `X-Registry-Auth`. */
+    pullImage(ref: string, auth?: Record<string, string>): Promise<void>;
+    loadImage(archive: Readable | Buffer): Promise<void>;
+    removeImage(ref: string): Promise<void>;
+}
+/** Splits a reference into `fromImage` and `tag` for `POST /images/create`. */
+export declare function splitImageRef(ref: string): {
+    fromImage: string;
+    tag: string;
+};
+/**
+ * Splits the 8-byte-header multiplexed stream (`[stream, 0, 0, 0, size(4, big endian)]` frames) that
+ * non-TTY attach, exec and logs use into `stdout` and `stderr`. `end` fires once the source ends.
+ */
+export declare function demux(source: Readable, stdout: Writable, stderr: Writable): void;
+/** `unix:///path` or a bare path from `DOCKER_HOST`; the agent talks to the local daemon only. */
+export declare function socketFromEnv(env?: NodeJS.ProcessEnv): string;
+export declare class DockerEngine implements DockerApi {
+    private readonly socketPath;
+    constructor(socketPath?: string);
+    private request;
+    /** Reads the response; non-2xx becomes a `DockerError` carrying the daemon's message. */
+    private call;
+    private json;
+    /** Consumes the JSON-lines progress stream of pull and load; a line with `error` fails the call. */
+    private progress;
+    version: () => Promise<DaemonVersion>;
+    info: () => Promise<DaemonInfo>;
+    listContainers(filter?: ContainerFilter, all?: boolean): Promise<ContainerSummary[]>;
+    inspectContainer: (id: string) => Promise<ContainerInspect>;
+    createContainer(name: string, body: CreateContainerBody): Promise<string>;
+    startContainer(id: string): Promise<void>;
+    stopContainer(id: string, timeoutSeconds?: number): Promise<void>;
+    restartContainer(id: string): Promise<void>;
+    removeContainer(id: string): Promise<void>;
+    connectNetwork(network: string, container: string, aliases?: string[]): Promise<void>;
+    logs(id: string, options?: LogsOptions): Promise<AttachedProcess>;
+    private isTty;
+    /**
+     * Wraps a response or hijacked socket as a process whose output is demultiplexed unless a TTY.
+     * `close` fires with `exitCode()` once the source and both output streams have ended.
+     */
+    private attachedFromStream;
+    putArchive(id: string, dir: string, tar: Readable | Buffer): Promise<void>;
+    execRun(id: string, cmd: string[]): Promise<{
+        code: number;
+        out: string;
+        err: string;
+    }>;
+    execStart(id: string, options: ExecOptions): Promise<AttachedProcess>;
+    private resizeExec;
+    inspectNetwork(name: string): Promise<NetworkInspect | null>;
+    createNetwork(name: string, labels: Record<string, string>): Promise<void>;
+    inspectVolume(name: string): Promise<VolumeInspect | null>;
+    createVolume(name: string, options: {
+        driver?: string;
+        opts?: Record<string, string>;
+        labels?: Record<string, string>;
+    }): Promise<void>;
+    removeVolume(name: string): Promise<void>;
+    inspectImage(ref: string): Promise<ImageInspect | null>;
+    pullImage(ref: string, auth?: Record<string, string>): Promise<void>;
+    loadImage(archive: Readable | Buffer): Promise<void>;
+    removeImage(ref: string): Promise<void>;
+}