@vibesdotdev/integrations-kubernetes 0.0.0-stage → 1.0.0-rc.1

package/dist/kind-cluster.js

@@ -0,0 +1,694 @@
+/**
+ * Kind Cluster Resource Provider
+ * Manages Kind (Kubernetes in Docker) cluster lifecycle including local registry
+ *
+ * Handles:
+ * - Cluster creation with local registry
+ * - Orphaned registry detection and cleanup
+ * - Cluster recovery (restart vs recreate)
+ * - Full lifecycle management
+ */
+import { CapabilityError, requireRuntimeCwd } from '@vibesdotdev/kernel';
+import { getLogger } from '@vibesdotdev/logging';
+import * as z from 'zod/v4';
+import { createSha256 } from '@vibesdotdev/shared/hashing';
+import { composePMChildEnv } from '@vibesdotdev/pm/helpers/process-env';
+import { pollUntil } from '@vibesdotdev/pm/utils/bounded-wait';
+import { runCapture, runTimedCapture } from '@vibesdotdev/pm/utils/exec';
+import { attempt } from '@vibesdotdev/pm/utils/attempt';
+import { hasErrno, rethrowFailure } from '@vibesdotdev/pm/helpers/failure';
+import { pmFileSystem, readBytesFileIfPresent } from '@vibesdotdev/pm/helpers/runtime-files';
+import { toolFailure, toolOutputExcerpt } from '@vibesdotdev/pm/resources/tool-env';
+import { DOCKER_TOOL_INHERIT_ENV } from "./tool-env.js";
+/**
+ * Kind cluster provider configuration schema
+ */
+const KindClusterConfigSchema = z.object({
+    /** Cluster name (defaults to resource ID) */
+    name: z.string().min(1).optional(),
+    /** Enable local registry (default: true) */
+    registry: z.boolean().default(true),
+    /** Registry port (default: 5001) */
+    registryPort: z.number().int().min(1024).max(65535).default(5001),
+    /** Registry container name (default: kind-registry) */
+    registryName: z.string().default('kind-registry'),
+    /** Kind config file path (optional) */
+    configFile: z.string().optional(),
+    /** Node image (optional, uses kind default) */
+    nodeImage: z.string().optional(),
+    /** Wait timeout for cluster ready (ms) */
+    waitTimeout: z.number().int().min(0).default(120000)
+});
+/** What a cluster's stored state remembers: the names it was created under. */
+const KindStateMetadataSchema = z.object({
+    clusterName: z.string().optional().catch(undefined),
+    registryName: z.string().optional().catch(undefined)
+});
+/** A container's published ports (`docker inspect -f '{{json .NetworkSettings.Ports}}'`): container port to host bindings. */
+const PortBindingsSchema = z
+    .record(z.string(), z.array(z.object({ HostIp: z.string().optional(), HostPort: z.string().optional() })).nullable())
+    .nullable()
+    .catch(null);
+const STATUS_CHECK_TIMEOUT_MS = 5000;
+async function detectDockerHost(runtime) {
+    const tryDocker = async (env) => {
+        const probe = await attempt(() => runTimedCapture(runtime, 'docker', ['info'], {
+            env,
+            inheritEnv: DOCKER_TOOL_INHERIT_ENV,
+            signal: runtime.lifecycle.signal,
+            timeoutMs: 3000
+        }));
+        if (probe.ok)
+            return !probe.value.timedOut && probe.value.exitCode === 0;
+        // No docker binary (ENOENT) or a daemon that did not answer within the
+        // probe's 3s budget: this host is not usable, a typed "no". Anything
+        // else is real.
+        const { failure } = probe;
+        const timedOut = failure instanceof Error && failure.name === 'TimeoutError';
+        if (hasErrno(failure, 'ENOENT') || timedOut)
+            return false;
+        return rethrowFailure(failure);
+    };
+    if (await tryDocker())
+        return null;
+    const home = runtime.getEnvSnapshot().HOME || '';
+    const candidates = [
+        `unix://${home}/Library/Containers/com.docker.docker/Data/docker.raw.sock`,
+        `unix://${home}/.docker/run/docker.sock`,
+        'unix:///var/run/docker.sock'
+    ];
+    const files = await pmFileSystem(runtime);
+    for (const candidate of candidates) {
+        const socketPath = candidate.replace('unix://', '');
+        // A candidate socket that is not there is skipped.
+        if (!(await files.exists(socketPath)))
+            continue;
+        if (await tryDocker({ ...(await dockerBaseEnv(runtime)), DOCKER_HOST: candidate })) {
+            return candidate;
+        }
+    }
+    return null;
+}
+/**
+ * The docker/kind CLIs' environment (C15): PM's base set and the host's
+ * re-entry facts and roots, plus the container-engine variables they read.
+ */
+function dockerBaseEnv(runtime) {
+    return composePMChildEnv(runtime, {
+        inheritEnv: DOCKER_TOOL_INHERIT_ENV
+    });
+}
+async function dockerEnv(runtime) {
+    const host = await detectDockerHost(runtime);
+    const env = await dockerBaseEnv(runtime);
+    if (host)
+        env.DOCKER_HOST = host;
+    return env;
+}
+/**
+ * Check if a Docker container exists
+ */
+async function containerExists(runtime, name) {
+    const { exitCode } = await runCapture(runtime, 'docker', ['inspect', name], {
+        env: await dockerEnv(runtime),
+        signal: runtime.lifecycle.signal,
+        inheritEnv: DOCKER_TOOL_INHERIT_ENV
+    });
+    return exitCode === 0;
+}
+/**
+ * Check if a Docker container is running
+ */
+async function containerRunning(runtime, name) {
+    const { stdout, exitCode } = await runCapture(runtime, 'docker', ['inspect', '--format', '{{.State.Running}}', name], {
+        env: await dockerEnv(runtime),
+        signal: runtime.lifecycle.signal,
+        inheritEnv: DOCKER_TOOL_INHERIT_ENV
+    });
+    return exitCode === 0 && stdout.trim() === 'true';
+}
+/** Check the cluster list within the caller's probe budget. */
+async function clusterExists(runtime, name, timeoutMs = STATUS_CHECK_TIMEOUT_MS) {
+    const result = await runTimedCapture(runtime, 'kind', ['get', 'clusters'], {
+        timeoutMs,
+        env: await dockerEnv(runtime),
+        signal: runtime.lifecycle.signal,
+        inheritEnv: DOCKER_TOOL_INHERIT_ENV
+    });
+    return !result.timedOut && result.exitCode === 0 && result.stdout.trim().split('\n').includes(name);
+}
+/**
+ * Check if kind cluster node is ready
+ */
+async function isNodeReady(runtime, clusterName, timeoutMs) {
+    const args = [
+        '--context', `kind-${clusterName}`, 'get', 'nodes', '-o',
+        'jsonpath={.items[0].status.conditions[?(@.type=="Ready")].status}'
+    ];
+    const options = { signal: runtime.lifecycle.signal, inheritEnv: DOCKER_TOOL_INHERIT_ENV };
+    const result = timeoutMs === undefined
+        ? await runCapture(runtime, 'kubectl', args, options)
+        : await runTimedCapture(runtime, 'kubectl', args, { ...options, timeoutMs });
+    return !('timedOut' in result && result.timedOut) && result.exitCode === 0 && result.stdout.trim() === 'True';
+}
+/**
+ * Detect orphaned registry container (registry exists but cluster doesn't)
+ */
+async function detectOrphanedRegistry(runtime, clusterName, registryName) {
+    const [hasCluster, registryExists, registryRunning] = await Promise.all([
+        clusterExists(runtime, clusterName),
+        containerExists(runtime, registryName),
+        containerRunning(runtime, registryName)
+    ]);
+    // Orphaned if registry exists but cluster doesn't
+    if (!hasCluster && registryExists) {
+        return { orphaned: true, running: registryRunning };
+    }
+    return { orphaned: false, running: registryRunning };
+}
+/**
+ * Clean up orphaned registry container
+ */
+async function cleanupOrphanedRegistry(runtime, registryName) {
+    const env = await dockerEnv(runtime);
+    await runCapture(runtime, 'docker', ['stop', registryName], {
+        env,
+        signal: runtime.lifecycle.signal,
+        inheritEnv: DOCKER_TOOL_INHERIT_ENV
+    });
+    await runCapture(runtime, 'docker', ['rm', registryName], {
+        env,
+        signal: runtime.lifecycle.signal,
+        inheritEnv: DOCKER_TOOL_INHERIT_ENV
+    });
+}
+/**
+ * Create local Docker registry for kind
+ */
+async function createRegistry(runtime, name, port) {
+    // Check if already exists and running
+    if (await containerRunning(runtime, name)) {
+        return;
+    }
+    // Remove if exists but not running
+    if (await containerExists(runtime, name)) {
+        await runCapture(runtime, 'docker', ['rm', name], {
+            env: await dockerEnv(runtime),
+            signal: runtime.lifecycle.signal,
+            inheritEnv: DOCKER_TOOL_INHERIT_ENV
+        });
+    }
+    // Create registry container
+    const { exitCode, stderr } = await runCapture(runtime, 'docker', [
+        'run',
+        '-d',
+        '--restart=always',
+        '-p',
+        `127.0.0.1:${port}:5000`,
+        '--network',
+        'bridge',
+        '--name',
+        name,
+        'registry:2'
+    ], {
+        env: await dockerEnv(runtime),
+        signal: runtime.lifecycle.signal,
+        inheritEnv: DOCKER_TOOL_INHERIT_ENV
+    });
+    if (exitCode !== 0) {
+        throw toolFailure({ tool: 'docker', action: 'run registry', outcome: { exitCode, stderr } });
+    }
+}
+/**
+ * Create kind cluster with registry configuration
+ */
+async function createCluster(runtime, name, config) {
+    const args = ['create', 'cluster', '--name', name];
+    if (config.nodeImage) {
+        args.push('--image', config.nodeImage);
+    }
+    if (config.configFile) {
+        args.push('--config', config.configFile);
+    }
+    // Create cluster
+    const { exitCode, stderr } = await runCapture(runtime, 'kind', args, {
+        env: await dockerEnv(runtime),
+        signal: runtime.lifecycle.signal,
+        inheritEnv: DOCKER_TOOL_INHERIT_ENV
+    });
+    if (exitCode !== 0) {
+        throw toolFailure({ tool: 'kind', action: 'create cluster', outcome: { exitCode, stderr } });
+    }
+    // Connect registry to kind network if registry is enabled
+    if (config.registry) {
+        await connectRegistryToCluster(runtime, name, config.registryName);
+    }
+}
+/**
+ * Connect registry container to kind network
+ */
+async function connectRegistryToCluster(runtime, clusterName, registryName) {
+    const networkName = 'kind';
+    const env = await dockerEnv(runtime);
+    // Check if already connected
+    const { stdout } = await runCapture(runtime, 'docker', [
+        'inspect',
+        '--format',
+        '{{range $key, $value := .NetworkSettings.Networks}}{{$key}} {{end}}',
+        registryName
+    ], {
+        env,
+        signal: runtime.lifecycle.signal,
+        inheritEnv: DOCKER_TOOL_INHERIT_ENV
+    });
+    if (stdout.includes(networkName)) {
+        return; // Already connected
+    }
+    // Connect to kind network
+    const { exitCode, stderr } = await runCapture(runtime, 'docker', ['network', 'connect', networkName, registryName], {
+        env,
+        signal: runtime.lifecycle.signal,
+        inheritEnv: DOCKER_TOOL_INHERIT_ENV
+    });
+    // Ignore "already connected" errors
+    if (exitCode !== 0 && !stderr.includes('already exists')) {
+        getLogger('pm:kind-cluster', runtime).warn('Could not connect registry to kind network', {
+            registryName,
+            exitCode,
+            output: toolOutputExcerpt(stderr)
+        });
+    }
+    // Configure nodes to use the local registry
+    await configureRegistryInCluster(runtime, clusterName, registryName);
+}
+/**
+ * Configure kind cluster nodes to use local registry
+ */
+async function configureRegistryInCluster(runtime, clusterName, _registryName) {
+    const context = `kind-${clusterName}`;
+    // Create ConfigMap for local registry hosting
+    const configMap = `
+apiVersion: v1
+kind: ConfigMap
+metadata:
+  name: local-registry-hosting
+  namespace: kube-public
+data:
+  localRegistryHosting.v1: |
+    host: "localhost:5001"
+    help: "https://kind.sigs.k8s.io/docs/user/local-registry/"
+`;
+    await runCapture(runtime, 'kubectl', ['--context', context, 'apply', '-f', '-'], {
+        signal: runtime.lifecycle.signal,
+        inheritEnv: DOCKER_TOOL_INHERIT_ENV,
+        stdin: configMap
+    });
+}
+/**
+ * Read a container's host-side port bindings.
+ * Returns a map of containerPort/proto → [{ HostIp, HostPort }, ...].
+ * Empty object on inspect failure.
+ */
+async function getContainerPortBindings(runtime, containerName) {
+    const { stdout, exitCode } = await runCapture(runtime, 'docker', ['inspect', '--format', '{{json .NetworkSettings.Ports}}', containerName], {
+        env: await dockerEnv(runtime),
+        signal: runtime.lifecycle.signal,
+        inheritEnv: DOCKER_TOOL_INHERIT_ENV
+    });
+    if (exitCode !== 0)
+        return {};
+    // docker's own JSON that does not parse is a failure, never "no ports".
+    return PortBindingsSchema.parse(JSON.parse(stdout)) ?? {};
+}
+/**
+ * List PersistentVolumeClaims in the cluster whose underlying storage
+ * would be lost on `kind delete cluster`. By default, kind uses the
+ * local-path-provisioner which writes data into the kind container's
+ * filesystem — NOT a host bind mount — so PVCs are destroyed with the
+ * cluster. Returns a list of `<namespace>/<name>` strings.
+ *
+ * Returns an empty list when kubectl is unavailable, the context doesn't
+ * exist, or there are no PVCs — the recreate command treats that as
+ * "no stateful data at risk".
+ */
+export async function listAtRiskPVCs(runtime, clusterName) {
+    const context = `kind-${clusterName}`;
+    const { stdout, exitCode, timedOut } = await runTimedCapture(runtime, 'kubectl', [
+        '--context',
+        context,
+        'get',
+        'pvc',
+        '--all-namespaces',
+        '-o',
+        'jsonpath={range .items[*]}{.metadata.namespace}/{.metadata.name}|{.spec.storageClassName}{"\\n"}{end}'
+    ], {
+        timeoutMs: STATUS_CHECK_TIMEOUT_MS,
+        env: await dockerEnv(runtime),
+        signal: runtime.lifecycle.signal,
+        inheritEnv: DOCKER_TOOL_INHERIT_ENV
+    });
+    if (timedOut || exitCode !== 0 || !stdout)
+        return [];
+    const atRisk = [];
+    for (const line of stdout.split('\n')) {
+        const trimmed = line.trim();
+        if (!trimmed)
+            continue;
+        const [identity, storageClass = ''] = trimmed.split('|');
+        // local-path is kind's default provisioner — backed by the kind
+        // container's filesystem, lost on cluster delete. Any other
+        // storageClass is opt-in and assumed to be persistent.
+        if (storageClass === '' ||
+            storageClass === 'standard' ||
+            storageClass.startsWith('local-path')) {
+            atRisk.push(identity);
+        }
+    }
+    return atRisk;
+}
+/**
+ * Check if a container's port bindings are actually active.
+ * After a Docker Desktop restart, containers may have HostConfig.PortBindings
+ * configured but NetworkSettings.Ports empty — meaning Docker failed to bind them.
+ */
+async function hasActivePortBindings(runtime, containerName) {
+    const ports = await getContainerPortBindings(runtime, containerName);
+    for (const bindings of Object.values(ports)) {
+        if (bindings && bindings.length > 0)
+            return true;
+    }
+    return false;
+}
+/**
+ * Assert that the registry container is bound to the configured host
+ * port. Docker won't change port mappings on a running container, so a
+ * mismatch means the user changed `registryPort` in config but the
+ * change can't take effect without recreating the container.
+ */
+async function assertRegistryPortMatches(runtime, registryName, desiredHostPort) {
+    if (!(await containerExists(runtime, registryName)))
+        return;
+    const bindings = await getContainerPortBindings(runtime, registryName);
+    const containerPort = '5000/tcp';
+    const actual = bindings[containerPort] ?? [];
+    const matched = actual.some((b) => b.HostPort === String(desiredHostPort));
+    if (matched)
+        return;
+    const actualPorts = actual
+        .map((b) => b.HostPort)
+        .filter(Boolean)
+        .join(', ') || '<none>';
+    throw new CapabilityError(`Registry container '${registryName}' is bound to host port ${actualPorts} but config requests ${desiredHostPort}. ` +
+        `Docker can't change port mappings on a running container — run ` +
+        `\`vibes pm resource recreate ${registryName === 'kind-registry' ? 'kind-vibes-local' : registryName}\` ` +
+        `(with --force if the cluster has stateful data) to rebuild with the new port.`, 'CONFLICT', {
+        reason: 'pm-kind-registry-port-mismatch',
+        retryable: false,
+        details: { registryName, desiredHostPort }
+    });
+}
+/**
+ * Attempt to restart a stopped cluster container
+ */
+async function restartClusterContainer(runtime, clusterName) {
+    const containerName = `${clusterName}-control-plane`;
+    // Check if container exists
+    if (!(await containerExists(runtime, containerName))) {
+        return false;
+    }
+    // Check for broken port bindings (common after Docker Desktop restart).
+    // If port bindings are gone, a simple restart won't fix it — the cluster
+    // must be fully recreated.
+    if (!(await hasActivePortBindings(runtime, containerName))) {
+        getLogger('pm:kind-cluster', runtime).info('Port bindings lost (Docker Desktop restart?), the cluster must be recreated', {
+            containerName
+        });
+        return false;
+    }
+    // Try to restart
+    const { exitCode } = await runCapture(runtime, 'docker', ['restart', containerName], {
+        env: await dockerEnv(runtime),
+        signal: runtime.lifecycle.signal,
+        inheritEnv: DOCKER_TOOL_INHERIT_ENV
+    });
+    if (exitCode !== 0) {
+        return false;
+    }
+    // Wait for the node to become ready (up to 30s), bounded by the runtime
+    // lifecycle (RC07). Poll: the kind node (owner) answers readiness only when
+    // asked (`kubectl get nodes`); it publishes no event to this process.
+    return pollUntil(runtime, () => isNodeReady(runtime, clusterName), {
+        timeoutMs: 30_000,
+        intervalMs: 1_000,
+        reason: 'pm-kind-node-ready'
+    });
+}
+/**
+ * Delete kind cluster
+ */
+async function deleteCluster(runtime, name) {
+    const { exitCode, stderr } = await runCapture(runtime, 'kind', ['delete', 'cluster', '--name', name], {
+        env: await dockerEnv(runtime),
+        signal: runtime.lifecycle.signal,
+        inheritEnv: DOCKER_TOOL_INHERIT_ENV
+    });
+    if (exitCode !== 0 && !stderr.includes('no kind cluster')) {
+        throw toolFailure({ tool: 'kind', action: 'delete cluster', outcome: { exitCode, stderr } });
+    }
+}
+/**
+ * Delete registry container
+ */
+async function deleteRegistry(runtime, name) {
+    if (await containerExists(runtime, name)) {
+        const env = await dockerEnv(runtime);
+        await runCapture(runtime, 'docker', ['stop', name], {
+            env,
+            signal: runtime.lifecycle.signal,
+            inheritEnv: DOCKER_TOOL_INHERIT_ENV
+        });
+        await runCapture(runtime, 'docker', ['rm', name], {
+            env,
+            signal: runtime.lifecycle.signal,
+            inheritEnv: DOCKER_TOOL_INHERIT_ENV
+        });
+    }
+}
+/**
+ * Kind Cluster Provider
+ * Creates and manages Kind clusters with local registry support
+ */
+export class KindClusterProvider {
+    type = 'kind';
+    subType = 'cluster';
+    configStore = new Map();
+    /**
+     * Setup (create or ensure) a kind cluster
+     */
+    async setup(config, { runtime }) {
+        const clusterConfig = this.validateConfig(config.config);
+        const clusterName = clusterConfig.name || config.id;
+        const registryName = clusterConfig.registryName;
+        this.configStore.set(config.id, config);
+        const log = getLogger('pm:kind-cluster', runtime);
+        // Step 1: Check for orphaned registry and clean up
+        const orphanCheck = await detectOrphanedRegistry(runtime, clusterName, registryName);
+        if (orphanCheck.orphaned) {
+            log.info('Cleaning up orphaned registry', { registryName });
+            await cleanupOrphanedRegistry(runtime, registryName);
+        }
+        // Step 2: Check if cluster already exists and is healthy
+        const hasCluster = await clusterExists(runtime, clusterName);
+        if (hasCluster) {
+            // Catch port-mapping drift before reporting success — Docker
+            // won't change port bindings on a running container, so a
+            // config change to `registryPort` is silently ineffective
+            // without an explicit recreate.
+            if (clusterConfig.registry) {
+                await assertRegistryPortMatches(runtime, registryName, clusterConfig.registryPort);
+            }
+            const nodeReady = await isNodeReady(runtime, clusterName);
+            if (nodeReady) {
+                // Cluster exists and is healthy
+                return this.createSuccessResult(config, clusterName, clusterConfig, 'existing');
+            }
+            // Cluster exists but node not ready - try restart
+            log.info('Cluster exists but its node is not ready, attempting restart', { clusterName });
+            const restarted = await restartClusterContainer(runtime, clusterName);
+            if (restarted) {
+                return this.createSuccessResult(config, clusterName, clusterConfig, 'restarted');
+            }
+            // Restart failed - recreate
+            log.info('Restart failed, recreating the cluster', { clusterName });
+            await deleteCluster(runtime, clusterName);
+        }
+        // Step 3: Create registry if enabled
+        if (clusterConfig.registry) {
+            log.info('Creating local registry', { registryName, port: clusterConfig.registryPort });
+            await createRegistry(runtime, registryName, clusterConfig.registryPort);
+        }
+        // Step 4: Create cluster
+        log.info('Creating kind cluster', { clusterName });
+        await createCluster(runtime, clusterName, clusterConfig);
+        return this.createSuccessResult(config, clusterName, clusterConfig, 'created');
+    }
+    /**
+     * Create success result
+     */
+    createSuccessResult(config, clusterName, clusterConfig, action) {
+        const state = {
+            id: config.id,
+            type: 'kind/cluster',
+            status: 'ready',
+            createdAt: new Date(),
+            lastChecked: new Date(),
+            metadata: {
+                clusterName,
+                context: `kind-${clusterName}`,
+                registryEnabled: clusterConfig.registry,
+                registryName: clusterConfig.registryName,
+                registryPort: clusterConfig.registryPort,
+                action
+            }
+        };
+        return {
+            state,
+            metadata: {
+                clusterName,
+                context: `kind-${clusterName}`,
+                action,
+                message: action === 'created'
+                    ? `Kind cluster '${clusterName}' created successfully`
+                    : action === 'restarted'
+                        ? `Kind cluster '${clusterName}' restarted successfully`
+                        : `Kind cluster '${clusterName}' already exists and is healthy`
+            }
+        };
+    }
+    /**
+     * Teardown (delete) cluster and registry
+     */
+    async teardown(id, state, { runtime }) {
+        const storedConfig = this.configStore.get(id);
+        const clusterConfig = storedConfig
+            ? this.validateConfig(storedConfig.config)
+            : {
+                name: id,
+                registry: true,
+                registryName: 'kind-registry',
+                registryPort: 5001,
+                waitTimeout: 120000
+            };
+        const remembered = KindStateMetadataSchema.parse(state?.metadata ?? {});
+        const clusterName = remembered.clusterName || clusterConfig.name || id;
+        const registryName = remembered.registryName || clusterConfig.registryName;
+        // Delete cluster first
+        await deleteCluster(runtime, clusterName);
+        // Delete registry if it was created by us
+        if (clusterConfig.registry) {
+            await deleteRegistry(runtime, registryName);
+        }
+        this.configStore.delete(id);
+    }
+    /**
+     * Get status of cluster
+     */
+    async status(id, { runtime }) {
+        const storedConfig = this.configStore.get(id);
+        const clusterName = storedConfig ? this.validateConfig(storedConfig.config).name || id : id;
+        const hasCluster = await clusterExists(runtime, clusterName, STATUS_CHECK_TIMEOUT_MS);
+        if (!hasCluster) {
+            return { status: 'missing' };
+        }
+        const nodeReady = await isNodeReady(runtime, clusterName, STATUS_CHECK_TIMEOUT_MS);
+        if (!nodeReady) {
+            return {
+                status: 'error',
+                error: 'Cluster exists but node is not ready'
+            };
+        }
+        return {
+            status: 'ready',
+            metadata: {
+                clusterName,
+                context: `kind-${clusterName}`
+            }
+        };
+    }
+    /**
+     * Check if cluster is ready
+     */
+    async checkReady(config, _state, { runtime }) {
+        const clusterConfig = this.validateConfig(config.config);
+        const clusterName = clusterConfig.name || config.id;
+        // Check cluster exists
+        const hasCluster = await clusterExists(runtime, clusterName, STATUS_CHECK_TIMEOUT_MS);
+        if (!hasCluster) {
+            return {
+                ready: false,
+                reason: `Kind cluster '${clusterName}' does not exist`,
+                retryAfter: 5000
+            };
+        }
+        // Check node is ready
+        const nodeReady = await isNodeReady(runtime, clusterName, STATUS_CHECK_TIMEOUT_MS);
+        if (!nodeReady) {
+            return {
+                ready: false,
+                reason: `Kind cluster '${clusterName}' node is not ready`,
+                retryAfter: 2000
+            };
+        }
+        return { ready: true };
+    }
+    /**
+     * Validate provider-specific configuration
+     */
+    validateConfig(config) {
+        return KindClusterConfigSchema.parse(config);
+    }
+    /**
+     * Get human-readable description
+     */
+    describe(config) {
+        const clusterConfig = this.validateConfig(config.config);
+        const clusterName = clusterConfig.name || config.id;
+        const registry = clusterConfig.registry
+            ? ` with registry on port ${clusterConfig.registryPort}`
+            : '';
+        return `Kind cluster '${clusterName}'${registry}`;
+    }
+    /**
+     * Data a `kind delete cluster` would destroy: the cluster's PVCs on
+     * kind's default local-path provisioner (see {@link listAtRiskPVCs}).
+     */
+    async listAtRiskData(config, { runtime }) {
+        const clusterConfig = this.validateConfig(config.config);
+        return listAtRiskPVCs(runtime, clusterConfig.name || config.id);
+    }
+    async computeSourceHash(config, { runtime }) {
+        const clusterConfig = this.validateConfig(config.config);
+        const hash = createSha256();
+        hash.update(`name:${clusterConfig.name || config.id}\n`);
+        hash.update(`registry:${clusterConfig.registry}\n`);
+        hash.update(`registryPort:${clusterConfig.registryPort}\n`);
+        hash.update(`registryName:${clusterConfig.registryName}\n`);
+        if (clusterConfig.nodeImage)
+            hash.update(`nodeImage:${clusterConfig.nodeImage}\n`);
+        if (clusterConfig.configFile) {
+            const files = await pmFileSystem(runtime);
+            const absPath = files.resolve(requireRuntimeCwd(runtime), clusterConfig.configFile);
+            const content = await readBytesFileIfPresent(files, absPath);
+            if (content === undefined) {
+                // A missing config file is part of the hash.
+                hash.update(`configFile:${clusterConfig.configFile}:missing\n`);
+            }
+            else {
+                hash.update(`configFile:${clusterConfig.configFile}\n`);
+                hash.update(content);
+            }
+        }
+        return hash.digestHex();
+    }
+}
+//# sourceMappingURL=kind-cluster.js.map