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

package/dist/esm/client/ContainerdClient.js

@@ -0,0 +1,416 @@
+import { randomBytes } from 'node:crypto';
+import { GRPCConnection, GRPCError, GRPCStatus, decode } from '@lakutata/grpc';
+import * as M from './Messages.js';
+/**
+ * The prefix of the paths of the services of containerd
+ */
+const SERVICES = '/containerd.services';
+/**
+ * The type URL of the specifications of the containers and of their processes (OCI runtime spec, JSON)
+ */
+export const SPEC_TYPE_URL = 'types.containerd.io/opencontainers/runtime-spec/1/Spec';
+export const PROCESS_TYPE_URL = 'types.containerd.io/opencontainers/runtime-spec/1/Process';
+export const RESOURCES_TYPE_URL = 'types.containerd.io/opencontainers/runtime-spec/1/LinuxResources';
+/**
+ * A date of a Timestamp
+ * @param timestamp
+ */
+export function timestampDate(timestamp) {
+    if (!timestamp)
+        return undefined;
+    return new Date(Number(timestamp.seconds ?? 0) * 1000 + Math.floor(Number(timestamp.nanos ?? 0) / 1e6));
+}
+/**
+ * Whether an error is the one of a call of a code
+ * @param error
+ * @param code
+ */
+export function isGRPCError(error, code) {
+    return error instanceof GRPCError && error.code === code;
+}
+/**
+ * The client of the API of containerd (its services of the version 1), in a namespace: its calls are the ones of
+ * ctr and nerdctl
+ */
+export class ContainerdClient {
+    constructor(socketPath, namespace) {
+        this.namespace = namespace;
+        this.grpc = new GRPCConnection(socketPath);
+    }
+    /**
+     * The options of a call: its namespace, its lease (the content and the snapshots it creates are kept by it until
+     * they are referenced)
+     * @param lease
+     * @param signal
+     */
+    options(lease, signal) {
+        return { metadata: { 'containerd-namespace': this.namespace, 'containerd-lease': lease }, signal: signal };
+    }
+    /**
+     * Call a method of a service
+     * @param service its name and its version (images.v1.Images)
+     * @param method
+     * @param requestSchema
+     * @param request
+     * @param responseSchema
+     * @param lease
+     * @param signal
+     */
+    call(service, method, requestSchema, request, responseSchema = M.Empty, lease, signal) {
+        return this.grpc.unary(`${SERVICES}.${service}/${method}`, requestSchema, request, responseSchema, this.options(lease, signal));
+    }
+    /**
+     * Call a method, undefined when what it reads does not exist
+     * @param promise
+     */
+    async orUndefined(promise) {
+        try {
+            return await promise;
+        }
+        catch (error) {
+            if (isGRPCError(error, GRPCStatus.NOT_FOUND))
+                return undefined;
+            throw error;
+        }
+    }
+    /*
+     * Version, namespaces
+     */
+    async version() {
+        return await this.call('version.v1.Version', 'Version', M.Empty, {}, M.VersionResponse);
+    }
+    /**
+     * Create the namespace of the client, when it does not exist
+     */
+    async ensureNamespace() {
+        try {
+            await this.call('namespaces.v1.Namespaces', 'Create', M.CreateNamespaceRequest, { namespace: { name: this.namespace } }, M.Empty);
+        }
+        catch (error) {
+            if (!isGRPCError(error, GRPCStatus.ALREADY_EXISTS))
+                throw error;
+        }
+    }
+    /*
+     * Leases
+     */
+    /**
+     * Create a lease, which keeps what is created under it until it is deleted (or expired)
+     * @param expireSeconds
+     */
+    async createLease(expireSeconds = 24 * 3600) {
+        const id = `lakutata-${Date.now()}-${randomBytes(4).toString('hex')}`;
+        const expire = new Date(Date.now() + expireSeconds * 1000).toISOString();
+        await this.call('leases.v1.Leases', 'Create', M.CreateLeaseRequest, { id: id, labels: { 'containerd.io/gc.expire': expire } }, M.CreateLeaseResponse);
+        return id;
+    }
+    async deleteLease(id) {
+        await this.orUndefined(this.call('leases.v1.Leases', 'Delete', M.DeleteLeaseRequest, { id: id }));
+    }
+    /*
+     * Images
+     */
+    async getImage(name) {
+        return (await this.orUndefined(this.call('images.v1.Images', 'Get', M.GetImageRequest, { name: name }, M.ImageResponse)))?.image;
+    }
+    async listImages(filters = []) {
+        return (await this.call('images.v1.Images', 'List', M.ListImagesRequest, { filters: filters }, M.ListImagesResponse)).images;
+    }
+    /**
+     * Create an image, or update it when it exists (its target and its labels)
+     * @param image
+     * @param lease
+     */
+    async putImage(image, lease) {
+        try {
+            return (await this.call('images.v1.Images', 'Create', M.CreateImageRequest, { image: image }, M.ImageResponse, lease)).image;
+        }
+        catch (error) {
+            if (!isGRPCError(error, GRPCStatus.ALREADY_EXISTS))
+                throw error;
+            return (await this.call('images.v1.Images', 'Update', M.UpdateImageRequest, { image: image, updateMask: { paths: ['target', 'labels'] } }, M.ImageResponse, lease)).image;
+        }
+    }
+    async deleteImage(name, sync = false) {
+        await this.call('images.v1.Images', 'Delete', M.DeleteImageRequest, { name: name, sync: sync });
+    }
+    /*
+     * Content
+     */
+    async contentInfo(digest) {
+        return (await this.orUndefined(this.call('content.v1.Content', 'Info', M.InfoRequest, { digest: digest }, M.InfoResponse)))?.info;
+    }
+    /**
+     * Set labels of a content
+     * @param digest
+     * @param labels
+     */
+    async labelContent(digest, labels) {
+        if (!Object.keys(labels).length)
+            return;
+        await this.call('content.v1.Content', 'Update', M.UpdateContentRequest, {
+            info: { digest: digest, labels: labels },
+            updateMask: { paths: Object.keys(labels).map((key) => `labels.${key}`) }
+        }, M.InfoResponse);
+    }
+    /**
+     * Read a content, by its chunks
+     * @param digest
+     * @param signal
+     */
+    async *readContent(digest, signal) {
+        const responses = this.grpc.serverStream(`${SERVICES}.content.v1.Content/Read`, M.ReadContentRequest, { digest: digest }, M.ReadContentResponse, this.options(undefined, signal));
+        for await (const response of responses)
+            if (response.data?.length)
+                yield response.data;
+    }
+    /**
+     * Read a content whole
+     * @param digest
+     */
+    async readAll(digest) {
+        const chunks = [];
+        for await (const chunk of this.readContent(digest))
+            chunks.push(chunk);
+        return Buffer.concat(chunks);
+    }
+    /**
+     * Write a content, checked by its digest (a content which exists is kept), its labels set
+     * @param descriptor its digest and its size
+     * @param data its bytes, or their chunks
+     * @param lease
+     * @param labels
+     * @param signal
+     */
+    async writeContent(descriptor, data, lease, labels = {}, signal) {
+        if (await this.contentInfo(descriptor.digest)) {
+            await this.labelContent(descriptor.digest, labels);
+            return;
+        }
+        const ref = `lakutata-${descriptor.digest}-${randomBytes(4).toString('hex')}`;
+        const stream = this.grpc.bidi(`${SERVICES}.content.v1.Content/Write`, M.WriteContentRequest, M.WriteContentResponse, this.options(lease, signal));
+        //The responses read while the requests are sent (one by request)
+        const responses = (async () => {
+            const all = [];
+            for await (const response of stream.responses)
+                all.push(response);
+            return all;
+        })();
+        responses.catch(() => undefined);
+        try {
+            let offset = 0;
+            const send = async (chunk) => {
+                //Messages of 1 MiB at most (the maximum message of gRPC is 4 MiB)
+                for (let start = 0; start < chunk.length; start += 1024 * 1024) {
+                    const part = chunk.subarray(start, start + 1024 * 1024);
+                    await stream.send({ action: M.WriteAction.WRITE, ref: ref, total: descriptor.size, expected: descriptor.digest, offset: offset, data: part });
+                    offset += part.length;
+                }
+            };
+            if (data instanceof Uint8Array)
+                await send(data);
+            else
+                for await (const chunk of data)
+                    await send(chunk);
+            await stream.send({ action: M.WriteAction.COMMIT, ref: ref, total: descriptor.size, expected: descriptor.digest, offset: offset, labels: labels });
+            stream.end();
+            const answers = await responses;
+            const committed = answers.find((answer) => answer.action === M.WriteAction.COMMIT);
+            if (committed && committed.digest !== descriptor.digest)
+                throw new Error(`The content written is ${committed.digest}, not ${descriptor.digest}`);
+        }
+        catch (error) {
+            stream.cancel();
+            //Written by another writer meanwhile
+            if (isGRPCError(error, GRPCStatus.ALREADY_EXISTS) || (await this.contentInfo(descriptor.digest))) {
+                await this.labelContent(descriptor.digest, labels);
+                return;
+            }
+            await this.orUndefined(this.call('content.v1.Content', 'Abort', M.AbortRequest, { ref: ref }));
+            throw error;
+        }
+    }
+    async deleteContent(digest) {
+        await this.orUndefined(this.call('content.v1.Content', 'Delete', M.DeleteContentRequest, { digest: digest }));
+    }
+    /*
+     * Snapshots, diff
+     */
+    async prepareSnapshot(snapshotter, key, parent, labels = {}, lease) {
+        return (await this.call('snapshots.v1.Snapshots', 'Prepare', M.PrepareSnapshotRequest, { snapshotter: snapshotter, key: key, parent: parent, labels: labels }, M.MountsResponse, lease)).mounts;
+    }
+    async snapshotMounts(snapshotter, key) {
+        return (await this.call('snapshots.v1.Snapshots', 'Mounts', M.MountsRequest, { snapshotter: snapshotter, key: key }, M.MountsResponse)).mounts;
+    }
+    async commitSnapshot(snapshotter, name, key, labels = {}, lease) {
+        await this.call('snapshots.v1.Snapshots', 'Commit', M.CommitSnapshotRequest, { snapshotter: snapshotter, name: name, key: key, labels: labels }, M.Empty, lease);
+    }
+    async viewSnapshot(snapshotter, key, parent, lease) {
+        return (await this.call('snapshots.v1.Snapshots', 'View', M.PrepareSnapshotRequest, { snapshotter: snapshotter, key: key, parent: parent }, M.MountsResponse, lease)).mounts;
+    }
+    /**
+     * The layer of the changes of a snapshot from another one (tar+gzip), written into the content store
+     * @param left the older one
+     * @param right the newer one
+     * @param lease
+     */
+    async diff(left, right, lease) {
+        return (await this.call('diff.v1.Diff', 'Diff', M.DiffRequest, { left: left, right: right, mediaType: 'application/vnd.oci.image.layer.v1.tar+gzip' }, M.DiffResponse, lease)).diff;
+    }
+    /**
+     * The metrics of the cgroup of a task: their type (io.containerd.cgroups.v1.Metrics, …v2.Metrics) and their bytes
+     * @param containerId
+     */
+    async metrics(containerId) {
+        return (await this.call('tasks.v1.Tasks', 'Metrics', M.MetricsRequest, { filters: [`id==${containerId}`] }, M.MetricsResponse)).metrics[0];
+    }
+    async removeSnapshot(snapshotter, key) {
+        await this.orUndefined(this.call('snapshots.v1.Snapshots', 'Remove', M.SnapshotKeyRequest, { snapshotter: snapshotter, key: key }));
+    }
+    async statSnapshot(snapshotter, key) {
+        return (await this.orUndefined(this.call('snapshots.v1.Snapshots', 'Stat', M.SnapshotKeyRequest, { snapshotter: snapshotter, key: key }, M.StatSnapshotResponse)))?.info;
+    }
+    async snapshotUsage(snapshotter, key) {
+        return await this.call('snapshots.v1.Snapshots', 'Usage', M.SnapshotKeyRequest, { snapshotter: snapshotter, key: key }, M.UsageResponse);
+    }
+    /**
+     * Apply a layer (its content) to the mounts of a snapshot
+     * @param layer
+     * @param mounts
+     * @param lease
+     */
+    async applyLayer(layer, mounts, lease) {
+        return (await this.call('diff.v1.Diff', 'Apply', M.ApplyRequest, { diff: { mediaType: layer.mediaType, digest: layer.digest, size: layer.size }, mounts: mounts }, M.ApplyResponse, lease)).applied;
+    }
+    /*
+     * Containers
+     */
+    async getContainer(id) {
+        return (await this.orUndefined(this.call('containers.v1.Containers', 'Get', M.GetContainerRequest, { id: id }, M.ContainerResponse)))?.container;
+    }
+    async listContainers(filters = []) {
+        return (await this.call('containers.v1.Containers', 'List', M.ListContainersRequest, { filters: filters }, M.ListContainersResponse)).containers;
+    }
+    async createContainer(container, lease) {
+        return (await this.call('containers.v1.Containers', 'Create', M.CreateContainerRequest, { container: container }, M.ContainerResponse, lease)).container;
+    }
+    async updateContainer(container, paths) {
+        return (await this.call('containers.v1.Containers', 'Update', M.UpdateContainerRequest, { container: container, updateMask: { paths: paths } }, M.ContainerResponse)).container;
+    }
+    async deleteContainer(id) {
+        await this.orUndefined(this.call('containers.v1.Containers', 'Delete', M.DeleteContainerRequest, { id: id }));
+    }
+    /*
+     * Tasks
+     */
+    async createTask(request) {
+        return (await this.call('tasks.v1.Tasks', 'Create', M.CreateTaskRequest, request, M.CreateTaskResponse)).pid ?? 0;
+    }
+    async startTask(containerId, execId = '') {
+        return (await this.call('tasks.v1.Tasks', 'Start', M.ProcessRequest, { containerId: containerId, execId: execId }, M.StartResponse)).pid ?? 0;
+    }
+    async deleteTask(containerId) {
+        return await this.orUndefined(this.call('tasks.v1.Tasks', 'Delete', M.DeleteTaskRequest, { containerId: containerId }, M.DeleteTaskResponse));
+    }
+    async deleteProcess(containerId, execId) {
+        return await this.orUndefined(this.call('tasks.v1.Tasks', 'DeleteProcess', M.ProcessRequest, { containerId: containerId, execId: execId }, M.DeleteTaskResponse));
+    }
+    async getTask(containerId, execId = '') {
+        return (await this.orUndefined(this.call('tasks.v1.Tasks', 'Get', M.ProcessRequest, { containerId: containerId, execId: execId }, M.GetTaskResponse)))?.process;
+    }
+    async listTasks() {
+        return (await this.call('tasks.v1.Tasks', 'List', M.ListTasksRequest, {}, M.ListTasksResponse)).tasks;
+    }
+    async kill(containerId, signal, options = {}) {
+        await this.call('tasks.v1.Tasks', 'Kill', M.KillRequest, { containerId: containerId, execId: options.execId ?? '', signal: signal, all: options.all ?? false });
+    }
+    async exec(request) {
+        await this.call('tasks.v1.Tasks', 'Exec', M.ExecProcessRequest, request);
+    }
+    async resizePty(containerId, execId, width, height) {
+        await this.call('tasks.v1.Tasks', 'ResizePty', M.ResizePtyRequest, { containerId: containerId, execId: execId, width: width, height: height });
+    }
+    async closeIO(containerId, execId) {
+        await this.call('tasks.v1.Tasks', 'CloseIO', M.CloseIORequest, { containerId: containerId, execId: execId, stdin: true });
+    }
+    async pause(containerId) {
+        await this.call('tasks.v1.Tasks', 'Pause', M.ContainerIdRequest, { containerId: containerId });
+    }
+    async resume(containerId) {
+        await this.call('tasks.v1.Tasks', 'Resume', M.ContainerIdRequest, { containerId: containerId });
+    }
+    async listPids(containerId) {
+        return (await this.call('tasks.v1.Tasks', 'ListPids', M.ContainerIdRequest, { containerId: containerId }, M.ListPidsResponse)).processes.map((process) => process.pid);
+    }
+    /**
+     * Wait for a process to exit (the task, an exec)
+     * @param containerId
+     * @param execId
+     * @param signal
+     */
+    async wait(containerId, execId = '', signal) {
+        const response = await this.call('tasks.v1.Tasks', 'Wait', M.ProcessRequest, { containerId: containerId, execId: execId }, M.WaitResponse, undefined, signal);
+        return { exitStatus: response.exitStatus ?? 0, exitedAt: timestampDate(response.exitedAt) };
+    }
+    /**
+     * Update the resources of a task (OCI LinuxResources)
+     * @param containerId
+     * @param resources
+     */
+    async updateTask(containerId, resources) {
+        await this.call('tasks.v1.Tasks', 'Update', M.UpdateTaskRequest, { containerId: containerId, resources: { typeUrl: RESOURCES_TYPE_URL, value: Buffer.from(JSON.stringify(resources)) } });
+    }
+    /*
+     * Events
+     */
+    /**
+     * The events of containerd, their fields decoded (the ones of the tasks, the containers and the images)
+     * @param filters the filters of containerd (topic~="/tasks/", namespace==default)
+     * @param signal its end
+     */
+    async *subscribe(filters = [], signal) {
+        //The events of all the namespaces: filtered by namespace
+        const responses = this.grpc.serverStream(`${SERVICES}.events.v1.Events/Subscribe`, M.SubscribeRequest, { filters: filters }, M.Envelope, { signal: signal });
+        try {
+            for await (const envelope of responses) {
+                const type = String(envelope.event?.typeUrl ?? '');
+                const schema = M.EVENTS[type];
+                yield {
+                    timestamp: timestampDate(envelope.timestamp) ?? new Date(),
+                    namespace: envelope.namespace ?? '',
+                    topic: envelope.topic ?? '',
+                    type: type,
+                    event: schema && envelope.event?.value ? decode(schema, envelope.event.value) : {}
+                };
+            }
+        }
+        catch (error) {
+            if (signal?.aborted && isGRPCError(error, GRPCStatus.CANCELLED))
+                return;
+            throw error;
+        }
+    }
+    /**
+     * An Any of JSON (the specifications of OCI)
+     * @param typeUrl
+     * @param value
+     */
+    static Json(typeUrl, value) {
+        return { typeUrl: typeUrl, value: Buffer.from(JSON.stringify(value)) };
+    }
+    /**
+     * The value of an Any of JSON
+     * @param any
+     */
+    static FromJson(any) {
+        if (!any?.value?.length)
+            return undefined;
+        return JSON.parse(Buffer.from(any.value).toString('utf8'));
+    }
+    /**
+     * Close the connection
+     */
+    close() {
+        this.grpc.close();
+    }
+}

package/dist/esm/client/DockerIgnore.js

@@ -0,0 +1,179 @@
+/*
+ * The rules of the .dockerignore files, rewritten from @balena/dockerignore (Copyright 2020 Balena Ltd., Apache License
+ * 2.0, and Copyright 2018 Zeit, Inc., MIT License, see THIRD_PARTY_NOTICES.md), which follows the implementation of
+ * Docker (moby/moby builder/dockerignore and pkg/fileutils)
+ */
+import path from 'node:path';
+/**
+ * The separators of the paths of the platform: on Windows, "/" and "\" separate the paths and "\" does not escape
+ */
+const SEPARATOR = path.sep;
+/**
+ * filepath.Clean of Go
+ * @param file
+ */
+function cleanPath(file) {
+    return path.normalize(file).replace(SEPARATOR === '\\' ? /(?<=.)\\$/ : /(?<=.)\/$/, '');
+}
+/**
+ * filepath.ToSlash of Go
+ * @param file
+ */
+function toSlash(file) {
+    return SEPARATOR === '/' ? file : file.replace(/\\/g, '/');
+}
+/**
+ * filepath.FromSlash of Go
+ * @param file
+ */
+function fromSlash(file) {
+    return SEPARATOR === '/' ? file : file.replace(/\//g, SEPARATOR);
+}
+/**
+ * The rules of a .dockerignore file: the files of a build context they exclude
+ */
+export class DockerIgnore {
+    #rules = [];
+    #cache = new Map();
+    /**
+     * @param content the content of a .dockerignore file
+     * @param ignoreCase match the case-insensitively, as Docker does not (false by default)
+     */
+    constructor(content = '', ignoreCase = false) {
+        this.ignoreCase = ignoreCase;
+        this.add(content);
+    }
+    /**
+     * Add the rules of a content
+     * @param content
+     */
+    add(content) {
+        for (const line of content.split(/\r?\n/)) {
+            if (!line.trim() || line.startsWith('#'))
+                continue;
+            const rule = this.rule(line.trim());
+            if (rule)
+                this.#rules.push(rule);
+        }
+        this.#cache.clear();
+        return this;
+    }
+    /**
+     * A rule of a line (moby/moby builder/dockerignore/dockerignore.go and pkg/fileutils/fileutils.go)
+     * @param line
+     */
+    rule(line) {
+        let pattern = line;
+        let negative = false;
+        if (pattern.startsWith('!')) {
+            negative = true;
+            pattern = pattern.substring(1).trim();
+        }
+        if (pattern.length > 0) {
+            pattern = toSlash(cleanPath(pattern));
+            if (pattern.length > 1 && pattern.startsWith('/'))
+                pattern = pattern.slice(1);
+        }
+        if (negative)
+            pattern = `!${pattern}`;
+        pattern = pattern.trim();
+        if (!pattern)
+            return undefined;
+        pattern = cleanPath(pattern);
+        if (pattern.startsWith('!')) {
+            if (pattern.length === 1)
+                return undefined;
+            negative = true;
+            pattern = pattern.substring(1);
+        }
+        else {
+            negative = false;
+        }
+        return { pattern: pattern, directories: pattern.split(SEPARATOR), negative: negative };
+    }
+    /**
+     * The regular expression of a rule (fileutils.go regexpMatch)
+     * @param rule
+     */
+    expression(rule) {
+        if (rule.expression)
+            return rule.expression;
+        const separator = SEPARATOR === '\\' ? '\\\\' : SEPARATOR;
+        let source = '^';
+        const pattern = rule.pattern;
+        for (let index = 0; index < pattern.length; index++) {
+            const character = pattern[index];
+            if (character === '*') {
+                if (pattern[index + 1] === '*') {
+                    index++;
+                    //"**/" is "**"
+                    if (pattern[index + 1] === SEPARATOR)
+                        index++;
+                    source += pattern[index + 1] === undefined ? '.*' : `(.*${separator})?`;
+                }
+                else {
+                    source += `[^${separator}]*`;
+                }
+            }
+            else if (character === '?') {
+                source += `[^${separator}]`;
+            }
+            else if (character === '.' || character === '$') {
+                source += `\\${character}`;
+            }
+            else if (character === '\\') {
+                if (SEPARATOR === '\\') {
+                    source += separator;
+                }
+                else if (pattern[index + 1] !== undefined) {
+                    source += `\\${pattern[++index]}`;
+                }
+                else {
+                    source += '\\';
+                }
+            }
+            else {
+                source += character;
+            }
+        }
+        return rule.expression = new RegExp(`${source}$`, this.ignoreCase ? 'i' : '');
+    }
+    /**
+     * Whether a file of the context is excluded by the rules (its path relative to the context, "/" separated)
+     * @param file
+     */
+    ignores(file) {
+        if (!file)
+            return true;
+        let ignored = this.#cache.get(file);
+        if (ignored === undefined)
+            this.#cache.set(file, ignored = this.test(file));
+        return ignored;
+    }
+    /**
+     * Whether a file is excluded: the last rule matching it or one of its parent directories decides
+     * @param file
+     */
+    test(file) {
+        const local = fromSlash(file);
+        const parent = cleanPath(path.dirname(local));
+        const parentDirectories = parent.split(SEPARATOR);
+        let matched = false;
+        for (const rule of this.#rules) {
+            let match = this.expression(rule).test(local);
+            if (!match && parent !== '.') {
+                if (rule.directories.includes('**')) {
+                    for (let index = rule.directories.filter((directory) => directory !== '**').length; index <= parentDirectories.length; index++) {
+                        match = match || this.expression(rule).test(parentDirectories.slice(0, index).join(SEPARATOR));
+                    }
+                }
+                else if (rule.directories.length <= parentDirectories.length) {
+                    match = this.expression(rule).test(parentDirectories.slice(0, rule.directories.length).join(SEPARATOR));
+                }
+            }
+            if (match)
+                matched = !rule.negative;
+        }
+        return matched;
+    }
+}

package/dist/esm/client/Fifo.js

@@ -0,0 +1,59 @@
+import { spawnSync } from 'node:child_process';
+import { closeSync, constants, openSync } from 'node:fs';
+import net from 'node:net';
+/**
+ * The FIFOs of the standard streams of a process of containerd (the ones of its cio): created by mkfifo, the shim
+ * writing (or reading) them, read (or written) from the event loop
+ */
+export class ProcessFifo {
+    #keeper;
+    #socket;
+    constructor(path, direction) {
+        this.path = path;
+        this.direction = direction;
+    }
+    /**
+     * Whether the FIFOs can be created (mkfifo of the system: coreutils, busybox)
+     */
+    static Supported() {
+        return spawnSync('mkfifo', ['--help'], { stdio: 'ignore' }).error === undefined;
+    }
+    /**
+     * Create a FIFO, kept open (read and write) for the shim to open its end without waiting
+     * @param path
+     * @param direction read: the shim writes it (stdout, stderr), write: the shim reads it (stdin)
+     */
+    static Create(path, direction) {
+        const result = spawnSync('mkfifo', ['-m', '0600', path], { stdio: ['ignore', 'ignore', 'pipe'] });
+        if (result.error || result.status !== 0)
+            throw new Error(`The FIFO ${path} is not created: ${result.error?.message ?? result.stderr.toString().trim()}`);
+        const fifo = new ProcessFifo(path, direction);
+        fifo.#keeper = openSync(path, constants.O_RDWR | constants.O_NONBLOCK);
+        return fifo;
+    }
+    /**
+     * Its end opened, once the shim has opened its own one (after the creation of the process): the one kept closed,
+     * the end of the stream is the one of the shim
+     */
+    open() {
+        if (this.#socket)
+            return this.#socket;
+        const flags = (this.direction === 'read' ? constants.O_RDONLY : constants.O_WRONLY) | constants.O_NONBLOCK;
+        this.#socket = new net.Socket({ fd: openSync(this.path, flags), readable: this.direction === 'read', writable: this.direction === 'write' });
+        this.releaseKeeper();
+        return this.#socket;
+    }
+    releaseKeeper() {
+        if (this.#keeper === undefined)
+            return;
+        closeSync(this.#keeper);
+        this.#keeper = undefined;
+    }
+    /**
+     * Close it
+     */
+    close() {
+        this.releaseKeeper();
+        this.#socket?.destroy();
+    }
+}