the-moby-effect 1.45.0-alpha.8 → 1.48.0

package/src/PodmanEngine.ts

@@ -0,0 +1,121 @@
+/**
+ * Podman engine
+ *
+ * @since 1.0.0
+ */
+
+import type * as HttpClient from "@effect/platform/HttpClient";
+import type * as Socket from "@effect/platform/Socket";
+import type * as MobyConnection from "./MobyConnection.js";
+
+import * as Function from "effect/Function";
+import * as Layer from "effect/Layer";
+import * as MobyEndpoints from "./MobyEndpoints.js";
+import * as MobyPlatforms from "./MobyPlatforms.js";
+
+/**
+ * @since 1.0.0
+ * @category Types
+ */
+export type PodmanLayer = Layer.Layer<
+    | MobyEndpoints.Containers
+    | MobyEndpoints.Execs
+    | MobyEndpoints.Images
+    | MobyEndpoints.Networks
+    | MobyEndpoints.Secrets
+    | MobyEndpoints.Systems
+    | MobyEndpoints.Volumes,
+    never,
+    never
+>;
+
+/**
+ * @since 1.0.0
+ * @category Types
+ */
+export type PodmanLayerWithoutHttpClientOrWebsocketConstructor = Layer.Layer<
+    Layer.Layer.Success<PodmanLayer>,
+    Layer.Layer.Error<PodmanLayer>,
+    Layer.Layer.Context<PodmanLayer> | HttpClient.HttpClient | Socket.WebSocketConstructor
+>;
+
+/**
+ * @since 1.0.0
+ * @category Layers
+ */
+export const layerWithoutHttpCLient: PodmanLayerWithoutHttpClientOrWebsocketConstructor = Layer.mergeAll(
+    MobyEndpoints.ContainersLayer,
+    MobyEndpoints.ExecsLayer,
+    MobyEndpoints.ImagesLayer,
+    MobyEndpoints.NetworksLayer,
+    MobyEndpoints.SecretsLayer,
+    MobyEndpoints.SystemsLayer,
+    MobyEndpoints.VolumesLayer
+);
+
+/**
+ * @since 1.0.0
+ * @category Layers
+ */
+export const layerNodeJS: (connectionOptions: MobyConnection.MobyConnectionOptions) => PodmanLayer = Function.compose(
+    MobyPlatforms.makeNodeHttpClientLayer,
+    (httpClientLayer) => Layer.provide(layerWithoutHttpCLient, httpClientLayer)
+);
+
+/**
+ * @since 1.0.0
+ * @category Layers
+ */
+export const layerBun: (connectionOptions: MobyConnection.MobyConnectionOptions) => PodmanLayer = Function.compose(
+    MobyPlatforms.makeBunHttpClientLayer,
+    (httpClientLayer) => Layer.provide(layerWithoutHttpCLient, httpClientLayer)
+);
+
+/**
+ * @since 1.0.0
+ * @category Layers
+ */
+export const layerDeno: (connectionOptions: MobyConnection.MobyConnectionOptions) => PodmanLayer = Function.compose(
+    MobyPlatforms.makeDenoHttpClientLayer,
+    (httpClientLayer) => Layer.provide(layerWithoutHttpCLient, httpClientLayer)
+);
+
+/**
+ * @since 1.0.0
+ * @category Layers
+ */
+export const layerUndici: (connectionOptions: MobyConnection.MobyConnectionOptions) => PodmanLayer = Function.compose(
+    MobyPlatforms.makeUndiciHttpClientLayer,
+    (httpClientLayer) => Layer.provide(layerWithoutHttpCLient, httpClientLayer)
+);
+
+/**
+ * @since 1.0.0
+ * @category Layers
+ */
+export const layerWeb: (
+    connectionOptions: MobyConnection.HttpConnectionOptionsTagged | MobyConnection.HttpsConnectionOptionsTagged
+) => PodmanLayer = Function.compose(MobyPlatforms.makeWebHttpClientLayer, (httpClientLayer) =>
+    Layer.provide(layerWithoutHttpCLient, httpClientLayer)
+);
+
+/**
+ * @since 1.0.0
+ * @category Layers
+ */
+export const layerFetch: (
+    connectionOptions: MobyConnection.HttpConnectionOptionsTagged | MobyConnection.HttpsConnectionOptionsTagged
+) => PodmanLayer = Function.compose(MobyPlatforms.makeFetchHttpClientLayer, (httpClientLayer) =>
+    Layer.provide(layerWithoutHttpCLient, httpClientLayer)
+);
+
+/**
+ * @since 1.0.0
+ * @category Layers
+ */
+export const layerAgnostic: (
+    connectionOptions: MobyConnection.HttpConnectionOptionsTagged | MobyConnection.HttpsConnectionOptionsTagged
+) => PodmanLayerWithoutHttpClientOrWebsocketConstructor = Function.compose(
+    MobyPlatforms.makeAgnosticHttpClientLayer,
+    (httpClientLayer) => Layer.provide(layerWithoutHttpCLient, httpClientLayer)
+);

package/src/Promises.ts

@@ -0,0 +1,68 @@
+/**
+ * Docker engine promises api
+ *
+ * @since 1.0.0
+ */
+
+import type * as Layer from "effect/Layer";
+import type * as MobySchemas from "./MobySchemas.js";
+
+import * as Chunk from "effect/Chunk";
+import * as Effect from "effect/Effect";
+import * as Function from "effect/Function";
+import * as ManagedRuntime from "effect/ManagedRuntime";
+import * as Stream from "effect/Stream";
+import * as DockerEngine from "./DockerEngine.js";
+import * as MobyConvey from "./MobyConvey.js";
+
+/**
+ * Create a promise client for the docker engine
+ *
+ * @since 1.0.0
+ * @category Promises
+ */
+export const promiseClient = async <E>(
+    layer: Layer.Layer<
+        Layer.Layer.Success<DockerEngine.DockerLayer>,
+        Layer.Layer.Error<DockerEngine.DockerLayer> | E,
+        Layer.Layer.Context<DockerEngine.DockerLayer>
+    >
+) => {
+    const managedRuntime = ManagedRuntime.make(layer);
+    const runtime = await managedRuntime.runtime();
+
+    return {
+        pull: Function.compose(DockerEngine.pull, Stream.toReadableStreamRuntime(runtime)),
+        build: Function.compose(DockerEngine.build, Stream.toReadableStreamRuntime(runtime)),
+        stop: Function.flow(DockerEngine.stop, managedRuntime.runPromise),
+        start: Function.flow(DockerEngine.start, managedRuntime.runPromise),
+        run: Function.flow(DockerEngine.run, managedRuntime.runPromise),
+        exec: Function.flow(DockerEngine.exec, managedRuntime.runPromise),
+        execNonBlocking: Function.flow(DockerEngine.execNonBlocking, managedRuntime.runPromise),
+        execWebsockets: Function.flow(DockerEngine.execWebsockets, managedRuntime.runPromise),
+        execWebsocketsNonBlocking: Function.compose(
+            DockerEngine.execWebsocketsNonBlocking,
+            Stream.toReadableStreamRuntime(runtime)
+        ),
+        ps: Function.flow(DockerEngine.ps, managedRuntime.runPromise),
+        push: Function.flow(DockerEngine.push, Stream.toReadableStreamRuntime(runtime)),
+        images: Function.flow(DockerEngine.images, managedRuntime.runPromise),
+        search: Function.flow(DockerEngine.search, managedRuntime.runPromise),
+        version: Function.flow(DockerEngine.version, managedRuntime.runPromise),
+        info: Function.flow(DockerEngine.info, managedRuntime.runPromise),
+        ping: Function.flow(DockerEngine.ping, managedRuntime.runPromise),
+        pingHead: Function.flow(DockerEngine.pingHead, managedRuntime.runPromise),
+        followProgressInConsole: Function.flow(
+            Stream.fromReadableStream<MobySchemas.JSONMessage, unknown>,
+            MobyConvey.followProgressInConsole,
+            Effect.map(Chunk.toReadonlyArray),
+            managedRuntime.runPromise
+        ),
+        waitForProgressToComplete: Function.flow(
+            Stream.fromReadableStream<MobySchemas.JSONMessage, unknown>,
+            MobyConvey.waitForProgressToComplete,
+            Effect.map(Chunk.toReadonlyArray),
+            managedRuntime.runPromise
+        ),
+    };
+};

package/src/index.ts

@@ -1,153 +1,83 @@
 /**
- * Connection agents
+ * Docker engine callbacks api
  *
  * @since 1.0.0
  */
-export * as Agent from "./Agent.js"
+export * as Callbacks from "./Callbacks.js"
 
 /**
- * Configs service
+ * Docker in docker engine.
  *
  * @since 1.0.0
  */
-export * as Configs from "./Configs.js"
+export * as DindEngine from "./DindEngine.js"
 
 /**
- * Containers service
+ * Docker compose engine.
  *
  * @since 1.0.0
  */
-export * as Containers from "./Containers.js"
+export * as DockerComposeEngine from "./DockerComposeEngine.js"
 
 /**
- * Demux helpers
+ * Docker engine.
  *
  * @since 1.0.0
  */
-export * as Demux from "./Demux.js"
+export * as DockerEngine from "./DockerEngine.js"
 
 /**
- * Distributions service
+ * Http, https, ssh, and unix socket connection agents for all platforms.
  *
  * @since 1.0.0
  */
-export * as Distribution from "./Distribution.js"
+export * as MobyConnection from "./MobyConnection.js"
 
 /**
- * Docker helpers
+ * Convenance utilities for Docker input and output streams.
  *
  * @since 1.0.0
  */
-export * as Docker from "./Docker.js"
+export * as MobyConvey from "./MobyConvey.js"
 
 /**
- * Execs service
+ * Demux utilities for different types of docker streams.
  *
  * @since 1.0.0
  */
-export * as Execs from "./Execs.js"
+export * as MobyDemux from "./MobyDemux.js"
 
 /**
- * Images service
+ * Moby endpoints.
  *
  * @since 1.0.0
  */
-export * as Images from "./Images.js"
+export * as MobyEndpoints from "./MobyEndpoints.js"
 
 /**
- * Generic Moby helpers
+ * Http client layers for all platforms.
  *
  * @since 1.0.0
  */
-export * as Moby from "./Moby.js"
+export * as MobyPlatforms from "./MobyPlatforms.js"
 
 /**
- * Networks service
+ * Moby schemas.
  *
  * @since 1.0.0
  */
-export * as Networks from "./Networks.js"
+export * as MobySchemas from "./MobySchemas.js"
 
 /**
- * Nodes service
+ * Podman engine
  *
  * @since 1.0.0
  */
-export * as Nodes from "./Nodes.js"
+export * as PodmanEngine from "./PodmanEngine.js"
 
 /**
- * Plugins service
+ * Docker engine promises api
  *
  * @since 1.0.0
  */
-export * as Plugins from "./Plugins.js"
-
-/**
- * Request helpers
- *
- * @since 1.0.0
- */
-export * as Requests from "./Requests.js"
-
-/**
- * Moby Schemas
- *
- * @since 1.0.0
- */
-export * as Schemas from "./Schemas.js"
-
-/**
- * Moby Schemas
- *
- * @since 1.0.0
- */
-export * as Schemas2 from "./Schemas2.js"
-
-/**
- * Secrets service
- *
- * @since 1.0.0
- */
-export * as Secrets from "./Secrets.js"
-
-/**
- * Services service
- *
- * @since 1.0.0
- */
-export * as Services from "./Services.js"
-
-/**
- * Sessions service
- *
- * @since 1.0.0
- */
-export * as Session from "./Session.js"
-
-/**
- * Swarms service
- *
- * @since 1.0.0
- */
-export * as Swarm from "./Swarm.js"
-
-/**
- * Systems service
- *
- * @since 1.0.0
- */
-export * as System from "./System.js"
-
-/**
- * Tasks service
- *
- * @since 1.0.0
- */
-export * as Tasks from "./Tasks.js"
-
-/**
- * Volumes service
- *
- * @since 1.0.0
- */
-export * as Volumes from "./Volumes.js"
+export * as Promises from "./Promises.js"

package/src/internal/blobs/constants.ts

@@ -0,0 +1,12 @@
+/** @internal */
+export const DefaultDindBaseImage: RecommendedDindBaseImages = "docker.io/library/docker:dind-rootless" as const;
+
+/** @internal */
+export type RecommendedDindBaseImages =
+    | "docker.io/library/docker:dind-rootless"
+    | "docker.io/library/docker:23-dind-rootless"
+    | "docker.io/library/docker:24-dind-rootless"
+    | "docker.io/library/docker:25-dind-rootless"
+    | "docker.io/library/docker:26-dind-rootless"
+    | "docker.io/library/docker:27-dind-rootless"
+    | "docker.io/library/docker:28-dind-rootless";

package/src/internal/blobs/http.ts

@@ -0,0 +1,10 @@
+import * as BlobConstants from "./constants.js";
+
+/** @internal */
+export const content = `ARG DIND_BASE_IMAGE="${BlobConstants.DefaultDindBaseImage}"
+FROM \${DIND_BASE_IMAGE}
+
+EXPOSE 2375
+ENV DOCKER_TLS_CERTDIR=
+CMD [ "--tls=false" ]
+`;

package/src/internal/blobs/https.ts

@@ -0,0 +1,9 @@
+import * as BlobConstants from "./constants.js";
+
+/** @internal */
+export const content = `ARG DIND_BASE_IMAGE="${BlobConstants.DefaultDindBaseImage}"
+FROM \${DIND_BASE_IMAGE}
+
+EXPOSE 2376
+ENV DOCKER_TLS_CERTDIR=/certs
+`;

package/src/internal/blobs/socket.ts

@@ -0,0 +1,6 @@
+import * as BlobConstants from "./constants.js";
+
+/** @internal */
+export const content = `ARG DIND_BASE_IMAGE="${BlobConstants.DefaultDindBaseImage}"
+FROM \${DIND_BASE_IMAGE}
+`;

package/src/internal/blobs/ssh.ts

@@ -0,0 +1,19 @@
+import * as BlobConstants from "./constants.js";
+
+/** @internal */
+export const content = `ARG DIND_BASE_IMAGE="${BlobConstants.DefaultDindBaseImage}"
+FROM \${DIND_BASE_IMAGE}
+USER root
+
+RUN \\
+    echo -n 'root:password' | chpasswd && \\
+    apk update && apk upgrade && apk add openssh-server && \\
+    echo "PermitRootLogin yes" >> /etc/ssh/sshd_config && \\
+    echo "PasswordAuthentication yes" >> /etc/ssh/sshd_config && \\
+    sed -i 's/AllowTcpForwarding no/AllowTcpForwarding yes/g' /etc/ssh/sshd_config && \\
+    ssh-keygen -A
+
+EXPOSE 22
+ENTRYPOINT ["/bin/sh", "-c"]
+CMD ["/usr/local/bin/dockerd-entrypoint.sh & /usr/sbin/sshd -D"]
+`;

package/src/internal/convey/sinks.ts

@@ -0,0 +1,35 @@
+import type * as Chunk from "effect/Chunk";
+import type * as Scope from "effect/Scope";
+
+import * as Console from "effect/Console";
+import * as Effect from "effect/Effect";
+import * as Function from "effect/Function";
+import * as Predicate from "effect/Predicate";
+import * as Sink from "effect/Sink";
+import * as Stream from "effect/Stream";
+
+import { JSONMessage } from "../generated/JSONMessage.generated.js";
+
+/** @internal */
+export const waitForProgressToComplete = <E1, R1>(
+    stream: Stream.Stream<JSONMessage, E1, R1>
+): Effect.Effect<Chunk.Chunk<JSONMessage>, E1, Exclude<R1, Scope.Scope>> => Stream.run(stream, Sink.collectAll());
+
+/** @internal */
+export const followProgressSink = Sink.forEach<JSONMessage, void, never, never>(
+    Effect.fnUntraced(function* (message) {
+        if (Predicate.isNotUndefined(message.status)) {
+            yield* Console.log(`${message.status}${message.progress ? " " : ""}${message.progress ?? ""}`);
+        } else if (Predicate.isNotUndefined(message.stream)) {
+            yield* Console.log(message.stream);
+        } else if (Predicate.isNotUndefined(message.aux)) {
+            yield* Console.log(message.aux.ID);
+        }
+    })
+);
+
+/** @internal */
+export const followProgressInConsole = <E1, R1>(
+    stream: Stream.Stream<JSONMessage, E1, R1>
+): Effect.Effect<Chunk.Chunk<JSONMessage>, E1, Exclude<R1, Scope.Scope>> =>
+    Function.pipe(stream, Stream.tapSink(followProgressSink), waitForProgressToComplete);

package/src/internal/demux/compressed.ts

@@ -0,0 +1,24 @@
+import * as Predicate from "effect/Predicate";
+
+/**
+ * @since 1.0.0
+ * @category Types
+ */
+export type CompressedDemuxOutput<A1, A2> = A1 extends undefined | void
+    ? A2 extends undefined | void
+        ? void
+        : readonly [stdout: undefined, stderr: A2]
+    : A2 extends undefined | void
+      ? readonly [stdout: A1, stderr: undefined]
+      : readonly [stdout: A1, stderr: A2];
+
+/**
+ * @since 1.0.0
+ * @category Demux Helpers
+ */
+export const compressDemuxOutput = <A1, A2>(
+    data: readonly [ranStdout: A1, ranStderr: A2]
+): CompressedDemuxOutput<A1, A2> =>
+    Predicate.isUndefined(data[0]) && Predicate.isUndefined(data[1])
+        ? (void undefined as CompressedDemuxOutput<A1, A2>)
+        : (data as CompressedDemuxOutput<A1, A2>);

package/src/internal/demux/demux.ts

@@ -0,0 +1,81 @@
+import type * as Socket from "@effect/platform/Socket";
+import type * as Effect from "effect/Effect";
+import type * as ParseResult from "effect/ParseResult";
+import type * as Scope from "effect/Scope";
+import type * as Stream from "effect/Stream";
+
+import * as Function from "effect/Function";
+import * as Sink from "effect/Sink";
+import * as Tuple from "effect/Tuple";
+
+import {
+    demuxMultiplexedToSingleSink,
+    EitherMultiplexedInput,
+    isMultiplexedChannel,
+    isMultiplexedSocket,
+} from "./multiplexed.js";
+import { demuxRawToSingleSink, EitherRawInput, isRawChannel, isRawSocket } from "./raw.js";
+
+/**
+ * Demux either a raw socket or a multiplexed socket to a single sink.
+ *
+ * @since 1.0.0
+ * @category Demux
+ */
+export const demuxToSingleSink = Function.dual<
+    // Data-last signature.
+    <A1, L1, E1, E2, R1, R2>(
+        source: Stream.Stream<string | Uint8Array, E1, R1>,
+        sink: Sink.Sink<A1, string, L1, E2, R2>,
+        options?: { encoding?: string | undefined } | undefined
+    ) => <IE = never, OE = Socket.SocketError, R3 = never>(
+        sockets: EitherRawInput<E1 | IE, OE, R3> | EitherMultiplexedInput<E1 | IE, OE, R3>
+    ) => Effect.Effect<
+        A1,
+        E1 | E2 | IE | OE | ParseResult.ParseError,
+        Exclude<R1, Scope.Scope> | Exclude<R2, Scope.Scope> | Exclude<R3, Scope.Scope>
+    >,
+    // Data-first signature.
+    <A1, L1, E1, E2, R1, R2, IE = never, OE = Socket.SocketError, R3 = never>(
+        sockets: EitherRawInput<E1 | IE, OE, R3> | EitherMultiplexedInput<E1 | IE, OE, R3>,
+        source: Stream.Stream<string | Uint8Array, E1, R1>,
+        sink: Sink.Sink<A1, string, L1, E2, R2>,
+        options?: { encoding?: string | undefined } | undefined
+    ) => Effect.Effect<
+        A1,
+        E1 | E2 | IE | OE | ParseResult.ParseError,
+        Exclude<R1, Scope.Scope> | Exclude<R2, Scope.Scope> | Exclude<R3, Scope.Scope>
+    >
+>(
+    /**
+     * We are data-first if the first argument is a channel or if the first
+     * argument is an object with a "stdout", "stderr", or "stdin" key.
+     */
+    (arguments_) =>
+        isRawSocket(arguments_[0]) ||
+        isRawChannel(arguments_[0]) ||
+        isMultiplexedSocket(arguments_[0]) ||
+        isMultiplexedChannel(arguments_[0]),
+
+    // Implementation, need the type parameters for checking the underlying.
+    <A1, L1, E1, E2, R1, R2, IE = never, OE = Socket.SocketError, R3 = never>(
+        socketOptions: EitherRawInput<E1 | IE, OE, R3> | EitherMultiplexedInput<E1 | IE, OE, R3>,
+        source: Stream.Stream<string | Uint8Array, E1, R1>,
+        sink: Sink.Sink<A1, string, L1, E2, R2>,
+        options?: { encoding?: string | undefined } | undefined
+    ): Effect.Effect<
+        A1,
+        E1 | E2 | IE | OE | ParseResult.ParseError,
+        Exclude<R1, Scope.Scope> | Exclude<R2, Scope.Scope> | Exclude<R3, Scope.Scope>
+    > => {
+        if (isRawSocket(socketOptions) || isRawChannel<E1 | IE, OE, R3>(socketOptions)) {
+            return demuxRawToSingleSink(socketOptions, source, sink, options);
+        }
+
+        if (isMultiplexedSocket(socketOptions) || isMultiplexedChannel<E1 | IE, OE, R3>(socketOptions)) {
+            return demuxMultiplexedToSingleSink(socketOptions, source, Sink.mapInput(sink, Tuple.getSecond), options);
+        }
+
+        return Function.absurd(socketOptions);
+    }
+);