@lakutata/containerd 0.0.0-stage → 3.0.0-beta.1

package/dist/cjs/containerd/lib/ContainerdContainerTTY.js

@@ -0,0 +1,178 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ContainerdContainerTTY = void 0;
+const core_1 = require("@lakutata/core");
+const di_1 = require("@lakutata/core/decorator/di");
+const dto_1 = require("@lakutata/core/decorator/dto");
+const node_stream_1 = require("node:stream");
+const ContainerTTYConsoleSizeOptions_js_1 = require("../options/container/ContainerTTYConsoleSizeOptions.js");
+const ContainerdErrors_js_1 = require("./ContainerdErrors.js");
+/**
+ * An interactive terminal in a running container: a process (a shell by default) run with a pseudo terminal, as
+ * `docker exec -it` does. Get it from {@link ContainerdContainer.createTTY}; do not create it yourself. Write its input
+ * with {@link ContainerdContainerTTY.write} (or {@link ContainerdContainerTTY.writable}), read its output with
+ * {@link ContainerdContainerTTY.onData} (or {@link ContainerdContainerTTY.readable}), or pipe a socket into
+ * {@link ContainerdContainerTTY.raw}. The terminal ends when its process exits or when it is closed; it is closed when
+ * the object is destroyed.
+ * @example
+ * ```typescript
+ * import {type Containerd, type ContainerdContainer, type ContainerdContainerTTY} from 'lakutata/com/containerd'
+ *
+ * declare const containerd: Containerd
+ *
+ * const container: ContainerdContainer = await containerd.getContainer('worker')
+ * const tty: ContainerdContainerTTY = await container.createTTY({cmd: ['/bin/sh', '-l'], consoleSize: {cols: 120, rows: 40}})
+ * tty.onData((chunk: Buffer): void => {
+ *     process.stdout.write(chunk)
+ * })
+ * tty.write('ls -la\n')
+ * await tty.resize({cols: 100, rows: 30})
+ * tty.write('exit\n')
+ * //The exit code of the shell
+ * console.log(await tty.wait())
+ * ```
+ */
+let ContainerdContainerTTY = class ContainerdContainerTTY extends core_1.Provider {
+    #terminal;
+    #duplexStream;
+    /**
+     * Start the terminal's process in the container.
+     * @throws {ContainerdContainerStateException} The container is not running.
+     * @throws {Error} The host has no `mkfifo`; the user is not found in the container.
+     * @protected
+     */
+    async init() {
+        try {
+            this.#terminal = await this.getStore().terminal(this.getRecord(), {
+                cmd: Array.isArray(this.cmd) ? this.cmd : ['/bin/sh', '-c', this.cmd],
+                cols: this.initialConsoleSize?.cols,
+                rows: this.initialConsoleSize?.rows,
+                env: this.env,
+                workingDir: this.workingDir,
+                user: this.user
+            });
+        }
+        catch (error) {
+            throw (0, ContainerdErrors_js_1.containerdError)(error);
+        }
+    }
+    /**
+     * Close the terminal, as {@link ContainerdContainerTTY.close} does.
+     * @protected
+     */
+    async destroy() {
+        await this.close();
+    }
+    /**
+     * The terminal as one duplex stream: writing sends input to the process, reading gives its output (to pipe a
+     * WebSocket or a socket into it). It is created at the first access and consumes the output from then on.
+     */
+    get raw() {
+        //Created once asked: it reads the output (which onData would not have otherwise)
+        if (!this.#duplexStream) {
+            this.#duplexStream = node_stream_1.Duplex.from({ readable: this.#terminal.output, writable: this.#terminal.input });
+            this.#duplexStream.on('error', () => undefined);
+        }
+        return this.#duplexStream;
+    }
+    /**
+     * The terminal's input: what is written is sent to the process, as typed on a keyboard (`\x03` for Ctrl+C).
+     */
+    get writable() {
+        return this.#terminal.input;
+    }
+    /**
+     * The terminal's output: what the process prints, its standard error included; it ends when the process exits.
+     */
+    get readable() {
+        return this.#terminal.output;
+    }
+    /**
+     * Resize the terminal's console; the process receives `SIGWINCH`.
+     * @param options The new size, in columns and rows (positive integers).
+     * @throws {GRPCError} The process has exited (from `@lakutata/grpc`).
+     */
+    async resize(options) {
+        await this.#terminal.resize(options.cols, options.rows);
+    }
+    /**
+     * Listen to the terminal's output. Each call adds a listener.
+     * @param handler Called with each chunk of output.
+     */
+    onData(handler) {
+        this.#terminal.output.on('data', handler);
+    }
+    /**
+     * Send input to the terminal's process.
+     * @param data The input, as text or bytes (`'ls\n'`, a newline to submit a line).
+     */
+    write(data) {
+        this.#terminal.input.write(data);
+    }
+    /**
+     * Wait for the terminal's process to exit; the terminal is then closed.
+     * @returns Its exit code (`137` when it was closed by {@link ContainerdContainerTTY.close}).
+     */
+    async wait() {
+        return await this.#terminal.exited;
+    }
+    /**
+     * Close the terminal: kill its process with `SIGKILL` and release its FIFOs. Nothing happens when it is already
+     * closed.
+     */
+    async close() {
+        await this.#terminal?.close();
+    }
+};
+exports.ContainerdContainerTTY = ContainerdContainerTTY;
+__decorate([
+    (0, di_1.Configurable)(core_1.DTO.Function()),
+    __metadata("design:type", Function)
+], ContainerdContainerTTY.prototype, "getStore", void 0);
+__decorate([
+    (0, di_1.Configurable)(core_1.DTO.Function()),
+    __metadata("design:type", Function)
+], ContainerdContainerTTY.prototype, "getRecord", void 0);
+__decorate([
+    (0, di_1.Configurable)(core_1.DTO.Alternatives(core_1.DTO.String(), core_1.DTO.Array(core_1.DTO.String()).min(1))),
+    __metadata("design:type", Object)
+], ContainerdContainerTTY.prototype, "cmd", void 0);
+__decorate([
+    (0, di_1.Configurable)(ContainerTTYConsoleSizeOptions_js_1.ContainerTTYConsoleSizeOptions.optional()),
+    __metadata("design:type", ContainerTTYConsoleSizeOptions_js_1.ContainerTTYConsoleSizeOptions
+    /**
+     * The environment variables added to the container's (`TERM` is `xterm` unless given).
+     * @default none
+     */
+    )
+], ContainerdContainerTTY.prototype, "initialConsoleSize", void 0);
+__decorate([
+    (0, di_1.Configurable)(core_1.DTO.Object().optional()),
+    __metadata("design:type", Object)
+], ContainerdContainerTTY.prototype, "env", void 0);
+__decorate([
+    (0, di_1.Configurable)(core_1.DTO.String().optional()),
+    __metadata("design:type", String)
+], ContainerdContainerTTY.prototype, "workingDir", void 0);
+__decorate([
+    (0, di_1.Configurable)(core_1.DTO.String().optional()),
+    __metadata("design:type", String)
+], ContainerdContainerTTY.prototype, "user", void 0);
+__decorate([
+    (0, dto_1.Accept)(ContainerTTYConsoleSizeOptions_js_1.ContainerTTYConsoleSizeOptions.required()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [ContainerTTYConsoleSizeOptions_js_1.ContainerTTYConsoleSizeOptions]),
+    __metadata("design:returntype", Promise)
+], ContainerdContainerTTY.prototype, "resize", null);
+exports.ContainerdContainerTTY = ContainerdContainerTTY = __decorate([
+    (0, di_1.Transient)()
+], ContainerdContainerTTY);

package/dist/cjs/containerd/lib/ContainerdErrors.d.ts

@@ -0,0 +1,6 @@
+/**
+ * The exception of an error of the client (by its code), or the one given
+ * @param error
+ * @param fallback the exception of the operation
+ */
+export declare function containerdError(error: unknown, fallback?: new (message: string) => Error): Error;

package/dist/cjs/containerd/lib/ContainerdErrors.js

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.containerdError = containerdError;
+const core_1 = require("@lakutata/core");
+const ContainerdImageNotFoundException_js_1 = require("../exceptions/ContainerdImageNotFoundException.js");
+const ContainerdPlatformException_js_1 = require("../exceptions/ContainerdPlatformException.js");
+const ContainerdContainerNameConflictException_js_1 = require("../exceptions/ContainerdContainerNameConflictException.js");
+const ContainerdContainerStateException_js_1 = require("../exceptions/ContainerdContainerStateException.js");
+const ContainerdNetworkNotFoundException_js_1 = require("../exceptions/ContainerdNetworkNotFoundException.js");
+const ContainerdPathNotFoundException_js_1 = require("../exceptions/ContainerdPathNotFoundException.js");
+/**
+ * The exception of an error of the client (by its code), or the one given
+ * @param error
+ * @param fallback the exception of the operation
+ */
+function containerdError(error, fallback) {
+    const message = error?.message ?? String(error);
+    switch (error?.code) {
+        case 'NOT_FOUND':
+            return new ContainerdImageNotFoundException_js_1.ContainerdImageNotFoundException(message);
+        case 'PLATFORM':
+            return new ContainerdPlatformException_js_1.ContainerdPlatformException(message);
+        case 'CONFLICT':
+            return new ContainerdContainerNameConflictException_js_1.ContainerdContainerNameConflictException(message);
+        case 'NETWORK_NOT_FOUND':
+            return new ContainerdNetworkNotFoundException_js_1.ContainerdNetworkNotFoundException(message);
+        case 'INVALID_VALUE':
+            return new core_1.InvalidValueException(message);
+        case 'PATH_NOT_FOUND':
+            return new ContainerdPathNotFoundException_js_1.ContainerdPathNotFoundException(message);
+        case 'RUNNING':
+        case 'NOT_RUNNING':
+        case 'PAUSED':
+            return new ContainerdContainerStateException_js_1.ContainerdContainerStateException(message);
+    }
+    return fallback ? new fallback(message) : error;
+}

package/dist/cjs/containerd/lib/ContainerdImage.d.ts

@@ -0,0 +1,149 @@
+import { Provider } from '@lakutata/core';
+import { Time } from '@lakutata/utils/Time';
+import type { ImageStore } from '../../client/ImageStore.js';
+import type { RegistryOptions } from '../../client/Registry.js';
+import { type Containerd } from '../Containerd.js';
+import type { ContainerdImageConfig } from '../types/ContainerdImageConfig.js';
+import { ImagePushOptions } from '../options/image/ImagePushOptions.js';
+import { ImageExportOptions } from '../options/image/ImageExportOptions.js';
+/**
+ * An image of the {@link Containerd} component's namespace: its name, digest, platforms, size and configuration, and
+ * the operations tag, push, export and remove. Get it from {@link Containerd.getImage}, {@link Containerd.listImages},
+ * {@link Containerd.pullImage}, {@link Containerd.buildImage}, {@link Containerd.importImage} or
+ * {@link ContainerdContainer.commit}; do not create it yourself. Each call returns a new object (transient).
+ *
+ * An image may hold several platforms (an index): the object describes one of them, the first one the machine runs
+ * ({@link Containerd.supportedPlatforms}), or the first one present. Its properties are a snapshot taken when it was
+ * obtained; {@link ContainerdImage.syncImageInfo} takes a new one.
+ * @example
+ * ```typescript
+ * import {type Containerd, type ContainerdImage} from 'lakutata/com/containerd'
+ *
+ * declare const containerd: Containerd
+ *
+ * const image: ContainerdImage = await containerd.pullImage({image: 'alpine:3.20', platform: ['linux/amd64', 'linux/arm64']})
+ * //docker.io/library/alpine:3.20, its platforms, the command its containers run
+ * console.log(image.name, image.platforms, image.config.cmd)
+ * const tagged: ContainerdImage = await image.tag('registry.example.com/team/alpine:3.20')
+ * await tagged.push({auth: {username: 'deploy', password: 'secret'}})
+ * //An archive loaded by docker load and nerdctl load
+ * await image.export({destination: '/tmp/alpine.tar'})
+ * await tagged.remove()
+ * ```
+ */
+export declare class ContainerdImage extends Provider {
+    /**
+     * Gives the component's image store; set by the component.
+     */
+    protected readonly getStore: () => ImageStore;
+    /**
+     * Gives the component that created the object.
+     */
+    protected readonly getContainerd: () => Containerd;
+    /**
+     * Gives the component's registry options (credentials, insecure registries) for the pushes.
+     */
+    protected readonly getRegistryOptions: () => RegistryOptions;
+    /**
+     * The image's name, normalized as Docker does (`docker.io/library/alpine:3.20`).
+     */
+    name: string;
+    /**
+     * The digest of the image's target: its index for a multi-platform image, else its manifest (`sha256:…`), as a
+     * registry knows it.
+     */
+    digest: string;
+    /**
+     * The media type of the image's target: an OCI or Docker index, or a manifest.
+     */
+    mediaType: string;
+    /**
+     * The labels of the image's containerd record (not the ones of its configuration: see `config.labels`).
+     */
+    labels: Record<string, string>;
+    /**
+     * When the image was created in containerd (pulled, imported, built).
+     */
+    createdAt: Time;
+    /**
+     * When the image's record was last updated in containerd (pulled again, tagged over).
+     */
+    updatedAt: Time;
+    /**
+     * The platforms whose content is present (the ones pulled), formatted `os/architecture[/variant]`.
+     */
+    platforms: string[];
+    /**
+     * The platform the object describes: the first one the machine runs, or the first one present.
+     */
+    platform: string;
+    /**
+     * The operating system of the platform described (`linux`).
+     */
+    os: string;
+    /**
+     * The architecture of the platform described (`amd64`, `arm64`).
+     */
+    arch: string;
+    /**
+     * The variant of the platform described (`v8`, `v7`); `undefined` when it has none.
+     */
+    variant: string | undefined;
+    /**
+     * The size of the platform described, in bytes: its configuration and its compressed layers.
+     */
+    size: number;
+    /**
+     * The configuration the image gives its containers, for the platform described: environment, command, entry point,
+     * working directory, user, exposed ports, volumes, labels and stop signal.
+     */
+    config: ContainerdImageConfig;
+    /**
+     * Read the image's information.
+     * @throws {ContainerdImageNotFoundException} The image does not exist.
+     * @throws {ContainerdPlatformException} The content of none of its platforms is present.
+     * @protected
+     */
+    protected init(): Promise<void>;
+    /**
+     * Read the image's information again from containerd into the object's properties.
+     * @throws {ContainerdImageNotFoundException} The image no longer exists.
+     * @throws {ContainerdPlatformException} The content of none of its platforms is present.
+     */
+    syncImageInfo(): Promise<void>;
+    /**
+     * Give the image another name, as `docker tag` does: a new image record with the same content. An image that has
+     * this name already is replaced. This object keeps its name.
+     * @param name The new name or reference (`registry.example.com/team/alpine:3.20`), normalized as Docker does.
+     * @returns The image under its new name.
+     * @throws {ContainerdImageNotFoundException} The image no longer exists.
+     */
+    tag(name: string): Promise<ContainerdImage>;
+    /**
+     * Push the image to its registry, or to another reference. With `platform`, only the manifest of that platform is
+     * pushed under the tag. Without it, when the content of all the platforms of its index is present, all of them and
+     * the index are pushed; otherwise only the manifest of the machine's platform. The credentials are `auth`, else the
+     * component's `registryAuths`. The push is aborted when the component is destroyed.
+     * @param options The `reference` to push to (the image's name by default), the `platform`, the credentials and the
+     * progress callback.
+     * @throws {ContainerdImageNotFoundException} The image no longer exists.
+     * @throws {ContainerdPlatformException} The platform to push (`platform`, or the machine's when only some platforms
+     * are present) is not present.
+     * @throws {ContainerdImagePushException} The registry cannot be reached or refuses the push (credentials, rights).
+     */
+    push(options?: ImagePushOptions): Promise<void>;
+    /**
+     * Export the image into an archive: an OCI image layout with the `manifest.json` of `docker load`, loaded by
+     * `docker load`, `nerdctl load` and {@link Containerd.importImage}.
+     * @param options The destination: a file path (created or replaced) or a writable stream.
+     * @throws {ContainerdImageNotFoundException} The image no longer exists.
+     * @throws {ContainerdImageExportException} The archive cannot be written.
+     */
+    export(options: ImageExportOptions): Promise<void>;
+    /**
+     * Remove the image's name. Its content and snapshots are collected by containerd once no other image and no
+     * container uses them; the containers of the image keep working.
+     * @throws {ContainerdImageNotFoundException} The image no longer exists.
+     */
+    remove(): Promise<void>;
+}

package/dist/cjs/containerd/lib/ContainerdImage.js

@@ -0,0 +1,222 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ContainerdImage = void 0;
+const core_1 = require("@lakutata/core");
+const di_1 = require("@lakutata/core/decorator/di");
+const dto_1 = require("@lakutata/core/decorator/dto");
+const Time_1 = require("@lakutata/utils/Time");
+const Platforms_js_1 = require("../../client/Platforms.js");
+const Reference_js_1 = require("../../client/Reference.js");
+const ImagePushOptions_js_1 = require("../options/image/ImagePushOptions.js");
+const ImageExportOptions_js_1 = require("../options/image/ImageExportOptions.js");
+const ContainerdImagePushException_js_1 = require("../exceptions/ContainerdImagePushException.js");
+const ContainerdImageExportException_js_1 = require("../exceptions/ContainerdImageExportException.js");
+const ContainerdErrors_js_1 = require("./ContainerdErrors.js");
+/**
+ * An image of the {@link Containerd} component's namespace: its name, digest, platforms, size and configuration, and
+ * the operations tag, push, export and remove. Get it from {@link Containerd.getImage}, {@link Containerd.listImages},
+ * {@link Containerd.pullImage}, {@link Containerd.buildImage}, {@link Containerd.importImage} or
+ * {@link ContainerdContainer.commit}; do not create it yourself. Each call returns a new object (transient).
+ *
+ * An image may hold several platforms (an index): the object describes one of them, the first one the machine runs
+ * ({@link Containerd.supportedPlatforms}), or the first one present. Its properties are a snapshot taken when it was
+ * obtained; {@link ContainerdImage.syncImageInfo} takes a new one.
+ * @example
+ * ```typescript
+ * import {type Containerd, type ContainerdImage} from 'lakutata/com/containerd'
+ *
+ * declare const containerd: Containerd
+ *
+ * const image: ContainerdImage = await containerd.pullImage({image: 'alpine:3.20', platform: ['linux/amd64', 'linux/arm64']})
+ * //docker.io/library/alpine:3.20, its platforms, the command its containers run
+ * console.log(image.name, image.platforms, image.config.cmd)
+ * const tagged: ContainerdImage = await image.tag('registry.example.com/team/alpine:3.20')
+ * await tagged.push({auth: {username: 'deploy', password: 'secret'}})
+ * //An archive loaded by docker load and nerdctl load
+ * await image.export({destination: '/tmp/alpine.tar'})
+ * await tagged.remove()
+ * ```
+ */
+let ContainerdImage = class ContainerdImage extends core_1.Provider {
+    /**
+     * Read the image's information.
+     * @throws {ContainerdImageNotFoundException} The image does not exist.
+     * @throws {ContainerdPlatformException} The content of none of its platforms is present.
+     * @protected
+     */
+    async init() {
+        await this.syncImageInfo();
+    }
+    /**
+     * Read the image's information again from containerd into the object's properties.
+     * @throws {ContainerdImageNotFoundException} The image no longer exists.
+     * @throws {ContainerdPlatformException} The content of none of its platforms is present.
+     */
+    async syncImageInfo() {
+        const store = this.getStore();
+        let resolved;
+        let platforms;
+        try {
+            platforms = await store.platforms(this.name);
+            const supported = this.getContainerd().supportedPlatforms();
+            const preferred = platforms.find((platform) => supported.includes((0, Platforms_js_1.formatPlatform)(platform))) ?? platforms[0];
+            resolved = await store.resolve(this.name, preferred);
+        }
+        catch (error) {
+            throw (0, ContainerdErrors_js_1.containerdError)(error);
+        }
+        const image = resolved.image;
+        const config = resolved.config.config ?? {};
+        this.name = image.name;
+        this.digest = image.target.digest;
+        this.mediaType = image.target.mediaType;
+        this.labels = image.labels ?? {};
+        this.createdAt = new Time_1.Time(timestampMilliseconds(image.createdAt));
+        this.updatedAt = new Time_1.Time(timestampMilliseconds(image.updatedAt));
+        this.platforms = platforms.map(Platforms_js_1.formatPlatform);
+        this.platform = (0, Platforms_js_1.formatPlatform)(resolved.platform);
+        this.os = resolved.platform.os;
+        this.arch = resolved.platform.architecture;
+        this.variant = resolved.platform.variant;
+        this.size = Number(resolved.manifest.config.size) + resolved.manifest.layers.reduce((size, layer) => size + Number(layer.size), 0);
+        this.config = {
+            env: Object.fromEntries((config.Env ?? []).map((entry) => [entry.split('=')[0], entry.slice(entry.indexOf('=') + 1)])),
+            cmd: config.Cmd ?? [],
+            entrypoint: config.Entrypoint ?? [],
+            workingDir: config.WorkingDir ?? '',
+            user: config.User ?? '',
+            exposedPorts: Object.keys(config.ExposedPorts ?? {}).map((key) => {
+                const [port, type] = key.split('/');
+                return { port: Number(port), type: (type ?? 'tcp') };
+            }),
+            volumes: Object.keys(config.Volumes ?? {}),
+            labels: config.Labels ?? {},
+            stopSignal: config.StopSignal
+        };
+    }
+    /**
+     * Give the image another name, as `docker tag` does: a new image record with the same content. An image that has
+     * this name already is replaced. This object keeps its name.
+     * @param name The new name or reference (`registry.example.com/team/alpine:3.20`), normalized as Docker does.
+     * @returns The image under its new name.
+     * @throws {ContainerdImageNotFoundException} The image no longer exists.
+     */
+    async tag(name) {
+        try {
+            return await this.getContainerd().getImage(await this.getStore().tag(this.name, name));
+        }
+        catch (error) {
+            throw (0, ContainerdErrors_js_1.containerdError)(error);
+        }
+    }
+    /**
+     * Push the image to its registry, or to another reference. With `platform`, only the manifest of that platform is
+     * pushed under the tag. Without it, when the content of all the platforms of its index is present, all of them and
+     * the index are pushed; otherwise only the manifest of the machine's platform. The credentials are `auth`, else the
+     * component's `registryAuths`. The push is aborted when the component is destroyed.
+     * @param options The `reference` to push to (the image's name by default), the `platform`, the credentials and the
+     * progress callback.
+     * @throws {ContainerdImageNotFoundException} The image no longer exists.
+     * @throws {ContainerdPlatformException} The platform to push (`platform`, or the machine's when only some platforms
+     * are present) is not present.
+     * @throws {ContainerdImagePushException} The registry cannot be reached or refuses the push (credentials, rights).
+     */
+    async push(options) {
+        if (!options)
+            return await this.push({});
+        const registry = this.getRegistryOptions();
+        try {
+            await this.getStore().push(this.name, {
+                reference: options.reference,
+                platform: options.platform ? (0, Platforms_js_1.parsePlatform)(options.platform) : undefined,
+                registry: options.auth ? { ...registry, credentials: { ...registry.credentials, [(0, Reference_js_1.parseReference)(options.reference ?? this.name).registry]: options.auth } } : registry,
+                progress: options.progressCallback
+            });
+        }
+        catch (error) {
+            throw (0, ContainerdErrors_js_1.containerdError)(error, ContainerdImagePushException_js_1.ContainerdImagePushException);
+        }
+    }
+    /**
+     * Export the image into an archive: an OCI image layout with the `manifest.json` of `docker load`, loaded by
+     * `docker load`, `nerdctl load` and {@link Containerd.importImage}.
+     * @param options The destination: a file path (created or replaced) or a writable stream.
+     * @throws {ContainerdImageNotFoundException} The image no longer exists.
+     * @throws {ContainerdImageExportException} The archive cannot be written.
+     */
+    async export(options) {
+        try {
+            await this.getStore().export([this.name], options.destination);
+        }
+        catch (error) {
+            throw (0, ContainerdErrors_js_1.containerdError)(error, ContainerdImageExportException_js_1.ContainerdImageExportException);
+        }
+    }
+    /**
+     * Remove the image's name. Its content and snapshots are collected by containerd once no other image and no
+     * container uses them; the containers of the image keep working.
+     * @throws {ContainerdImageNotFoundException} The image no longer exists.
+     */
+    async remove() {
+        try {
+            await this.getStore().remove(this.name);
+        }
+        catch (error) {
+            throw (0, ContainerdErrors_js_1.containerdError)(error);
+        }
+    }
+};
+exports.ContainerdImage = ContainerdImage;
+__decorate([
+    (0, di_1.Configurable)(core_1.DTO.Function()),
+    __metadata("design:type", Function)
+], ContainerdImage.prototype, "getStore", void 0);
+__decorate([
+    (0, di_1.Configurable)(core_1.DTO.Function()),
+    __metadata("design:type", Function)
+], ContainerdImage.prototype, "getContainerd", void 0);
+__decorate([
+    (0, di_1.Configurable)(core_1.DTO.Function()),
+    __metadata("design:type", Function)
+], ContainerdImage.prototype, "getRegistryOptions", void 0);
+__decorate([
+    (0, di_1.Configurable)(core_1.DTO.String()),
+    __metadata("design:type", String)
+], ContainerdImage.prototype, "name", void 0);
+__decorate([
+    (0, dto_1.Accept)(core_1.DTO.String().required()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [String]),
+    __metadata("design:returntype", Promise)
+], ContainerdImage.prototype, "tag", null);
+__decorate([
+    (0, dto_1.Accept)(ImagePushOptions_js_1.ImagePushOptions.optional()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [ImagePushOptions_js_1.ImagePushOptions]),
+    __metadata("design:returntype", Promise)
+], ContainerdImage.prototype, "push", null);
+__decorate([
+    (0, dto_1.Accept)(ImageExportOptions_js_1.ImageExportOptions.required()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [ImageExportOptions_js_1.ImageExportOptions]),
+    __metadata("design:returntype", Promise)
+], ContainerdImage.prototype, "export", null);
+exports.ContainerdImage = ContainerdImage = __decorate([
+    (0, di_1.Transient)()
+], ContainerdImage);
+/**
+ * The milliseconds of a Timestamp
+ * @param timestamp
+ */
+function timestampMilliseconds(timestamp) {
+    return timestamp ? Number(timestamp.seconds ?? 0) * 1000 + Math.floor(Number(timestamp.nanos ?? 0) / 1e6) : Date.now();
+}

package/dist/cjs/containerd/options/ContainerdPruneOptions.d.ts

@@ -0,0 +1,44 @@
+import { DTO } from '@lakutata/core';
+/**
+ * What {@link Containerd.prune} removes; every field is optional. A resource whose removal fails is skipped. Unlike the
+ * Docker component's options, the volumes are kept by default, and `allImages` removes the tagged images too.
+ * @example
+ * ```typescript
+ * import {Containerd} from 'lakutata/com/containerd'
+ *
+ * declare const containerd: Containerd
+ *
+ * //The stopped containers and the dangling images (the defaults), and the unused volumes with their data
+ * const removed = await containerd.prune({volumes: true})
+ * console.log(removed.containers, removed.images, removed.volumes)
+ * ```
+ */
+export declare class ContainerdPruneOptions extends DTO {
+    /**
+     * Remove the containers which do not run (their status `'created'` or `'exited'`), with their snapshots and their
+     * logs.
+     * @default true
+     */
+    containers?: boolean;
+    /**
+     * Remove the dangling images (named by a digest, without a tag) no container uses.
+     * @default true
+     */
+    images?: boolean;
+    /**
+     * Remove all the images no container uses, the tagged ones too (whatever `images` is).
+     * @default false
+     */
+    allImages?: boolean;
+    /**
+     * Remove the networks no container uses, among the ones created by nerdctl or the component; never `host`, `none`
+     * nor the default `bridge` network.
+     * @default false
+     */
+    networks?: boolean;
+    /**
+     * Remove the volumes no container uses, with their data.
+     * @default false
+     */
+    volumes?: boolean;
+}