Add NerdctlClient for Finch and nerdctl support

.vscode/launch.json

@@ -31,7 +31,7 @@
                 "<node_internals>/**"
             ],
             "env": {
-                "CONTAINER_CLIENT_TYPE": "${input:containerRuntime}", // Set to 'docker' or 'podman'
+                "CONTAINER_CLIENT_TYPE": "${input:containerRuntime}", // Set to 'docker', 'podman', or 'nerdctl'
                 "RUN_IN_WSL": "0", // Set to 1 if running in WSL
                 "DOCKER_HUB_USERNAME": "${input:dockerHubUsername}",
                 "DOCKER_HUB_PAT": "${input:dockerHubPAT}"
@@ -87,7 +87,8 @@
             "description": "Select the container runtime to use for integration tests",
             "options": [
                 "docker",
-                "podman"
+                "podman",
+                "nerdctl"
             ],
             "default": "docker"
         },

packages/vscode-container-client/src/clients/DockerClientBase/DockerClientBase.ts

@@ -138,6 +138,107 @@ export abstract class DockerClientBase extends ConfigurableClient implements ICo
      */
     protected readonly defaultFormatForJson: string = "{{json .}}";
 
+    //#region Output parsing helpers
+
+    /**
+     * Parse newline-delimited JSON output (one JSON object per line, as emitted
+     * by `--format "{{json .}}"`) into normalized items. Empty lines are skipped.
+     * In non-strict mode, per-line and top-level parse errors are swallowed and
+     * whatever was successfully parsed is returned; in strict mode they propagate.
+     * @param output The raw command output
+     * @param strict Whether to throw on parse errors
+     * @param parseOne Callback that parses and normalizes a single line of JSON
+     * @returns The normalized items
+     */
+    protected parsePerLineJson<T>(output: string, strict: boolean, parseOne: (json: string) => T): Promise<Array<T>> {
+        const results = new Array<T>();
+
+        // Split on \r?\n so both LF and CRLF line endings are handled cleanly.
+        for (const line of output.split(/\r?\n/)) {
+            if (!line) {
+                continue;
+            }
+
+            try {
+                results.push(parseOne(line));
+            } catch (err) {
+                if (strict) {
+                    throw err;
+                }
+            }
+        }
+
+        return Promise.resolve(results);
+    }
+
+    /**
+     * Parse command output that may be either a single JSON value (array or
+     * object) or newline-delimited JSON objects. This handles clients/commands
+     * that inconsistently emit a JSON array vs. one object per line (e.g. multi
+     * target inspect).
+     * @param output The raw command output
+     * @param strict Whether to throw when a newline-delimited line fails to parse
+     * @returns The parsed values as a flat array of unknowns
+     */
+    protected parseJsonArrayOrLines(output: string, strict: boolean = false): Array<unknown> {
+        const trimmed = output.trim();
+        if (!trimmed) {
+            return [];
+        }
+
+        // First, try to parse the whole output as a single JSON value
+        try {
+            const parsed: unknown = JSON.parse(trimmed);
+            return Array.isArray(parsed) ? parsed as Array<unknown> : [parsed];
+        } catch {
+            // Not a single JSON value (e.g. newline-delimited objects); fall through.
+        }
+
+        // Fall back to newline-delimited JSON objects (LF or CRLF)
+        const results = new Array<unknown>();
+        for (const line of trimmed.split(/\r?\n/)) {
+            if (!line) {
+                continue;
+            }
+            try {
+                results.push(JSON.parse(line));
+            } catch (err) {
+                if (strict) {
+                    throw err;
+                }
+                // Otherwise skip unparseable lines
+            }
+        }
+        return results;
+    }
+
+    /**
+     * Parse inspect-style output (a JSON array or newline-delimited JSON objects)
+     * into normalized items. In non-strict mode, per-item normalization errors are
+     * swallowed; in strict mode they propagate.
+     * @param output The raw command output
+     * @param strict Whether to throw on normalization errors
+     * @param normalizeOne Callback that validates and normalizes a single parsed record
+     * @returns The normalized items
+     */
+    protected parseInspectJson<T>(output: string, strict: boolean, normalizeOne: (item: unknown) => T): Promise<Array<T>> {
+        const results = new Array<T>();
+
+        for (const item of this.parseJsonArrayOrLines(output, strict)) {
+            try {
+                results.push(normalizeOne(item));
+            } catch (err) {
+                if (strict) {
+                    throw err;
+                }
+            }
+        }
+
+        return Promise.resolve(results);
+    }
+
+    //#endregion
+
     //#region Information Commands
 
     protected getInfoCommandArgs(

packages/vscode-container-client/src/clients/DockerClientBase/parseDockerLikeLabels.ts

@@ -4,34 +4,17 @@
  *--------------------------------------------------------------------------------------------*/
 
 import { Labels } from "../../contracts/ContainerClient";
+import { parseLabelsString } from "../../contracts/ZodTransforms";
 
 /**
  * Parse Docker-like label string
- * @param rawLabels Comma seperated string of labels
+ * @param rawLabels Comma separated string of labels
  * @returns A {@link Labels} record
+ *
+ * Thin wrapper that delegates to {@link parseLabelsString} so the schema
+ * transforms in `contracts/ZodTransforms` and this client helper share a single
+ * implementation.
  */
 export function parseDockerLikeLabels(rawLabels: string): Labels {
-    const labels: Labels = {};
-    let lastKey: string | undefined;
-
-    for (const fragment of rawLabels.split(',')) {
-        const index = fragment.indexOf('=');
-
-        if (index < 0) {
-            // No '=' means this fragment is a continuation of the previous label's
-            // value, which itself contained a comma (e.g. multiple compose config
-            // files in `com.docker.compose.project.config_files`). `docker ... ls`
-            // joins labels with commas and does not escape commas inside values, so
-            // we stitch the value back together here.
-            if (lastKey !== undefined) {
-                labels[lastKey] += `,${fragment}`;
-            }
-            continue;
-        }
-
-        lastKey = fragment.substring(0, index);
-        labels[lastKey] = fragment.substring(index + 1);
-    }
-
-    return labels;
+    return parseLabelsString(rawLabels);
 }

packages/vscode-container-client/src/clients/DockerClientBase/parseDockerRawPortString.ts

@@ -6,32 +6,49 @@
 import { PortBinding } from '../../contracts/ContainerClient';
 import { normalizeIpAddress } from './normalizeIpAddress';
 
+const shortFormRegex = /^(?<containerPort>\d+)\/(?<protocol>tcp|udp)$/i;
+
+// Supports:
+// - hostPort->containerPort[/protocol]
+// - hostIp:hostPort->containerPort[/protocol]
+// - [ipv6]:hostPort->containerPort[/protocol]
+// - bare IPv6 host without brackets, e.g. Docker's `:::8080->80/tcp` wildcard
+//   or `::1:8080->80/tcp`. The optional host is captured lazily up to the last
+//   `:` before the host port, so embedded IPv6 colons are preserved; brackets
+//   (if any) are stripped by normalizeIpAddress.
+const longFormRegex = /^(?:(?<host>\[[^\]]*\]|[^\s]*?):)?(?<hostPort>\d+)\s*->\s*(?<containerPort>\d+)(?:\/(?<protocol>tcp|udp))?$/i;
+
 /**
  * Attempt to parse a Docker-like raw port binding string
  * @param portString the raw port string to parse, e.g. "1234/tcp" or "0.0.0.0:1234->1234/udp"
  * @returns Parsed raw port string as a PortBinding record or undefined if invalid
  */
 export function parseDockerRawPortString(portString: string): PortBinding | undefined {
-    const portRegex = /((?<hostIp>[\da-f.:[\]]+)(:(?<hostPort>\d+)))?(\s*->\s*)?((?<containerPort>\d+)\/(?<protocol>tcp|udp))/i;
-    const result = portRegex.exec(portString);
-
-    if (!result?.groups) {
+    const trimmed = portString.trim();
+    if (!trimmed) {
         return undefined;
     }
 
-    const hostIp = result.groups.hostIp || undefined;
-    const hostPort = result.groups.hostPort ? Number.parseInt(result.groups.hostPort) : undefined;
-    const containerPort = result.groups.containerPort ? Number.parseInt(result.groups.containerPort) : undefined;
-    const protocol = result.groups.protocol || undefined;
+    const shortMatch = shortFormRegex.exec(trimmed);
+    if (shortMatch?.groups) {
+        return {
+            containerPort: Number.parseInt(shortMatch.groups.containerPort, 10),
+            protocol: shortMatch.groups.protocol.toLowerCase() as 'tcp' | 'udp',
+        };
+    }
 
-    if (containerPort === undefined || (protocol !== 'tcp' && protocol !== 'udp')) {
+    const longMatch = longFormRegex.exec(trimmed);
+    if (!longMatch?.groups) {
         return undefined;
     }
 
+    const hostIp = normalizeIpAddress(longMatch.groups.host);
+    const protocol = (longMatch.groups.protocol?.toLowerCase() as 'tcp' | 'udp' | undefined) ?? 'tcp';
+
     return {
-        hostIp: normalizeIpAddress(hostIp),
-        hostPort,
-        containerPort,
+        ...(hostIp !== undefined ? { hostIp } : {}),
+        hostPort: Number.parseInt(longMatch.groups.hostPort, 10),
+        containerPort: Number.parseInt(longMatch.groups.containerPort, 10),
         protocol,
     };
 }

packages/vscode-container-client/src/clients/DockerComposeClientBase/DockerComposeClientBase.ts

@@ -29,7 +29,7 @@ import {
 } from '../../contracts/ContainerOrchestratorClient';
 import { ConfigurableClient } from '../ConfigurableClient';
 
-function withCommonOrchestratorArgs(options: CommonOrchestratorCommandOptions): CommandLineCurryFn {
+export function withCommonOrchestratorArgs(options: CommonOrchestratorCommandOptions): CommandLineCurryFn {
     return composeArgs(
         withNamedArg('--file', options.files),
         withNamedArg('--env-file', options.environmentFile),
@@ -38,7 +38,7 @@ function withCommonOrchestratorArgs(options: CommonOrchestratorCommandOptions):
     );
 }
 
-function withComposeArg(composeV2: boolean): CommandLineCurryFn {
+export function withComposeArg(composeV2: boolean): CommandLineCurryFn {
     // If using Compose V2, then add the `compose` argument at the beginning
     // That way, the command is `docker compose` instead of `docker-compose`
     return withArg(composeV2 ? 'compose' : undefined);