@procedures/docker 0.2.3 → 0.3.0

package/src/module.ts

@@ -4,7 +4,10 @@
  * Procedure Registration for Docker operations
  *
  * Provides docker.run, docker.build, docker.pull, docker.exec, docker.stop,
- * docker.rm, docker.ps, docker.logs, docker.compose.up, docker.compose.down procedures.
+ * docker.rm, docker.ps, docker.logs, docker.compose.up, docker.compose.down procedures, and since
+ * roadmap R41 docker.compose.ps/logs/build/restart, docker.images, docker.inspect,
+ * docker.volume.list/create/remove, docker.network.list/create/remove, docker.tag, docker.push
+ * and docker.prune.
  */
 
 
@@ -49,6 +52,83 @@ import {
   DockerLogsOutputSchema,
 } from "./types.js";
 import type { ProcedureContext } from "@procedures/client";
+import { dockerComposePs } from "./procedures/docker/compose/ps.js";
+import { dockerComposeLogs } from "./procedures/docker/compose/logs.js";
+import { dockerComposeBuild } from "./procedures/docker/compose/build.js";
+import { dockerComposeRestart } from "./procedures/docker/compose/restart.js";
+import { dockerImages } from "./procedures/docker/images.js";
+import { dockerInspect } from "./procedures/docker/inspect.js";
+import { dockerVolumeList } from "./procedures/docker/volume/list.js";
+import { dockerVolumeCreate } from "./procedures/docker/volume/create.js";
+import { dockerVolumeRemove } from "./procedures/docker/volume/remove.js";
+import { dockerNetworkList } from "./procedures/docker/network/list.js";
+import { dockerNetworkCreate } from "./procedures/docker/network/create.js";
+import { dockerNetworkRemove } from "./procedures/docker/network/remove.js";
+import { dockerTag } from "./procedures/docker/tag.js";
+import { dockerPush } from "./procedures/docker/push.js";
+import { dockerPrune } from "./procedures/docker/prune.js";
+import {
+  DockerComposePsInputSchema,
+  DockerComposePsOutputSchema,
+  type DockerComposePsInput,
+  type DockerComposePsOutput,
+  DockerComposeLogsInputSchema,
+  DockerComposeLogsOutputSchema,
+  type DockerComposeLogsInput,
+  type DockerComposeLogsOutput,
+  DockerComposeBuildInputSchema,
+  DockerComposeBuildOutputSchema,
+  type DockerComposeBuildInput,
+  type DockerComposeBuildOutput,
+  DockerComposeRestartInputSchema,
+  DockerComposeRestartOutputSchema,
+  type DockerComposeRestartInput,
+  type DockerComposeRestartOutput,
+  DockerImagesInputSchema,
+  DockerImagesOutputSchema,
+  type DockerImagesInput,
+  type DockerImagesOutput,
+  DockerInspectInputSchema,
+  DockerInspectOutputSchema,
+  type DockerInspectInput,
+  type DockerInspectOutput,
+  DockerVolumeListInputSchema,
+  DockerVolumeListOutputSchema,
+  type DockerVolumeListInput,
+  type DockerVolumeListOutput,
+  DockerVolumeCreateInputSchema,
+  DockerVolumeCreateOutputSchema,
+  type DockerVolumeCreateInput,
+  type DockerVolumeCreateOutput,
+  DockerVolumeRemoveInputSchema,
+  DockerVolumeRemoveOutputSchema,
+  type DockerVolumeRemoveInput,
+  type DockerVolumeRemoveOutput,
+  DockerNetworkListInputSchema,
+  DockerNetworkListOutputSchema,
+  type DockerNetworkListInput,
+  type DockerNetworkListOutput,
+  DockerNetworkCreateInputSchema,
+  DockerNetworkCreateOutputSchema,
+  type DockerNetworkCreateInput,
+  type DockerNetworkCreateOutput,
+  DockerNetworkRemoveInputSchema,
+  DockerNetworkRemoveOutputSchema,
+  type DockerNetworkRemoveInput,
+  type DockerNetworkRemoveOutput,
+  DockerTagInputSchema,
+  DockerTagOutputSchema,
+  type DockerTagInput,
+  type DockerTagOutput,
+  DockerPushInputSchema,
+  DockerPushOutputSchema,
+  type DockerPushInput,
+  type DockerPushOutput,
+  DockerPruneInputSchema,
+  DockerPruneOutputSchema,
+  type DockerPruneInput,
+  type DockerPruneOutput,
+} from "./types.js";
 
 // =============================================================================
 // Procedures
@@ -186,6 +266,8 @@ const dockerLogsProcedure = createProcedure()
     description: "Get container logs",
     calls: ["shell.run", "shell.stream"],
     effects: { reads: ["docker"], writes: [] },
+    // With follow, the stream runs as long as the container (roadmap R15)
+    stream: { unbounded: true },
     args: ["container"],
     shorts: { follow: "f", tail: "n", timestamps: "t" },
     output: "json",
@@ -233,6 +315,237 @@ const dockerComposeDownProcedure = createProcedure()
   })
   .build();
 
+// =============================================================================
+// Roadmap R41: compose ps, logs, build, restart, images, inspect, volumes, networks, tag, push, prune
+// =============================================================================
+
+const dockerComposePsProcedure = createProcedure()
+  .path(["docker", "compose", "ps"])
+  .input(zodAdapter<DockerComposePsInput>(DockerComposePsInputSchema))
+  .output(zodAdapter<DockerComposePsOutput>(DockerComposePsOutputSchema))
+  .meta({
+    description: "List the containers of a compose project",
+    calls: ["shell.run"],
+    // Docker reads the compose file
+    effects: { reads: ["docker", "fs"], writes: [] },
+    args: ["services"],
+    shorts: { file: "f", all: "a", format: "F" },
+    output: "json",
+  })
+  .handler(async (input: DockerComposePsInput, ctx: ProcedureContext): Promise<DockerComposePsOutput> => dockerComposePs(input, ctx))
+  .build();
+
+const dockerComposeLogsProcedure = createProcedure()
+  .path(["docker", "compose", "logs"])
+  .input(zodAdapter<DockerComposeLogsInput>(DockerComposeLogsInputSchema))
+  .output(zodAdapter<DockerComposeLogsOutput>(DockerComposeLogsOutputSchema))
+  .meta({
+    description: "Get the logs of the services of a compose project (without follow)",
+    calls: ["shell.run"],
+    effects: { reads: ["docker", "fs"], writes: [] },
+    args: ["services"],
+    shorts: { file: "f", tail: "n", timestamps: "t" },
+    output: "json",
+  })
+  .handler(async (input: DockerComposeLogsInput, ctx: ProcedureContext): Promise<DockerComposeLogsOutput> => dockerComposeLogs(input, ctx))
+  .build();
+
+const dockerComposeBuildProcedure = createProcedure()
+  .path(["docker", "compose", "build"])
+  .input(zodAdapter<DockerComposeBuildInput>(DockerComposeBuildInputSchema))
+  .output(zodAdapter<DockerComposeBuildOutput>(DockerComposeBuildOutputSchema))
+  .meta({
+    description: "Build the images of the services of a compose project",
+    calls: ["shell.run"],
+    // As docker.build: the RUN steps are code of the project, and docker pulls the base images.
+    // The tags go to the new images, and the earlier images stay.
+    effects: { reads: ["docker", "fs", "network"], writes: ["docker", "process"], destructive: false },
+    args: ["services"],
+    shorts: { file: "f" },
+    output: "json",
+  })
+  .handler(async (input: DockerComposeBuildInput, ctx: ProcedureContext): Promise<DockerComposeBuildOutput> => dockerComposeBuild(input, ctx))
+  .build();
+
+const dockerComposeRestartProcedure = createProcedure()
+  .path(["docker", "compose", "restart"])
+  .input(zodAdapter<DockerComposeRestartInput>(DockerComposeRestartInputSchema))
+  .output(zodAdapter<DockerComposeRestartOutput>(DockerComposeRestartOutputSchema))
+  .meta({
+    description: "Restart the services of a compose project",
+    calls: ["shell.run"],
+    // A restart stops the processes of the services. Each call restarts them again.
+    effects: { reads: ["docker", "fs"], writes: ["docker"] },
+    args: ["services"],
+    shorts: { file: "f", time: "t" },
+    output: "json",
+  })
+  .handler(async (input: DockerComposeRestartInput, ctx: ProcedureContext): Promise<DockerComposeRestartOutput> => dockerComposeRestart(input, ctx))
+  .build();
+
+const dockerImagesProcedure = createProcedure()
+  .path(["docker", "images"])
+  .input(zodAdapter<DockerImagesInput>(DockerImagesInputSchema))
+  .output(zodAdapter<DockerImagesOutput>(DockerImagesOutputSchema))
+  .meta({
+    description: "List images",
+    calls: ["shell.run"],
+    effects: { reads: ["docker"], writes: [] },
+    args: ["repository"],
+    shorts: { all: "a", filter: "f", format: "F" },
+    output: "json",
+  })
+  .handler(async (input: DockerImagesInput, ctx: ProcedureContext): Promise<DockerImagesOutput> => dockerImages(input, ctx))
+  .build();
+
+const dockerInspectProcedure = createProcedure()
+  .path(["docker", "inspect"])
+  .input(zodAdapter<DockerInspectInput>(DockerInspectInputSchema))
+  .output(zodAdapter<DockerInspectOutput>(DockerInspectOutputSchema))
+  .meta({
+    description: "Give the details of containers, images, volumes or networks: data has the JSON of docker",
+    calls: ["shell.run"],
+    effects: { reads: ["docker"], writes: [] },
+    args: ["targets"],
+    shorts: { type: "T", format: "F" },
+    output: "json",
+  })
+  .handler(async (input: DockerInspectInput, ctx: ProcedureContext): Promise<DockerInspectOutput> => dockerInspect(input, ctx))
+  .build();
+
+const dockerVolumeListProcedure = createProcedure()
+  .path(["docker", "volume", "list"])
+  .input(zodAdapter<DockerVolumeListInput>(DockerVolumeListInputSchema))
+  .output(zodAdapter<DockerVolumeListOutput>(DockerVolumeListOutputSchema))
+  .meta({
+    description: "List volumes",
+    calls: ["shell.run"],
+    effects: { reads: ["docker"], writes: [] },
+    shorts: { filter: "f", format: "F" },
+    output: "json",
+  })
+  .handler(async (input: DockerVolumeListInput, ctx: ProcedureContext): Promise<DockerVolumeListOutput> => dockerVolumeList(input, ctx))
+  .build();
+
+const dockerVolumeCreateProcedure = createProcedure()
+  .path(["docker", "volume", "create"])
+  .input(zodAdapter<DockerVolumeCreateInput>(DockerVolumeCreateInputSchema))
+  .output(zodAdapter<DockerVolumeCreateOutput>(DockerVolumeCreateOutputSchema))
+  .meta({
+    description: "Create a volume. A volume that exists stays as it is",
+    calls: ["shell.run"],
+    effects: { reads: ["docker"], writes: ["docker"], destructive: false, idempotent: true },
+    args: ["name"],
+    shorts: { driver: "d" },
+    output: "json",
+  })
+  .handler(async (input: DockerVolumeCreateInput, ctx: ProcedureContext): Promise<DockerVolumeCreateOutput> => dockerVolumeCreate(input, ctx))
+  .build();
+
+const dockerVolumeRemoveProcedure = createProcedure()
+  .path(["docker", "volume", "remove"])
+  .input(zodAdapter<DockerVolumeRemoveInput>(DockerVolumeRemoveInputSchema))
+  .output(zodAdapter<DockerVolumeRemoveOutput>(DockerVolumeRemoveOutputSchema))
+  .meta({
+    description: "Remove volumes. Their data is lost",
+    calls: ["shell.run"],
+    effects: { reads: ["docker"], writes: ["docker"], destructive: true, idempotent: true },
+    args: ["volumes"],
+    shorts: { force: "f" },
+    output: "json",
+  })
+  .handler(async (input: DockerVolumeRemoveInput, ctx: ProcedureContext): Promise<DockerVolumeRemoveOutput> => dockerVolumeRemove(input, ctx))
+  .build();
+
+const dockerNetworkListProcedure = createProcedure()
+  .path(["docker", "network", "list"])
+  .input(zodAdapter<DockerNetworkListInput>(DockerNetworkListInputSchema))
+  .output(zodAdapter<DockerNetworkListOutput>(DockerNetworkListOutputSchema))
+  .meta({
+    description: "List networks",
+    calls: ["shell.run"],
+    effects: { reads: ["docker"], writes: [] },
+    shorts: { filter: "f", format: "F" },
+    output: "json",
+  })
+  .handler(async (input: DockerNetworkListInput, ctx: ProcedureContext): Promise<DockerNetworkListOutput> => dockerNetworkList(input, ctx))
+  .build();
+
+const dockerNetworkCreateProcedure = createProcedure()
+  .path(["docker", "network", "create"])
+  .input(zodAdapter<DockerNetworkCreateInput>(DockerNetworkCreateInputSchema))
+  .output(zodAdapter<DockerNetworkCreateOutput>(DockerNetworkCreateOutputSchema))
+  .meta({
+    description: "Create a network. A name that exists is an error",
+    calls: ["shell.run"],
+    effects: { reads: ["docker"], writes: ["docker"], destructive: false, idempotent: true },
+    args: ["name"],
+    shorts: { driver: "d" },
+    output: "json",
+  })
+  .handler(async (input: DockerNetworkCreateInput, ctx: ProcedureContext): Promise<DockerNetworkCreateOutput> => dockerNetworkCreate(input, ctx))
+  .build();
+
+const dockerNetworkRemoveProcedure = createProcedure()
+  .path(["docker", "network", "remove"])
+  .input(zodAdapter<DockerNetworkRemoveInput>(DockerNetworkRemoveInputSchema))
+  .output(zodAdapter<DockerNetworkRemoveOutput>(DockerNetworkRemoveOutputSchema))
+  .meta({
+    description: "Remove networks",
+    calls: ["shell.run"],
+    effects: { reads: ["docker"], writes: ["docker"], destructive: true, idempotent: true },
+    args: ["networks"],
+    output: "json",
+  })
+  .handler(async (input: DockerNetworkRemoveInput, ctx: ProcedureContext): Promise<DockerNetworkRemoveOutput> => dockerNetworkRemove(input, ctx))
+  .build();
+
+const dockerTagProcedure = createProcedure()
+  .path(["docker", "tag"])
+  .input(zodAdapter<DockerTagInput>(DockerTagInputSchema))
+  .output(zodAdapter<DockerTagOutput>(DockerTagOutputSchema))
+  .meta({
+    description: "Give an image another name. An image that had the name loses it",
+    calls: ["shell.run"],
+    // The name moves from another image, so it is destructive
+    effects: { reads: ["docker"], writes: ["docker"], idempotent: true },
+    args: ["source", "target"],
+    output: "json",
+  })
+  .handler(async (input: DockerTagInput, ctx: ProcedureContext): Promise<DockerTagOutput> => dockerTag(input, ctx))
+  .build();
+
+const dockerPushProcedure = createProcedure()
+  .path(["docker", "push"])
+  .input(zodAdapter<DockerPushInput>(DockerPushInputSchema))
+  .output(zodAdapter<DockerPushOutput>(DockerPushOutputSchema))
+  .meta({
+    description: "Push an image to a registry. The registry replaces an image with the same tag",
+    calls: ["shell.run"],
+    // A write to the registry: it replaces the image of the tag there
+    effects: { reads: ["docker", "network"], writes: ["network"], idempotent: true },
+    args: ["image"],
+    shorts: { allTags: "a" },
+    output: "json",
+  })
+  .handler(async (input: DockerPushInput, ctx: ProcedureContext): Promise<DockerPushOutput> => dockerPush(input, ctx))
+  .build();
+
+const dockerPruneProcedure = createProcedure()
+  .path(["docker", "prune"])
+  .input(zodAdapter<DockerPruneInput>(DockerPruneInputSchema))
+  .output(zodAdapter<DockerPruneOutput>(DockerPruneOutputSchema))
+  .meta({
+    description: "Remove unused containers, images, volumes, networks or build cache. It needs confirm: true",
+    calls: ["shell.run"],
+    // The removed objects and their data are lost. A second call finds less to remove.
+    effects: { reads: ["docker"], writes: ["docker"], destructive: true, idempotent: true },
+    shorts: { kind: "k", all: "a", filter: "f" },
+    output: "json",
+  })
+  .handler(async (input: DockerPruneInput, ctx: ProcedureContext): Promise<DockerPruneOutput> => dockerPrune(input, ctx))
+  .build();
+
 // =============================================================================
 // Registration
 // =============================================================================
@@ -252,6 +565,21 @@ export const dockerModule: ProcedureModule = defineModule("@procedures/docker",
     dockerLogsProcedure,
     dockerComposeUpProcedure,
     dockerComposeDownProcedure,
+    dockerComposePsProcedure,
+    dockerComposeLogsProcedure,
+    dockerComposeBuildProcedure,
+    dockerComposeRestartProcedure,
+    dockerImagesProcedure,
+    dockerInspectProcedure,
+    dockerVolumeListProcedure,
+    dockerVolumeCreateProcedure,
+    dockerVolumeRemoveProcedure,
+    dockerNetworkListProcedure,
+    dockerNetworkCreateProcedure,
+    dockerNetworkRemoveProcedure,
+    dockerTagProcedure,
+    dockerPushProcedure,
+    dockerPruneProcedure,
   ], [shellModule]);
 
 export default dockerModule;

package/src/procedures/docker/compose/build.ts

@@ -0,0 +1,23 @@
+/**
+ * docker.compose.build procedure
+ *
+ * Build the images of the services of a compose project (roadmap R41).
+ */
+
+import type { ProcedureContext } from "@procedures/client";
+import { composeArgs, runDocker, serviceArgs } from "../shared.js";
+import type { DockerComposeBuildInput, DockerComposeBuildOutput } from "../../../types.js";
+
+/**
+ * Build the images of the services of a compose project
+ */
+export async function dockerComposeBuild(input: DockerComposeBuildInput, ctx: ProcedureContext): Promise<DockerComposeBuildOutput> {
+  const args = composeArgs(input.file, "build");
+  if (input.noCache) args.push("--no-cache");
+  if (input.pull) args.push("--pull");
+  for (const [key, value] of Object.entries(input.buildArgs ?? {})) {
+    args.push("--build-arg", `${key}=${value}`);
+  }
+  args.push(...serviceArgs(input.services));
+  return runDocker(args, input, ctx);
+}

package/src/procedures/docker/compose/logs.ts

@@ -0,0 +1,23 @@
+/**
+ * docker.compose.logs procedure
+ *
+ * Get the logs of the services of a compose project (roadmap R41). The procedure does not follow
+ * the logs: it gives the lines that exist, without colors.
+ */
+
+import type { ProcedureContext } from "@procedures/client";
+import { composeArgs, runDocker, serviceArgs } from "../shared.js";
+import type { DockerComposeLogsInput, DockerComposeLogsOutput } from "../../../types.js";
+
+/**
+ * Get the logs of the services of a compose project
+ */
+export async function dockerComposeLogs(input: DockerComposeLogsInput, ctx: ProcedureContext): Promise<DockerComposeLogsOutput> {
+  const args = composeArgs(input.file, "logs");
+  args.push("--no-color");
+  if (input.tail !== undefined) args.push("--tail", String(input.tail));
+  if (input.since) args.push("--since", input.since);
+  if (input.timestamps) args.push("--timestamps");
+  args.push(...serviceArgs(input.services));
+  return runDocker(args, input, ctx);
+}

package/src/procedures/docker/compose/ps.ts

@@ -0,0 +1,20 @@
+/**
+ * docker.compose.ps procedure
+ *
+ * List the containers of a compose project (roadmap R41).
+ */
+
+import type { ProcedureContext } from "@procedures/client";
+import { composeArgs, runDocker, serviceArgs } from "../shared.js";
+import type { DockerComposePsInput, DockerComposePsOutput } from "../../../types.js";
+
+/**
+ * List the containers of a compose project
+ */
+export async function dockerComposePs(input: DockerComposePsInput, ctx: ProcedureContext): Promise<DockerComposePsOutput> {
+  const args = composeArgs(input.file, "ps");
+  if (input.all) args.push("--all");
+  if (input.format) args.push("--format", input.format);
+  args.push(...serviceArgs(input.services));
+  return runDocker(args, input, ctx);
+}

package/src/procedures/docker/compose/restart.ts

@@ -0,0 +1,19 @@
+/**
+ * docker.compose.restart procedure
+ *
+ * Restart the services of a compose project (roadmap R41).
+ */
+
+import type { ProcedureContext } from "@procedures/client";
+import { composeArgs, runDocker, serviceArgs } from "../shared.js";
+import type { DockerComposeRestartInput, DockerComposeRestartOutput } from "../../../types.js";
+
+/**
+ * Restart the services of a compose project
+ */
+export async function dockerComposeRestart(input: DockerComposeRestartInput, ctx: ProcedureContext): Promise<DockerComposeRestartOutput> {
+  const args = composeArgs(input.file, "restart");
+  if (input.time !== undefined) args.push("--timeout", String(input.time));
+  args.push(...serviceArgs(input.services));
+  return runDocker(args, input, ctx);
+}

package/src/procedures/docker/exec.ts

@@ -5,7 +5,7 @@
  */
 
 import type { ProcedureContext } from "@procedures/client";
-import { dockerArg, runDocker, words } from "./shared.js";
+import { commandWords, dockerArg, runDocker } from "./shared.js";
 import type { DockerExecInput, DockerCommandOutput } from "../../types.js";
 
 /**
@@ -30,7 +30,12 @@ export async function dockerExec(
     }
 
     args.push(dockerArg("container", input.container));
-    args.push(...words(input.command));
+    // The command: args as they are, or command split at whitespace
+    const command = commandWords(input);
+    if (command.length === 0) {
+      throw new Error("docker.exec needs command or args");
+    }
+    args.push(...command);
 
     return runDocker(args, input, ctx);
   }

package/src/procedures/docker/images.ts

@@ -0,0 +1,21 @@
+/**
+ * docker.images procedure
+ *
+ * List images (roadmap R41).
+ */
+
+import type { ProcedureContext } from "@procedures/client";
+import { dockerArg, runDocker } from "./shared.js";
+import type { DockerImagesInput, DockerImagesOutput } from "../../types.js";
+
+/**
+ * List images
+ */
+export async function dockerImages(input: DockerImagesInput, ctx: ProcedureContext): Promise<DockerImagesOutput> {
+  const args = ["images"];
+  if (input.all) args.push("--all");
+  if (input.filter) args.push("--filter", input.filter);
+  if (input.format) args.push("--format", input.format);
+  if (input.repository) args.push(dockerArg("repository", input.repository));
+  return runDocker(args, input, ctx);
+}

package/src/procedures/docker/index.ts

@@ -8,3 +8,18 @@ export { dockerPs } from "./ps.js";
 export { dockerLogs, type DockerLogItem } from "./logs.js";
 export { dockerComposeUp } from "./up.js";
 export { dockerComposeDown } from "./down.js";
+export { dockerComposePs } from "./compose/ps.js";
+export { dockerComposeLogs } from "./compose/logs.js";
+export { dockerComposeBuild } from "./compose/build.js";
+export { dockerComposeRestart } from "./compose/restart.js";
+export { dockerImages } from "./images.js";
+export { dockerInspect } from "./inspect.js";
+export { dockerVolumeList } from "./volume/list.js";
+export { dockerVolumeCreate } from "./volume/create.js";
+export { dockerVolumeRemove } from "./volume/remove.js";
+export { dockerNetworkList } from "./network/list.js";
+export { dockerNetworkCreate } from "./network/create.js";
+export { dockerNetworkRemove } from "./network/remove.js";
+export { dockerTag } from "./tag.js";
+export { dockerPush } from "./push.js";
+export { dockerPrune } from "./prune.js";

package/src/procedures/docker/inspect.ts

@@ -0,0 +1,31 @@
+/**
+ * docker.inspect procedure
+ *
+ * Give the details of containers, images, volumes or networks as JSON (roadmap R41). Without
+ * `format`, docker writes a JSON array, and `data` has it parsed.
+ */
+
+import type { ProcedureContext } from "@procedures/client";
+import { dockerArg, runDocker } from "./shared.js";
+import type { DockerInspectInput, DockerInspectOutput } from "../../types.js";
+
+/**
+ * Give the details of containers, images, volumes or networks as JSON
+ */
+export async function dockerInspect(input: DockerInspectInput, ctx: ProcedureContext): Promise<DockerInspectOutput> {
+  const args = ["inspect"];
+  if (input.type) args.push("--type", input.type);
+  if (input.format) args.push("--format", input.format);
+  args.push(...input.targets.map((target) => dockerArg("target", target)));
+
+  const result: DockerInspectOutput = await runDocker(args, input, ctx);
+  // Docker writes the array also when a target is missing (exit 1): the found ones are in it
+  if (!input.format && result.stdout.trim().startsWith("[")) {
+    try {
+      result.data = JSON.parse(result.stdout);
+    } catch {
+      // Not JSON: stdout has the text
+    }
+  }
+  return result;
+}

package/src/procedures/docker/network/create.ts

@@ -0,0 +1,22 @@
+/**
+ * docker.network.create procedure
+ *
+ * Create a network (roadmap R41). Docker refuses a name that exists, so a second call changes
+ * nothing. The output is the ID of the network.
+ */
+
+import type { ProcedureContext } from "@procedures/client";
+import { dockerArg, labelArgs, runDocker } from "../shared.js";
+import type { DockerNetworkCreateInput, DockerNetworkCreateOutput } from "../../../types.js";
+
+/**
+ * Create a network
+ */
+export async function dockerNetworkCreate(input: DockerNetworkCreateInput, ctx: ProcedureContext): Promise<DockerNetworkCreateOutput> {
+  const args = ["network", "create"];
+  if (input.driver) args.push("--driver", input.driver);
+  if (input.internal) args.push("--internal");
+  args.push(...labelArgs(input.labels));
+  args.push(dockerArg("network", input.name));
+  return runDocker(args, input, ctx);
+}

package/src/procedures/docker/network/list.ts

@@ -0,0 +1,19 @@
+/**
+ * docker.network.list procedure
+ *
+ * List networks (roadmap R41).
+ */
+
+import type { ProcedureContext } from "@procedures/client";
+import { runDocker } from "../shared.js";
+import type { DockerNetworkListInput, DockerNetworkListOutput } from "../../../types.js";
+
+/**
+ * List networks
+ */
+export async function dockerNetworkList(input: DockerNetworkListInput, ctx: ProcedureContext): Promise<DockerNetworkListOutput> {
+  const args = ["network", "ls"];
+  if (input.filter) args.push("--filter", input.filter);
+  if (input.format) args.push("--format", input.format);
+  return runDocker(args, input, ctx);
+}

package/src/procedures/docker/network/remove.ts

@@ -0,0 +1,17 @@
+/**
+ * docker.network.remove procedure
+ *
+ * Remove networks (roadmap R41). Docker refuses a network that a container uses.
+ */
+
+import type { ProcedureContext } from "@procedures/client";
+import { dockerArg, runDocker } from "../shared.js";
+import type { DockerNetworkRemoveInput, DockerNetworkRemoveOutput } from "../../../types.js";
+
+/**
+ * Remove networks
+ */
+export async function dockerNetworkRemove(input: DockerNetworkRemoveInput, ctx: ProcedureContext): Promise<DockerNetworkRemoveOutput> {
+  const args = ["network", "rm", ...input.networks.map((network) => dockerArg("network", network))];
+  return runDocker(args, input, ctx);
+}

package/src/procedures/docker/prune.ts

@@ -0,0 +1,30 @@
+/**
+ * docker.prune procedure
+ *
+ * Remove unused containers, images, volumes, networks or build cache (roadmap R41). The removed
+ * objects and their data are lost, so the input must have `confirm: true`. Docker does not ask:
+ * the procedure passes `--force`.
+ */
+
+import type { ProcedureContext } from "@procedures/client";
+import { runDocker } from "./shared.js";
+import type { DockerPruneInput, DockerPruneOutput } from "../../types.js";
+
+/**
+ * Remove unused containers, images, volumes, networks or build cache
+ */
+export async function dockerPrune(input: DockerPruneInput, ctx: ProcedureContext): Promise<DockerPruneOutput> {
+  // The schema requires it. A direct call of this function gets the same check.
+  if (input.confirm !== true) {
+    throw new Error("docker.prune needs confirm: true. The removed objects and their data are lost");
+  }
+  const kind = input.kind ?? "system";
+  if (input.volumes && kind !== "system") {
+    throw new Error(`docker.prune: volumes needs the kind system, not ${kind}`);
+  }
+  const args = [kind, "prune", "--force"];
+  if (input.all) args.push("--all");
+  if (input.volumes) args.push("--volumes");
+  if (input.filter) args.push("--filter", input.filter);
+  return runDocker(args, input, ctx);
+}

package/src/procedures/docker/push.ts

@@ -0,0 +1,20 @@
+/**
+ * docker.push procedure
+ *
+ * Push an image to a registry (roadmap R41). The registry replaces an image with the same tag.
+ * Docker uses the credentials of `docker login`.
+ */
+
+import type { ProcedureContext } from "@procedures/client";
+import { dockerArg, runDocker } from "./shared.js";
+import type { DockerPushInput, DockerPushOutput } from "../../types.js";
+
+/**
+ * Push an image to a registry
+ */
+export async function dockerPush(input: DockerPushInput, ctx: ProcedureContext): Promise<DockerPushOutput> {
+  const args = ["push"];
+  if (input.allTags) args.push("--all-tags");
+  args.push(dockerArg("image", input.image));
+  return runDocker(args, input, ctx);
+}