k6ctl 1.1.0 → 1.3.0

package/src/services/kubernetes.service.ts

@@ -1,14 +1,30 @@
-import { existsSync, promises as fs_promises } from 'fs';
+import { existsSync, promises as fs_promises, createReadStream } 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 type { ArchivedFile, ConfigMapResult, VolumeClaimResult } from '../types/kubernetes.types';
 import { TestRunManifest } from '../types/testRunManifest.types';
 import { printTableGeneric } from '../utils/table.util';
-import { unlink } from 'node:fs/promises';
 
 export class KubernetesService {
-  constructor(private readonly k8sApi: k8s.CoreV1Api, private readonly k8sCustomApi: k8s.CustomObjectsApi) { }
+  constructor(
+    private readonly k8sApi: k8s.CoreV1Api,
+    private readonly k8sCustomApi: k8s.CustomObjectsApi,
+    private readonly kc?: k8s.KubeConfig,
+  ) { }
+
+  private getKubeConfig(): k8s.KubeConfig {
+    if (this.kc) return this.kc;
+    const kc = new k8s.KubeConfig();
+    kc.loadFromDefault();
+    return kc;
+  }
+
+  private isNotFoundError(error: unknown): boolean {
+    if ((error as any)?.statusCode === 404) return true;
+    if ((error as Error)?.message?.includes('HTTP-Code: 404')) return true;
+    return false;
+  }
 
   async createConfigMap(archiveFile: ArchivedFile, namespace: string): Promise<ConfigMapResult> {
     // Check if the archive file exists
@@ -39,17 +55,125 @@ export class KubernetesService {
 
     await this.k8sApi.createNamespacedConfigMap({ namespace, body: configMap });
     logger.info(`ConfigMap ${configMapName} created in namespace ${namespace}`);
-    
+
     // Clean up the archive file after creating the ConfigMap
-    await unlink(archiveFile.archivePath).catch(error => console.error(`Error deleting file ${archiveFile.archivePath}:`, error));
+    await fs_promises.unlink(archiveFile.archivePath).catch(error => console.error(`Error deleting file ${archiveFile.archivePath}:`, error));
     return { namespace, configMapName };
   }
 
+  async createPVCWithArchive(archiveFile: ArchivedFile, namespace: string): Promise<VolumeClaimResult> {
+    if (!existsSync(archiveFile.archivePath)) {
+      throw new Error(`Archive file not found at path: ${archiveFile.archivePath}`);
+    }
+
+    const stats = await fs_promises.stat(archiveFile.archivePath);
+    const storageMi = Math.max(10, Math.ceil(stats.size * 2 / (1024 * 1024)));
+    const volumeClaimName = parse(archiveFile.archiveFilename).name;
+
+    // Create PVC
+    const pvc: k8s.V1PersistentVolumeClaim = {
+      apiVersion: 'v1',
+      kind: 'PersistentVolumeClaim',
+      metadata: { name: volumeClaimName, namespace },
+      spec: {
+        accessModes: ['ReadWriteOnce'],
+        resources: { requests: { storage: `${storageMi}Mi` } },
+      },
+    };
+    await this.k8sApi.createNamespacedPersistentVolumeClaim({ namespace, body: pvc });
+    logger.info(`PVC ${volumeClaimName} created in namespace ${namespace} (${storageMi}Mi)`);
+
+    // Create helper pod mounting the PVC
+    const helperPodName = `archive-uploader-${Date.now()}`;
+    const helperPod: k8s.V1Pod = {
+      apiVersion: 'v1',
+      kind: 'Pod',
+      metadata: { name: helperPodName, namespace },
+      spec: {
+        restartPolicy: 'Never',
+        containers: [{
+          name: 'helper',
+          image: 'busybox',
+          command: ['sleep', 'infinity'],
+          volumeMounts: [{ name: 'data', mountPath: '/data' }],
+        }],
+        volumes: [{ name: 'data', persistentVolumeClaim: { claimName: volumeClaimName } }],
+      },
+    };
+    await this.k8sApi.createNamespacedPod({ namespace, body: helperPod });
+    logger.info(`Helper pod ${helperPodName} created in namespace ${namespace}`);
+
+    // Wait for pod to reach Running state
+    await this.waitForPodRunning(helperPodName, namespace);
+
+    // Stream archive into pod via exec (like kubectl cp)
+    const exec = new k8s.Exec(this.getKubeConfig());
+    const stdin = createReadStream(archiveFile.archivePath);
+    await new Promise<void>((resolve, reject) => {
+      exec.exec(
+        namespace,
+        helperPodName,
+        'helper',
+        ['tee', `/data/${archiveFile.archiveFilename}`],
+        null,
+        null,
+        stdin,
+        false,
+        (status: k8s.V1Status) => {
+          if (status.status === 'Success') resolve();
+          else reject(new Error(`Failed to upload archive to pod: ${status.message ?? JSON.stringify(status)}`));
+        },
+      ).catch(reject);
+    });
+    logger.info(`Archive ${archiveFile.archiveFilename} uploaded to PVC ${volumeClaimName}`);
+
+    // Delete helper pod
+    await this.k8sApi.deleteNamespacedPod({ name: helperPodName, namespace })
+      .catch(err => logger.debug(`Error deleting helper pod ${helperPodName}: ${(err as Error).message}`));
+    logger.info(`Helper pod ${helperPodName} deleted`);
+
+    // Clean up local archive file
+    await fs_promises.unlink(archiveFile.archivePath)
+      .catch(err => logger.debug(`Error deleting archive file ${archiveFile.archivePath}: ${(err as Error).message}`));
+
+    return { namespace, volumeClaimName, archiveFilename: archiveFile.archiveFilename };
+  }
+
+  private async waitForPodRunning(podName: string, namespace: string, maxWaitMs: number = 60_000): Promise<void> {
+    const pollInterval = 2_000;
+    const start = Date.now();
+    while (Date.now() - start < maxWaitMs) {
+      const pod = await this.k8sApi.readNamespacedPod({ name: podName, namespace });
+      if (pod.status?.phase === 'Running') return;
+      if (pod.status?.phase === 'Failed') throw new Error(`Helper pod ${podName} failed to start`);
+      await new Promise(r => setTimeout(r, pollInterval));
+    }
+    throw new Error(`Helper pod ${podName} did not reach Running state within ${maxWaitMs}ms`);
+  }
+
+  async deleteVolumeClaimByName(volumeClaimName: string, namespace: string = "default"): Promise<void> {
+    try {
+      await this.k8sApi.deleteNamespacedPersistentVolumeClaim({ name: volumeClaimName, namespace });
+      logger.info(`PVC ${volumeClaimName} deleted from namespace ${namespace}`);
+    } catch (error) {
+      if (this.isNotFoundError(error)) {
+        logger.warn(`PVC ${volumeClaimName} not found in namespace ${namespace}, skipping deletion`);
+        return;
+      }
+      const errorMessage = (error as Error).message ?? 'Unknown error';
+      throw new Error(`Failed to delete PVC ${volumeClaimName} from namespace ${namespace}: ${errorMessage}`);
+    }
+  }
+
   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) {
+      if (this.isNotFoundError(error)) {
+        logger.warn(`ConfigMap ${configMapName} not found in namespace ${namespace}, skipping deletion`);
+        return;
+      }
       const errorMessage = (error as Error).message ?? 'Unknown error';
       throw new Error(`Failed to delete ConfigMap ${configMapName} from namespace ${namespace}: ${errorMessage}`);
     }
@@ -85,27 +209,28 @@ export class KubernetesService {
         namespace: namespace,
         plural: "testruns",
       });
-      return response;
+      return response.items as TestRunManifest[];
     } 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> {
+  async listPods(namespace: string = "default"): Promise<k8s.V1PodList> {
     try {
       const response = await this.k8sApi.listNamespacedPod({ namespace });
-      return response;
+      return response as k8s.V1PodList;
     } 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> {
+  async listConfigMaps(namespace: string = "default"): Promise<k8s.V1ConfigMapList> {
     try {
       const response = await this.k8sApi.listNamespacedConfigMap({ namespace });
-      return response;
+      response.items = response.items?.filter(cm => cm.metadata?.name?.startsWith('archive-'));
+      return response as k8s.V1ConfigMapList;
     } catch (error) {
       const errorMessage = (error as Error).message ?? 'Unknown error';
       throw new Error(`Failed to list ConfigMaps in namespace ${namespace}: ${errorMessage}`);
@@ -127,16 +252,37 @@ export class KubernetesService {
       await this.k8sCustomApi.deleteNamespacedCustomObject(this.getTestRunCustomObjectParams(testRunName, namespace));
       logger.info(`TestRun ${testRunName} deleted from namespace ${namespace}`);
     } catch (error) {
+      if (this.isNotFoundError(error)) {
+        logger.warn(`TestRun ${testRunName} not found in namespace ${namespace}, skipping deletion`);
+        return;
+      }
       const errorMessage = (error as Error).message ?? 'Unknown error';
       throw new Error(`Failed to delete TestRun ${testRunName} from namespace ${namespace}: ${errorMessage}`);
     }
   }
 
-  async getTestRun(testRunName: string, namespace: string = "default"): Promise<any> {
+  async deletePodByName(podName: string, namespace: string = "default"): Promise<void> {
+    try {
+      await this.k8sApi.deleteNamespacedPod({ name: podName, namespace });
+      logger.info(`Pod ${podName} deleted from namespace ${namespace}`);
+    } catch (error) {
+      if (this.isNotFoundError(error)) {
+        logger.warn(`Pod ${podName} not found in namespace ${namespace}, skipping deletion`);
+        return;
+      }
+      const errorMessage = (error as Error).message ?? 'Unknown error';
+      throw new Error(`Failed to delete Pod ${podName} from namespace ${namespace}: ${errorMessage}`);
+    }
+  }
+
+  async getTestRun(testRunName: string, namespace: string = "default"): Promise<TestRunManifest | null> {
     try {
       const response = await this.k8sCustomApi.getNamespacedCustomObject(this.getTestRunCustomObjectParams(testRunName, namespace));
-      return response;
+      return response as TestRunManifest;
     } catch (error) {
+      if (this.isNotFoundError(error)) {
+        return null;
+      }
       const errorMessage = (error as Error).message ?? 'Unknown error';
       throw new Error(`Failed to get TestRun ${testRunName} in namespace ${namespace}: ${errorMessage}`);
     }
@@ -148,7 +294,7 @@ export class KubernetesService {
         namespace,
         labelSelector: `k6_cr=${testRunName}`,
       });
-      return response;
+      return response as k8s.V1PodList;
     } catch (error) {
       const errorMessage = (error as Error).message ?? 'Unknown error';
       throw new Error(`Failed to get pods for TestRun ${testRunName} in namespace ${namespace}: ${errorMessage}`);
@@ -201,7 +347,7 @@ export function createDefaultKubernetesService(context?: string): KubernetesServ
   if (context) kc.setCurrentContext(context);
   const k8sApi = kc.makeApiClient(k8s.CoreV1Api);
   const k8sCustomApi = kc.makeApiClient(k8s.CustomObjectsApi);
-  return new KubernetesService(k8sApi, k8sCustomApi);
+  return new KubernetesService(k8sApi, k8sCustomApi, kc);
 }
 
 export function printPodsTable(data: k8s.V1PodList): void {
@@ -273,7 +419,6 @@ export function printTestRunsTable(testRuns: TestRunManifest[]): void {
       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

@@ -1,10 +1,13 @@
 import { exec } from 'child_process';
-import { existsSync } from 'fs';
-import { basename, join, parse } from 'node:path';
+import { existsSync, statSync } from 'fs';
+import { promises as fsPromises } from 'node:fs';
+import { dirname, basename, join, parse } from 'node:path';
+import { tmpdir } from 'node:os';
 import { promisify } from 'util';
 import logger from '../utils/logger';
+import * as tar from 'tar';
 
-import type { ArchiveResult, ExecFn } from '../types/script.types';
+import type { ArchiveResult, ExecFn, K6InspectResult, K6ScenarioMetrics } from '../types/script.types';
 
 const defaultExecAsync = promisify(exec);
 
@@ -45,10 +48,12 @@ export class ScriptService {
       if (!existsSync(archiveOutput)) {
         throw new Error(`Failed to create archive: ${stderr}`);
       }
-      logger.info(`Archive created successfully at: ${archiveOutput}`);
+      const archiveSize = statSync(archiveOutput).size;
+      logger.info(`Archive created successfully at: ${archiveOutput} (size: ${archiveSize} bytes)`);
       return {
         archivePath: archiveOutput,
         archiveFilename: basename(archiveOutput),
+        archiveSize,
         scriptPath: scriptPath,
         scriptFilename: basename(scriptPath),
       };
@@ -57,6 +62,69 @@ export class ScriptService {
       throw new Error(`Failed to archive the script: ${errorMessage}`);
     }
   }
+
+  async inspectScript(scriptPath: string): Promise<K6InspectResult> {
+    const { stdout, stderr } = await this.execCmd(`k6 inspect ${scriptPath}`);
+    if (stderr) {
+      logger.error(`Error inspecting script: ${stderr}`);
+      throw new Error(`Failed to inspect the script: ${stderr}`);
+    }
+    return JSON.parse(stdout) as K6InspectResult;
+  }
+
+  async extractModifyAndRecompress(archive: ArchiveResult, scenarioMetrics: K6ScenarioMetrics[]): Promise<ArchiveResult> {
+    if (!existsSync(archive.archivePath)) {
+      throw new Error(`Archive file not found at path: ${archive.archivePath}`);
+    }
+
+    const tempRoot = await fsPromises.mkdtemp(join(tmpdir(), 'k6ctl-archive-'));
+    const extractDir = join(tempRoot, 'extracted');
+
+    try {
+      await fsPromises.mkdir(extractDir, { recursive: true });
+
+      await tar.x({
+        file: archive.archivePath,
+        cwd: extractDir,        
+      });
+
+      const metadataPath = join(extractDir, 'metadata.json');
+      if (!existsSync(metadataPath)) {
+        throw new Error(`metadata.json not found in extracted archive: ${archive.archiveFilename}`);
+      }
+
+      const metadataRaw = await fsPromises.readFile(metadataPath, 'utf8');
+      const metadata = JSON.parse(metadataRaw) as Record<string, unknown>;
+      const updatedMetadata = updateMetadata(metadata, scenarioMetrics);
+      await fsPromises.writeFile(metadataPath, `${JSON.stringify(updatedMetadata, null, 2)}\n`, 'utf8');
+
+      const outputArchivePath = join(dirname(archive.archivePath), `${parse(archive.archiveFilename).name}.tar`);
+
+      await tar.c({
+        file: outputArchivePath,
+        cwd: extractDir,
+      }, ['metadata.json', 'data', 'file']);
+
+      if (!existsSync(outputArchivePath)) {
+        throw new Error(`Failed to create modified archive at path: ${outputArchivePath}`);
+      }
+
+      logger.info(`Archive metadata updated successfully: ${outputArchivePath}`);
+
+      return {
+        archivePath: outputArchivePath,
+        archiveFilename: basename(outputArchivePath),
+        scriptPath: archive.scriptPath,
+        scriptFilename: archive.scriptFilename,
+        archiveSize: statSync(outputArchivePath).size,
+      };
+    } catch (error) {
+      const errorMessage = (error as Error).message ?? 'Unknown error';
+      throw new Error(`Failed to extract, modify, and recompress archive: ${errorMessage}`);
+    } finally {
+      await fsPromises.rm(tempRoot, { recursive: true, force: true });
+    }
+  }
 }
 
 export function createDefaultScriptService(): ScriptService {
@@ -77,3 +145,33 @@ function sanitizeText(text: string): string {
   sanitized = sanitized.replace(/^[.-]+|[.-]+$/g, '');
   return sanitized;
 }
+
+function shellQuote(value: string): string {
+  return `'${value.replace(/'/g, `'\\''`)}'`;
+}
+
+function updateMetadata(metadata: Record<string, unknown>, scenarioMetrics: K6ScenarioMetrics[]): Record<string, unknown> {
+  if (isRecord(metadata.options) && isRecord(metadata.options.scenarios)) {
+    applyScenarioMetricsToScenarios(metadata.options.scenarios, scenarioMetrics);
+  }
+  return metadata;
+}
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+  return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+
+function applyScenarioMetricsToScenarios(
+  scenarios: Record<string, unknown>,
+  scenarioMetrics: K6ScenarioMetrics[]
+) {
+  for (const metric of scenarioMetrics) {
+    const scenario = scenarios[metric.name];
+    if (!isRecord(scenario)) {
+      continue;
+    }
+    const recommendedMaxVUs = Math.ceil(metric.recommendedMaxVUs);
+    scenario.maxVUs = recommendedMaxVUs;
+    scenario.preAllocatedVUs = Math.max(1, Math.ceil(recommendedMaxVUs * 0.7));
+  }
+}

package/src/types/kubernetes.types.ts

@@ -7,3 +7,9 @@ export interface ConfigMapResult {
   namespace: string;
   configMapName: string;
 }
+
+export interface VolumeClaimResult {
+  namespace: string;
+  volumeClaimName: string;
+  archiveFilename: string;
+}

package/src/types/lastRun.types.ts

@@ -1,7 +1,8 @@
 export interface LastRunState {
   testRunName: string;
   namespace: string;
-  configMapName: string;
+  configMapName?: string;
+  volumeClaimName?: string;
   scriptPath: string;
   createdAt: string;
 }

package/src/types/script.types.ts

@@ -1,8 +1,48 @@
 export interface ArchiveResult {
   archivePath: string;
   archiveFilename: string;
+  archiveSize: number;
   scriptPath: string;
   scriptFilename: string;
 }
 
+export interface K6ScenarioOptions {
+  executor: string;
+  startTime?: string;
+  gracefulStop?: string;
+  env?: Record<string, string>;
+  exec?: string;
+  tags?: Record<string, string>;
+  startRate?: number;
+  timeUnit?: string;  // e.g. "1s", "500ms"
+  stages?: Array<{ duration: string; target: number }>;
+  preAllocatedVUs?: number;
+  maxVUs?: number;
+}
+
+export interface K6InspectResult {
+  scenarios?: Record<string, K6ScenarioOptions>;
+}
+
+export interface K6StageMetrics {
+  stageIndex: number;
+  duration: string;
+  durationSeconds: number;
+  fromTps: number;
+  toTps: number;
+  avgTps: number;
+  estimatedIterations: number;
+  requiredVUsAtTarget: number;
+  recommendedVUsAtTarget: number;
+}
+
+export interface K6ScenarioMetrics {
+  name: string;
+  peakTps: number;
+  totalIterations: number;
+  requiredMaxVUs: number;
+  recommendedMaxVUs: number;
+  stageMetrics: K6StageMetrics[];
+}
+
 export type ExecFn = (cmd: string) => Promise<{ stdout: string; stderr: string }>;

package/src/types/testRunManifest.types.ts

@@ -1,3 +1,5 @@
+import { RunnerEnvVar } from "../utils/testRunManifestBuilder";
+
 export interface TestRunManifest {
   apiVersion: string;
   kind: string;
@@ -13,10 +15,7 @@ export interface TestRunManifest {
     separate?: boolean;
     runner?: {
       image?: string;
-      env?: Array<{
-        name: string;
-        value: string;
-      }>;
+      env?: RunnerEnvVar[];
       resources?: {
         limits: {
           cpu: string

package/src/utils/testRunManifestBuilder.ts

@@ -1,9 +1,11 @@
 import logger from '../utils/logger';
-import type { ArchivedFile, ConfigMapResult } from '../types/kubernetes.types';
+import type { ArchivedFile, ConfigMapResult, VolumeClaimResult } from '../types/kubernetes.types';
 import { K6Config } from '../types/config.types';
 import { TestRunManifest } from '../types/testRunManifest.types';
 
-type RunnerEnvVar = { name: string; value: string };
+export type RunnerEnvVar =
+    | { name: string; value: string }
+    | { name: string; valueFrom: { secretKeyRef: { name: string; key: string } } };
 const K6_GROUP = "k6.io";
 const K6_VERSION = "v1alpha1";
 const K6_KIND = "TestRun";
@@ -61,24 +63,15 @@ function buildRunnerEnv(
     cfg: K6Config,
     envFromLoader?: Record<string, string>
 ): RunnerEnvVar[] | undefined {
-    const envMap = new Map<string, string>();
+    const envMap = new Map<string, RunnerEnvVar>();
     if (envFromLoader) {
-        for (const [key, value] of Object.entries(envFromLoader)) {
-            if (value !== undefined && value !== null) {
-                envMap.set(key, String(value));
-            }
+        for (const [key, raw] of Object.entries(envFromLoader)) {
+            if (raw === undefined || raw === null) continue;
+            addEnvToMap(key, raw, envMap);
         }
     }
-    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: RunnerEnvVar[] = Array.from(envMap.entries()).map(([name, value]) => ({
-        name,
-        value,
-    }));
+    addPrometheusEnvVars(cfg, envMap);
+    const envArray: RunnerEnvVar[] = Array.from(envMap.values());
     return envArray.length > 0 ? envArray : undefined;
 }
 
@@ -99,4 +92,73 @@ function buildArgumentsString(args: string[] | undefined, cfg: K6Config, name: s
         return undefined;
     }
     return finalArgs.join(" ");
-}
+}
+
+function parseSecretPlaceholder(value: string): { secretName: string; secretKey: string } | null {
+    const m = /^\{\{SECRETS\.([^.}]+)\.([^.}]+)\}\}$/.exec(value.trim());
+    if (!m) return null;
+    return { secretName: m[1], secretKey: m[2] };
+}
+
+function addEnvToMap(key: string, raw: string, envMap: Map<string, RunnerEnvVar>) {
+    const value = String(raw);
+    const secret = parseSecretPlaceholder(value);
+    if (secret) {
+        envMap.set(key, { name: key, valueFrom: { secretKeyRef: { name: secret.secretName, key: secret.secretKey } } });
+    } else {
+        envMap.set(key, { name: key, value });
+    }
+}
+
+function addPrometheusEnvVars(cfg: K6Config, envMap: Map<string, RunnerEnvVar>) {
+    if (cfg.prometheus?.serverUrl) {
+        envMap.set(K6_PROMETHEUS_RW_SERVER_URL, {
+            name: K6_PROMETHEUS_RW_SERVER_URL,
+            value: cfg.prometheus.serverUrl,
+        });
+        if (cfg.prometheus.trendStats?.length) {
+            envMap.set(K6_PROMETHEUS_RW_TREND_STATS, {
+                name: K6_PROMETHEUS_RW_TREND_STATS,
+                value: cfg.prometheus.trendStats.join(","),
+            });
+        }
+    }
+}
+
+export function buildTestRunManifestWithVolumeClaim(
+    volumeClaimResult: VolumeClaimResult,
+    cfg: K6Config,
+    envFromLoader?: Record<string, string>
+): TestRunManifest {
+    const testName = volumeClaimResult.volumeClaimName.replace('archive-', 'test-');
+    const argumentsString = buildArgumentsString(cfg.arguments, cfg, testName);
+    logger.debug('Constructed arguments string for TestRun manifest (volume):', argumentsString);
+    const testRun: TestRunManifest = {
+        apiVersion: `${K6_GROUP}/${K6_VERSION}`,
+        kind: K6_KIND,
+        metadata: {
+            name: testName,
+            namespace: volumeClaimResult.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: {
+                volumeClaim: {
+                    name: volumeClaimResult.volumeClaimName,
+                    file: volumeClaimResult.archiveFilename,
+                },
+            },
+        },
+    };
+    logger.debug('Constructed TestRun manifest (volume):', JSON.stringify(testRun, null, 2));
+    return testRun;
+}