k6ctl 1.0.0

package/dist/utils/testRunManifestBuilder.js

@@ -0,0 +1,89 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildTestRunManifest = buildTestRunManifest;
+const logger_1 = __importDefault(require("../utils/logger"));
+const K6_GROUP = "k6.io";
+const K6_VERSION = "v1alpha1";
+const K6_KIND = "TestRun";
+const K6_CLEANUP_LABEL = "post";
+const ARG_OUT = "--out";
+const ARG_TAG = "--tag";
+const ARG_OUT_PROMETHEUS = "experimental-prometheus-rw";
+const K6_PROMETHEUS_RW_SERVER_URL = "K6_PROMETHEUS_RW_SERVER_URL";
+const K6_PROMETHEUS_RW_TREND_STATS = "K6_PROMETHEUS_RW_TREND_STATS";
+function buildTestRunManifest(configMapResult, archiveOutput, cfg, envFromLoader) {
+    const testName = configMapResult.configMapName.replace("archive-", "test-");
+    const argumentsString = buildArgumentsString(cfg.arguments, cfg, testName);
+    logger_1.default.debug("Constructed arguments string for TestRun manifest:", argumentsString);
+    const testRun = {
+        apiVersion: `${K6_GROUP}/${K6_VERSION}`,
+        kind: K6_KIND,
+        metadata: {
+            name: testName,
+            namespace: configMapResult.namespace,
+        },
+        spec: {
+            parallelism: cfg.parallelism,
+            arguments: argumentsString,
+            quiet: String(cfg.quiet),
+            ...(cfg.cleanup === true ? { cleanup: K6_CLEANUP_LABEL } : {}),
+            separate: cfg.separate,
+            runner: {
+                image: cfg.runner?.image,
+                env: buildRunnerEnv(cfg, envFromLoader),
+                ...(cfg.runner?.resources ? { resources: cfg.runner.resources } : {}),
+            },
+            script: {
+                configMap: {
+                    name: configMapResult.configMapName,
+                    file: archiveOutput.archiveFilename,
+                },
+            },
+        },
+    };
+    logger_1.default.debug("Constructed TestRun manifest:", JSON.stringify(testRun, null, 2));
+    return testRun;
+}
+function buildRunnerEnv(cfg, envFromLoader) {
+    const envMap = new Map();
+    if (envFromLoader) {
+        for (const [key, value] of Object.entries(envFromLoader)) {
+            if (value !== undefined && value !== null) {
+                envMap.set(key, String(value));
+            }
+        }
+    }
+    if (cfg.prometheus?.serverUrl) {
+        envMap.set(K6_PROMETHEUS_RW_SERVER_URL, cfg.prometheus.serverUrl);
+        if (cfg.prometheus.trendStats?.length) {
+            envMap.set(K6_PROMETHEUS_RW_TREND_STATS, cfg.prometheus.trendStats.join(","));
+        }
+    }
+    const envArray = Array.from(envMap.entries()).map(([name, value]) => ({
+        name,
+        value,
+    }));
+    return envArray.length > 0 ? envArray : undefined;
+}
+function buildArgumentsString(args, cfg, name) {
+    const finalArgs = [...(args ?? [])];
+    if (cfg.prometheus?.serverUrl) {
+        const hasOut = finalArgs.includes(ARG_OUT);
+        if (!hasOut) {
+            finalArgs.push(ARG_OUT);
+        }
+        const hasPrometheusOut = finalArgs.includes(ARG_OUT_PROMETHEUS);
+        if (!hasPrometheusOut) {
+            finalArgs.push(ARG_OUT_PROMETHEUS);
+        }
+        finalArgs.push(ARG_TAG, `testid=${name}`);
+    }
+    if (finalArgs.length === 0) {
+        return undefined;
+    }
+    return finalArgs.join(" ");
+}
+//# sourceMappingURL=testRunManifestBuilder.js.map

package/dist/utils/testRunManifestBuilder.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"testRunManifestBuilder.js","sourceRoot":"","sources":["../../src/utils/testRunManifestBuilder.ts"],"names":[],"mappings":";;;;;AAgBA,oDAyCC;AAzDD,6DAAqC;AAMrC,MAAM,QAAQ,GAAG,OAAO,CAAC;AACzB,MAAM,UAAU,GAAG,UAAU,CAAC;AAC9B,MAAM,OAAO,GAAG,SAAS,CAAC;AAC1B,MAAM,gBAAgB,GAAG,MAAM,CAAC;AAChC,MAAM,OAAO,GAAG,OAAO,CAAC;AACxB,MAAM,OAAO,GAAG,OAAO,CAAC;AACxB,MAAM,kBAAkB,GAAG,4BAA4B,CAAC;AACxD,MAAM,2BAA2B,GAAG,6BAA6B,CAAC;AAClE,MAAM,4BAA4B,GAAG,8BAA8B,CAAC;AAEpE,SAAgB,oBAAoB,CAChC,eAAgC,EAChC,aAA2B,EAC3B,GAAa,EACb,aAAsC;IAEtC,MAAM,QAAQ,GAAG,eAAe,CAAC,aAAa,CAAC,OAAO,CAAC,UAAU,EAAE,OAAO,CAAC,CAAC;IAC5E,MAAM,eAAe,GAAG,oBAAoB,CACxC,GAAG,CAAC,SAAS,EACb,GAAG,EACH,QAAQ,CACX,CAAC;IACF,gBAAM,CAAC,KAAK,CAAC,oDAAoD,EAAE,eAAe,CAAC,CAAC;IACpF,MAAM,OAAO,GAAoB;QAC7B,UAAU,EAAE,GAAG,QAAQ,IAAI,UAAU,EAAE;QACvC,IAAI,EAAE,OAAO;QACb,QAAQ,EAAE;YACN,IAAI,EAAE,QAAQ;YACd,SAAS,EAAE,eAAe,CAAC,SAAS;SACvC;QACD,IAAI,EAAE;YACF,WAAW,EAAE,GAAG,CAAC,WAAW;YAC5B,SAAS,EAAE,eAAe;YAC1B,KAAK,EAAE,MAAM,CAAC,GAAG,CAAC,KAAK,CAAC;YACxB,GAAG,CAAC,GAAG,CAAC,OAAO,KAAK,IAAI,CAAC,CAAC,CAAC,EAAE,OAAO,EAAE,gBAAgB,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC;YAC9D,QAAQ,EAAE,GAAG,CAAC,QAAQ;YACtB,MAAM,EAAE;gBACJ,KAAK,EAAE,GAAG,CAAC,MAAM,EAAE,KAAK;gBACxB,GAAG,EAAE,cAAc,CAAC,GAAG,EAAE,aAAa,CAAC;gBACvC,GAAG,CAAC,GAAG,CAAC,MAAM,EAAE,SAAS,CAAC,CAAC,CAAC,EAAE,SAAS,EAAE,GAAG,CAAC,MAAM,CAAC,SAAS,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC;aACxE;YACD,MAAM,EAAE;gBACJ,SAAS,EAAE;oBACP,IAAI,EAAE,eAAe,CAAC,aAAa;oBACnC,IAAI,EAAE,aAAa,CAAC,eAAe;iBACtC;aACJ;SACJ;KACJ,CAAC;IACF,gBAAM,CAAC,KAAK,CAAC,+BAA+B,EAAE,IAAI,CAAC,SAAS,CAAC,OAAO,EAAE,IAAI,EAAE,CAAC,CAAC,CAAC,CAAC;IAChF,OAAO,OAAO,CAAC;AACnB,CAAC;AAED,SAAS,cAAc,CACnB,GAAa,EACb,aAAsC;IAEtC,MAAM,MAAM,GAAG,IAAI,GAAG,EAAkB,CAAC;IACzC,IAAI,aAAa,EAAE,CAAC;QAChB,KAAK,MAAM,CAAC,GAAG,EAAE,KAAK,CAAC,IAAI,MAAM,CAAC,OAAO,CAAC,aAAa,CAAC,EAAE,CAAC;YACvD,IAAI,KAAK,KAAK,SAAS,IAAI,KAAK,KAAK,IAAI,EAAE,CAAC;gBACxC,MAAM,CAAC,GAAG,CAAC,GAAG,EAAE,MAAM,CAAC,KAAK,CAAC,CAAC,CAAC;YACnC,CAAC;QACL,CAAC;IACL,CAAC;IACD,IAAI,GAAG,CAAC,UAAU,EAAE,SAAS,EAAE,CAAC;QAC5B,MAAM,CAAC,GAAG,CAAC,2BAA2B,EAAE,GAAG,CAAC,UAAU,CAAC,SAAS,CAAC,CAAC;QAClE,IAAI,GAAG,CAAC,UAAU,CAAC,UAAU,EAAE,MAAM,EAAE,CAAC;YACpC,MAAM,CAAC,GAAG,CAAC,4BAA4B,EAAE,GAAG,CAAC,UAAU,CAAC,UAAU,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC,CAAC;QAClF,CAAC;IACL,CAAC;IACD,MAAM,QAAQ,GAAmB,KAAK,CAAC,IAAI,CAAC,MAAM,CAAC,OAAO,EAAE,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,IAAI,EAAE,KAAK,CAAC,EAAE,EAAE,CAAC,CAAC;QAClF,IAAI;QACJ,KAAK;KACR,CAAC,CAAC,CAAC;IACJ,OAAO,QAAQ,CAAC,MAAM,GAAG,CAAC,CAAC,CAAC,CAAC,QAAQ,CAAC,CAAC,CAAC,SAAS,CAAC;AACtD,CAAC;AAED,SAAS,oBAAoB,CAAC,IAA0B,EAAE,GAAa,EAAE,IAAY;IACjF,MAAM,SAAS,GAAG,CAAC,GAAG,CAAC,IAAI,IAAI,EAAE,CAAC,CAAC,CAAC;IACpC,IAAI,GAAG,CAAC,UAAU,EAAE,SAAS,EAAE,CAAC;QAC5B,MAAM,MAAM,GAAG,SAAS,CAAC,QAAQ,CAAC,OAAO,CAAC,CAAC;QAC3C,IAAI,CAAC,MAAM,EAAE,CAAC;YACV,SAAS,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC;QAC5B,CAAC;QACD,MAAM,gBAAgB,GAAG,SAAS,CAAC,QAAQ,CAAC,kBAAkB,CAAC,CAAC;QAChE,IAAI,CAAC,gBAAgB,EAAE,CAAC;YACpB,SAAS,CAAC,IAAI,CAAC,kBAAkB,CAAC,CAAC;QACvC,CAAC;QACD,SAAS,CAAC,IAAI,CAAC,OAAO,EAAE,UAAU,IAAI,EAAE,CAAC,CAAC;IAC9C,CAAC;IACD,IAAI,SAAS,CAAC,MAAM,KAAK,CAAC,EAAE,CAAC;QACzB,OAAO,SAAS,CAAC;IACrB,CAAC;IACD,OAAO,SAAS,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC;AAC/B,CAAC"}

package/package.json

@@ -0,0 +1,44 @@
+{
+  "name": "k6ctl",
+  "version": "1.0.0",
+  "description": "CLI tool to run k6 tests on Kubernetes using k6-operator",
+  "main": "dist/index.js",
+  "bin": {
+    "k6ctl": "dist/cli.js"
+  },
+  "scripts": {
+    "build": "tsc",
+    "dev": "tsc --watch",
+    "test:unit": "jest -c test/jest.config.unit.js",
+    "test:integration": "jest -c test/jest.config.integration.js"
+  },
+  "keywords": [
+    "k6",
+    "kubernetes",
+    "k6-operator",
+    "load-testing",
+    "performance-testing",
+    "cli"
+  ],
+  "author": "",
+  "license": "MIT",
+  "dependencies": {
+    "@kubernetes/client-node": "^1.4.0",
+    "cli-table3": "^0.6.5",
+    "commander": "^14.0.3",
+    "dotenv": "^17.3.1",
+    "js-yaml": "^4.1.1",
+    "winston": "^3.19.0",
+    "zod": "^4.3.6"
+  },
+  "devDependencies": {
+    "@jest/globals": "^30.2.0",
+    "@types/js-yaml": "^4.0.9",
+    "@types/node": "^25.2.3",
+    "ts-jest": "^29.4.6",
+    "typescript": "^5.9.3"
+  },
+  "engines": {
+    "node": ">=18.0.0"
+  }
+}

package/src/cli.ts

@@ -0,0 +1,31 @@
+#!/usr/bin/env node
+
+import { Argument, Command } from 'commander';
+import { runTest } from './commands/run';
+import { list } from './commands/list';
+import { version } from '../package.json';
+
+const program = new Command();
+
+program
+  .name('k6ctl')
+  .description('CLI tool to run k6 tests on Kubernetes using k6-operator')
+  .version(version);
+
+program
+  .command('run <script>')
+  .description('Run a k6 test script')
+  .option('-c, --config <path>', 'Path to config file', 'k6ctl.config.js')
+  .option('-n, --namespace <namespace>', 'Kubernetes namespace')
+  .option('-p, --parallelism <number>', 'Number of parallel test pods')
+  .option('-v, --verbose', 'enable debug logging')
+  .action(runTest);
+
+program
+  .command('list')
+  .description('List all resources')
+  .addArgument(new Argument('[type]', 'Resource type').choices(['pods', 'testruns', 'configmaps']).default('all'))
+  .option('-n, --namespace <namespace>', 'Kubernetes namespace', 'default')
+  .action(list);
+
+program.parse();

package/src/commands/list.ts

@@ -0,0 +1,29 @@
+import logger, { setLogLevel } from '../utils/logger';
+import { createDefaultKubernetesService } from '../services/kubernetes.service';
+
+export async function list(type: string, options: { namespace?: string }) {
+  const kubernetesService = createDefaultKubernetesService();
+  switch (type) {
+    case 'all':
+      logger.debug(`Listing all resources in namespace: ${options.namespace}`);
+      await kubernetesService.listTestRuns(options.namespace);
+      await kubernetesService.listPods(options.namespace);
+      await kubernetesService.listConfigMaps(options.namespace);
+      break;
+    case 'pods':
+      logger.debug(`Listing Pods in namespace: ${options.namespace}`);
+      await kubernetesService.listPods(options.namespace);
+      break;
+    case 'testruns':
+      logger.debug(`Listing TestRuns in namespace: ${options.namespace}`);
+      await kubernetesService.listTestRuns(options.namespace);
+      break;
+    case 'configmaps':
+      logger.debug(`Listing ConfigMaps in namespace: ${options.namespace}`);
+      await kubernetesService.listConfigMaps(options.namespace);
+      break;
+    default:
+      logger.debug(`Listing ${type} in namespace: ${options.namespace}`);
+      break;
+  }
+}

package/src/commands/run.ts

@@ -0,0 +1,52 @@
+import { createDefaultKubernetesService } from '../services/kubernetes.service';
+import { ScriptService } from '../services/script.service';
+import { loadK6Config } from '../utils/configLoader';
+import { loadAndValidateEnv } from '../utils/env';
+import logger, { setLogLevel } from '../utils/logger';
+import { buildTestRunManifest } from '../utils/testRunManifestBuilder';
+
+interface RunOptions {
+  config: string;
+  namespace?: string;
+  parallelism?: number;
+  verbose?: boolean;
+}
+
+export async function runTest(scriptPath: string, options: RunOptions) {
+  if (options.verbose) setLogLevel('debug');
+  logger.debug(`Running k6 test: ${scriptPath}`);
+  logger.debug(`Using config: ${JSON.stringify(options.config, null, 2)}`);
+
+  try {
+    // Initialize services
+    const scriptService = new ScriptService();
+    const kubernetesService = createDefaultKubernetesService();
+
+    // Load test script
+    const archive = await scriptService.archiveTest(scriptPath);
+
+    // Load config
+    const config = loadK6Config(options.config);
+
+    // Load environment variables
+    let envVars;
+    try {
+      envVars = loadAndValidateEnv();
+    } catch (error) {
+      logger.warn("Warning: no environment variables loaded, continuing anyway.");
+      logger.debug(`Error loading environment variables: ${error instanceof Error ? error.message : String(error)}`);
+    }
+
+    // Create configmap for test script
+    const configMap = await kubernetesService.createConfigMap(archive, config.namespace);
+
+    // Build testrun
+    const testRunManifest = buildTestRunManifest(configMap, archive, config, envVars);
+
+    // Create testrun resource
+    const testRunResult = await kubernetesService.createTestRun(testRunManifest);
+
+  } catch (error) {
+    logger.error(`Error running test: ${error instanceof Error ? error.message : String(error)}`);
+  }
+}

package/src/services/kubernetes.service.ts

@@ -0,0 +1,238 @@
+import { existsSync, promises as fs_promises } from 'fs';
+import { parse } from 'node:path';
+import * as k8s from '@kubernetes/client-node';
+import logger from '../utils/logger';
+import type { ArchivedFile, ConfigMapResult } from '../types/kubernetes.types';
+import { TestRunManifest } from '../types/testRunManifest.types';
+import { printTableGeneric } from '../utils/table.util';
+
+export class KubernetesService {
+  constructor(private readonly k8sApi: k8s.CoreV1Api, private readonly k8sCustomApi: k8s.CustomObjectsApi) { }
+
+  async createConfigMap(archiveFile: ArchivedFile, namespace: string): Promise<ConfigMapResult> {
+    // Check if the archive file exists
+    if (!existsSync(archiveFile.archivePath)) {
+      throw new Error(`Archive file not found at path: ${archiveFile.archivePath}`);
+    }
+
+    // Check archive file size (should be less than 1MB for k8s configmap)
+    const stats = await fs_promises.stat(archiveFile.archivePath);
+    if (stats.size > 1024 * 1024) {
+      throw new Error(`Archive file is too large to be stored in a configmap (size: ${stats.size} bytes)`);
+    }
+
+    const configMapName = parse(archiveFile.archiveFilename).name;
+    const fileContent = await fs_promises.readFile(archiveFile.archivePath, 'base64');
+
+    const configMap: k8s.V1ConfigMap = {
+      apiVersion: 'v1',
+      kind: 'ConfigMap',
+      metadata: {
+        name: configMapName,
+        namespace: namespace,
+      },
+      binaryData: {
+        [archiveFile.archiveFilename]: fileContent,
+      },
+    };
+
+    await this.k8sApi.createNamespacedConfigMap({ namespace, body: configMap });
+    logger.info(`ConfigMap ${configMapName} created in namespace ${namespace}`);
+    return { namespace, configMapName };
+  }
+
+  async deleteConfigMap(configMapName: string, namespace: string): Promise<void> {
+    try {
+      await this.k8sApi.deleteNamespacedConfigMap({ name: configMapName, namespace });
+      logger.info(`ConfigMap ${configMapName} deleted from namespace ${namespace}`);
+    } catch (error) {
+      const errorMessage = (error as Error).message ?? 'Unknown error';
+      throw new Error(`Failed to delete ConfigMap ${configMapName} from namespace ${namespace}: ${errorMessage}`);
+    }
+  }
+
+  async createTestRun(testRunManifest: TestRunManifest): Promise<any> {
+    try {
+      const response = await this.k8sCustomApi.createNamespacedCustomObject({
+        group: testRunManifest.apiVersion.split('/')[0],
+        version: testRunManifest.apiVersion.split('/')[1],
+        namespace: testRunManifest.metadata.namespace,
+        plural: "testruns",
+        body: testRunManifest,
+      });
+      logger.info(`TestRun ${testRunManifest.metadata.name} created in namespace ${testRunManifest.metadata.namespace}`);
+      logger.debug(`Create response: ${JSON.stringify(response)}`);
+      return response;
+    } catch (error) {
+      const errorMessage = (error as Error).message ?? 'Unknown error';
+      throw new Error(`Failed to create TestRun ${testRunManifest.metadata.name} in namespace ${testRunManifest.metadata.namespace}: ${errorMessage}`);
+    }
+  }
+
+  async deleteTestRun(testRunManifest: TestRunManifest): Promise<void> {
+    try {
+      const response = await this.k8sCustomApi.deleteNamespacedCustomObject({
+        group: testRunManifest.apiVersion.split('/')[0],
+        version: testRunManifest.apiVersion.split('/')[1],
+        namespace: testRunManifest.metadata.namespace,
+        plural: "testruns",
+        name: testRunManifest.metadata.name,
+      });
+      logger.info(`TestRun ${testRunManifest.metadata.name} deleted from namespace ${testRunManifest.metadata.namespace}`);
+      logger.debug(`Delete response: ${JSON.stringify(response)}`);
+    } catch (error) {
+      const errorMessage = (error as Error).message ?? 'Unknown error';
+      throw new Error(`Failed to delete TestRun ${testRunManifest.metadata.name} from namespace ${testRunManifest.metadata.namespace}: ${errorMessage}`);
+    }
+  }
+
+  async listTestRuns(namespace: string = "default"): Promise<any> {
+    try {
+      const response = await this.k8sCustomApi.listNamespacedCustomObject({
+        group: "k6.io",
+        version: "v1alpha1",
+        namespace: namespace,
+        plural: "testruns",
+      });
+      // logger.debug(`List response: ${JSON.stringify(response)}`);
+      printTestRunsTable((response as any).items ?? []);
+      return response;
+    } catch (error) {
+      const errorMessage = (error as Error).message ?? 'Unknown error';
+      throw new Error(`Failed to list TestRuns in namespace ${namespace}: ${errorMessage}`);
+    }
+  }
+
+  async listPods(namespace: string = "default"): Promise<any> {
+    try {
+      const response = await this.k8sApi.listNamespacedPod({ namespace });
+      printPodsTable(response);
+      // logger.debug(`List Pods: ${JSON.stringify(response)}`);
+      return response;
+    } catch (error) {
+      const errorMessage = (error as Error).message ?? 'Unknown error';
+      throw new Error(`Failed to list Pods in namespace ${namespace}: ${errorMessage}`);
+    }
+  }
+
+  async listConfigMaps(namespace: string = "default"): Promise<any> {
+    try {
+      const response = await this.k8sApi.listNamespacedConfigMap({ namespace });
+      printConfigMapsTable(response);
+      // logger.debug(`List ConfigMaps: ${JSON.stringify(response)}`);
+      return response;
+    } catch (error) {
+      const errorMessage = (error as Error).message ?? 'Unknown error';
+      throw new Error(`Failed to list ConfigMaps in namespace ${namespace}: ${errorMessage}`);
+    }
+  }
+}
+
+function fmt(v: any) {
+  return v ?? "N/A";
+}
+
+function getNamespace(obj: any) {
+  return obj?.metadata?.namespace ?? "default";
+}
+
+function getName(obj: any) {
+  return obj?.metadata?.name ?? "unknown";
+}
+
+function ageSince(isoDate: any): string {
+  if (!isoDate) return "N/A";
+  const created = new Date(isoDate).getTime();
+  const now = Date.now();
+  let s = Math.max(0, Math.floor((now - created) / 1000));
+  const days = Math.floor(s / 86400); s %= 86400;
+  const hrs = Math.floor(s / 3600); s %= 3600;
+  const mins = Math.floor(s / 60);
+  if (days > 0) return `${days}d${hrs}h`;
+  if (hrs > 0) return `${hrs}h${mins}m`;
+  return `${mins}m`;
+}
+
+export function createDefaultKubernetesService(context?: string): KubernetesService {
+  const kc = new k8s.KubeConfig();
+  kc.loadFromDefault();
+  if (context) kc.setCurrentContext(context);
+  const k8sApi = kc.makeApiClient(k8s.CoreV1Api);
+  const k8sCustomApi = kc.makeApiClient(k8s.CustomObjectsApi);
+  return new KubernetesService(k8sApi, k8sCustomApi);
+}
+
+export function printPodsTable(data: k8s.V1PodList): void {
+  const pods = data.items ?? [];
+  const ns = pods[0]?.metadata?.namespace ?? "unknown";
+  printTableGeneric({
+    title: "Pods",
+    headers: ["Pod", "Namespace", "Container", "Node Name", "Req CPU", "Req Mem", "Lim CPU", "Lim Mem", "Status"],
+    items: pods,
+    toRows: (pod) => {
+      const podName = getName(pod);
+      const namespace = getNamespace(pod);
+      const status = pod.status?.phase ?? "unknown";
+      const node = pod.spec?.nodeName ?? "unknown";
+      const containers = pod.spec?.containers ?? [];
+      if (containers.length === 0) {
+        return [[podName, namespace, "-", "-", "-", "-", "-", status, node]];
+      }
+      return containers.map((c) => {
+        const r = c.resources || {};
+        const req = r.requests || {};
+        const lim = r.limits || {};
+        const statusEmoji = status === 'Succeeded' ? '🟢' : status === 'Failed' ? '🔴' : '🟡';
+        return [
+          podName,
+          namespace,
+          c.name,
+          node,
+          fmt(req.cpu),
+          fmt(req.memory),
+          fmt(lim.cpu),
+          fmt(lim.memory),
+          `${status} ${statusEmoji}`,
+        ];
+      });
+    }
+  });
+}
+
+export function printConfigMapsTable(data: k8s.V1ConfigMapList): void {
+  const cms = data.items ?? [];
+  const ns = cms[0]?.metadata?.namespace ?? "unknown";
+  printTableGeneric({
+    title: "ConfigMaps",
+    headers: ["Name", "Namespace", "Data keys", "Binary keys", "Age"],
+    items: cms,
+    toRows: (cm) => {
+      const name = getName(cm);
+      const namespace = getNamespace(cm);
+      const dataKeys = Object.keys(cm.data ?? {}).length ? Object.keys(cm.data ?? {}).join(", ") : "0";
+      const binKeys = Object.keys(cm.binaryData ?? {}).length ? Object.keys(cm.binaryData ?? {}).join(", ") : "0";
+      const age = ageSince(cm.metadata?.creationTimestamp);
+      return [[name, namespace, dataKeys, binKeys, age]];
+    }
+  });
+}
+
+export function printTestRunsTable(testRuns: TestRunManifest[]): void {
+  const ns = testRuns[0]?.metadata?.namespace ?? "unknown";
+  printTableGeneric({
+    title: "TestRuns",
+    headers: ["Name", "Namespace", "Parallelism", "Cleanup", "Separate", "Quiet", "Age"],
+    items: testRuns,
+    toRows: (tr) => {
+      const name = tr.metadata?.name ?? "unknown";
+      const namespace = tr.metadata?.namespace ?? "unknown";
+      const parallelism = tr.spec?.parallelism ?? "N/A";
+      const cleanup = tr.spec?.cleanup ?? "N/A";
+      const separate = tr.spec?.separate ?? "N/A";
+      const quiet = tr.spec?.quiet ?? "N/A";
+      const age = (tr as any)?.metadata?.creationTimestamp ?? "N/A";
+      // const age = ageSince((tr as any)?.metadata?.creationTimestamp) || "N/A";
+      return [[name, namespace, parallelism, cleanup, separate, quiet, age]];
+    }
+  });
+}

package/src/services/script.service.ts

@@ -0,0 +1,79 @@
+import { exec } from 'child_process';
+import { existsSync } from 'fs';
+import { basename, join, parse } from 'node:path';
+import { promisify } from 'util';
+import logger from '../utils/logger';
+
+import type { ArchiveResult, ExecFn } from '../types/script.types';
+
+const defaultExecAsync = promisify(exec);
+
+export class ScriptService {
+  constructor(private readonly execCmd: ExecFn = defaultExecAsync) { }
+
+  async archiveTest(scriptPath: string, outputDirectory?: string): Promise<ArchiveResult> {
+    // Check if the script file exists
+    if (!existsSync(scriptPath)) throw new Error(`Script file not found at path: ${scriptPath}`);
+
+    if (outputDirectory) {
+      // Check if the output directory exists
+      if (!existsSync(outputDirectory)) {
+        throw new Error(`Output directory does not exist at path: ${outputDirectory}`);
+      }
+    }
+
+    // Check if k6 is installed
+    try {
+      await this.execCmd('k6 version');
+    } catch {
+      throw new Error('k6 is not installed. Please install k6 to archive scripts.');
+    }
+
+    // Archive the script using k6
+    try {
+      // Get the script name without extension to use as prefix for the archive file
+      const scriptName = parse(scriptPath).name;
+      const sanitizedScriptName = sanitizeText(scriptName);
+      const archiveOutput = join(outputDirectory ?? '.', `archive-${sanitizedScriptName}-${Date.now()}.tar`);
+      const archiveCommand = `k6 archive -v -O ${archiveOutput} ${scriptPath}`;
+      logger.debug(`Archiving script with command: ${archiveCommand}`);
+      const { stdout, stderr } = await this.execCmd(archiveCommand);
+      logger.debug(`Standard Output: ${stdout}`);
+      logger.debug(`Standard Error: ${stderr}`);
+
+      // Check if the file was created successfully
+      if (!existsSync(archiveOutput)) {
+        throw new Error(`Failed to create archive: ${stderr}`);
+      }
+      logger.info(`Archive created successfully at: ${archiveOutput}`);
+      return {
+        archivePath: archiveOutput,
+        archiveFilename: basename(archiveOutput),
+        scriptPath: scriptPath,
+        scriptFilename: basename(scriptPath),
+      };
+    } catch (error) {
+      const errorMessage = (error as Error).message ?? 'Unknown error';
+      throw new Error(`Failed to archive the script: ${errorMessage}`);
+    }
+  }
+}
+
+export function createDefaultScriptService(): ScriptService {
+  return new ScriptService();
+}
+
+// ---------------------------------------------------------------------------
+// Private helpers
+// ---------------------------------------------------------------------------
+
+function sanitizeText(text: string): string {
+  let sanitized = text.toLowerCase();
+  sanitized = sanitized.replace(/_/g, '-');
+  sanitized = sanitized.replace(/[^a-z0-9.-]/g, '-');
+  sanitized = sanitized.replace(/^[^a-z0-9]+|[^a-z0-9]+$/g, '');
+  sanitized = sanitized.replace(/[-]+/g, '-');
+  sanitized = sanitized.replace(/[.]+/g, '-');
+  sanitized = sanitized.replace(/^[.-]+|[.-]+$/g, '');
+  return sanitized;
+}

package/src/types/config.types.ts

@@ -0,0 +1,25 @@
+export interface K6Config {
+  namespace?: string;
+  parallelism?: number;
+  arguments?: string[] | undefined;
+  cleanup?: boolean;
+  quiet?: boolean;
+  separate?: boolean;
+  runner?: {
+    image?: string;
+    resources?: {
+      limits: {
+        cpu: string;
+        memory: string;
+      };
+      requests: {
+        cpu: string;
+        memory: string;
+      };
+    };
+  }
+  prometheus?: {
+    serverUrl: string;
+    trendStats?: string[];
+  }
+}

package/src/types/kubernetes.types.ts

@@ -0,0 +1,9 @@
+export interface ArchivedFile {
+  archivePath: string;
+  archiveFilename: string;
+}
+
+export interface ConfigMapResult {
+  namespace: string;
+  configMapName: string;
+}

package/src/types/script.types.ts

@@ -0,0 +1,8 @@
+export interface ArchiveResult {
+  archivePath: string;
+  archiveFilename: string;
+  scriptPath: string;
+  scriptFilename: string;
+}
+
+export type ExecFn = (cmd: string) => Promise<{ stdout: string; stderr: string }>;

package/src/types/testRunManifest.types.ts

@@ -0,0 +1,42 @@
+export interface TestRunManifest {
+  apiVersion: string;
+  kind: string;
+  metadata: {
+    name: string;
+    namespace: string;
+  };
+  spec: {
+    parallelism?: number;
+    arguments?: string;
+    quiet?: string;
+    cleanup?: string;
+    separate?: boolean;
+    runner?: {
+      image?: string;
+      env?: Array<{
+        name: string;
+        value: string;
+      }>;
+      resources?: {
+        limits: {
+          cpu: string
+          memory: string
+        }
+        requests: {
+          cpu: string
+          memory: string
+        }
+      }
+    };
+    script: {
+      configMap?: {
+        name: string;
+        file: string;
+      };
+      volumeClaim?: {
+        name: string;
+        file: string;
+      }
+    };
+  };
+}