@elench/testkit 0.1.36 → 0.1.37

package/lib/runner/artifacts.mjs

@@ -7,6 +7,7 @@ import {
 } from "../timing/index.mjs";
 
 const TIMINGS_FILENAME = "timings.json";
+const RESULT_ARTIFACTS_DIRNAME = "artifacts";
 
 export function writeRunArtifact(productDir, artifact) {
   const resultsDir = path.join(productDir, ".testkit", "results");
@@ -21,6 +22,65 @@ export function writeStatusArtifact(productDir, artifact) {
   );
 }
 
+export function resetResultArtifacts(productDir) {
+  fs.rmSync(path.join(productDir, ".testkit", "results", RESULT_ARTIFACTS_DIRNAME), {
+    recursive: true,
+    force: true,
+  });
+}
+
+export function persistTaskArtifacts(productDir, task, emittedArtifacts) {
+  if (!Array.isArray(emittedArtifacts) || emittedArtifacts.length === 0) return [];
+
+  const artifactsDir = path.join(
+    productDir,
+    ".testkit",
+    "results",
+    RESULT_ARTIFACTS_DIRNAME,
+    sanitizePathSegment(task.serviceName || "service")
+  );
+  fs.mkdirSync(artifactsDir, { recursive: true });
+
+  return emittedArtifacts.map((artifact, index) => {
+    const fileName = `task-${task.id}-${String(index + 1).padStart(2, "0")}-${sanitizePathSegment(artifact.name || "artifact")}.json`;
+    const relativePath = path.join(
+      ".testkit",
+      "results",
+      RESULT_ARTIFACTS_DIRNAME,
+      sanitizePathSegment(task.serviceName || "service"),
+      fileName
+    );
+    const absolutePath = path.join(productDir, relativePath);
+    const payload = {
+      schemaVersion: 1,
+      source: "testkit-runtime-artifact",
+      service: task.serviceName,
+      suite: {
+        key: task.suiteKey,
+        name: task.suiteName,
+        type: task.type,
+      },
+      file: task.file,
+      taskId: task.id,
+      index,
+      name: artifact.name,
+      kind: artifact.kind || null,
+      summary: artifact.summary || null,
+      contentType: artifact.contentType || "application/json",
+      emittedAt: artifact.emittedAt || null,
+      data: artifact.data,
+    };
+    fs.writeFileSync(absolutePath, `${JSON.stringify(payload, null, 2)}\n`);
+    return {
+      name: payload.name,
+      kind: payload.kind,
+      summary: payload.summary,
+      contentType: payload.contentType,
+      path: normalizePath(relativePath),
+    };
+  });
+}
+
 export function loadTimings(productDir) {
   const filePath = path.join(productDir, ".testkit", TIMINGS_FILENAME);
   if (!fs.existsSync(filePath)) {
@@ -41,3 +101,15 @@ export function saveTimings(productDir, timings, updates) {
   fs.mkdirSync(rootDir, { recursive: true });
   fs.writeFileSync(path.join(rootDir, TIMINGS_FILENAME), JSON.stringify(next, null, 2));
 }
+
+function sanitizePathSegment(value) {
+  return String(value)
+    .trim()
+    .toLowerCase()
+    .replace(/[^a-z0-9._-]+/g, "-")
+    .replace(/^-+|-+$/g, "") || "artifact";
+}
+
+function normalizePath(filePath) {
+  return filePath.split(path.sep).join("/");
+}

package/lib/runner/default-runtime-runner.mjs

@@ -3,6 +3,8 @@ import path from "path";
 import { execa } from "execa";
 import { bundleK6File } from "../bundler/index.mjs";
 import { resolveK6Binary } from "../config/index.mjs";
+import { persistTaskArtifacts } from "./artifacts.mjs";
+import { RUNTIME_ARTIFACT_MARKER } from "../runtime-src/k6/artifacts.js";
 import { determineDefaultRuntimeFailure } from "./default-runtime-errors.mjs";
 import { formatBatchDescriptor } from "./formatting.mjs";
 import { buildExecutionEnv } from "./template.mjs";
@@ -85,10 +87,17 @@ export async function runDefaultRuntimeTask(targetConfig, task, args, lifecycle,
     }
   );
 
-  if (result.stdout) process.stdout.write(result.stdout);
-  if (result.stderr) process.stderr.write(result.stderr);
+  const stdout = parseDefaultRuntimeOutput(result.stdout || "");
+  const stderr = parseDefaultRuntimeOutput(result.stderr || "");
+  if (stdout.visibleOutput) process.stdout.write(stdout.visibleOutput);
+  if (stderr.visibleOutput) process.stderr.write(stderr.visibleOutput);
 
   const summary = readDefaultRuntimeSummary(summaryFile);
+  const runtimeArtifacts = persistTaskArtifacts(
+    targetConfig.productDir,
+    task,
+    [...stdout.artifacts, ...stderr.artifacts]
+  );
   const runtimeError = determineDefaultRuntimeFailure(result, summary, firstLine);
   const finishedAt = Date.now();
 
@@ -99,6 +108,7 @@ export async function runDefaultRuntimeTask(targetConfig, task, args, lifecycle,
     durationMs: finishedAt - startedAt,
     startedAt,
     finishedAt,
+    artifacts: runtimeArtifacts,
   };
 }
 
@@ -117,3 +127,42 @@ export function readDefaultRuntimeSummary(filePath) {
     return null;
   }
 }
+
+function parseDefaultRuntimeOutput(output) {
+  if (!output) {
+    return {
+      visibleOutput: "",
+      artifacts: [],
+    };
+  }
+
+  const visibleLines = [];
+  const artifacts = [];
+  for (const line of output.split(/\r?\n/)) {
+    const rawPayload = extractArtifactPayload(line);
+    if (rawPayload !== null) {
+      try {
+        artifacts.push(JSON.parse(decodeURIComponent(rawPayload)));
+      } catch {
+        visibleLines.push(line);
+      }
+      continue;
+    }
+    visibleLines.push(line);
+  }
+
+  return {
+    visibleOutput: visibleLines.join("\n"),
+    artifacts,
+  };
+}
+
+function extractArtifactPayload(line) {
+  if (line.startsWith(RUNTIME_ARTIFACT_MARKER)) {
+    return line.slice(RUNTIME_ARTIFACT_MARKER.length);
+  }
+
+  const k6ConsoleMatch = line.match(/msg="TESTKIT_ARTIFACT:(.*)"(?:\s+source=console)?$/);
+  if (!k6ConsoleMatch) return null;
+  return k6ConsoleMatch[1];
+}

package/lib/runner/orchestrator.mjs

@@ -16,7 +16,13 @@ import {
 } from "./results.mjs";
 import { buildRunArtifact, buildStatusArtifact } from "./reporting.mjs";
 import { buildRunSummaryLines, formatError } from "./formatting.mjs";
-import { loadTimings, saveTimings, writeRunArtifact, writeStatusArtifact } from "./artifacts.mjs";
+import {
+  loadTimings,
+  resetResultArtifacts,
+  saveTimings,
+  writeRunArtifact,
+  writeStatusArtifact,
+} from "./artifacts.mjs";
 import {
   cleanupRunById,
   cleanupRuns,
@@ -39,6 +45,7 @@ export async function runAll(configs, typeValues, suiteSelectors, opts, allConfi
   const telemetry = configs[0]?.telemetry || null;
   const productDir = configs[0]?.productDir || process.cwd();
   await cleanupStaleRuns(productDir);
+  resetResultArtifacts(productDir);
   const metadata = {
     git: collectGitMetadata(productDir),
     host: {

package/lib/runner/results.mjs

@@ -45,6 +45,7 @@ export function buildServiceTrackers(servicePlans, startedAt) {
               error: null,
               reason: null,
               status: "not_run",
+              artifacts: [],
             },
           ];
         }),
@@ -57,6 +58,7 @@ export function buildServiceTrackers(servicePlans, startedAt) {
             error: null,
             reason: file.reason,
             status: "skipped",
+            artifacts: [],
           },
         ]),
       ]),
@@ -118,6 +120,7 @@ export function recordTaskOutcome(trackers, task, outcome, finishedAt = Date.now
     existingFileResult.error = outcome.error;
     existingFileResult.reason = outcome.reason || null;
     existingFileResult.status = status;
+    existingFileResult.artifacts = Array.isArray(outcome.artifacts) ? outcome.artifacts : [];
   } else {
     suite.fileResultsByPath.set(normalizedPath, {
       path: normalizedPath,
@@ -126,6 +129,7 @@ export function recordTaskOutcome(trackers, task, outcome, finishedAt = Date.now
       error: outcome.error,
       reason: outcome.reason || null,
       status,
+      artifacts: Array.isArray(outcome.artifacts) ? outcome.artifacts : [],
     });
   }
   if (status === "failed" && !suite.failedFileSet.has(task.file)) {
@@ -243,6 +247,9 @@ function finalizeSuite(suite) {
       durationMs: file.durationMs,
       error: file.error,
       reason: file.reason,
+      ...(Array.isArray(file.artifacts) && file.artifacts.length > 0
+        ? { artifacts: file.artifacts }
+        : {}),
     }));
 
   return {

package/lib/runtime/index.d.ts

@@ -23,6 +23,12 @@ export interface RuntimeOptions {
   thresholds?: Record<string, unknown>;
 }
 
+export interface RuntimeArtifactOptions {
+  contentType?: string;
+  kind?: string;
+  summary?: string;
+}
+
 export interface RuntimeEnv {
   BASE: string;
   MACHINE_ID?: string;
@@ -133,6 +139,11 @@ export declare const http: RuntimeHttpClient;
 
 export declare function file(data: unknown, filename?: string, contentType?: string): unknown;
 export declare function json<T = unknown>(response: Pick<RuntimeResponse, "body">): T;
+export declare function emitArtifact(
+  name: string,
+  data: unknown,
+  options?: RuntimeArtifactOptions
+): void;
 export declare function contains<T extends Record<string, unknown>>(
   rows: T[],
   field: keyof T | string,

package/lib/runtime/index.mjs

@@ -10,6 +10,9 @@ export function file(data, filename, contentType) {
   return rawHttp.file(data, filename, contentType);
 }
 
+export {
+  emitArtifact,
+} from "../runtime-src/k6/artifacts.js";
 export {
   allMatch,
   contains,

package/lib/runtime-src/k6/artifacts.js

@@ -0,0 +1,36 @@
+export const RUNTIME_ARTIFACT_MARKER = "TESTKIT_ARTIFACT:";
+
+export function emitArtifact(name, data, options = {}) {
+  const normalizedName = normalizeArtifactName(name);
+  const payload = encodeURIComponent(
+    JSON.stringify({
+      name: normalizedName,
+      kind: normalizeOptionalString(options.kind),
+      summary: normalizeOptionalString(options.summary),
+      contentType: normalizeContentType(options.contentType),
+      data,
+      emittedAt: new Date().toISOString(),
+    })
+  );
+  console.log(
+    `${RUNTIME_ARTIFACT_MARKER}${payload}`
+  );
+}
+
+function normalizeArtifactName(name) {
+  if (typeof name !== "string" || name.trim().length === 0) {
+    throw new Error("emitArtifact(name, data) requires a non-empty artifact name");
+  }
+  return name.trim();
+}
+
+function normalizeOptionalString(value) {
+  if (value === undefined || value === null) return null;
+  const normalized = String(value).trim();
+  return normalized.length > 0 ? normalized : null;
+}
+
+function normalizeContentType(value) {
+  const normalized = normalizeOptionalString(value);
+  return normalized || "application/json";
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@elench/testkit",
-  "version": "0.1.36",
+  "version": "0.1.37",
   "description": "CLI for discovering and running local HTTP, DAL, and Playwright test suites",
   "type": "module",
   "types": "./lib/index.d.ts",