the-moby-effect 1.48.4 → 1.51.0

package/src/internal/engines/docker.ts

@@ -1,18 +1,19 @@
 import type * as Socket from "@effect/platform/Socket";
+import type * as EffectSchemas from "effect-schemas";
 import type * as ParseResult from "effect/ParseResult";
 import type * as Scope from "effect/Scope";
+import type * as DockerEngine from "../../DockerEngine.js";
 import type * as MobySchemas from "../../MobySchemas.js";
+import type * as IdSchemas from "../schemas/id.js";
 
 import * as Array from "effect/Array";
 import * as Channel from "effect/Channel";
 import * as Effect from "effect/Effect";
 import * as Function from "effect/Function";
 import * as Global from "effect/GlobalValue";
-import * as Match from "effect/Match";
 import * as MutableHashMap from "effect/MutableHashMap";
 import * as Option from "effect/Option";
 import * as Predicate from "effect/Predicate";
-import * as Schedule from "effect/Schedule";
 import * as Schema from "effect/Schema";
 import * as Sink from "effect/Sink";
 import * as Stream from "effect/Stream";
@@ -20,39 +21,35 @@ import * as Tuple from "effect/Tuple";
 import * as MobyDemux from "../../MobyDemux.js";
 import * as MobyEndpoints from "../../MobyEndpoints.js";
 
+import * as internalCircular from "../endpoints/circular.js";
+
 /** @internal */
 export const pull = ({
-    auth,
     image,
     platform,
 }: {
     image: string;
-    auth?: string | undefined;
     platform?: string | undefined;
-}): Stream.Stream<MobySchemas.JSONMessage, MobyEndpoints.ImagesError, MobyEndpoints.Images> =>
-    Stream.unwrap(
-        MobyEndpoints.Images.use((images) => images.create({ fromImage: image, "X-Registry-Auth": auth, platform }))
-    );
+}): Stream.Stream<MobySchemas.JSONMessage, DockerEngine.DockerError, MobyEndpoints.Images> =>
+    Stream.unwrap(MobyEndpoints.Images.use((images) => images.create({ fromImage: image, platform })));
 
 /** @internal */
 export const pullScoped = ({
-    auth,
     image,
     platform,
 }: {
     image: string;
-    auth?: string | undefined;
     platform?: string | undefined;
 }): Effect.Effect<
-    Stream.Stream<MobySchemas.JSONMessage, MobyEndpoints.ImagesError, never>,
+    Stream.Stream<MobySchemas.JSONMessage, DockerEngine.DockerError, never>,
     never,
     MobyEndpoints.Images | Scope.Scope
 > =>
     Effect.Do.pipe(
         Effect.bind("images", () => MobyEndpoints.Images),
-        Effect.let("stream", () => pull({ image, auth, platform })),
+        Effect.let("stream", () => pull({ image, platform })),
         Effect.let("acquire", ({ images, stream }) => Stream.provideService(stream, MobyEndpoints.Images, images)),
-        Effect.let("release", ({ images }) => images.delete({ name: image })),
+        Effect.let("release", ({ images }) => images.delete(image)),
         Effect.flatMap(({ acquire, release }) =>
             Effect.acquireRelease(
                 Effect.sync(() => acquire),
@@ -63,51 +60,45 @@ export const pullScoped = ({
 
 /** @internal */
 export const build = <E1>({
-    auth,
-    buildArgs,
+    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<MobySchemas.JSONMessage, MobyEndpoints.ImagesError, MobyEndpoints.Images> =>
+    buildargs?: Record<string, string | undefined> | undefined;
+}): Stream.Stream<MobySchemas.JSONMessage, DockerEngine.DockerError, MobyEndpoints.Images> =>
     Stream.unwrap(
-        MobyEndpoints.Images.use((images) =>
-            images.build({ context, buildArgs, dockerfile, platform, t: tag, "X-Registry-Config": auth })
-        )
+        MobyEndpoints.Images.use((images) => images.build(context, { buildargs, dockerfile, platform, t: tag }))
     );
 
 /** @internal */
 export const buildScoped = <E1>({
-    auth,
-    buildArgs,
+    buildargs,
     context,
     dockerfile,
     platform,
     tag,
 }: {
     tag: string;
-    auth?: string | undefined;
     platform?: string | undefined;
     dockerfile?: string | undefined;
-    buildArgs?: Record<string, string | undefined> | undefined;
+    buildargs?: Record<string, string | undefined> | undefined;
     context: Stream.Stream<Uint8Array, E1, never>;
 }): Effect.Effect<
-    Stream.Stream<MobySchemas.JSONMessage, MobyEndpoints.ImagesError, never>,
+    Stream.Stream<MobySchemas.JSONMessage, DockerEngine.DockerError, never>,
     never,
     Scope.Scope | MobyEndpoints.Images
 > =>
     Effect.Do.pipe(
         Effect.bind("images", () => MobyEndpoints.Images),
-        Effect.let("stream", () => build({ tag, buildArgs, auth, context, platform, dockerfile })),
+        Effect.let("stream", () => build({ tag, buildargs, context, platform, dockerfile })),
         Effect.let("acquire", ({ images, stream }) => Stream.provideService(stream, MobyEndpoints.Images, images)),
-        Effect.let("release", ({ images }) => images.delete({ name: tag })),
+        Effect.let("release", ({ images }) => images.delete(tag)),
         Effect.flatMap(({ acquire, release }) =>
             Effect.acquireRelease(
                 Effect.sync(() => acquire),
@@ -118,118 +109,71 @@ export const buildScoped = <E1>({
 
 /** @internal */
 export const start = (
-    containerId: string
-): Effect.Effect<void, MobyEndpoints.ContainersError, MobyEndpoints.Containers> =>
+    containerId: IdSchemas.ContainerIdentifier
+): Effect.Effect<void, DockerEngine.DockerError, MobyEndpoints.Containers> =>
     MobyEndpoints.Containers.use((containers) => containers.start(containerId));
 
 /** @internal */
 export const stop = (
-    containerId: string
-): Effect.Effect<void, MobyEndpoints.ContainersError, MobyEndpoints.Containers> =>
+    containerId: IdSchemas.ContainerIdentifier
+): Effect.Effect<void, DockerEngine.DockerError, MobyEndpoints.Containers> =>
     MobyEndpoints.Containers.use((containers) => containers.stop(containerId));
 
 /** @internal */
 export const run = (
-    containerOptions: Parameters<MobyEndpoints.Containers["create"]>[0]
-): Effect.Effect<MobySchemas.ContainerInspectResponse, MobyEndpoints.ContainersError, MobyEndpoints.Containers> =>
+    options: Omit<ConstructorParameters<typeof MobySchemas.ContainerCreateRequest>[0], "HostConfig"> & {
+        readonly name?: string | undefined;
+        readonly platform?: string | undefined;
+        readonly HostConfig?: ConstructorParameters<typeof MobySchemas.ContainerHostConfig>[0] | undefined;
+    }
+): Effect.Effect<MobySchemas.ContainerInspectResponse, DockerEngine.DockerError, MobyEndpoints.Containers> =>
     Effect.gen(function* () {
         const containers = yield* MobyEndpoints.Containers;
-        const containerCreateResponse = yield* containers.create(containerOptions);
-        yield* containers.start(containerCreateResponse.Id);
-
-        // Helper to wait until a container is dead or running
-        const waitUntilContainerDeadOrRunning = Function.pipe(
-            containers.inspect(containerCreateResponse.Id),
-            // Effect.tap(({ State }) => Effect.log(`Waiting for container to be running, state=${State?.Status}`)),
-            Effect.flatMap(({ State }) =>
-                Function.pipe(
-                    Match.value(State?.Status),
-                    Match.when("running", (_s) => Effect.void),
-                    Match.when("created", (_s) => Effect.fail("Waiting")),
-                    // Match.when(Schemas.ContainerState_Status.RUNNING, (_s) => Effect.void),
-                    // Match.when(Schemas.ContainerState_Status.CREATED, (_s) => Effect.fail("Waiting")),
-                    Match.orElse((_s) => Effect.fail("Container is dead or killed"))
-                ).pipe(
-                    Effect.mapError(
-                        (s) => new MobyEndpoints.ContainersError({ method: "inspect", cause: new Error(s) })
-                    )
-                )
-            )
-        ).pipe(
-            Effect.retry(
-                Schedule.spaced(500).pipe(
-                    Schedule.whileInput(({ message }: MobyEndpoints.ContainersError) => message === "Waiting")
-                )
-            )
-        );
-
-        // Helper for if the container has a healthcheck, wait for it to report healthy
-        const waitUntilContainerHealthy = Function.pipe(
-            containers.inspect(containerCreateResponse.Id),
-            // Effect.tap(({ State }) =>
-            //     Effect.log(`Waiting for container to be healthy, health=${State?.Health?.Status}`)
-            // ),
-            Effect.flatMap(({ State }) =>
-                Function.pipe(
-                    Match.value(State?.Health?.Status),
-                    Match.when(undefined, (_s) => Effect.void),
-                    Match.when("healthy", (_s) => Effect.void),
-                    Match.when("starting", (_s) => Effect.fail("Waiting")),
-                    // Match.when(Schemas.Health_Status.HEALTHY, (_s) => Effect.void),
-                    // Match.when(Schemas.Health_Status.STARTING, (_s) => Effect.fail("Waiting")),
-                    Match.orElse((_s) => Effect.fail("Container is unhealthy"))
-                ).pipe(
-                    Effect.mapError(
-                        (s) => new MobyEndpoints.ContainersError({ method: "inspect", cause: new Error(s) })
-                    )
-                )
-            )
-        ).pipe(
-            Effect.retry(
-                Schedule.spaced(500).pipe(
-                    Schedule.whileInput(({ message }: MobyEndpoints.ContainersError) => message === "Waiting")
-                )
-            )
-        );
-
-        yield* waitUntilContainerDeadOrRunning;
-        yield* waitUntilContainerHealthy;
-        return yield* containers.inspect(containerCreateResponse.Id);
+        const { Id: containerId } = yield* containers.create(options);
+        yield* containers.start(containerId);
+        const inspect = yield* containers.inspect(containerId);
+        return inspect;
     });
 
 /** @internal */
 export const runScoped = (
-    containerOptions: Parameters<MobyEndpoints.Containers["create"]>[0]
+    options: Omit<ConstructorParameters<typeof MobySchemas.ContainerCreateRequest>[0], "HostConfig"> & {
+        readonly name?: string | undefined;
+        readonly platform?: string | undefined;
+        readonly HostConfig?: ConstructorParameters<typeof MobySchemas.ContainerHostConfig>[0] | undefined;
+    }
 ): Effect.Effect<
     MobySchemas.ContainerInspectResponse,
-    MobyEndpoints.ContainersError,
+    DockerEngine.DockerError,
     Scope.Scope | MobyEndpoints.Containers
 > => {
-    const acquire = run(containerOptions);
-    const release = (containerData: MobySchemas.ContainerInspectResponse) =>
-        Effect.orDie(
-            Effect.gen(function* () {
-                const containers = yield* MobyEndpoints.Containers;
-                // FIXME: this cleanup should be better
-                yield* Effect.catchTag(containers.stop(containerData.Id), "ContainersError", () => Effect.void);
-                yield* containers.delete(containerData.Id, { force: true });
-            })
+    const acquire = Effect.map(
+        MobyEndpoints.Containers.use((containers) => containers.create(options)),
+        ({ Id }) => Id
+    );
+    const release = (containerId: IdSchemas.ContainerIdentifier) =>
+        Effect.orDie(MobyEndpoints.Containers.use((containers) => containers.delete(containerId, { force: true })));
+    return Effect.acquireRelease(acquire, release)
+        .pipe(Effect.tap((containerId) => start(containerId)))
+        .pipe(
+            Effect.flatMap((containerId) =>
+                MobyEndpoints.Containers.use((containers) => containers.inspect(containerId))
+            )
         );
-    return Effect.acquireRelease(acquire, release);
 };
 
 /** @internal */
-export const execNonBlocking = <T extends boolean | undefined = undefined>({
+export const execNonBlocking = <const T extends boolean = false>({
     command,
     containerId,
     detach,
 }: {
-    detach?: T;
-    containerId: string;
+    detach: T;
+    containerId: IdSchemas.ContainerIdentifier;
     command: string | Array<string>;
 }): Effect.Effect<
-    [socket: T extends true ? void : MobyDemux.RawSocket | MobyDemux.MultiplexedSocket, execId: string],
-    MobyEndpoints.ExecsError,
+    [[T] extends [false] ? MobyDemux.RawSocket | MobyDemux.MultiplexedSocket : void, IdSchemas.ExecIdentifier],
+    DockerEngine.DockerError,
     MobyEndpoints.Execs
 > =>
     Effect.gen(function* () {
@@ -241,7 +185,7 @@ export const execNonBlocking = <T extends boolean | undefined = undefined>({
             Cmd: Predicate.isString(command) ? command.split(" ") : command,
         });
 
-        const socket = yield* execs.start<T>(execId.Id, { Detach: detach as T });
+        const socket = yield* execs.start(execId.Id, { Detach: detach, Tty: false });
         return Tuple.make(socket, execId.Id);
     });
 
@@ -250,22 +194,19 @@ export const exec = ({
     command,
     containerId,
 }: {
-    containerId: string;
+    containerId: IdSchemas.ContainerIdentifier;
     command: string | Array<string>;
 }): Effect.Effect<
-    readonly [exitCode: number, output: string],
-    MobyEndpoints.ExecsError | Socket.SocketError | ParseResult.ParseError,
+    [exitCode: Schema.Schema.Type<EffectSchemas.Number.I64>, output: string],
+    DockerEngine.DockerError | ParseResult.ParseError | Socket.SocketError,
     MobyEndpoints.Execs
 > =>
     Effect.gen(function* () {
         const [socket, execId] = yield* execNonBlocking({ command, containerId, detach: false });
         const output = yield* MobyDemux.demuxToSingleSink(socket, Stream.never, Sink.mkString);
         const execInspectResponse = yield* MobyEndpoints.Execs.use((execs) => execs.inspect(execId));
-        if (execInspectResponse.Running === true) {
-            return yield* new MobyEndpoints.ExecsError({ method: "exec", cause: new Error("Exec is still running") });
-        } else {
-            return Tuple.make(execInspectResponse.ExitCode, output);
-        }
+        if (execInspectResponse.Running === true) return yield* Effect.dieMessage("Exec is still running");
+        else return Tuple.make(execInspectResponse.ExitCode, output);
     });
 
 /** @internal */
@@ -277,11 +218,13 @@ const execWebsocketsRegistry = Global.globalValue("the-moby-effect/engines/docke
 export const execWebsocketsNonBlocking = ({
     command,
     containerId,
+    cwd,
 }: {
     command: string | Array<string>;
-    containerId: string;
+    cwd?: string | undefined;
+    containerId: IdSchemas.ContainerIdentifier;
 }): Effect.Effect<
-    MobyDemux.MultiplexedChannel<never, Socket.SocketError | MobyEndpoints.ContainersError, never>,
+    MobyDemux.MultiplexedChannel<never, DockerEngine.DockerError | Socket.SocketError, never>,
     never,
     MobyEndpoints.Containers
 > =>
@@ -298,27 +241,47 @@ export const execWebsocketsNonBlocking = ({
 
         const acquire = Effect.gen(function* () {
             const inspect = yield* containers.inspect(containerId);
-            const command = Array.join(inspect.Config?.Cmd ?? [], " ");
-            yield* Effect.mapError(
-                Schema.decodeUnknown(
-                    Schema.Literal(
-                        "/bin/sh", // Basic shell available in most containers
-                        "/bin/bash", // Bash shell (common in many Linux distributions)
-                        "/usr/bin/bash", // Alternative location for bash
-                        "/bin/dash", // Debian Almquist shell (lightweight shell)
-                        "/bin/ash", // Lightweight shell used in Alpine Linux
-                        "/bin/zsh", // Z shell
-                        "/usr/bin/zsh", // Alternative location for zsh
-                        "/bin/ksh", // Korn shell
-                        "/bin/tcsh", // TENEX C shell
-                        "/bin/csh", // C shell
-                        "/usr/bin/fish", // Friendly interactive shell
-                        "/usr/local/bin/bash", // Alternative location for bash
-                        "/usr/local/bin/sh", // Alternative location for sh
-                        "/busybox/sh" // Busybox shell
-                    )
-                )(command),
-                (cause) => new MobyEndpoints.ContainersError({ method: "exec", cause })
+            const command = inspect.Config?.Cmd;
+            const entrypoint = Option.fromNullable(inspect.Config?.Entrypoint)
+                .pipe(Option.flatMap(Array.head))
+                .pipe(Option.getOrUndefined);
+
+            yield* Schema.decodeUnknown(Schema.Union(Schema.Undefined, Schema.Null))(command).pipe(
+                Effect.mapError(
+                    (cause) =>
+                        new internalCircular.DockerError({
+                            module: "containers",
+                            method: "execWebsocketsNonBlocking",
+                            cause,
+                        })
+                )
+            );
+            yield* Schema.decodeUnknown(
+                Schema.Literal(
+                    "/bin/sh", // Basic shell available in most containers
+                    "/bin/bash", // Bash shell (common in many Linux distributions)
+                    "/usr/bin/bash", // Alternative location for bash
+                    "/bin/dash", // Debian Almquist shell (lightweight shell)
+                    "/bin/ash", // Lightweight shell used in Alpine Linux
+                    "/bin/zsh", // Z shell
+                    "/usr/bin/zsh", // Alternative location for zsh
+                    "/bin/ksh", // Korn shell
+                    "/bin/tcsh", // TENEX C shell
+                    "/bin/csh", // C shell
+                    "/usr/bin/fish", // Friendly interactive shell
+                    "/usr/local/bin/bash", // Alternative location for bash
+                    "/usr/local/bin/sh", // Alternative location for sh
+                    "/busybox/sh" // Busybox shell
+                )
+            )(entrypoint).pipe(
+                Effect.mapError(
+                    (cause) =>
+                        new internalCircular.DockerError({
+                            module: "containers",
+                            method: "execWebsocketsNonBlocking",
+                            cause,
+                        })
+                )
             );
             yield* mutex.take(1);
         });
@@ -332,7 +295,8 @@ export const execWebsocketsNonBlocking = ({
 
         const use = Effect.gen(function* () {
             const cmd = Predicate.isString(command) ? command : Array.join(command, " ");
-            const input = Stream.succeed(`${cmd}; exit\n`);
+            const cwdCommand = Predicate.isUndefined(cwd) ? cmd : `cd ${cwd} && ${cmd}`;
+            const input = Stream.succeed(`${cwdCommand}; exit\n`);
             const stdinSocket = yield* containers.attachWebsocket(containerId, { stdin: true, stream: true });
             const stdoutSocket = yield* containers.attachWebsocket(containerId, { stdout: true, stream: true });
             const stderrSocket = yield* containers.attachWebsocket(containerId, { stderr: true, stream: true });
@@ -358,10 +322,10 @@ export const execWebsockets = ({
     containerId,
 }: {
     command: string | Array<string>;
-    containerId: string;
+    containerId: IdSchemas.ContainerIdentifier;
 }): Effect.Effect<
     readonly [stdout: string, stderr: string],
-    MobyEndpoints.ContainersError | Socket.SocketError | ParseResult.ParseError,
+    DockerEngine.DockerError | ParseResult.ParseError | Socket.SocketError,
     MobyEndpoints.Containers
 > =>
     Function.pipe(
@@ -372,50 +336,42 @@ export const execWebsockets = ({
 /** @internal */
 export const ps = (
     options?: Parameters<MobyEndpoints.Containers["list"]>[0]
-): Effect.Effect<
-    ReadonlyArray<MobySchemas.ContainerListResponseItem>,
-    MobyEndpoints.ContainersError,
-    MobyEndpoints.Containers
-> => MobyEndpoints.Containers.use((containers) => containers.list(options));
+): Effect.Effect<ReadonlyArray<MobySchemas.ContainerSummary>, DockerEngine.DockerError, MobyEndpoints.Containers> =>
+    MobyEndpoints.Containers.use((containers) => containers.list(options));
 
 /** @internal */
 export const push = (
-    options: Parameters<MobyEndpoints.Images["push"]>[0]
-): Stream.Stream<string, MobyEndpoints.ImagesError, MobyEndpoints.Images> =>
-    Stream.unwrap(MobyEndpoints.Images.use((images) => images.push(options)));
+    name: string,
+    options?: Parameters<MobyEndpoints.Images["push"]>[1]
+): Stream.Stream<MobySchemas.JSONMessage, DockerEngine.DockerError, MobyEndpoints.Images> =>
+    Stream.unwrap(MobyEndpoints.Images.use((images) => images.push(name, options)));
 
 /** @internal */
 export const images = (
     options?: Parameters<MobyEndpoints.Images["list"]>[0]
-): Effect.Effect<ReadonlyArray<MobySchemas.ImageSummary>, MobyEndpoints.ImagesError, MobyEndpoints.Images> =>
+): Effect.Effect<ReadonlyArray<MobySchemas.ImageSummary>, DockerEngine.DockerError, MobyEndpoints.Images> =>
     MobyEndpoints.Images.use((images) => images.list(options));
 
 /** @internal */
 export const search = (
     options: Parameters<MobyEndpoints.Images["search"]>[0]
-): Effect.Effect<ReadonlyArray<MobySchemas.RegistrySearchResponse>, MobyEndpoints.ImagesError, MobyEndpoints.Images> =>
+): Effect.Effect<ReadonlyArray<MobySchemas.RegistrySearchResult>, DockerEngine.DockerError, MobyEndpoints.Images> =>
     MobyEndpoints.Images.use((images) => images.search(options));
 
 /** @internal */
-export const version: () => Effect.Effect<
-    Readonly<MobySchemas.SystemVersionResponse>,
-    MobyEndpoints.SystemsError,
-    MobyEndpoints.Systems
-> = Function.constant(MobyEndpoints.Systems.use((systems) => systems.version()));
+export const version: () => Effect.Effect<MobySchemas.TypesVersion, DockerEngine.DockerError, MobyEndpoints.System> =
+    Function.constant(MobyEndpoints.System.use((systems) => systems.version()));
 
 /** @internal */
-export const info: () => Effect.Effect<
-    Readonly<MobySchemas.SystemInfoResponse>,
-    MobyEndpoints.SystemsError,
-    MobyEndpoints.Systems
-> = Function.constant(MobyEndpoints.Systems.use((systems) => systems.info()));
+export const info: () => Effect.Effect<MobySchemas.SystemInfo, DockerEngine.DockerError, MobyEndpoints.System> =
+    Function.constant(MobyEndpoints.System.use((systems) => systems.info()));
 
 /** @internal */
-export const ping: () => Effect.Effect<"OK", MobyEndpoints.SystemsError, MobyEndpoints.Systems> = Function.constant(
-    MobyEndpoints.Systems.use((systems) => systems.ping())
+export const ping: () => Effect.Effect<void, DockerEngine.DockerError, MobyEndpoints.System> = Function.constant(
+    MobyEndpoints.System.use((systems) => systems.ping())
 );
 
 /** @internal */
-export const pingHead: () => Effect.Effect<void, MobyEndpoints.SystemsError, MobyEndpoints.Systems> = Function.constant(
-    MobyEndpoints.Systems.use((systems) => systems.ping())
+export const pingHead: () => Effect.Effect<void, DockerEngine.DockerError, MobyEndpoints.System> = Function.constant(
+    MobyEndpoints.System.use((systems) => systems.ping())
 );