the-moby-effect 1.48.3 → 1.51.0

package/src/internal/engines/dockerCompose.ts

@@ -1,6 +1,7 @@
 import type * as ParseResult from "effect/ParseResult";
 import type * as Scope from "effect/Scope";
 import type * as DockerComposeEngine from "../../DockerComposeEngine.js";
+import type * as IdSchemas from "../schemas/id.js";
 
 import * as PlatformError from "@effect/platform/Error";
 import * as Socket from "@effect/platform/Socket";
@@ -9,8 +10,11 @@ import * as Context from "effect/Context";
 import * as Effect from "effect/Effect";
 import * as Function from "effect/Function";
 import * as Layer from "effect/Layer";
+import * as Number from "effect/Number";
+import * as Option from "effect/Option";
 import * as Predicate from "effect/Predicate";
 import * as Record from "effect/Record";
+import * as Schema from "effect/Schema";
 import * as Sink from "effect/Sink";
 import * as Stream from "effect/Stream";
 import * as String from "effect/String";
@@ -19,6 +23,183 @@ import * as DockerEngine from "../../DockerEngine.js";
 import * as MobyDemux from "../../MobyDemux.js";
 import * as MobyEndpoints from "../../MobyEndpoints.js";
 
+/** @internal */
+const makeTempDirScoped = (
+    containerId: IdSchemas.ContainerIdentifier
+): Effect.Effect<string, DockerComposeError, MobyEndpoints.Containers | Scope.Scope> =>
+    Effect.acquireRelease(
+        Effect.gen(function* () {
+            const [stderr, stdout] = yield* Effect.mapError(
+                DockerEngine.execWebsockets({
+                    containerId,
+                    command: "mktemp -d",
+                }),
+                (cause) =>
+                    new DockerComposeError({
+                        cause,
+                        method: "makeTempDirScoped",
+                    })
+            );
+
+            if (String.isNonEmpty(stderr)) {
+                throw new DockerComposeError({
+                    cause: stderr,
+                    method: "makeTempDirScoped",
+                });
+            }
+
+            class schema extends Schema.startsWith<typeof Schema.String>("/tmp/")(Schema.String) {}
+            const tempDir = yield* Effect.mapError(
+                Schema.decode(schema)(stdout),
+                (cause) =>
+                    new DockerComposeError({
+                        cause,
+                        method: "makeTempDirScoped",
+                    })
+            );
+
+            yield* Effect.annotateCurrentSpan("tempDir", tempDir);
+            return tempDir;
+        }),
+        (tempDir) =>
+            Effect.orDieWith(
+                DockerEngine.execWebsockets({
+                    containerId,
+                    command: `rm -rf ${tempDir}`,
+                }),
+                (cause) =>
+                    new DockerComposeError({
+                        cause,
+                        method: "makeTempDirScoped",
+                    })
+            )
+    );
+
+/** @internal */
+const uploadProject = Function.dual<
+    <E1, R1>(
+        project: Stream.Stream<Uint8Array, E1, R1>
+    ) => (
+        containerId: IdSchemas.ContainerIdentifier
+    ) => Effect.Effect<string, E1 | DockerComposeError, R1 | MobyEndpoints.Containers | Scope.Scope>,
+    <E1, R1>(
+        containerId: IdSchemas.ContainerIdentifier,
+        project: Stream.Stream<Uint8Array, E1, R1>
+    ) => Effect.Effect<string, E1 | DockerComposeError, R1 | MobyEndpoints.Containers | Scope.Scope>
+>(
+    2,
+    <E1, R1>(
+        containerId: IdSchemas.ContainerIdentifier,
+        project: Stream.Stream<Uint8Array, E1, R1>
+    ): Effect.Effect<string, E1 | DockerComposeError, R1 | MobyEndpoints.Containers | Scope.Scope> =>
+        Effect.gen(function* () {
+            const containers = yield* MobyEndpoints.Containers;
+            const projectUploadDir = yield* makeTempDirScoped(containerId);
+            yield* Effect.annotateCurrentSpan("projectUploadDir", projectUploadDir);
+            yield* containers.putArchive(containerId, project, { path: projectUploadDir });
+            return projectUploadDir;
+        }).pipe(
+            Effect.catchTag(
+                "DockerError",
+                (cause) =>
+                    new DockerComposeError({
+                        cause,
+                        method: "uploadProject",
+                    })
+            )
+        )
+);
+
+/** @internal */
+const camelToKebab = Function.compose(String.camelToSnake, String.snakeToKebab);
+
+/** @internal */
+const stringifyOptions = (
+    options: Record<
+        string,
+        | string
+        | number
+        | boolean
+        | undefined
+        | Array<string | number | boolean>
+        | Record<string, string | number | boolean>
+    >
+): string =>
+    Function.pipe(
+        options,
+        Record.toEntries,
+        Array.filter(Function.flow(Tuple.getSecond, Predicate.isNotUndefined)),
+        Array.flatMap(([key, value]): Array<readonly [string, string | number | boolean]> => {
+            if (Predicate.isString(value) || Predicate.isNumber(value) || Predicate.isBoolean(value)) {
+                return [Tuple.make(key, value)];
+            } else if (Array.isArray(value)) {
+                return Array.map(value, (v) => [key, v]);
+            } else if (Predicate.isRecord(value)) {
+                return Record.toEntries(value);
+            } else {
+                return Function.absurd(value as never);
+            }
+        }),
+        Array.map(([key, value]) => `--${camelToKebab(key)}=${value}`),
+        Array.join(" ")
+    );
+
+/** @internal */
+const runCommand = (
+    containerId: IdSchemas.ContainerIdentifier,
+    projectPath: string,
+    method: string,
+    services: ReadonlyArray<string> | undefined = [],
+    options:
+        | Record<
+              string,
+              | string
+              | number
+              | boolean
+              | undefined
+              | Array<string | number | boolean>
+              | Record<string, string | number | boolean>
+          >
+        | undefined = {}
+): Stream.Stream<Uint8Array, DockerComposeError, MobyEndpoints.Containers> =>
+    Effect.gen(function* () {
+        const multiplexed = yield* DockerEngine.execWebsocketsNonBlocking({
+            containerId,
+            cwd: projectPath,
+            command: `COMPOSE_STATUS_STDOUT=1 docker compose ${method} ${stringifyOptions(options)} ${Array.join(services, " ")}`,
+        });
+
+        const { stderr, stdin, stdout } = yield* MobyDemux.fan(multiplexed, { requestedCapacity: 16 });
+
+        const streamFailableEnsuring = <A, X, E1, E2, R1, R2>(
+            stream: Stream.Stream<A, E1, R1>,
+            effect: Effect.Effect<X, E2, R2>
+        ): Stream.Stream<A, E1 | E2, R1 | R2> =>
+            Stream.flatMap(stream, (a: A) => Stream.fromEffect(Effect.map(effect, Function.constant(a))));
+
+        return streamFailableEnsuring(
+            MobyDemux.mergeRawToTaggedStream(stdout, stderr),
+            MobyDemux.demuxRawToSingleSink(stdin, Stream.make(new Socket.CloseEvent()), Sink.drain)
+        );
+    }).pipe(
+        Stream.unwrap,
+        Stream.mapEffect((entry) => {
+            if (Predicate.isTagged(entry, "stdout")) {
+                return Effect.succeed(entry.value);
+            } else {
+                const decoded = new TextDecoder("utf-8").decode(entry.value);
+                return Effect.fail(new DockerComposeError({ method, cause: decoded }));
+            }
+        }),
+        Stream.mapError(
+            (cause) =>
+                new DockerComposeError({
+                    cause,
+                    method,
+                })
+        )
+    );
+
 /** @internal */
 export const DockerComposeErrorTypeId: DockerComposeEngine.DockerComposeErrorTypeId = Symbol.for(
     "@the-moby-effect/engines/DockerCompose/DockerComposeError"
@@ -41,10 +222,10 @@ export const isDockerComposeError = (u: unknown): u is DockerComposeError =>
 /** @internal */
 export class DockerComposeError extends PlatformError.TypeIdError(DockerComposeErrorTypeId, "DockerComposeError")<{
     method: string;
-    cause: ParseResult.ParseError | Socket.SocketError | MobyEndpoints.ExecsError | unknown;
+    cause: ParseResult.ParseError | Socket.SocketError | DockerEngine.DockerError | unknown;
 }> {
-    get message() {
-        return `${this.method}`;
+    public override get message() {
+        return `${String.capitalize(this.method)}`;
     }
 }
 
@@ -53,620 +234,535 @@ export const DockerCompose: Context.Tag<DockerComposeEngine.DockerCompose, Docke
     Context.GenericTag<DockerComposeEngine.DockerCompose>("@the-moby-effect/engines/DockerCompose");
 
 /** @internal */
-export const make: Effect.Effect<
+export const make: (options?: {
+    dockerEngineSocket?: string | undefined;
+}) => Effect.Effect<
     DockerComposeEngine.DockerCompose,
-    MobyEndpoints.SystemsError | MobyEndpoints.ContainersError,
-    MobyEndpoints.Containers | MobyEndpoints.Systems | Scope.Scope
-> = Effect.gen(function* () {
+    DockerEngine.DockerError,
+    MobyEndpoints.Containers | MobyEndpoints.System | MobyEndpoints.Images | Scope.Scope
+> = Effect.fnUntraced(function* (options) {
     const containers = yield* MobyEndpoints.Containers;
+    const runCommandHelper = Function.flow(runCommand, Stream.provideService(MobyEndpoints.Containers, containers));
     yield* DockerEngine.pingHead();
 
-    const dindContainerId = yield* DockerEngine.runScoped({
-        spec: {
-            Image: "docker.io/library/docker:latest",
-            Entrypoint: ["/bin/sh"],
-            Tty: false,
-            OpenStdin: true,
-            AttachStdin: true,
-            AttachStdout: true,
-            AttachStderr: true,
-            HostConfig: {
-                Privileged: true,
-                Binds: ["/var/run/docker.sock:/var/run/docker.sock"],
-            },
-        },
-    }).pipe(Effect.map(({ Id }) => Id));
-
-    // Helper to upload the project to the dind
-    const uploadProject = <E1>(
-        project: Stream.Stream<Uint8Array, E1, never>
-    ): Effect.Effect<void, E1 | DockerComposeError, never> =>
-        Effect.catchTag(
-            containers.putArchive(dindContainerId, { path: "/", stream: project }),
-            "ContainersError",
-            (cause) => new DockerComposeError({ method: "uploadProject", cause })
-        );
-
-    // Convert a string from camelCase to kebab-case
-    const camelToKebab = Function.compose(String.camelToSnake, String.snakeToKebab);
-
-    // Stringify options for a command
-    const stringifyOptions = (
-        options: Record<
-            string,
-            | string
-            | number
-            | boolean
-            | undefined
-            | Array<string | number | boolean>
-            | Record<string, string | number | boolean>
-        >
-    ): string =>
-        Function.pipe(
-            options,
-            Record.toEntries,
-            Array.filter(Function.flow(Tuple.getSecond, Predicate.isNotUndefined)),
-            Array.flatMap(([key, value]): Array<readonly [string, string | number | boolean]> => {
-                if (Predicate.isString(value) || Predicate.isNumber(value) || Predicate.isBoolean(value)) {
-                    return [Tuple.make(key, value)];
-                } else if (Array.isArray(value)) {
-                    return Array.map(value, (v) => [key, v]);
-                } else if (Predicate.isRecord(value)) {
-                    return Record.toEntries(value);
-                } else {
-                    return Function.absurd(value as never);
-                }
-            }),
-            Array.map(([key, value]) => `--${camelToKebab(key)}=${value}`),
-            Array.join(" ")
-        );
-
-    // Helper to run a command in the dind
-    const runCommand = (
-        method: string,
-        services: ReadonlyArray<string> | undefined = [],
-        options:
-            | Record<
-                  string,
-                  | string
-                  | number
-                  | boolean
-                  | undefined
-                  | Array<string | number | boolean>
-                  | Record<string, string | number | boolean>
-              >
-            | undefined = {}
-    ): Stream.Stream<Uint8Array, DockerComposeError, never> =>
-        Effect.gen(function* () {
-            const multiplexed = yield* DockerEngine.execWebsocketsNonBlocking({
-                containerId: dindContainerId,
-                command: `COMPOSE_STATUS_STDOUT=1 docker compose ${method} ${stringifyOptions(options)} ${Array.join(services, " ")}`,
-            });
-
-            const { stderr, stdin, stdout } = yield* MobyDemux.fan(multiplexed, { requestedCapacity: 16 });
-
-            const streamFailableEnsuring = <A, X, E1, E2, R1, R2>(
-                stream: Stream.Stream<A, E1, R1>,
-                effect: Effect.Effect<X, E2, R2>
-            ): Stream.Stream<A, E1 | E2, R1 | R2> =>
-                Stream.flatMap(stream, (a: A) => Stream.fromEffect(Effect.map(effect, Function.constant(a))));
-
-            return streamFailableEnsuring(
-                MobyDemux.mergeRawToTaggedStream(stdout, stderr),
-                MobyDemux.demuxRawToSingleSink(stdin, Stream.make(new Socket.CloseEvent()), Sink.drain)
-            );
-        }).pipe(
-            Stream.unwrap,
-            Stream.mapEffect((entry) => {
-                if (Predicate.isTagged(entry, "stdout")) {
-                    return Effect.succeed(entry.value);
-                } else {
-                    const decoded = new TextDecoder("utf-8").decode(entry.value);
-                    return Effect.fail(new DockerComposeError({ method, cause: decoded }));
-                }
-            }),
-            Stream.mapError((cause) => new DockerComposeError({ method, cause })),
-            Stream.provideService(MobyEndpoints.Containers, containers)
-        );
-
-    // Actual compose implementation
-    return DockerCompose.of({
-        [TypeId]: TypeId,
-
-        build: <E1>(
-            project: Stream.Stream<Uint8Array, E1, never>,
+    const build =
+        (dindContainerId: IdSchemas.ContainerIdentifier, projectPath: string) =>
+        (
             services?: Array<string> | undefined,
             options?: DockerComposeEngine.BuildOptions | undefined
-        ): Stream.Stream<string, E1 | DockerComposeError, never> =>
+        ): Stream.Stream<string, DockerComposeError, never> =>
             Function.pipe(
-                uploadProject(project),
-                Effect.map(() => runCommand("build", services, { ...options })),
-                Stream.unwrap,
+                runCommandHelper(dindContainerId, projectPath, "build", services, { ...options }),
                 Stream.decodeText(),
                 Stream.splitLines
-            ),
+            );
 
-        config: <E1>(
-            project: Stream.Stream<Uint8Array, E1, never>,
+    const config =
+        (dindContainerId: IdSchemas.ContainerIdentifier, projectPath: string) =>
+        (
             services?: Array<string> | undefined,
             options?: DockerComposeEngine.ConfigOptions | undefined
-        ): Effect.Effect<string, E1 | DockerComposeError, never> =>
+        ): Effect.Effect<string, DockerComposeError, never> =>
             Function.pipe(
-                uploadProject(project),
-                Effect.map(() => runCommand("config", services, { ...options })),
-                Stream.unwrap,
+                runCommandHelper(dindContainerId, projectPath, "config", services, { ...options }),
                 Stream.decodeText(),
                 Stream.splitLines,
                 Stream.run(Sink.mkString)
-            ),
-
-        // cp: <E1>(
-        //     project: Stream.Stream<Uint8Array, E1, never>,
-        //     service: string,
-        //     srcPath: string,
-        //     destPath: string,
-        //     options?: DockerComposeEngine.CopyOptions | undefined
-        // ): Stream.Stream<Uint8Array, E1 | DockerComposeError, never> => {},
-
-        create: <E1>(
-            project: Stream.Stream<Uint8Array, E1, never>,
+            );
+
+    const cpTo =
+        (dindContainerId: IdSchemas.ContainerIdentifier, projectPath: string) =>
+        <E1, R1>(
+            service: string,
+            localSrc: Stream.Stream<Uint8Array, E1, R1>,
+            remoteDestLocation: string,
+            options?: DockerComposeEngine.CopyOptions | undefined
+        ): Effect.Effect<void, E1 | DockerComposeError, R1> =>
+            Effect.gen(function* () {
+                const remoteTransferDir = yield* Effect.provideService(
+                    makeTempDirScoped(dindContainerId),
+                    MobyEndpoints.Containers,
+                    containers
+                );
+                yield* Effect.mapError(
+                    containers.putArchive(dindContainerId, localSrc, { path: remoteTransferDir }),
+                    (cause) => new DockerComposeError({ method: "cpTo", cause })
+                );
+                const command = `cp ${remoteTransferDir} ${service}:${remoteDestLocation}`;
+                return yield* Stream.runDrain(
+                    runCommandHelper(dindContainerId, projectPath, command, [], { ...options })
+                );
+            }).pipe(Effect.scoped);
+
+    const cpFrom =
+        (dindContainerId: IdSchemas.ContainerIdentifier, projectPath: string) =>
+        (
+            service: string,
+            remoteSrcLocation: string,
+            options?: DockerComposeEngine.CopyOptions | undefined
+        ): Stream.Stream<Uint8Array, DockerComposeError, never> =>
+            Function.pipe(
+                Stream.scoped(makeTempDirScoped(dindContainerId)),
+                Stream.provideService(MobyEndpoints.Containers, containers),
+                Stream.tap((remoteTransferDir) =>
+                    Stream.runDrain(
+                        runCommandHelper(
+                            dindContainerId,
+                            projectPath,
+                            `cp ${service}:${remoteSrcLocation} ${remoteTransferDir}`,
+                            [],
+                            {
+                                ...options,
+                            }
+                        )
+                    )
+                ),
+                Stream.flatMap((remoteTransferDir) =>
+                    Stream.mapError(
+                        containers.archive(dindContainerId, { path: remoteTransferDir }),
+                        (cause) =>
+                            new DockerComposeError({
+                                cause,
+                                method: "cpFrom",
+                            })
+                    )
+                )
+            );
+
+    const create =
+        (dindContainerId: IdSchemas.ContainerIdentifier, projectPath: string) =>
+        (
             services?: Array<string> | undefined,
             options?: DockerComposeEngine.CreateOptions | undefined
-        ): Effect.Effect<void, E1 | DockerComposeError, never> =>
+        ): Effect.Effect<void, DockerComposeError, never> =>
             Function.pipe(
-                uploadProject(project),
-                Effect.map(() => runCommand("create", services, { ...options })),
-                Stream.unwrap,
+                runCommandHelper(dindContainerId, projectPath, "create", services, { ...options }),
                 Stream.runDrain
-            ),
+            );
 
-        down: <E1>(
-            project: Stream.Stream<Uint8Array, E1, never>,
+    const down =
+        (dindContainerId: IdSchemas.ContainerIdentifier, projectPath: string) =>
+        (
             services?: Array<string> | undefined,
             options?: DockerComposeEngine.DownOptions | undefined
-        ): Effect.Effect<void, E1 | DockerComposeError, never> =>
+        ): Effect.Effect<void, DockerComposeError, never> =>
             Function.pipe(
-                uploadProject(project),
-                Effect.map(() => runCommand("down", services, { ...options })),
-                Stream.unwrap,
+                runCommandHelper(dindContainerId, projectPath, "down", services, { ...options }),
                 Stream.runDrain
-            ),
-
-        // events: <E1>(
-        //     project: Stream.Stream<Uint8Array, E1, never>,
-        //     services?: Array<string> | undefined,
-        //     options?: DockerComposeEngine.EventsOptions | undefined
-        // ): Stream.Stream<Uint8Array, E1 | DockerComposeError, never> => {},
-
-        // exec: <E1>(
-        //     project: Stream.Stream<Uint8Array, E1, never>,
-        //     service: string,
-        //     command: string,
-        //     args?: Array<string> | undefined,
-        //     options?: DockerComposeEngine.ExecOptions | undefined
-        // ): Stream.Stream<Uint8Array, E1 | DockerComposeError, never> => {},
-
-        images: <E1>(
-            project: Stream.Stream<Uint8Array, E1, never>,
+            );
+
+    const events =
+        (dindContainerId: IdSchemas.ContainerIdentifier, projectPath: string) =>
+        (
+            services?: Array<string> | undefined,
+            options?: DockerComposeEngine.EventsOptions | undefined
+        ): Stream.Stream<string, DockerComposeError, never> =>
+            Function.pipe(
+                runCommandHelper(dindContainerId, projectPath, "events", services, { ...options }),
+                Stream.decodeText(),
+                Stream.splitLines
+            );
+
+    const exec =
+        (dindContainerId: IdSchemas.ContainerIdentifier, projectPath: string) =>
+        (
+            service: string,
+            command: string,
+            args?: Array<string> | undefined,
+            options?: DockerComposeEngine.ExecOptions | undefined
+        ): Effect.Effect<
+            MobyDemux.MultiplexedChannel<never, DockerEngine.DockerError | Socket.SocketError, never>,
+            DockerComposeError,
+            Scope.Scope
+        > =>
+            Effect.provideService(
+                DockerEngine.execWebsocketsNonBlocking({
+                    containerId: dindContainerId,
+                    cwd: projectPath,
+                    command: `COMPOSE_STATUS_STDOUT=1 docker compose exec ${stringifyOptions({ ...options })} ${service} ${command} ${Array.join(args ?? [], " ")}`,
+                }),
+                MobyEndpoints.Containers,
+                containers
+            );
+
+    const images =
+        (dindContainerId: IdSchemas.ContainerIdentifier, projectPath: string) =>
+        (
             services?: Array<string> | undefined,
             options?: DockerComposeEngine.ImagesOptions | undefined
-        ): Stream.Stream<string, E1 | DockerComposeError, never> =>
+        ): Stream.Stream<string, DockerComposeError, never> =>
             Function.pipe(
-                uploadProject(project),
-                Effect.map(() => runCommand("images", services, { ...options })),
-                Stream.unwrap,
+                runCommandHelper(dindContainerId, projectPath, "images", services, { ...options }),
                 Stream.decodeText(),
                 Stream.splitLines
-            ),
+            );
 
-        kill: <E1>(
-            project: Stream.Stream<Uint8Array, E1, never>,
+    const kill =
+        (dindContainerId: IdSchemas.ContainerIdentifier, projectPath: string) =>
+        (
             services?: Array<string> | undefined,
             options?: DockerComposeEngine.KillOptions | undefined
-        ): Effect.Effect<void, E1 | DockerComposeError, never> =>
+        ): Effect.Effect<void, DockerComposeError, never> =>
             Function.pipe(
-                uploadProject(project),
-                Effect.map(() => runCommand("kill", services, { ...options })),
-                Stream.unwrap,
+                runCommandHelper(dindContainerId, projectPath, "kill", services, { ...options }),
                 Stream.runDrain
-            ),
+            );
 
-        logs: <E1>(
-            project: Stream.Stream<Uint8Array, E1, never>,
+    const logs =
+        (dindContainerId: IdSchemas.ContainerIdentifier, projectPath: string) =>
+        (
             services?: Array<string> | undefined,
             options?: DockerComposeEngine.LogsOptions | undefined
-        ): Stream.Stream<string, E1 | DockerComposeError, never> =>
+        ): Stream.Stream<string, DockerComposeError, never> =>
             Function.pipe(
-                uploadProject(project),
-                Effect.map(() => runCommand("logs", services, { ...options })),
-                Stream.unwrap,
+                runCommandHelper(dindContainerId, projectPath, "logs", services, { ...options }),
                 Stream.decodeText(),
                 Stream.splitLines
-            ),
+            );
 
-        ls: <E1>(
-            project: Stream.Stream<Uint8Array, E1, never>,
-            options?: DockerComposeEngine.ListOptions | undefined
-        ): Stream.Stream<string, E1 | DockerComposeError, never> =>
+    const ls =
+        (dindContainerId: IdSchemas.ContainerIdentifier, projectPath: string) =>
+        (options?: DockerComposeEngine.ListOptions | undefined): Stream.Stream<string, DockerComposeError, never> =>
             Function.pipe(
-                uploadProject(project),
-                Effect.map(() => runCommand("ls", [], { ...options })),
-                Stream.unwrap,
+                runCommandHelper(dindContainerId, projectPath, "ls", [], { ...options }),
                 Stream.decodeText(),
                 Stream.splitLines
-            ),
+            );
 
-        pause: <E1>(
-            project: Stream.Stream<Uint8Array, E1, never>,
-            services?: Array<string> | undefined
-        ): Effect.Effect<void, E1 | DockerComposeError, never> =>
+    const pause =
+        (dindContainerId: IdSchemas.ContainerIdentifier, projectPath: string) =>
+        (services?: Array<string> | undefined): Effect.Effect<void, DockerComposeError, never> =>
+            Function.pipe(runCommandHelper(dindContainerId, projectPath, "pause", services), Stream.runDrain);
+
+    const port =
+        (dindContainerId: IdSchemas.ContainerIdentifier, projectPath: string) =>
+        (
+            service: string,
+            privatePort: number,
+            options?: DockerComposeEngine.PortOptions | undefined
+        ): Effect.Effect<number, DockerComposeError, never> =>
             Function.pipe(
-                uploadProject(project),
-                Effect.map(() => runCommand("pause", services)),
-                Stream.unwrap,
-                Stream.runDrain
-            ),
-
-        // port: <E1>(
-        //     project: Stream.Stream<Uint8Array, E1, never>,
-        //     service: string,
-        //     privatePort: number,
-        //     options?: DockerComposeEngine.PortOptions | undefined
-        // ): Effect.Effect<number, E1 | DockerComposeError, never> => {},
+                runCommandHelper(dindContainerId, projectPath, "port", [service, privatePort.toString()], {
+                    ...options,
+                }),
+                Stream.decodeText(),
+                Stream.splitLines,
+                Stream.take(1),
+                Stream.runHead,
+                Effect.map(Option.flatMap(Number.parse)),
+                Effect.map(Option.getOrThrow)
+            );
 
-        ps: <E1>(
-            project: Stream.Stream<Uint8Array, E1, never>,
+    const ps =
+        (dindContainerId: IdSchemas.ContainerIdentifier, projectPath: string) =>
+        (
             services?: Array<string> | undefined,
             options?: DockerComposeEngine.PsOptions | undefined
-        ): Stream.Stream<string, E1 | DockerComposeError, never> =>
+        ): Stream.Stream<string, DockerComposeError, never> =>
             Function.pipe(
-                uploadProject(project),
-                Effect.map(() => runCommand("ps", services, { ...options })),
-                Stream.unwrap,
+                runCommandHelper(dindContainerId, projectPath, "ps", services, { ...options }),
                 Stream.decodeText(),
                 Stream.splitLines
-            ),
+            );
 
-        pull: <E1>(
-            project: Stream.Stream<Uint8Array, E1, never>,
+    const pull =
+        (dindContainerId: IdSchemas.ContainerIdentifier, projectPath: string) =>
+        (
             services?: Array<string> | undefined,
             options?: DockerComposeEngine.PullOptions | undefined
-        ): Stream.Stream<string, E1 | DockerComposeError, never> =>
+        ): Stream.Stream<string, DockerComposeError, never> =>
             Function.pipe(
-                uploadProject(project),
-                Effect.map(() => runCommand("pull", services, { ...options })),
-                Stream.unwrap,
+                runCommandHelper(dindContainerId, projectPath, "pull", services, { ...options }),
                 Stream.decodeText(),
                 Stream.splitLines
-            ),
+            );
 
-        push: <E1>(
-            project: Stream.Stream<Uint8Array, E1, never>,
+    const push =
+        (dindContainerId: IdSchemas.ContainerIdentifier, projectPath: string) =>
+        (
             services?: Array<string> | undefined,
             options?: DockerComposeEngine.PushOptions | undefined
-        ): Effect.Effect<void, E1 | DockerComposeError, never> =>
+        ): Effect.Effect<void, DockerComposeError, never> =>
             Function.pipe(
-                uploadProject(project),
-                Effect.map(() => runCommand("push", services, { ...options })),
-                Stream.unwrap,
+                runCommandHelper(dindContainerId, projectPath, "push", services, { ...options }),
                 Stream.runDrain
-            ),
+            );
 
-        restart: <E1>(
-            project: Stream.Stream<Uint8Array, E1, never>,
+    const restart =
+        (dindContainerId: IdSchemas.ContainerIdentifier, projectPath: string) =>
+        (
             services?: Array<string> | undefined,
             options?: DockerComposeEngine.RestartOptions | undefined
-        ): Effect.Effect<void, E1 | DockerComposeError, never> =>
+        ): Effect.Effect<void, DockerComposeError, never> =>
             Function.pipe(
-                uploadProject(project),
-                Effect.map(() => runCommand("restart", services, { ...options })),
-                Stream.unwrap,
+                runCommandHelper(dindContainerId, projectPath, "restart", services, { ...options }),
                 Stream.runDrain
-            ),
+            );
 
-        rm: <E1>(
-            project: Stream.Stream<Uint8Array, E1, never>,
+    const rm =
+        (dindContainerId: IdSchemas.ContainerIdentifier, projectPath: string) =>
+        (
             services?: Array<string> | undefined,
             options?: DockerComposeEngine.RmOptions | undefined
-        ): Effect.Effect<void, E1 | DockerComposeError, never> =>
+        ): Effect.Effect<void, DockerComposeError, never> =>
             Function.pipe(
-                uploadProject(project),
-                Effect.map(() => runCommand("rm", services, { ...options })),
-                Stream.unwrap,
+                runCommandHelper(dindContainerId, projectPath, "rm", services, { ...options }),
                 Stream.runDrain
-            ),
-
-        // run: <E1>(
-        //     project: Stream.Stream<Uint8Array, E1, never>,
-        //     service: string,
-        //     command: string,
-        //     args?: Array<string> | undefined,
-        //     options?: DockerComposeEngine.RunOptions | undefined
-        // ): Stream.Stream<Uint8Array, E1 | DockerComposeError, never> => {},
-
-        start: <E1>(
-            project: Stream.Stream<Uint8Array, E1, never>,
-            services?: Array<string> | undefined
-        ): Effect.Effect<void, E1 | DockerComposeError, never> =>
-            Function.pipe(
-                uploadProject(project),
-                Effect.map(() => runCommand("start", services)),
-                Stream.unwrap,
-                Stream.runDrain
-            ),
+            );
+
+    const run =
+        (dindContainerId: IdSchemas.ContainerIdentifier, projectPath: string) =>
+        (
+            service: string,
+            command: string,
+            args?: Array<string> | undefined,
+            options?: DockerComposeEngine.RunOptions | undefined
+        ): Effect.Effect<
+            MobyDemux.MultiplexedChannel<never, DockerEngine.DockerError | Socket.SocketError, never>,
+            DockerComposeError,
+            Scope.Scope
+        > =>
+            Effect.provideService(
+                DockerEngine.execWebsocketsNonBlocking({
+                    containerId: dindContainerId,
+                    cwd: projectPath,
+                    command: `COMPOSE_STATUS_STDOUT=1 docker compose run ${stringifyOptions({ ...options })} ${service} ${command} ${Array.join(args ?? [], " ")}`,
+                }),
+                MobyEndpoints.Containers,
+                containers
+            );
+
+    const start =
+        (dindContainerId: IdSchemas.ContainerIdentifier, projectPath: string) =>
+        (services?: Array<string> | undefined): Effect.Effect<void, DockerComposeError, never> =>
+            Function.pipe(runCommandHelper(dindContainerId, projectPath, "start", services), Stream.runDrain);
 
-        stop: <E1>(
-            project: Stream.Stream<Uint8Array, E1, never>,
+    const stop =
+        (dindContainerId: IdSchemas.ContainerIdentifier, projectPath: string) =>
+        (
             services?: Array<string> | undefined,
             options?: DockerComposeEngine.StopOptions | undefined
-        ): Effect.Effect<void, E1 | DockerComposeError, never> =>
+        ): Effect.Effect<void, DockerComposeError, never> =>
             Function.pipe(
-                uploadProject(project),
-                Effect.map(() => runCommand("stop", services, { ...options })),
-                Stream.unwrap,
+                runCommandHelper(dindContainerId, projectPath, "stop", services, { ...options }),
                 Stream.runDrain
-            ),
+            );
 
-        top: <E1>(
-            project: Stream.Stream<Uint8Array, E1, never>,
-            services?: Array<string> | undefined
-        ): Stream.Stream<string, E1 | DockerComposeError, never> =>
+    const top =
+        (dindContainerId: IdSchemas.ContainerIdentifier, projectPath: string) =>
+        (services?: Array<string> | undefined): Stream.Stream<string, DockerComposeError, never> =>
             Function.pipe(
-                uploadProject(project),
-                Effect.map(() => runCommand("top", services)),
-                Stream.unwrap,
+                runCommandHelper(dindContainerId, projectPath, "top", services),
                 Stream.decodeText(),
                 Stream.splitLines
-            ),
+            );
 
-        unpause: <E1>(
-            project: Stream.Stream<Uint8Array, E1, never>,
-            services?: Array<string> | undefined
-        ): Effect.Effect<void, E1 | DockerComposeError, never> =>
-            Function.pipe(
-                uploadProject(project),
-                Effect.map(() => runCommand("unpause", services)),
-                Stream.unwrap,
-                Stream.runDrain
-            ),
+    const unpause =
+        (dindContainerId: IdSchemas.ContainerIdentifier, projectPath: string) =>
+        (services?: Array<string> | undefined): Effect.Effect<void, DockerComposeError, never> =>
+            Function.pipe(runCommandHelper(dindContainerId, projectPath, "unpause", services), Stream.runDrain);
 
-        up: <E1>(
-            project: Stream.Stream<Uint8Array, E1, never>,
+    const up =
+        (dindContainerId: IdSchemas.ContainerIdentifier, projectPath: string) =>
+        (
             services?: Array<string> | undefined,
             options?: DockerComposeEngine.UpOptions | undefined
-        ): Effect.Effect<void, E1 | DockerComposeError, never> =>
+        ): Effect.Effect<void, DockerComposeError, never> =>
             Function.pipe(
-                uploadProject(project),
-                Effect.map(() => runCommand("up", services, { ...options })),
-                Stream.unwrap,
+                runCommandHelper(dindContainerId, projectPath, "up", services, { ...options }),
                 Stream.runDrain
-            ),
+            );
 
-        version: <E1>(
-            project: Stream.Stream<Uint8Array, E1, never>,
-            options?: DockerComposeEngine.VersionOptions | undefined
-        ): Effect.Effect<string, E1 | DockerComposeError, never> =>
+    const version =
+        (dindContainerId: IdSchemas.ContainerIdentifier, projectPath: string) =>
+        (options?: DockerComposeEngine.VersionOptions | undefined): Effect.Effect<string, DockerComposeError, never> =>
             Function.pipe(
-                uploadProject(project),
-                Effect.map(() => runCommand("version", [], { ...options })),
-                Stream.unwrap,
+                runCommandHelper(dindContainerId, projectPath, "version", [], { ...options }),
                 Stream.decodeText(),
                 Stream.run(Sink.mkString)
-            ),
+            );
 
-        wait: <E1>(
-            project: Stream.Stream<Uint8Array, E1, never>,
+    const wait =
+        (dindContainerId: IdSchemas.ContainerIdentifier, projectPath: string) =>
+        (
             services: Array.NonEmptyReadonlyArray<string>,
             options?: DockerComposeEngine.WaitOptions | undefined
-        ): Effect.Effect<void, E1 | DockerComposeError, never> =>
+        ): Effect.Effect<void, DockerComposeError, never> =>
             Function.pipe(
-                uploadProject(project),
-                Effect.map(() => runCommand("wait", services, { ...options })),
-                Stream.unwrap,
+                runCommandHelper(dindContainerId, projectPath, "wait", services, { ...options }),
                 Stream.runDrain
-            ),
+            );
+
+    const pullStream = DockerEngine.pull({ image: "docker.io/library/docker:latest" });
+    yield* Stream.runDrain(pullStream);
+
+    const dindContainerIdResource = yield* DockerEngine.runScoped({
+        Image: "docker.io/library/docker:latest",
+        Entrypoint: ["/bin/sh"],
+        Tty: false,
+        OpenStdin: true,
+        AttachStdin: true,
+        AttachStdout: true,
+        AttachStderr: true,
+        HostConfig: {
+            Privileged: true,
+            Binds: [`${options?.dockerEngineSocket ?? "/var/run/docker.sock"}:/var/run/docker.sock`],
+        },
+    }).pipe(Effect.map(({ Id }) => Id));
+
+    const uncurryEffectWithUploadProject =
+        (dindContainerId: IdSchemas.ContainerIdentifier) =>
+        <P extends Array<any>, A, E, R>(
+            func: (
+                dindContainerId: IdSchemas.ContainerIdentifier,
+                projectPath: string
+            ) => (...args: P) => Effect.Effect<A, E, R>
+        ) =>
+        <E1, R1>(
+            project: Stream.Stream<Uint8Array, E1, R1>,
+            ...args: P
+        ): Effect.Effect<A, E | E1 | DockerComposeError, Exclude<R, Scope.Scope> | Exclude<R1, Scope.Scope>> =>
+            uploadProject(project)(dindContainerId)
+                .pipe(Effect.provideService(MobyEndpoints.Containers, containers))
+                .pipe(Effect.flatMap((cwd) => func(dindContainerId, cwd)(...args)))
+                .pipe(Effect.scoped);
+
+    const uncurryStreamWithUploadProject =
+        (dindContainerId: IdSchemas.ContainerIdentifier) =>
+        <P extends Array<any>, A, E, R>(
+            func: (
+                dindContainerId: IdSchemas.ContainerIdentifier,
+                projectPath: string
+            ) => (...args: P) => Stream.Stream<A, E, R>
+        ) =>
+        <E1, R1>(
+            project: Stream.Stream<Uint8Array, E1, R1>,
+            ...args: P
+        ): Stream.Stream<A, E | E1 | DockerComposeError, R | R1> =>
+            uploadProject(project)(dindContainerId)
+                .pipe(Stream.scoped)
+                .pipe(Stream.provideService(MobyEndpoints.Containers, containers))
+                .pipe(Stream.flatMap((cwd) => func(dindContainerId, cwd)(...args)));
+
+    const uncurryEffect = uncurryEffectWithUploadProject(dindContainerIdResource);
+    const uncurryStream = uncurryStreamWithUploadProject(dindContainerIdResource);
 
+    // Actual compose implementation
+    return DockerCompose.of({
+        [TypeId]: TypeId,
+        build: uncurryStream(build),
+        config: uncurryEffect(config),
+        cpTo: <E1, R1, E2, R2>(
+            project: Stream.Stream<Uint8Array, E1, R1>,
+            service: string,
+            localSrc: Stream.Stream<Uint8Array, E2, R2>,
+            remoteDestLocation: string,
+            options?: DockerComposeEngine.CopyOptions | undefined
+        ): Effect.Effect<void, E1 | E2 | DockerComposeError, Exclude<R1, Scope.Scope> | Exclude<R2, Scope.Scope>> =>
+            Effect.gen(function* () {
+                const cwd = yield* Effect.provideService(
+                    uploadProject(project)(dindContainerIdResource),
+                    MobyEndpoints.Containers,
+                    containers
+                );
+                yield* cpTo(dindContainerIdResource, cwd)(service, localSrc, remoteDestLocation, options);
+            }).pipe(Effect.scoped),
+        cpFrom: uncurryStream(cpFrom),
+        create: uncurryEffect(create),
+        down: uncurryEffect(down),
+        events: uncurryStream(events),
+        exec: uncurryEffect(exec),
+        images: uncurryStream(images),
+        kill: uncurryEffect(kill),
+        logs: uncurryStream(logs),
+        ls: uncurryStream(ls),
+        pause: uncurryEffect(pause),
+        port: uncurryEffect(port),
+        ps: uncurryStream(ps),
+        pull: uncurryStream(pull),
+        push: uncurryEffect(push),
+        restart: uncurryEffect(restart),
+        rm: uncurryEffect(rm),
+        run: uncurryEffect(run),
+        start: uncurryEffect(start),
+        stop: uncurryEffect(stop),
+        top: uncurryStream(top),
+        unpause: uncurryEffect(unpause),
+        up: uncurryEffect(up),
+        version: uncurryEffect(version),
+        wait: uncurryEffect(wait),
         forProject: <E1>(
             project: Stream.Stream<Uint8Array, E1, never>
-        ): Effect.Effect<DockerComposeEngine.DockerComposeProject, E1 | DockerComposeError, never> =>
-            makeProjectLayer(project, uploadProject, runCommand),
+        ): Effect.Effect<
+            DockerComposeEngine.DockerComposeProject,
+            E1 | DockerComposeError | DockerEngine.DockerError,
+            Scope.Scope
+        > =>
+            Effect.gen(function* () {
+                const projectDindContainerIdResource = yield* DockerEngine.runScoped({
+                    Image: "docker.io/library/docker:latest",
+                    Entrypoint: ["/bin/sh"],
+                    Tty: false,
+                    OpenStdin: true,
+                    AttachStdin: true,
+                    AttachStdout: true,
+                    AttachStderr: true,
+                    HostConfig: {
+                        Privileged: true,
+                        Binds: [`${options?.dockerEngineSocket ?? "/var/run/docker.sock"}:/var/run/docker.sock`],
+                    },
+                })
+                    .pipe(Effect.map(({ Id }) => Id))
+                    .pipe(Effect.provideService(MobyEndpoints.Containers, containers));
+
+                const cwd = yield* Effect.provideService(
+                    uploadProject(projectDindContainerIdResource, project),
+                    MobyEndpoints.Containers,
+                    containers
+                );
+
+                return {
+                    [DockerComposeProjectTypeId]: DockerComposeProjectTypeId,
+                    build: build(projectDindContainerIdResource, cwd),
+                    config: config(projectDindContainerIdResource, cwd),
+                    cpTo: cpTo(projectDindContainerIdResource, cwd),
+                    cpFrom: cpFrom(projectDindContainerIdResource, cwd),
+                    create: create(projectDindContainerIdResource, cwd),
+                    down: down(projectDindContainerIdResource, cwd),
+                    events: events(projectDindContainerIdResource, cwd),
+                    exec: exec(projectDindContainerIdResource, cwd),
+                    images: images(projectDindContainerIdResource, cwd),
+                    kill: kill(projectDindContainerIdResource, cwd),
+                    logs: logs(projectDindContainerIdResource, cwd),
+                    ls: ls(projectDindContainerIdResource, cwd),
+                    pause: pause(projectDindContainerIdResource, cwd),
+                    port: port(projectDindContainerIdResource, cwd),
+                    ps: ps(projectDindContainerIdResource, cwd),
+                    pull: pull(projectDindContainerIdResource, cwd),
+                    push: push(projectDindContainerIdResource, cwd),
+                    restart: restart(projectDindContainerIdResource, cwd),
+                    rm: rm(projectDindContainerIdResource, cwd),
+                    run: run(projectDindContainerIdResource, cwd),
+                    start: start(projectDindContainerIdResource, cwd),
+                    stop: stop(projectDindContainerIdResource, cwd),
+                    top: top(projectDindContainerIdResource, cwd),
+                    unpause: unpause(projectDindContainerIdResource, cwd),
+                    up: up(projectDindContainerIdResource, cwd),
+                    version: version(projectDindContainerIdResource, cwd),
+                    wait: wait(projectDindContainerIdResource, cwd),
+                };
+            }),
     });
 });
 
 /** @internal */
-export const layer: Layer.Layer<
+export const layer = (
+    options?: { dockerEngineSocket?: string | undefined } | undefined
+): Layer.Layer<
     DockerComposeEngine.DockerCompose,
-    MobyEndpoints.SystemsError | MobyEndpoints.ContainersError,
-    Layer.Layer.Success<DockerEngine.DockerLayer>
-> = Layer.scoped(DockerCompose, make);
-
-/** @internal */
-export const makeProjectLayer = <E1>(
-    project: Stream.Stream<Uint8Array, E1, never>,
-    uploadProject: (
-        project: Stream.Stream<Uint8Array, E1, never>
-    ) => Effect.Effect<void, E1 | DockerComposeError, never>,
-    runCommand: (
-        method: string,
-        services?: ReadonlyArray<string> | undefined,
-        options?:
-            | Record<
-                  string,
-                  | string
-                  | number
-                  | boolean
-                  | undefined
-                  | Array<string | number | boolean>
-                  | Record<string, string | number | boolean>
-              >
-            | undefined
-    ) => Stream.Stream<Uint8Array, DockerComposeError, never>
-): Effect.Effect<DockerComposeEngine.DockerComposeProject, E1 | DockerComposeError, never> =>
-    Effect.gen(function* () {
-        yield* uploadProject(project);
-
-        return {
-            [DockerComposeProjectTypeId]: DockerComposeProjectTypeId,
-
-            build: (
-                services?: Array<string> | undefined,
-                options?: DockerComposeEngine.BuildOptions | undefined
-            ): Stream.Stream<string, DockerComposeError, never> =>
-                Function.pipe(runCommand("build", services, { ...options }), Stream.decodeText(), Stream.splitLines),
-
-            config: (
-                services?: Array<string> | undefined,
-                options?: DockerComposeEngine.ConfigOptions | undefined
-            ): Effect.Effect<string, DockerComposeError, never> =>
-                Function.pipe(
-                    runCommand("config", services, { ...options }),
-                    Stream.decodeText(),
-                    Stream.splitLines,
-                    Stream.run(Sink.mkString)
-                ),
-
-            // cp: (
-            //
-            //     service: string,
-            //     srcPath: string,
-            //     destPath: string,
-            //     options?: DockerComposeEngine.CopyOptions | undefined
-            // ): Stream.Stream<Uint8Array, DockerComposeError, never> => {},
-
-            create: (
-                services?: Array<string> | undefined,
-                options?: DockerComposeEngine.CreateOptions | undefined
-            ): Effect.Effect<void, DockerComposeError, never> =>
-                Function.pipe(runCommand("create", services, { ...options }), Stream.runDrain),
-
-            down: (
-                services?: Array<string> | undefined,
-                options?: DockerComposeEngine.DownOptions | undefined
-            ): Effect.Effect<void, DockerComposeError, never> =>
-                Function.pipe(runCommand("down", services, { ...options }), Stream.runDrain),
-
-            // events: (
-            //
-            //     services?: Array<string> | undefined,
-            //     options?: DockerComposeEngine.EventsOptions | undefined
-            // ): Stream.Stream<Uint8Array, DockerComposeError, never> => {},
-
-            // exec: (
-            //
-            //     service: string,
-            //     command: string,
-            //     args?: Array<string> | undefined,
-            //     options?: DockerComposeEngine.ExecOptions | undefined
-            // ): Stream.Stream<Uint8Array, DockerComposeError, never> => {},
-
-            images: (
-                services?: Array<string> | undefined,
-                options?: DockerComposeEngine.ImagesOptions | undefined
-            ): Stream.Stream<string, DockerComposeError, never> =>
-                Function.pipe(runCommand("images", services, { ...options }), Stream.decodeText(), Stream.splitLines),
-
-            kill: (
-                services?: Array<string> | undefined,
-                options?: DockerComposeEngine.KillOptions | undefined
-            ): Effect.Effect<void, DockerComposeError, never> =>
-                Function.pipe(runCommand("kill", services, { ...options }), Stream.runDrain),
-
-            logs: (
-                services?: Array<string> | undefined,
-                options?: DockerComposeEngine.LogsOptions | undefined
-            ): Stream.Stream<string, DockerComposeError, never> =>
-                Function.pipe(runCommand("logs", services, { ...options }), Stream.decodeText(), Stream.splitLines),
-
-            ls: (
-                options?: DockerComposeEngine.ListOptions | undefined
-            ): Stream.Stream<string, DockerComposeError, never> =>
-                Function.pipe(runCommand("ls", [], { ...options }), Stream.decodeText(), Stream.splitLines),
-
-            pause: (services?: Array<string> | undefined): Effect.Effect<void, DockerComposeError, never> =>
-                Function.pipe(runCommand("pause", services), Stream.runDrain),
-
-            // port: (
-            //
-            //     service: string,
-            //     privatePort: number,
-            //     options?: DockerComposeEngine.PortOptions | undefined
-            // ): Effect.Effect<number, DockerComposeError, never> => {},
-
-            ps: (
-                services?: Array<string> | undefined,
-                options?: DockerComposeEngine.PsOptions | undefined
-            ): Stream.Stream<string, DockerComposeError, never> =>
-                Function.pipe(runCommand("ps", services, { ...options }), Stream.decodeText(), Stream.splitLines),
-
-            pull: (
-                services?: Array<string> | undefined,
-                options?: DockerComposeEngine.PullOptions | undefined
-            ): Stream.Stream<string, DockerComposeError, never> =>
-                Function.pipe(runCommand("pull", services, { ...options }), Stream.decodeText(), Stream.splitLines),
-
-            push: (
-                services?: Array<string> | undefined,
-                options?: DockerComposeEngine.PushOptions | undefined
-            ): Effect.Effect<void, DockerComposeError, never> =>
-                Function.pipe(runCommand("push", services, { ...options }), Stream.runDrain),
-
-            restart: (
-                services?: Array<string> | undefined,
-                options?: DockerComposeEngine.RestartOptions | undefined
-            ): Effect.Effect<void, DockerComposeError, never> =>
-                Function.pipe(runCommand("restart", services, { ...options }), Stream.runDrain),
-
-            rm: (
-                services?: Array<string> | undefined,
-                options?: DockerComposeEngine.RmOptions | undefined
-            ): Effect.Effect<void, DockerComposeError, never> =>
-                Function.pipe(runCommand("rm", services, { ...options }), Stream.runDrain),
-
-            // run: (
-            //
-            //     service: string,
-            //     command: string,
-            //     args?: Array<string> | undefined,
-            //     options?: DockerComposeEngine.RunOptions | undefined
-            // ): Stream.Stream<Uint8Array, DockerComposeError, never> => {},
-
-            start: (services?: Array<string> | undefined): Effect.Effect<void, DockerComposeError, never> =>
-                Function.pipe(runCommand("start", services), Stream.runDrain),
-
-            stop: (
-                services?: Array<string> | undefined,
-                options?: DockerComposeEngine.StopOptions | undefined
-            ): Effect.Effect<void, DockerComposeError, never> =>
-                Function.pipe(runCommand("stop", services, { ...options }), Stream.runDrain),
-
-            top: (services?: Array<string> | undefined): Stream.Stream<string, DockerComposeError, never> =>
-                Function.pipe(runCommand("top", services), Stream.decodeText(), Stream.splitLines),
-
-            unpause: (services?: Array<string> | undefined): Effect.Effect<void, DockerComposeError, never> =>
-                Function.pipe(runCommand("unpause", services), Stream.runDrain),
-
-            up: (
-                services?: Array<string> | undefined,
-                options?: DockerComposeEngine.UpOptions | undefined
-            ): Effect.Effect<void, DockerComposeError, never> =>
-                Function.pipe(runCommand("up", services, { ...options }), Stream.runDrain),
-
-            version: (
-                options?: DockerComposeEngine.VersionOptions | undefined
-            ): Effect.Effect<string, DockerComposeError, never> =>
-                Function.pipe(
-                    runCommand("version", [], { ...options }),
-                    Stream.decodeText(),
-                    Stream.run(Sink.mkString)
-                ),
-
-            wait: (
-                services: Array.NonEmptyReadonlyArray<string>,
-                options?: DockerComposeEngine.WaitOptions | undefined
-            ): Effect.Effect<void, DockerComposeError, never> =>
-                Function.pipe(runCommand("wait", services, { ...options }), Stream.runDrain),
-        };
-    });
+    DockerEngine.DockerError,
+    MobyEndpoints.Containers | MobyEndpoints.System | MobyEndpoints.Images
+> => Layer.scoped(DockerCompose, make(options));
 
 /** @internal */
 export const layerProject: <E1>(
@@ -676,12 +772,12 @@ export const layerProject: <E1>(
     readonly tag: Context.Tag<DockerComposeEngine.DockerComposeProject, DockerComposeEngine.DockerComposeProject>;
     readonly layer: Layer.Layer<
         DockerComposeEngine.DockerComposeProject,
-        E1 | DockerComposeError,
+        E1 | DockerComposeError | DockerEngine.DockerError,
         DockerComposeEngine.DockerCompose
     >;
 } = <E1>(project: Stream.Stream<Uint8Array, E1, never>, tagIdentifier: string) => {
     const tag = Context.GenericTag<DockerComposeEngine.DockerComposeProject>(tagIdentifier);
     const effect = Effect.flatMap(DockerCompose, ({ forProject }) => forProject(project));
-    const layer = Layer.effect(tag, effect);
+    const layer = Layer.scoped(tag, effect);
     return { tag, layer } as const;
 };