@nexusgpu/repterm-plugin-kubectl 0.1.0

package/dist/plugin-kubectl/src/matchers.js

@@ -0,0 +1,527 @@
+/**
+ * Kubernetes Matchers for Repterm
+ *
+ * Provides expect() matchers for Kubernetes resources.
+ * All operations are executed through kubectl API (PTY visible).
+ *
+ * @packageDocumentation
+ */
+import { expect } from 'bun:test';
+import { KubectlResult } from './result.js';
+// ===== K8sResource Wrapper =====
+/**
+ * Wrapper class for Kubernetes resources
+ * Holds reference to kubectl methods for matcher operations
+ */
+export class K8sResource {
+    kubectl;
+    kind;
+    name;
+    constructor(kubectl, kind, name) {
+        this.kubectl = kubectl;
+        this.kind = kind;
+        this.name = name;
+    }
+}
+// ===== Helper Functions =====
+/**
+ * Create a Pod resource wrapper
+ */
+export function pod(kubectl, name) {
+    return new K8sResource(kubectl, 'pod', name);
+}
+/**
+ * Create a Deployment resource wrapper
+ */
+export function deployment(kubectl, name) {
+    return new K8sResource(kubectl, 'deployment', name);
+}
+/**
+ * Create a Service resource wrapper
+ */
+export function service(kubectl, name) {
+    return new K8sResource(kubectl, 'service', name);
+}
+/**
+ * Create a StatefulSet resource wrapper
+ */
+export function statefulset(kubectl, name) {
+    return new K8sResource(kubectl, 'statefulset', name);
+}
+/**
+ * Create a Job resource wrapper
+ */
+export function job(kubectl, name) {
+    return new K8sResource(kubectl, 'job', name);
+}
+/**
+ * Create a ConfigMap resource wrapper
+ */
+export function configmap(kubectl, name) {
+    return new K8sResource(kubectl, 'configmap', name);
+}
+/**
+ * Create a Secret resource wrapper
+ */
+export function secret(kubectl, name) {
+    return new K8sResource(kubectl, 'secret', name);
+}
+/**
+ * Create a generic resource wrapper
+ */
+export function resource(kubectl, kind, name) {
+    return new K8sResource(kubectl, kind, name);
+}
+// ===== Tensor Fusion CRD Wrappers =====
+/**
+ * Create a GPUPool resource wrapper (Tensor Fusion CRD)
+ */
+export function gpupool(kubectl, name) {
+    return new K8sResource(kubectl, 'gpupool', name);
+}
+/**
+ * Create a GPU resource wrapper (Tensor Fusion CRD)
+ */
+export function gpu(kubectl, name) {
+    return new K8sResource(kubectl, 'gpu', name);
+}
+/**
+ * Create a TensorFusionWorkload resource wrapper (Tensor Fusion CRD)
+ */
+export function tensorfusionworkload(kubectl, name) {
+    return new K8sResource(kubectl, 'tensorfusionworkload', name);
+}
+/**
+ * Create a TensorFusionConnection resource wrapper (Tensor Fusion CRD)
+ */
+export function tensorfusionconnection(kubectl, name) {
+    return new K8sResource(kubectl, 'tensorfusionconnection', name);
+}
+/**
+ * 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 function crd(kubectl, kind, name) {
+    return new K8sResource(kubectl, kind, name);
+}
+// ===== Type Guard =====
+function isK8sResource(value) {
+    return value instanceof K8sResource;
+}
+function isKubectlResult(value) {
+    return value instanceof KubectlResult;
+}
+// ===== Register Matchers =====
+/**
+ * Register K8s matchers with expect
+ */
+export function registerK8sMatchers() {
+    expect.extend({
+        /**
+         * Assert that a kubectl operation succeeded
+         */
+        async toBeSuccessful(received) {
+            if (!isKubectlResult(received)) {
+                return {
+                    pass: false,
+                    message: () => 'Expected value to be a KubectlResult (from kubectl.apply/delete/patch/scale/label)',
+                };
+            }
+            const pass = received.successful;
+            return {
+                pass,
+                message: () => pass
+                    ? 'Expected kubectl command to fail, but it succeeded'
+                    : `Expected kubectl command to succeed, but failed:\n${received.output.slice(0, 500)}`,
+                actual: pass ? 'succeeded' : 'failed',
+                expected: 'succeeded',
+            };
+        },
+        /**
+         * Assert that a Pod is in Running state
+         */
+        async toBeRunning(received, ...args) {
+            const timeout = args[0] ?? 60000;
+            if (!isK8sResource(received)) {
+                return {
+                    pass: false,
+                    message: () => 'Expected value to be a K8sResource',
+                };
+            }
+            const { kubectl, kind, name } = received;
+            if (kind !== 'pod') {
+                return {
+                    pass: false,
+                    message: () => `toBeRunning() is only valid for pods, got ${kind}`,
+                };
+            }
+            try {
+                await kubectl.waitForPod(name, 'Running', timeout);
+                return {
+                    pass: true,
+                    message: () => `Expected pod/${name} not to be Running`,
+                };
+            }
+            catch {
+                return {
+                    pass: false,
+                    message: () => `Expected pod/${name} to be Running within ${timeout}ms`,
+                    actual: 'Not Running',
+                    expected: 'Running',
+                };
+            }
+        },
+        /**
+         * Assert that a Pod has a specific phase
+         */
+        async toHavePhase(received, ...args) {
+            const phase = args[0];
+            if (!isK8sResource(received)) {
+                return {
+                    pass: false,
+                    message: () => 'Expected value to be a K8sResource',
+                };
+            }
+            const { kubectl, kind, name } = received;
+            try {
+                const actualPhase = await kubectl.getJsonPath(kind, name, '.status.phase');
+                const pass = actualPhase === phase;
+                return {
+                    pass,
+                    message: () => pass
+                        ? `Expected ${kind}/${name} not to have phase ${phase}`
+                        : `Expected ${kind}/${name} to have phase ${phase}, got ${actualPhase}`,
+                    actual: actualPhase,
+                    expected: phase,
+                };
+            }
+            catch (e) {
+                return {
+                    pass: false,
+                    message: () => `Failed to get ${kind}/${name}: ${e}`,
+                };
+            }
+        },
+        /**
+         * Assert that a resource has a specific number of replicas
+         */
+        async toHaveReplicas(received, ...args) {
+            const count = args[0];
+            if (!isK8sResource(received)) {
+                return {
+                    pass: false,
+                    message: () => 'Expected value to be a K8sResource',
+                };
+            }
+            const { kubectl, kind, name } = received;
+            try {
+                const actual = await kubectl.getJsonPath(kind, name, '.status.replicas') ?? 0;
+                const pass = actual === count;
+                return {
+                    pass,
+                    message: () => pass
+                        ? `Expected ${kind}/${name} not to have ${count} replicas`
+                        : `Expected ${kind}/${name} to have ${count} replicas, got ${actual}`,
+                    actual,
+                    expected: count,
+                };
+            }
+            catch (e) {
+                return {
+                    pass: false,
+                    message: () => `Failed to get ${kind}/${name}: ${e}`,
+                };
+            }
+        },
+        /**
+         * Assert that a resource has a specific number of available replicas
+         */
+        async toHaveAvailableReplicas(received, ...args) {
+            const count = args[0];
+            if (!isK8sResource(received)) {
+                return {
+                    pass: false,
+                    message: () => 'Expected value to be a K8sResource',
+                };
+            }
+            const { kubectl, kind, name } = received;
+            try {
+                const actual = await kubectl.getJsonPath(kind, name, '.status.availableReplicas') ?? 0;
+                const pass = actual === count;
+                return {
+                    pass,
+                    message: () => pass
+                        ? `Expected ${kind}/${name} not to have ${count} available replicas`
+                        : `Expected ${kind}/${name} to have ${count} available replicas, got ${actual}`,
+                    actual,
+                    expected: count,
+                };
+            }
+            catch (e) {
+                return {
+                    pass: false,
+                    message: () => `Failed to get ${kind}/${name}: ${e}`,
+                };
+            }
+        },
+        /**
+         * Assert that a Deployment is available
+         */
+        async toBeAvailable(received) {
+            if (!isK8sResource(received)) {
+                return {
+                    pass: false,
+                    message: () => 'Expected value to be a K8sResource',
+                };
+            }
+            const { kubectl, kind, name } = received;
+            try {
+                const jsonPath = '.status.conditions[?(@.type=="Available")].status';
+                const statusValue = await kubectl.getJsonPath(kind, name, jsonPath);
+                // JSONPath may return multiple values separated by space, take first
+                const actualStatus = statusValue?.split(' ')?.[0];
+                const pass = actualStatus === 'True';
+                return {
+                    pass,
+                    message: () => pass
+                        ? `Expected ${kind}/${name} not to be available`
+                        : `Expected ${kind}/${name} to be available`,
+                    actual: actualStatus,
+                    expected: 'True',
+                };
+            }
+            catch (e) {
+                return {
+                    pass: false,
+                    message: () => `Failed to get ${kind}/${name}: ${e}`,
+                };
+            }
+        },
+        /**
+         * Assert that a resource exists in the cluster
+         */
+        async toExistInCluster(received) {
+            if (!isK8sResource(received)) {
+                return {
+                    pass: false,
+                    message: () => 'Expected value to be a K8sResource',
+                };
+            }
+            const { kubectl, kind, name } = received;
+            const exists = await kubectl.exists(kind, name);
+            return {
+                pass: exists,
+                message: () => exists
+                    ? `Expected ${kind}/${name} not to exist in cluster`
+                    : `Expected ${kind}/${name} to exist in cluster`,
+            };
+        },
+        /**
+         * Assert that a resource has a specific label
+         */
+        async toHaveLabel(received, ...args) {
+            const key = args[0];
+            const value = args[1];
+            if (!isK8sResource(received)) {
+                return {
+                    pass: false,
+                    message: () => 'Expected value to be a K8sResource',
+                };
+            }
+            const { kubectl, kind, name } = received;
+            try {
+                // Escape dots in label key for JSONPath
+                const escapedKey = key.replace(/\./g, '\\.');
+                const jsonPath = `.metadata.labels.${escapedKey}`;
+                const actualValue = await kubectl.getJsonPath(kind, name, jsonPath);
+                const pass = value !== undefined ? actualValue === value : actualValue !== undefined;
+                return {
+                    pass,
+                    message: () => {
+                        if (value !== undefined) {
+                            return pass
+                                ? `Expected ${kind}/${name} not to have label ${key}=${value}`
+                                : `Expected ${kind}/${name} to have label ${key}=${value}, got ${actualValue}`;
+                        }
+                        return pass
+                            ? `Expected ${kind}/${name} not to have label ${key}`
+                            : `Expected ${kind}/${name} to have label ${key}`;
+                    },
+                    actual: actualValue,
+                    expected: value ?? `label "${key}" exists`,
+                };
+            }
+            catch (e) {
+                return {
+                    pass: false,
+                    message: () => `Failed to get ${kind}/${name}: ${e}`,
+                };
+            }
+        },
+        /**
+         * Assert that a resource has a specific annotation
+         */
+        async toHaveAnnotation(received, ...args) {
+            const key = args[0];
+            const value = args[1];
+            if (!isK8sResource(received)) {
+                return {
+                    pass: false,
+                    message: () => 'Expected value to be a K8sResource',
+                };
+            }
+            const { kubectl, kind, name } = received;
+            try {
+                // Escape dots in annotation key for JSONPath
+                const escapedKey = key.replace(/\./g, '\\.');
+                const jsonPath = `.metadata.annotations.${escapedKey}`;
+                const actualValue = await kubectl.getJsonPath(kind, name, jsonPath);
+                const pass = value !== undefined ? actualValue === value : actualValue !== undefined;
+                return {
+                    pass,
+                    message: () => {
+                        if (value !== undefined) {
+                            return pass
+                                ? `Expected ${kind}/${name} not to have annotation ${key}=${value}`
+                                : `Expected ${kind}/${name} to have annotation ${key}=${value}, got ${actualValue}`;
+                        }
+                        return pass
+                            ? `Expected ${kind}/${name} not to have annotation ${key}`
+                            : `Expected ${kind}/${name} to have annotation ${key}`;
+                    },
+                    actual: actualValue,
+                    expected: value ?? `annotation "${key}" exists`,
+                };
+            }
+            catch (e) {
+                return {
+                    pass: false,
+                    message: () => `Failed to get ${kind}/${name}: ${e}`,
+                };
+            }
+        },
+        /**
+         * Assert that a resource has a specific condition
+         */
+        async toHaveCondition(received, ...args) {
+            const type = args[0];
+            const status = args[1];
+            if (!isK8sResource(received)) {
+                return {
+                    pass: false,
+                    message: () => 'Expected value to be a K8sResource',
+                };
+            }
+            const { kubectl, kind, name } = received;
+            try {
+                const jsonPath = `.status.conditions[?(@.type=="${type}")].status`;
+                const statusValue = await kubectl.getJsonPath(kind, name, jsonPath);
+                // JSONPath may return multiple values separated by space, take first
+                const actualStatus = statusValue?.split(' ')?.[0];
+                const pass = actualStatus === status;
+                return {
+                    pass,
+                    message: () => pass
+                        ? `Expected ${kind}/${name} not to have condition ${type}=${status}`
+                        : `Expected ${kind}/${name} to have condition ${type}=${status}, got ${actualStatus ?? 'not found'}`,
+                    actual: actualStatus,
+                    expected: status,
+                };
+            }
+            catch (e) {
+                return {
+                    pass: false,
+                    message: () => `Failed to get ${kind}/${name}: ${e}`,
+                };
+            }
+        },
+        /**
+         * Assert that a resource does not exist in the cluster
+         */
+        async toNotExistInCluster(received) {
+            if (!isK8sResource(received)) {
+                return {
+                    pass: false,
+                    message: () => 'Expected value to be a K8sResource',
+                };
+            }
+            const { kubectl, kind, name } = received;
+            const exists = await kubectl.exists(kind, name);
+            return {
+                pass: !exists,
+                message: () => !exists
+                    ? `Expected ${kind}/${name} to exist in cluster`
+                    : `Expected ${kind}/${name} not to exist in cluster`,
+            };
+        },
+        /**
+         * Assert that a resource has a specific number of ready replicas
+         */
+        async toHaveReadyReplicas(received, ...args) {
+            const count = args[0];
+            if (!isK8sResource(received)) {
+                return {
+                    pass: false,
+                    message: () => 'Expected value to be a K8sResource',
+                };
+            }
+            const { kubectl, kind, name } = received;
+            try {
+                const actual = await kubectl.getJsonPath(kind, name, '.status.readyReplicas') ?? 0;
+                const pass = actual === count;
+                return {
+                    pass,
+                    message: () => pass
+                        ? `Expected ${kind}/${name} not to have ${count} ready replicas`
+                        : `Expected ${kind}/${name} to have ${count} ready replicas, got ${actual}`,
+                    actual,
+                    expected: count,
+                };
+            }
+            catch (e) {
+                return {
+                    pass: false,
+                    message: () => `Failed to get ${kind}/${name}: ${e}`,
+                };
+            }
+        },
+        /**
+         * Assert that a resource has a specific status field value
+         * Supports dot notation for nested paths (e.g., 'phase', 'available.tflops')
+         */
+        async toHaveStatusField(received, ...args) {
+            const path = args[0];
+            const expectedValue = args[1];
+            if (!isK8sResource(received)) {
+                return {
+                    pass: false,
+                    message: () => 'Expected value to be a K8sResource',
+                };
+            }
+            const { kubectl, kind, name } = received;
+            try {
+                const jsonPath = `.status.${path}`;
+                const actual = await kubectl.getJsonPath(kind, name, jsonPath);
+                const pass = actual === expectedValue;
+                return {
+                    pass,
+                    message: () => pass
+                        ? `Expected ${kind}/${name} not to have status.${path} = ${JSON.stringify(expectedValue)}`
+                        : `Expected ${kind}/${name} to have status.${path} = ${JSON.stringify(expectedValue)}, got ${JSON.stringify(actual)}`,
+                    actual,
+                    expected: expectedValue,
+                };
+            }
+            catch (e) {
+                return {
+                    pass: false,
+                    message: () => `Failed to get ${kind}/${name}: ${e}`,
+                };
+            }
+        },
+    });
+}
+// Auto-register matchers when this module is imported
+registerK8sMatchers();

package/dist/plugin-kubectl/src/result.d.ts

@@ -0,0 +1,80 @@
+/**
+ * Kubectl Result Types
+ *
+ * Provides result classes for kubectl commands with intelligent success detection.
+ * Handles both normal mode (exitCode-based) and PTY/recording mode (output-based).
+ *
+ * @packageDocumentation
+ */
+/**
+ * Base class for kubectl command execution results.
+ * Provides unified success detection logic for both PTY and non-PTY modes.
+ */
+export declare abstract class KubectlResult {
+    /** Command output (stdout + stderr in PTY mode) */
+    readonly output: string;
+    /** The executed command */
+    readonly command: string;
+    /** Exit code (-1 in PTY mode where exit code is unavailable) */
+    readonly exitCode: number;
+    constructor(
+    /** Command output (stdout + stderr in PTY mode) */
+    output: string, 
+    /** The executed command */
+    command: string, 
+    /** Exit code (-1 in PTY mode where exit code is unavailable) */
+    exitCode: number);
+    /**
+     * Check if the command succeeded.
+     * - Non-PTY mode: Uses exitCode === 0
+     * - PTY mode (exitCode === -1): Delegates to subclass isOutputSuccessful()
+     */
+    get successful(): boolean;
+    /** Subclass implementation: determine success based on output content */
+    protected abstract isOutputSuccessful(): boolean;
+    /** Common error detection helper */
+    protected hasError(): boolean;
+}
+/**
+ * Result for kubectl apply command.
+ * Success indicators: "created", "configured", "unchanged"
+ */
+export declare class ApplyResult extends KubectlResult {
+    protected isOutputSuccessful(): boolean;
+}
+/**
+ * Result for kubectl delete command.
+ * Success indicators: "deleted" or "not found" (with --ignore-not-found)
+ */
+export declare class DeleteResult extends KubectlResult {
+    protected isOutputSuccessful(): boolean;
+}
+/**
+ * Result for kubectl patch command.
+ * Success indicators: "patched" or "(no change)"
+ */
+export declare class PatchResult extends KubectlResult {
+    protected isOutputSuccessful(): boolean;
+}
+/**
+ * Result for kubectl scale command.
+ * Success indicators: "scaled"
+ */
+export declare class ScaleResult extends KubectlResult {
+    protected isOutputSuccessful(): boolean;
+}
+/**
+ * Result for kubectl label/annotate commands.
+ * Success indicators: "labeled" or "annotated"
+ */
+export declare class LabelResult extends KubectlResult {
+    protected isOutputSuccessful(): boolean;
+}
+/**
+ * Result for kubectl wait command.
+ * Success indicators: "condition met" or specific condition messages
+ */
+export declare class WaitResult extends KubectlResult {
+    protected isOutputSuccessful(): boolean;
+}
+//# sourceMappingURL=result.d.ts.map

package/dist/plugin-kubectl/src/result.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"result.d.ts","sourceRoot":"","sources":["../../../src/result.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH;;;GAGG;AACH,8BAAsB,aAAa;IAE3B,mDAAmD;aACnC,MAAM,EAAE,MAAM;IAC9B,2BAA2B;aACX,OAAO,EAAE,MAAM;IAC/B,gEAAgE;aAChD,QAAQ,EAAE,MAAM;;IALhC,mDAAmD;IACnC,MAAM,EAAE,MAAM;IAC9B,2BAA2B;IACX,OAAO,EAAE,MAAM;IAC/B,gEAAgE;IAChD,QAAQ,EAAE,MAAM;IAGpC;;;;OAIG;IACH,IAAI,UAAU,IAAI,OAAO,CAOxB;IAED,yEAAyE;IACzE,SAAS,CAAC,QAAQ,CAAC,kBAAkB,IAAI,OAAO;IAEhD,oCAAoC;IACpC,SAAS,CAAC,QAAQ,IAAI,OAAO;CAUhC;AAED;;;GAGG;AACH,qBAAa,WAAY,SAAQ,aAAa;IAC1C,SAAS,CAAC,kBAAkB,IAAI,OAAO;CAM1C;AAED;;;GAGG;AACH,qBAAa,YAAa,SAAQ,aAAa;IAC3C,SAAS,CAAC,kBAAkB,IAAI,OAAO;CAU1C;AAED;;;GAGG;AACH,qBAAa,WAAY,SAAQ,aAAa;IAC1C,SAAS,CAAC,kBAAkB,IAAI,OAAO;CAM1C;AAED;;;GAGG;AACH,qBAAa,WAAY,SAAQ,aAAa;IAC1C,SAAS,CAAC,kBAAkB,IAAI,OAAO;CAM1C;AAED;;;GAGG;AACH,qBAAa,WAAY,SAAQ,aAAa;IAC1C,SAAS,CAAC,kBAAkB,IAAI,OAAO;CAM1C;AAED;;;GAGG;AACH,qBAAa,UAAW,SAAQ,aAAa;IACzC,SAAS,CAAC,kBAAkB,IAAI,OAAO;CAS1C"}