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

package/src/DockerEngine.ts

@@ -0,0 +1,427 @@
+/**
+ * Docker engine.
+ *
+ * @since 1.0.0
+ */
+
+import type * as HttpClient from "@effect/platform/HttpClient";
+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 type * as MobyConnection from "./MobyConnection.js";
+import type * as Schemas from "./MobySchemas.js";
+
+import * as Function from "effect/Function";
+import * as Layer from "effect/Layer";
+import * as internalDocker from "./internal/engines/docker.js";
+import * as MobyEndpoints from "./MobyEndpoints.js";
+import * as MobyPlatforms from "./MobyPlatforms.js";
+
+/**
+ * @since 1.0.0
+ * @category Layers
+ */
+export type DockerLayer = Layer.Layer<
+    Layer.Layer.Success<DockerLayerWithoutHttpClientOrWebsocketConstructor>,
+    Layer.Layer.Error<DockerLayerWithoutHttpClientOrWebsocketConstructor>,
+    Exclude<
+        Layer.Layer.Context<DockerLayerWithoutHttpClientOrWebsocketConstructor>,
+        HttpClient.HttpClient | Socket.WebSocketConstructor
+    >
+>;
+
+/**
+ * @since 1.0.0
+ * @category Layers
+ */
+export type DockerLayerWithoutHttpClientOrWebsocketConstructor = Layer.Layer<
+    | MobyEndpoints.Configs
+    | MobyEndpoints.Containers
+    | MobyEndpoints.Distributions
+    | MobyEndpoints.Execs
+    | MobyEndpoints.Images
+    | MobyEndpoints.Networks
+    | MobyEndpoints.Nodes
+    | MobyEndpoints.Plugins
+    | MobyEndpoints.Secrets
+    | MobyEndpoints.Services
+    | MobyEndpoints.Sessions
+    | MobyEndpoints.Swarm
+    | MobyEndpoints.Systems
+    | MobyEndpoints.Tasks
+    | MobyEndpoints.Volumes,
+    never,
+    HttpClient.HttpClient | Socket.WebSocketConstructor
+>;
+
+/**
+ * @since 1.0.0
+ * @category Layers
+ */
+export const layerWithoutHttpCLient: DockerLayerWithoutHttpClientOrWebsocketConstructor = Layer.mergeAll(
+    MobyEndpoints.ConfigsLayer,
+    MobyEndpoints.ContainersLayer,
+    MobyEndpoints.DistributionsLayer,
+    MobyEndpoints.ExecsLayer,
+    MobyEndpoints.ImagesLayer,
+    MobyEndpoints.NetworksLayer,
+    MobyEndpoints.NodesLayer,
+    MobyEndpoints.PluginsLayer,
+    MobyEndpoints.SecretsLayer,
+    MobyEndpoints.ServicesLayer,
+    MobyEndpoints.SessionsLayer,
+    MobyEndpoints.SwarmLayer,
+    MobyEndpoints.SystemsLayer,
+    MobyEndpoints.TasksLayer,
+    MobyEndpoints.VolumesLayer
+);
+
+/**
+ * @since 1.0.0
+ * @category Layers
+ */
+export const layerNodeJS: (connectionOptions: MobyConnection.MobyConnectionOptions) => DockerLayer = Function.compose(
+    MobyPlatforms.makeNodeHttpClientLayer,
+    (httpClientLayer) => Layer.provide(layerWithoutHttpCLient, httpClientLayer)
+);
+
+/**
+ * @since 1.0.0
+ * @category Layers
+ */
+export const layerBun: (connectionOptions: MobyConnection.MobyConnectionOptions) => DockerLayer = Function.compose(
+    MobyPlatforms.makeBunHttpClientLayer,
+    (httpClientLayer) => Layer.provide(layerWithoutHttpCLient, httpClientLayer)
+);
+
+/**
+ * @since 1.0.0
+ * @category Layers
+ */
+export const layerDeno: (connectionOptions: MobyConnection.MobyConnectionOptions) => DockerLayer = Function.compose(
+    MobyPlatforms.makeDenoHttpClientLayer,
+    (httpClientLayer) => Layer.provide(layerWithoutHttpCLient, httpClientLayer)
+);
+
+/**
+ * @since 1.0.0
+ * @category Layers
+ */
+export const layerUndici: (connectionOptions: MobyConnection.MobyConnectionOptions) => DockerLayer = Function.compose(
+    MobyPlatforms.makeUndiciHttpClientLayer,
+    (httpClientLayer) => Layer.provide(layerWithoutHttpCLient, httpClientLayer)
+);
+
+/**
+ * @since 1.0.0
+ * @category Layers
+ */
+export const layerWeb: (
+    connectionOptions: MobyConnection.HttpConnectionOptionsTagged | MobyConnection.HttpsConnectionOptionsTagged
+) => DockerLayer = Function.compose(MobyPlatforms.makeWebHttpClientLayer, (httpClientLayer) =>
+    Layer.provide(layerWithoutHttpCLient, httpClientLayer)
+);
+
+/**
+ * @since 1.0.0
+ * @category Layers
+ */
+export const layerFetch: (
+    connectionOptions: MobyConnection.HttpConnectionOptionsTagged | MobyConnection.HttpsConnectionOptionsTagged
+) => DockerLayer = Function.compose(MobyPlatforms.makeFetchHttpClientLayer, (httpClientLayer) =>
+    Layer.provide(layerWithoutHttpCLient, httpClientLayer)
+);
+
+/**
+ * @since 1.0.0
+ * @category Layers
+ */
+export const layerAgnostic: (
+    connectionOptions: MobyConnection.HttpConnectionOptionsTagged | MobyConnection.HttpsConnectionOptionsTagged
+) => DockerLayerWithoutHttpClientOrWebsocketConstructor = Function.compose(
+    MobyPlatforms.makeAgnosticHttpClientLayer,
+    (httpClientLayer) => Layer.provide(layerWithoutHttpCLient, httpClientLayer)
+);
+
+/**
+ * Implements the `docker build` command. It doesn't have all the flags that the
+ * images build endpoint exposes.
+ *
+ * @since 1.0.0
+ * @category Docker
+ */
+export const build: <E1>({
+    auth,
+    buildArgs,
+    context,
+    dockerfile,
+    platform,
+    tag,
+}: {
+    tag: string;
+    auth?: string | undefined;
+    platform?: string | undefined;
+    dockerfile?: string | undefined;
+    context: Stream.Stream<Uint8Array, E1, never>;
+    buildArgs?: Record<string, string | undefined> | undefined;
+}) => Stream.Stream<Schemas.JSONMessage, MobyEndpoints.ImagesError, MobyEndpoints.Images> = internalDocker.build;
+
+/**
+ * Implements the `docker build` command as a scoped effect. When the scope is
+ * closed, the built image is removed. It doesn't have all the flags that the
+ * images build endpoint exposes.
+ *
+ * @since 1.0.0
+ * @category Docker
+ */
+export const buildScoped: <E1>({
+    auth,
+    buildArgs,
+    context,
+    dockerfile,
+    platform,
+    tag,
+}: {
+    tag: string;
+    auth?: string | undefined;
+    platform?: string | undefined;
+    dockerfile?: string | undefined;
+    buildArgs?: Record<string, string | undefined> | undefined;
+    context: Stream.Stream<Uint8Array, E1, never>;
+}) => Effect.Effect<
+    Stream.Stream<Schemas.JSONMessage, MobyEndpoints.ImagesError, never>,
+    never,
+    Scope.Scope | MobyEndpoints.Images
+> = internalDocker.buildScoped;
+
+/**
+ * Implements the `docker exec` command in a blocking fashion. Incompatible with
+ * web.
+ *
+ * @since 1.0.0
+ * @category Docker
+ */
+export const exec: ({
+    command,
+    containerId,
+}: {
+    containerId: string;
+    command: string | Array<string>;
+}) => Effect.Effect<
+    readonly [exitCode: number, output: string],
+    MobyEndpoints.ExecsError | Socket.SocketError | ParseResult.ParseError,
+    MobyEndpoints.Execs
+> = internalDocker.exec;
+
+/**
+ * Implements the `docker exec` command in a non blocking fashion. Incompatible
+ * with web when not detached.
+ *
+ * @since 1.0.0
+ * @category Docker
+ */
+export const execNonBlocking = internalDocker.execNonBlocking;
+
+/**
+ * Implements the `docker exec` command in a blocking fashion with websockets as
+ * the underlying transport instead of the docker engine exec apis so that is
+ * can be compatible with web.
+ *
+ * @since 1.0.0
+ * @category Docker
+ */
+export const execWebsockets: ({
+    command,
+    containerId,
+}: {
+    command: string | Array<string>;
+    containerId: string;
+}) => Effect.Effect<
+    readonly [stdout: string, stderr: string],
+    MobyEndpoints.ContainersError | Socket.SocketError | ParseResult.ParseError,
+    MobyEndpoints.Containers
+> = internalDocker.execWebsockets;
+
+/**
+ * Implements the `docker exec` command in a non blocking fashion with
+ * websockets as the underlying transport instead of the docker engine exec apis
+ * so that is can be compatible with web.
+ *
+ * @since 1.0.0
+ * @category Docker
+ */
+export const execWebsocketsNonBlocking = internalDocker.execWebsocketsNonBlocking;
+
+/**
+ * Implements the `docker images` command.
+ *
+ * @since 1.0.0
+ * @category Docker
+ */
+export const images: (
+    options?: Parameters<MobyEndpoints.Images["list"]>[0]
+) => Effect.Effect<ReadonlyArray<Schemas.ImageSummary>, MobyEndpoints.ImagesError, MobyEndpoints.Images> =
+    internalDocker.images;
+
+/**
+ * Implements the `docker info` command.
+ *
+ * @since 1.0.0
+ * @category Docker
+ */
+export const info: () => Effect.Effect<
+    Readonly<Schemas.SystemInfoResponse>,
+    MobyEndpoints.SystemsError,
+    MobyEndpoints.Systems
+> = internalDocker.info;
+
+/**
+ * Implements the `docker ping` command.
+ *
+ * @since 1.0.0
+ * @category Docker
+ */
+export const ping: () => Effect.Effect<"OK", MobyEndpoints.SystemsError, MobyEndpoints.Systems> = internalDocker.ping;
+
+/**
+ * Implements the `docker ping` command.
+ *
+ * @since 1.0.0
+ * @category Docker
+ */
+export const pingHead: () => Effect.Effect<void, MobyEndpoints.SystemsError, MobyEndpoints.Systems> =
+    internalDocker.pingHead;
+
+/**
+ * Implements the `docker ps` command.
+ *
+ * @since 1.0.0
+ * @category Docker
+ */
+export const ps: (
+    options?: Parameters<MobyEndpoints.Containers["list"]>[0]
+) => Effect.Effect<
+    ReadonlyArray<Schemas.ContainerListResponseItem>,
+    MobyEndpoints.ContainersError,
+    MobyEndpoints.Containers
+> = internalDocker.ps;
+
+/**
+ * Implements the `docker pull` command. It does not have all the flags that the
+ * images create endpoint exposes.
+ *
+ * @since 1.0.0
+ * @category Docker
+ */
+export const pull: ({
+    auth,
+    image,
+    platform,
+}: {
+    image: string;
+    auth?: string | undefined;
+    platform?: string | undefined;
+}) => Stream.Stream<Schemas.JSONMessage, MobyEndpoints.ImagesError, MobyEndpoints.Images> = internalDocker.pull;
+
+/**
+ * Implements the `docker pull` command as a scoped effect. When the scope is
+ * closed, the pulled image is removed. It doesn't have all the flag =
+ * internalDocker.flags that the images create endpoint exposes.
+ *
+ * @since 1.0.0
+ * @category Docker
+ */
+export const pullScoped: ({
+    auth,
+    image,
+    platform,
+}: {
+    image: string;
+    auth?: string | undefined;
+    platform?: string | undefined;
+}) => Effect.Effect<
+    Stream.Stream<Schemas.JSONMessage, MobyEndpoints.ImagesError, never>,
+    never,
+    MobyEndpoints.Images | Scope.Scope
+> = internalDocker.pullScoped;
+
+/**
+ * Implements the `docker push` command.
+ *
+ * @since 1.0.0
+ * @category Docker
+ */
+export const push: (
+    options: Parameters<MobyEndpoints.Images["push"]>[0]
+) => Stream.Stream<string, MobyEndpoints.ImagesError, MobyEndpoints.Images> = internalDocker.push;
+
+/**
+ * Implements `docker run` command.
+ *
+ * @since 1.0.0
+ * @category Docker
+ */
+export const run: (
+    containerOptions: Parameters<MobyEndpoints.Containers["create"]>[0]
+) => Effect.Effect<Schemas.ContainerInspectResponse, MobyEndpoints.ContainersError, MobyEndpoints.Containers> =
+    internalDocker.run;
+
+/**
+ * Implements `docker run` command as a scoped effect. When the scope is closed,
+ * both the image and the container is removed = internalDocker.removed.
+ *
+ * @since 1.0.0
+ * @category Docker
+ */
+export const runScoped: (
+    containerOptions: Parameters<MobyEndpoints.Containers["create"]>[0]
+) => Effect.Effect<
+    Schemas.ContainerInspectResponse,
+    MobyEndpoints.ContainersError,
+    Scope.Scope | MobyEndpoints.Containers
+> = internalDocker.runScoped;
+
+/**
+ * Implements the `docker search` command.
+ *
+ * @since 1.0.0
+ * @category Docker
+ */
+export const search: (
+    options: Parameters<MobyEndpoints.Images["search"]>[0]
+) => Effect.Effect<ReadonlyArray<Schemas.RegistrySearchResponse>, MobyEndpoints.ImagesError, MobyEndpoints.Images> =
+    internalDocker.search;
+
+/**
+ * Implements the `docker start` command.
+ *
+ * @since 1.0.0
+ * @category Docker
+ */
+export const start: (
+    containerId: string
+) => Effect.Effect<void, MobyEndpoints.ContainersError, MobyEndpoints.Containers> = internalDocker.start;
+
+/**
+ * Implements the `docker stop` command.
+ *
+ * @since 1.0.0
+ * @category Docker
+ */
+export const stop: (
+    containerId: string
+) => Effect.Effect<void, MobyEndpoints.ContainersError, MobyEndpoints.Containers> = internalDocker.stop;
+
+/**
+ * Implements the `docker version` command.
+ *
+ * @since 1.0.0
+ * @category Docker
+ */
+export const version: () => Effect.Effect<
+    Readonly<Schemas.SystemVersionResponse>,
+    MobyEndpoints.SystemsError,
+    MobyEndpoints.Systems
+> = internalDocker.version;

package/src/MobyConnection.ts

@@ -0,0 +1,238 @@
+/**
+ * Http, https, ssh, and unix socket connection agents for all platforms.
+ *
+ * @since 1.0.0
+ */
+
+import type * as ConfigError from "effect/ConfigError";
+import type * as ssh2 from "ssh2";
+
+import * as Path from "@effect/platform/Path";
+import * as Data from "effect/Data";
+import * as Effect from "effect/Effect";
+
+import * as internal from "./internal/platforms/connection.js";
+
+/**
+ * Connection options for how to connect to your moby/docker instance. Can be a
+ * unix socket on the current machine. Can be an ssh connection to a remote
+ * machine with a remote user, remote machine, remote port, and remote socket
+ * path. Can be an http connection to a remote machine with a host, port, and
+ * path. Or it can be an https connection to a remote machine with a host, port,
+ * path, cert, ca, key, and passphrase.
+ *
+ * @since 1.0.0
+ * @category Connection Types
+ */
+export type MobyConnectionOptions = Data.TaggedEnum<{
+    socket: { readonly socketPath: string; readonly version?: string | undefined };
+    ssh: {
+        readonly remoteSocketPath: string;
+        readonly host: string;
+        readonly version?: string | undefined;
+    } & Exclude<ssh2.ConnectConfig, "host">;
+    http: {
+        readonly host: string;
+        readonly port: number;
+        readonly path?: string | undefined;
+        readonly version?: string | undefined;
+    };
+    https: {
+        readonly host: string;
+        readonly port: number;
+        readonly version?: string | undefined;
+        readonly path?: string | undefined;
+        readonly cert?: string | undefined;
+        readonly ca?: string | undefined;
+        readonly key?: string | undefined;
+        readonly passphrase?: string | undefined;
+    };
+}>;
+
+/**
+ * @since 1.0.0
+ * @category Connection Types
+ */
+export type SocketConnectionOptions = Data.TaggedEnum.Args<MobyConnectionOptions, "socket">;
+
+/**
+ * @since 1.0.0
+ * @category Connection Types
+ */
+export type SocketConnectionOptionsTagged = Data.TaggedEnum.Value<MobyConnectionOptions, "socket">;
+
+/**
+ * @since 1.0.0
+ * @category Connection Types
+ */
+export type HttpConnectionOptions = Data.TaggedEnum.Args<MobyConnectionOptions, "http">;
+
+/**
+ * @since 1.0.0
+ * @category Connection Types
+ */
+export type HttpConnectionOptionsTagged = Data.TaggedEnum.Value<MobyConnectionOptions, "http">;
+
+/**
+ * @since 1.0.0
+ * @category Connection Types
+ */
+export type HttpsConnectionOptions = Data.TaggedEnum.Args<MobyConnectionOptions, "https">;
+
+/**
+ * @since 1.0.0
+ * @category Connection Types
+ */
+export type HttpsConnectionOptionsTagged = Data.TaggedEnum.Value<MobyConnectionOptions, "https">;
+
+/**
+ * @since 1.0.0
+ * @category Connection Types
+ */
+export type SshConnectionOptions = Data.TaggedEnum.Args<MobyConnectionOptions, "ssh">;
+
+/**
+ * @since 1.0.0
+ * @category Connection Types
+ */
+export type SshConnectionOptionsTagged = Data.TaggedEnum.Value<MobyConnectionOptions, "ssh">;
+
+/**
+ * Connection options for how to connect to your moby/docker instance. Can be a
+ * unix socket on the current machine. Can be an ssh connection to a remote
+ * machine with a remote user, remote machine, remote port, and remote socket
+ * path. Can be an http connection to a remote machine with a host, port, and
+ * path. Or it can be an https connection to a remote machine with a host, port,
+ * path, cert, ca, key, and passphrase.
+ *
+ * @since 1.0.0
+ * @category Connection Types
+ */
+export const MobyConnectionOptions = internal.MobyConnectionOptions;
+
+/**
+ * @since 1.0.0
+ * @category Connection Constructors
+ * @example
+ *     import { SocketConnectionOptions } from "the-moby-effect/MobyConnection";
+ *     const connectionOptions = SocketConnectionOptions({
+ *         socketPath: "/var/run/docker.sock",
+ *     });
+ */
+export const SocketConnectionOptions = internal.SocketConnectionOptions;
+
+/**
+ * Connects to a remote machine over ssh. This specific ssh implementation uses
+ * the OpenSSH extension "ForwardOutLocalStream" (so you must being running an
+ * OpenSSH server or something that implements the "ForwardOutLocalStream"
+ * extension) that opens a connection to a UNIX domain socket at socketPath on
+ * the server.
+ *
+ * @since 1.0.0
+ * @category Connection Constructors
+ * @example
+ *     import { SshConnectionOptions } from "the-moby-effect/MobyConnection";
+ *     const connectionOptions = SshConnectionOptions({
+ *         host: "host.domain.com",
+ *         port: 2222,
+ *         username: "user",
+ *         password: "password",
+ *         remoteSocketPath: "/var/run/docker.sock",
+ *     });
+ */
+export const SshConnectionOptions = internal.SshConnectionOptions;
+
+/**
+ * @since 1.0.0
+ * @category Connection Constructors
+ * @example
+ *     import { HttpConnectionOptions } from "the-moby-effect/MobyConnection";
+ *     const connectionOptions = HttpConnectionOptions({
+ *         host: "host.domain.com",
+ *         port: 2375,
+ *         path: "/proxy-path",
+ *     });
+ */
+export const HttpConnectionOptions = internal.HttpConnectionOptions;
+
+/**
+ * @since 1.0.0
+ * @category Connection Constructors
+ * @example
+ *     import { HttpsConnectionOptions } from "the-moby-effect/MobyConnection";
+ *     const connectionOptions = HttpsConnectionOptions({
+ *         host: "host.domain.com",
+ *         port: 2375,
+ *         path: "/proxy-path",
+ *         // passphrase: "password",
+ *         // ca: fs.readFileSync("ca.pem"),
+ *         // key: fs.readFileSync("key.pem"),
+ *         // cert: fs.readFileSync("cert.pem"),
+ *     });
+ */
+export const HttpsConnectionOptions = internal.HttpsConnectionOptions;
+
+/**
+ * From
+ * https://docs.docker.com/engine/reference/commandline/dockerd/#daemon-socket-option
+ *
+ * "The Docker client will honor the DOCKER_HOST environment variable to set the
+ * -H flag for the client"
+ *
+ * And then from
+ * https://docs.docker.com/engine/reference/commandline/dockerd/#bind-docker-to-another-hostport-or-a-unix-socket
+ *
+ * "-H accepts host and port assignment in the following format:
+ * `tcp://[host]:[port][path]` or `unix://path`
+ *
+ * For example:
+ *
+ * - `unix://path/to/socket` -> Unix socket located at path/to/socket
+ * - When -H is empty, it will default to the same value as when no -H was passed
+ *   in
+ * - `http://host:port/path` -> HTTP connection on host:port and prepend path to
+ *   all requests
+ * - `https://host:port/path` -> HTTPS connection on host:port and prepend path to
+ *   all requests
+ * - `ssh://me@example.com:22/var/run/docker.sock` -> SSH connection to
+ *   example.com on port 22
+ *
+ * @since 1.0.0
+ * @category Constructors
+ */
+export const connectionOptionsFromUrl: (
+    dockerHost: string
+) => Effect.Effect<MobyConnectionOptions, ConfigError.ConfigError, never> = internal.connectionOptionsFromUrl;
+
+/**
+ * Creates a MobyApi layer from the DOCKER_HOST environment variable as a url.
+ *
+ * @since 1.0.0
+ * @category Constructors
+ */
+export const connectionOptionsFromDockerHostEnvironmentVariable: Effect.Effect<
+    MobyConnectionOptions,
+    ConfigError.ConfigError,
+    never
+> = internal.connectionOptionsFromDockerHostEnvironmentVariable;
+
+/**
+ * Creates a MobyApi layer from the platform default system socket location.
+ *
+ * @since 1.0.0
+ * @category Constructors
+ */
+export const connectionOptionsFromPlatformSystemSocketDefault: Effect.Effect<
+    MobyConnectionOptions,
+    ConfigError.ConfigError,
+    never
+> = internal.connectionOptionsFromPlatformSystemSocketDefault;
+
+/**
+ * Creates a MobyApi layer from the platform default system socket location.
+ *
+ * @since 1.0.0
+ * @category Constructors
+ */
+export const connectionOptionsFromUserSocketDefault: Effect.Effect<MobyConnectionOptions, never, Path.Path> =
+    internal.connectionOptionsFromUserSocketDefault;

package/src/MobyConvey.ts

@@ -0,0 +1,45 @@
+/**
+ * Convenance utilities for Docker input and output streams.
+ *
+ * @since 1.0.0
+ */
+
+import type * as Chunk from "effect/Chunk";
+import type * as Effect from "effect/Effect";
+import type * as Scope from "effect/Scope";
+import type * as Sink from "effect/Sink";
+import type * as Stream from "effect/Stream";
+import type * as MobySchemas from "./MobySchemas.js";
+
+import * as internal from "./internal/convey/sinks.js";
+
+/**
+ * Waits for the progress stream to complete and returns the result.
+ *
+ * @since 1.0.0
+ * @category Conveyance Sinks
+ */
+export const waitForProgressToComplete: <E1, R1>(
+    stream: Stream.Stream<MobySchemas.JSONMessage, E1, R1>
+) => Effect.Effect<Chunk.Chunk<MobySchemas.JSONMessage>, E1, Exclude<R1, Scope.Scope>> =
+    internal.waitForProgressToComplete;
+
+/**
+ * Consumes the progress stream and logs it to the console.
+ *
+ * @since 1.0.0
+ * @category Conveyance Sinks
+ */
+export const followProgressSink: Sink.Sink<void, MobySchemas.JSONMessage, never, never, never> =
+    internal.followProgressSink;
+
+/**
+ * Tracks the progress stream in the console and returns the result.
+ *
+ * @since 1.0.0
+ * @category Conveyance Sinks
+ */
+export const followProgressInConsole: <E1, R1>(
+    stream: Stream.Stream<MobySchemas.JSONMessage, E1, R1>
+) => Effect.Effect<Chunk.Chunk<MobySchemas.JSONMessage>, E1, Exclude<R1, Scope.Scope>> =
+    internal.followProgressInConsole;