@nexusgpu/repterm-plugin-kubectl 0.1.0

package/dist/index.js

@@ -0,0 +1,544 @@
+/**
+ * Kubectl Plugin for Repterm
+ *
+ * Provides Kubernetes-specific testing utilities and commands.
+ *
+ * @packageDocumentation
+ */
+import { definePlugin } from 'repterm-api';
+import { ApplyResult, DeleteResult, PatchResult, ScaleResult, LabelResult, WaitResult, } from './result.js';
+/**
+ * Create the kubectl plugin
+ *
+ * @example
+ * ```ts
+ * import { defineConfig, createTestWithPlugins } from 'repterm';
+ * import { kubectlPlugin } from '@nexusgpu/repterm-plugin-kubectl';
+ *
+ * const config = defineConfig({
+ *   plugins: [kubectlPlugin({ namespace: 'test' })] as const,
+ * });
+ *
+ * const test = createTestWithPlugins(config);
+ *
+ * test('deploy nginx', async (ctx) => {
+ *   await ctx.plugins.kubectl.apply(`...`);
+ *   await ctx.plugins.kubectl.waitForPod('nginx', 'Running');
+ * });
+ * ```
+ */
+export function kubectlPlugin(options = {}) {
+    let currentNamespace = options.namespace || 'default';
+    const kubeconfig = options.kubeconfig;
+    return definePlugin('kubectl', (ctx) => {
+        const testContext = ctx.testContext;
+        const buildCommand = (args) => {
+            let cmd = 'kubectl';
+            if (kubeconfig) {
+                cmd += ` --kubeconfig=${kubeconfig}`;
+            }
+            cmd += ` -n ${currentNamespace} ${args}`;
+            return cmd;
+        };
+        const executeCommand = async (args) => {
+            const cmd = buildCommand(args);
+            if (ctx.debug) {
+                console.log(`[kubectl] Executing: ${cmd}`);
+            }
+            const result = await testContext.terminal.run(`${cmd}`);
+            return result.output;
+        };
+        const methods = {
+            run: executeCommand,
+            command: (args) => buildCommand(args),
+            waitForPod: async (name, status = 'Running', timeout = 60000) => {
+                const timeoutSec = Math.ceil(timeout / 1000);
+                // Use kubectl wait instead of polling for cleaner recording
+                const cmd = buildCommand(`wait --for=jsonpath='{.status.phase}'=${status} pod/${name} --timeout=${timeoutSec}s`);
+                await testContext.terminal.run(cmd);
+            },
+            apply: async (yaml) => {
+                // Use heredoc to avoid quote> prompt in recording
+                const cmd = `cat <<'EOF' | kubectl -n ${currentNamespace} apply -f -
+${yaml.trim()}
+EOF`;
+                const result = await testContext.terminal.run(`${cmd}`);
+                return new ApplyResult(result.output, cmd, result.code);
+            },
+            delete: async (resource, name, options) => {
+                let args = `delete ${resource} ${name} --ignore-not-found`;
+                if (options?.force) {
+                    args += ' --grace-period=0 --force';
+                }
+                const cmd = buildCommand(args);
+                const result = await testContext.terminal.run(cmd, { timeout: options?.force ? 10000 : 60000 });
+                return new DeleteResult(result.output, cmd, result.code);
+            },
+            get: ((resource, name, options) => {
+                // Watch mode: start continuous watch, return Promise<WatchProcess>
+                if (options?.watch) {
+                    let args = name ? `get ${resource} ${name} -w` : `get ${resource} -w`;
+                    if (options.selector) {
+                        args += ` -l ${options.selector}`;
+                    }
+                    if (options.fieldSelector) {
+                        args += ` --field-selector=${options.fieldSelector}`;
+                    }
+                    if (options.allNamespaces) {
+                        args += ' -A';
+                    }
+                    if (options.output) {
+                        args += ` -o ${options.output}`;
+                    }
+                    const cmd = buildCommand(args);
+                    const proc = testContext.terminal.run(cmd);
+                    // Return Promise so caller must await; ensures stepTitle and command input complete
+                    return (async () => {
+                        await proc.start?.(); // Wait for input to finish
+                        return {
+                            interrupt: async () => {
+                                await proc.interrupt?.();
+                            }
+                        };
+                    })();
+                }
+                // Normal mode: fetch JSON data
+                return (async () => {
+                    let args = name ? `get ${resource} ${name}` : `get ${resource}`;
+                    if (options?.selector) {
+                        args += ` -l ${options.selector}`;
+                    }
+                    if (options?.fieldSelector) {
+                        args += ` --field-selector=${options.fieldSelector}`;
+                    }
+                    if (options?.allNamespaces) {
+                        args += ' -A';
+                    }
+                    args += ' -o json';
+                    // Build full command with optional jq filter
+                    let fullCmd = buildCommand(args);
+                    if (options?.jqFilter) {
+                        fullCmd += ` | jq '${options.jqFilter}'`;
+                    }
+                    const result = await testContext.terminal.run(fullCmd);
+                    let stdout;
+                    if (testContext.terminal.isPtyMode?.()) {
+                        const silentResult = await testContext.terminal.run(fullCmd, { silent: true });
+                        stdout = silentResult.stdout;
+                    }
+                    else {
+                        stdout = result.stdout;
+                    }
+                    // Check for kubectl errors before parsing JSON
+                    const trimmed = stdout.trim();
+                    if (trimmed.startsWith('error:') || trimmed.startsWith('Error') ||
+                        trimmed.includes('Error from server') || trimmed.includes('not found')) {
+                        throw new Error(`kubectl get failed: ${trimmed}`);
+                    }
+                    try {
+                        return JSON.parse(trimmed);
+                    }
+                    catch {
+                        return trimmed;
+                    }
+                })();
+            }),
+            getJsonPath: async (resource, name, jsonPath, options) => {
+                let args = `get ${resource} ${name}`;
+                if (options?.selector) {
+                    args += ` -l ${options.selector}`;
+                }
+                if (options?.fieldSelector) {
+                    args += ` --field-selector=${options.fieldSelector}`;
+                }
+                if (options?.allNamespaces) {
+                    args += ' -A';
+                }
+                // Ensure jsonPath is properly quoted
+                const escapedPath = jsonPath.startsWith('{') ? jsonPath : `{${jsonPath}}`;
+                args += ` -o jsonpath='${escapedPath}'`;
+                const cmd = buildCommand(args);
+                const result = await testContext.terminal.run(cmd);
+                const output = testContext.terminal.isPtyMode?.()
+                    ? (await testContext.terminal.run(cmd, { silent: true })).stdout
+                    : result.stdout;
+                const trimmed = output.trim();
+                // Handle empty/null values
+                if (trimmed === '' || trimmed === '<none>' || trimmed === '<nil>') {
+                    return undefined;
+                }
+                // Try to parse as JSON (numbers, booleans, etc.), otherwise return as string
+                try {
+                    return JSON.parse(trimmed);
+                }
+                catch {
+                    return trimmed;
+                }
+            },
+            exists: async (resource, name) => {
+                try {
+                    const cmd = buildCommand(`get ${resource} ${name} -o name`);
+                    const result = await testContext.terminal.run(`${cmd}`);
+                    // In PTY mode, use silent run for clean output
+                    let stdout = result.stdout;
+                    if (testContext.terminal.isPtyMode?.()) {
+                        const silentResult = await testContext.terminal.run(cmd, { silent: true });
+                        stdout = silentResult.stdout;
+                    }
+                    // Support both formats: deployment/name and deployment.apps/name
+                    return stdout.includes(`/${name}`);
+                }
+                catch {
+                    return false;
+                }
+            },
+            setNamespace: (namespace) => {
+                currentNamespace = namespace;
+            },
+            getNamespace: () => currentNamespace,
+            getKubeconfig: () => kubeconfig,
+            setCluster: (kubeConfigPath) => {
+                const quoted = kubeConfigPath.replace(/'/g, "'\\''");
+                return `export KUBECONFIG='${quoted}'`;
+            },
+            clusterInfo: async () => {
+                try {
+                    // Run cluster-info command
+                    let kubectlCmd = 'kubectl';
+                    if (kubeconfig) {
+                        kubectlCmd += ` --kubeconfig=${kubeconfig}`;
+                    }
+                    const result = await testContext.terminal.run(`${kubectlCmd} cluster-info`);
+                    const output = result.output;
+                    // Parse control plane URL
+                    const controlPlaneMatch = output.match(/Kubernetes (?:control plane|master) is running at (https?:\/\/[^\s]+)/);
+                    const coreDNSMatch = output.match(/CoreDNS is running at (https?:\/\/[^\s]+)/);
+                    // Get server version
+                    let serverVersion;
+                    try {
+                        const versionResult = await testContext.terminal.run(`${kubectlCmd} version --short 2>/dev/null || ${kubectlCmd} version -o json`, { silent: true });
+                        const versionOutput = versionResult.stdout;
+                        // Try to parse JSON format
+                        try {
+                            const versionJson = JSON.parse(versionOutput);
+                            serverVersion = versionJson.serverVersion?.gitVersion;
+                        }
+                        catch {
+                            // Try short format: Server Version: v1.28.0
+                            const versionMatch = versionOutput.match(/Server Version:\s*(v[\d.]+)/);
+                            serverVersion = versionMatch?.[1];
+                        }
+                    }
+                    catch {
+                        // Ignore version fetch errors
+                    }
+                    return {
+                        reachable: true,
+                        controlPlane: controlPlaneMatch?.[1],
+                        coreDNS: coreDNSMatch?.[1],
+                        serverVersion,
+                    };
+                }
+                catch (e) {
+                    return {
+                        reachable: false,
+                        error: e instanceof Error ? e.message : String(e),
+                    };
+                }
+            },
+            // ===== New Core APIs =====
+            logs: async (podName, options) => {
+                let args = `logs ${podName}`;
+                if (options?.container)
+                    args += ` -c ${options.container}`;
+                if (options?.tail !== undefined)
+                    args += ` --tail=${options.tail}`;
+                if (options?.since)
+                    args += ` --since=${options.since}`;
+                if (options?.previous)
+                    args += ` --previous`;
+                if (options?.follow)
+                    args += ` -f`;
+                return executeCommand(args);
+            },
+            exec: async (podName, command, options) => {
+                const cmd = Array.isArray(command) ? command.join(' ') : command;
+                let args = `exec ${podName}`;
+                if (options?.container)
+                    args += ` -c ${options.container}`;
+                args += ` -- ${cmd}`;
+                return executeCommand(args);
+            },
+            describe: async (resource, name) => {
+                const args = name ? `describe ${resource} ${name}` : `describe ${resource}`;
+                return executeCommand(args);
+            },
+            wait: async (resource, name, condition, options) => {
+                const timeoutMs = options?.timeout ?? 20000;
+                const timeoutSec = Math.ceil(timeoutMs / 1000);
+                let cmd;
+                if (options?.forDelete) {
+                    cmd = buildCommand(`wait ${resource}/${name} --for=delete --timeout=${timeoutSec}s`);
+                }
+                else {
+                    cmd = buildCommand(`wait ${resource}/${name} --for=condition=${condition} --timeout=${timeoutSec}s`);
+                }
+                const result = await testContext.terminal.run(cmd);
+                return new WaitResult(result.output, cmd, result.code);
+            },
+            waitForJsonPath: async (resource, name, jsonPath, value, timeout = 60000) => {
+                const timeoutSec = Math.ceil(timeout / 1000);
+                // Ensure jsonPath is properly formatted for kubectl wait
+                const formattedPath = jsonPath.startsWith('{') ? jsonPath : `{${jsonPath}}`;
+                await executeCommand(`wait ${resource}/${name} --for=jsonpath='${formattedPath}'=${value} --timeout=${timeoutSec}s`);
+            },
+            waitForReplicas: async (resource, name, count, timeout = 60000) => {
+                const startTime = Date.now();
+                const checkInterval = 2000;
+                while (Date.now() - startTime < timeout) {
+                    try {
+                        const res = await methods.get(resource, name);
+                        const readyReplicas = res?.status?.readyReplicas ?? 0;
+                        if (readyReplicas >= count) {
+                            return;
+                        }
+                    }
+                    catch {
+                        // Resource might not exist yet, continue waiting
+                    }
+                    await new Promise((resolve) => setTimeout(resolve, checkInterval));
+                }
+                throw new Error(`Timeout waiting for ${resource}/${name} to have ${count} ready replicas`);
+            },
+            // ===== Resource Management APIs =====
+            scale: async (resource, name, replicas) => {
+                const cmd = buildCommand(`scale ${resource}/${name} --replicas=${replicas}`);
+                const result = await testContext.terminal.run(cmd);
+                return new ScaleResult(result.output, cmd, result.code);
+            },
+            patch: async (resource, name, patch, type = 'strategic') => {
+                const patchStr = typeof patch === 'string' ? patch : JSON.stringify(patch);
+                const escapedPatch = patchStr.replace(/'/g, "'\\''");
+                const cmd = buildCommand(`patch ${resource} ${name} --type=${type} -p '${escapedPatch}'`);
+                const result = await testContext.terminal.run(cmd);
+                return new PatchResult(result.output, cmd, result.code);
+            },
+            label: async (resource, name, labels) => {
+                const labelArgs = Object.entries(labels)
+                    .map(([key, value]) => (value === null ? `${key}-` : `${key}=${value}`))
+                    .join(' ');
+                const cmd = buildCommand(`label ${resource} ${name} ${labelArgs} --overwrite`);
+                const result = await testContext.terminal.run(cmd);
+                return new LabelResult(result.output, cmd, result.code);
+            },
+            annotate: async (resource, name, annotations) => {
+                const annotationArgs = Object.entries(annotations)
+                    .map(([key, value]) => (value === null ? `${key}-` : `${key}=${value}`))
+                    .join(' ');
+                const cmd = buildCommand(`annotate ${resource} ${name} ${annotationArgs} --overwrite`);
+                const result = await testContext.terminal.run(cmd);
+                return new LabelResult(result.output, cmd, result.code);
+            },
+            // ===== Rollout Management =====
+            rollout: {
+                status: async (resource, name) => {
+                    // Get resource status via JSON
+                    const res = await methods.get(resource, name);
+                    const status = res?.status ?? {};
+                    const conditions = status.conditions ?? [];
+                    const availableCondition = conditions.find((c) => c.type === 'Available');
+                    const progressingCondition = conditions.find((c) => c.type === 'Progressing');
+                    const ready = availableCondition?.status === 'True' &&
+                        (progressingCondition?.status === 'True' || status.updatedReplicas === status.replicas);
+                    return {
+                        ready,
+                        replicas: status.replicas ?? 0,
+                        updatedReplicas: status.updatedReplicas ?? 0,
+                        availableReplicas: status.availableReplicas ?? 0,
+                    };
+                },
+                history: async (resource, name) => {
+                    const output = await executeCommand(`rollout history ${resource}/${name}`);
+                    const lines = output.split('\n').filter((line) => line.trim());
+                    // Parse history output
+                    const entries = [];
+                    for (const line of lines) {
+                        const match = line.match(/^\s*(\d+)\s+(.*)$/);
+                        if (match) {
+                            entries.push({
+                                revision: parseInt(match[1], 10),
+                                changeCause: match[2].trim() || undefined,
+                            });
+                        }
+                    }
+                    return entries;
+                },
+                undo: async (resource, name, revision) => {
+                    const args = revision !== undefined ? `--to-revision=${revision}` : '';
+                    await executeCommand(`rollout undo ${resource}/${name} ${args}`.trim());
+                },
+                restart: async (resource, name) => {
+                    await executeCommand(`rollout restart ${resource}/${name}`);
+                },
+                pause: async (resource, name) => {
+                    await executeCommand(`rollout pause ${resource}/${name}`);
+                },
+                resume: async (resource, name) => {
+                    await executeCommand(`rollout resume ${resource}/${name}`);
+                },
+            },
+            // ===== Advanced Features =====
+            portForward: async (resource, ports, options) => {
+                const address = options?.address ?? '127.0.0.1';
+                const [localPortStr] = ports.split(':');
+                const localPort = parseInt(localPortStr, 10);
+                // Build the kubectl command
+                const args = ['kubectl'];
+                if (currentNamespace) {
+                    args.push('-n', currentNamespace);
+                }
+                args.push('port-forward', resource, ports, `--address=${address}`);
+                // Start port-forward using Bun.spawn (silent, not in terminal)
+                const proc = Bun.spawn(args, {
+                    stdout: 'pipe',
+                    stderr: 'pipe',
+                });
+                // Wait for port-forward to establish
+                const delay = options?.delay ?? 2000;
+                await new Promise((resolve) => setTimeout(resolve, delay));
+                return {
+                    localPort,
+                    stop: async () => {
+                        // Kill the process directly
+                        proc.kill();
+                        await proc.exited;
+                    },
+                };
+            },
+            waitForService: async (name, timeout = 60000) => {
+                const timeoutSec = Math.ceil(timeout / 1000);
+                // Use kubectl wait for Endpoints to have addresses instead of polling
+                const waitCmd = buildCommand(`wait --for=jsonpath='{.subsets[0].addresses}' endpoints/${name} --timeout=${timeoutSec}s`);
+                await testContext.terminal.run(waitCmd);
+                // Fetch Service and Endpoints details
+                const svc = await methods.get('service', name);
+                const endpoints = await methods.get('endpoints', name);
+                const clusterIP = svc?.spec?.clusterIP;
+                const port = svc?.spec?.ports?.[0]?.port;
+                const addresses = endpoints?.subsets?.[0]?.addresses ?? [];
+                if (!clusterIP || !port) {
+                    throw new Error(`Service ${name} missing clusterIP or port`);
+                }
+                return {
+                    clusterIP,
+                    port,
+                    endpoints: addresses.map((a) => a.ip),
+                };
+            },
+            getEvents: async (options) => {
+                let args = 'get events -o json';
+                if (options?.fieldSelector) {
+                    args += ` --field-selector=${options.fieldSelector}`;
+                }
+                const cmd = buildCommand(args);
+                try {
+                    const result = await testContext.terminal.run(cmd);
+                    let stdout = result.stdout;
+                    if (testContext.terminal.isPtyMode?.()) {
+                        const silentResult = await testContext.terminal.run(cmd, { silent: true });
+                        stdout = silentResult.stdout;
+                    }
+                    const data = JSON.parse(stdout);
+                    const items = data.items ?? [];
+                    return items.map((item) => ({
+                        type: (item.type ?? 'Normal'),
+                        reason: item.reason ?? '',
+                        message: item.message ?? '',
+                        involvedObject: {
+                            kind: item.involvedObject?.kind ?? '',
+                            name: item.involvedObject?.name ?? '',
+                        },
+                        lastTimestamp: item.lastTimestamp ?? '',
+                    }));
+                }
+                catch {
+                    return [];
+                }
+            },
+            getNodes: async (options) => {
+                let args = 'get nodes -o json';
+                if (options?.selector) {
+                    args += ` -l ${options.selector}`;
+                }
+                const cmd = buildCommand(args);
+                try {
+                    const result = await testContext.terminal.run(cmd);
+                    let stdout = result.stdout;
+                    if (testContext.terminal.isPtyMode?.()) {
+                        const silentResult = await testContext.terminal.run(cmd, { silent: true });
+                        stdout = silentResult.stdout;
+                    }
+                    const data = JSON.parse(stdout);
+                    const items = data.items ?? [];
+                    return items.map((item) => {
+                        const conditions = item.status?.conditions ?? [];
+                        const readyCondition = conditions.find((c) => c.type === 'Ready');
+                        const labels = item.metadata?.labels ?? {};
+                        // Extract roles from labels
+                        const roles = Object.keys(labels)
+                            .filter((k) => k.startsWith('node-role.kubernetes.io/'))
+                            .map((k) => k.replace('node-role.kubernetes.io/', ''));
+                        const addresses = item.status?.addresses ?? [];
+                        const internalIP = addresses.find((a) => a.type === 'InternalIP')?.address ?? '';
+                        return {
+                            name: item.metadata?.name ?? '',
+                            status: (readyCondition?.status === 'True' ? 'Ready' : 'NotReady'),
+                            roles: roles.length > 0 ? roles : ['<none>'],
+                            version: item.status?.nodeInfo?.kubeletVersion ?? '',
+                            internalIP,
+                        };
+                    });
+                }
+                catch {
+                    return [];
+                }
+            },
+            cp: async (source, dest, options) => {
+                let args = `cp ${source} ${dest}`;
+                if (options?.container) {
+                    args += ` -c ${options.container}`;
+                }
+                await executeCommand(args);
+            },
+        };
+        const hooks = {
+            beforeTest: async () => {
+                if (ctx.debug) {
+                    console.log(`[kubectl] Using namespace: ${currentNamespace}`);
+                }
+            },
+            afterTest: async (_, error) => {
+                if (error && ctx.debug) {
+                    console.log(`[kubectl] Test failed, consider cleaning up resources`);
+                }
+            },
+        };
+        return {
+            methods,
+            hooks,
+            context: {
+                kubectl: {
+                    namespace: currentNamespace,
+                    kubeconfig,
+                },
+            },
+        };
+    });
+}
+export const defaultKubectlPlugin = kubectlPlugin();
+// Re-export matchers
+export { K8sResource, pod, deployment, service, statefulset, job, configmap, secret, resource, 
+// Tensor Fusion CRD wrappers
+gpupool, gpu, tensorfusionworkload, tensorfusionconnection, crd, registerK8sMatchers, } from './matchers.js';
+// Re-export result types
+export { KubectlResult, ApplyResult, DeleteResult, PatchResult, ScaleResult, LabelResult, } from './result.js';

package/dist/matchers.d.ts

@@ -0,0 +1,113 @@
+/**
+ * Kubernetes Matchers for Repterm
+ *
+ * Provides expect() matchers for Kubernetes resources.
+ * All operations are executed through kubectl API (PTY visible).
+ *
+ * @packageDocumentation
+ */
+import type { KubectlMethods } from './index.js';
+/**
+ * Augment bun:test Matchers to include K8s matcher methods.
+ * This provides TypeScript type information for dynamically added matchers.
+ */
+declare module 'bun:test' {
+    interface Matchers<T> {
+        /** Assert that a kubectl operation succeeded */
+        toBeSuccessful(): Promise<void>;
+        /** Assert that a resource exists in the cluster */
+        toExistInCluster(): Promise<void>;
+        /** Assert that a resource does not exist in the cluster */
+        toNotExistInCluster(): Promise<void>;
+        /** Assert that a Pod is in Running state */
+        toBeRunning(timeout?: number): Promise<void>;
+        /** Assert that a Pod has a specific phase */
+        toHavePhase(phase: string): Promise<void>;
+        /** Assert that a resource has a specific number of replicas */
+        toHaveReplicas(count: number): Promise<void>;
+        /** Assert that a resource has a specific number of ready replicas */
+        toHaveReadyReplicas(count: number): Promise<void>;
+        /** Assert that a resource has a specific number of available replicas */
+        toHaveAvailableReplicas(count: number): Promise<void>;
+        /** Assert that a Deployment is available */
+        toBeAvailable(): Promise<void>;
+        /** Assert that a resource has a specific label */
+        toHaveLabel(key: string, value?: string): Promise<void>;
+        /** Assert that a resource has a specific annotation */
+        toHaveAnnotation(key: string, value?: string): Promise<void>;
+        /** Assert that a resource has a specific condition */
+        toHaveCondition(type: string, status: 'True' | 'False' | 'Unknown'): Promise<void>;
+        /** Assert that a resource has a specific status field value (supports dot notation for nested paths) */
+        toHaveStatusField(path: string, value: unknown): Promise<void>;
+    }
+}
+/**
+ * Wrapper class for Kubernetes resources
+ * Holds reference to kubectl methods for matcher operations
+ */
+export declare class K8sResource {
+    readonly kubectl: KubectlMethods;
+    readonly kind: string;
+    readonly name: string;
+    constructor(kubectl: KubectlMethods, kind: string, name: string);
+}
+/**
+ * Create a Pod resource wrapper
+ */
+export declare function pod(kubectl: KubectlMethods, name: string): K8sResource;
+/**
+ * Create a Deployment resource wrapper
+ */
+export declare function deployment(kubectl: KubectlMethods, name: string): K8sResource;
+/**
+ * Create a Service resource wrapper
+ */
+export declare function service(kubectl: KubectlMethods, name: string): K8sResource;
+/**
+ * Create a StatefulSet resource wrapper
+ */
+export declare function statefulset(kubectl: KubectlMethods, name: string): K8sResource;
+/**
+ * Create a Job resource wrapper
+ */
+export declare function job(kubectl: KubectlMethods, name: string): K8sResource;
+/**
+ * Create a ConfigMap resource wrapper
+ */
+export declare function configmap(kubectl: KubectlMethods, name: string): K8sResource;
+/**
+ * Create a Secret resource wrapper
+ */
+export declare function secret(kubectl: KubectlMethods, name: string): K8sResource;
+/**
+ * Create a generic resource wrapper
+ */
+export declare function resource(kubectl: KubectlMethods, kind: string, name: string): K8sResource;
+/**
+ * Create a GPUPool resource wrapper (Tensor Fusion CRD)
+ */
+export declare function gpupool(kubectl: KubectlMethods, name: string): K8sResource;
+/**
+ * Create a GPU resource wrapper (Tensor Fusion CRD)
+ */
+export declare function gpu(kubectl: KubectlMethods, name: string): K8sResource;
+/**
+ * Create a TensorFusionWorkload resource wrapper (Tensor Fusion CRD)
+ */
+export declare function tensorfusionworkload(kubectl: KubectlMethods, name: string): K8sResource;
+/**
+ * Create a TensorFusionConnection resource wrapper (Tensor Fusion CRD)
+ */
+export declare function tensorfusionconnection(kubectl: KubectlMethods, name: string): K8sResource;
+/**
+ * Create a custom CRD resource wrapper with explicit API group
+ * @param kubectl - kubectl methods instance
+ * @param kind - Resource kind (e.g., 'gpupool.tensor-fusion.ai')
+ * @param name - Resource name
+ */
+export declare function crd(kubectl: KubectlMethods, kind: string, name: string): K8sResource;
+/**
+ * Register K8s matchers with expect
+ */
+export declare function registerK8sMatchers(): void;
+//# sourceMappingURL=matchers.d.ts.map

package/dist/matchers.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"matchers.d.ts","sourceRoot":"","sources":["../src/matchers.ts"],"names":[],"mappings":"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"}