harness-mcp-v2 3.2.19 → 3.2.21

package/build/registry/extractors.js

@@ -43,6 +43,17 @@ export const pageExtract = (raw) => {
         total: r.data?.totalElements ?? r.data?.totalItems ?? 0,
     };
 };
+/**
+ * Spring Data page at the response root (no NG `{ data }` envelope):
+ * `{ content, totalElements }`. Used by Release Management (RMG) list APIs.
+ */
+export const springPageExtract = (raw) => {
+    const r = raw;
+    return {
+        items: Array.isArray(r.content) ? r.content : [],
+        total: typeof r.totalElements === "number" ? r.totalElements : 0,
+    };
+};
 /** Extract `data` from NG API and wrap primitive values in an object for structuredContent compatibility. */
 export const countExtract = (raw) => {
     const r = raw;
@@ -125,8 +136,8 @@ export const stoExemptionsExtract = (raw, input) => {
     };
 };
 /**
- * STO SAST remediation DiffOccurrences
- * (`GET /sto/api/v2/sast-remediation/diff-occurrences`).
+ * STO Remediation DiffOccurrences
+ * (`GET /sto/api/v2/remediation-agent/diff-occurrences`).
  *
  * API shape:
  *   { validationScanId, existingOccurrences: [...], newOccurrences: [...],
@@ -136,7 +147,7 @@ export const stoExemptionsExtract = (raw, input) => {
  * tell still-present vs newly introduced occurrences without two list calls.
  * Fingerprint is not on the wire (Diff matching is server-side only).
  */
-export const stoSastRemediationDiffExtract = (raw) => {
+export const stoRemediationDiffExtract = (raw) => {
     if (raw === null || raw === undefined || typeof raw !== "object")
         return raw;
     const r = raw;
@@ -779,18 +790,53 @@ export const chaosK8sInfraListExtract = (raw) => {
         total: r.totalNoOfInfrastructures ?? (Array.isArray(r.infras) ? r.infras.length : 0),
     };
 };
-// Read a well-known input value from the inputs[] slice by name.
-const readLoadtestInput = (inputs, name) => (inputs ?? []).find((i) => i?.name === name)?.value;
+// Pick the tool-specific sub-object out of toolConfig; loadTestManager also
+// accepts flat toolConfig at the root for forward-compat, so fall back to that.
+const pickToolBlock = (toolType, toolConfig) => {
+    if (!toolConfig)
+        return undefined;
+    const key = typeof toolType === "string" ? toolType.toLowerCase() : "";
+    const nested = key
+        ? toolConfig[key]
+        : undefined;
+    return nested ?? toolConfig;
+};
+const readTunable = (tc, name) => {
+    if (!tc)
+        return undefined;
+    const tunables = tc.tunables;
+    return tunables?.[name];
+};
+const readScriptField = (tc, name) => {
+    if (!tc)
+        return undefined;
+    const script = tc.script;
+    return script?.[name];
+};
+// K6 rpsLimit has two historical storage locations: tunables.rpsLimit (current
+// authoring surface) and options.rpsLimit (legacy/UI-authored path — see
+// loadTestManager k6.go LoadOptions.RPSLimit). Mirror the backend's own
+// dispatch-time fallback precedence (loadtest_handlers.go) so read-side scalars
+// stay truthful regardless of which shape a given record was persisted with.
+const readK6RpsLimit = (tc) => {
+    const fromTunables = readTunable(tc, "rpsLimit");
+    if (fromTunables != null && fromTunables !== 0)
+        return fromTunables;
+    const options = tc?.options;
+    const fromOptions = options?.rpsLimit;
+    if (fromOptions != null && fromOptions !== 0)
+        return fromOptions;
+    return undefined;
+};
 /**
- * Project a single load test (InternalApiLoadTestResponse) to a stable shape.
+ * Project a single load test (LoadTestResponse) to a stable shape.
  *
- * The new wire format carries every recognised tunable inside `inputs[]`
- * (TemplateInput) and user-defined non-secrets inside `variables[]`
- * (TemplateVariable). We pass both arrays through as-is for fidelity AND
- * surface derived convenience scalars (target_url / users / duration_sec / ...)
- * that mirror the create-side LLM surface so round-trips are intuitive.
+ * Since the variables migration, all tunables and custom env vars live under
+ * toolConfig.<tool>.tunables / toolConfig.<tool>.variables (see LocustSpec /
+ * K6Spec / JMeterSpec in loadTestManager/internal/domain). We pass toolConfig
+ * through as-is for fidelity AND surface derived convenience scalars mirroring
+ * the create-side LLM surface so round-trips are intuitive.
  *
- * Drops the large base64 scriptContent and backend user-detail envelopes.
  * Mirrors `identity` into `loadtestId` so the deep-link resolver fills
  * {loadtestId} instead of falling back to the name.
  */
@@ -798,35 +844,64 @@ export const chaosLoadTestExtract = (raw) => {
     if (!raw || typeof raw !== "object" || Array.isArray(raw))
         return raw;
     const t = raw;
-    const inputs = Array.isArray(t.inputs) ? t.inputs : undefined;
-    const variables = Array.isArray(t.variables) ? t.variables : undefined;
+    const toolConfig = t.toolConfig;
+    const toolBlock = pickToolBlock(t.toolType, toolConfig);
+    const variables = toolBlock?.variables;
+    const envVars = toolBlock?.envVars;
     return {
         loadtestId: t.identity,
+        uniqueId: t.uniqueId,
+        parentUniqueId: t.parentUniqueId,
         identity: t.identity,
         name: t.name,
         description: t.description,
         tags: t.tags,
+        serviceReferences: t.serviceReferences,
         environmentIdentifier: t.environmentIdentifier,
         infraIdentifier: t.infraIdentifier,
+        infraType: t.infraType,
         targetType: t.targetType,
         toolType: t.toolType,
         scriptSource: t.scriptSource,
-        // Canonical slices — passed through as-is for fidelity.
-        inputs,
+        importType: t.importType,
+        templateReference: t.templateReference,
+        templateUpdateAvailable: t.templateUpdateAvailable,
+        latestRevisionIdentifier: t.latestRevisionIdentifier,
+        maxDurationSec: t.maxDurationSec,
+        cleanupPolicy: t.cleanupPolicy,
+        resources: t.resources,
+        // Canonical tool config — passed through as-is for fidelity.
+        toolConfig,
         variables,
-        yaml: t.yaml,
-        // Derived convenience scalars (read-side mirror of the create-side LLM surface).
-        target_url: readLoadtestInput(inputs, "targetUrl"),
-        users: readLoadtestInput(inputs, "targetUsers"),
-        duration_sec: readLoadtestInput(inputs, "durationSeconds"),
-        ramp_up_sec: readLoadtestInput(inputs, "rampUpTimeSec"),
-        worker_count: readLoadtestInput(inputs, "workerCount"),
-        script_image: readLoadtestInput(inputs, "scriptImage"),
-        script_entrypoint: readLoadtestInput(inputs, "scriptEntrypoint"),
-        load_args: readLoadtestInput(inputs, "loadArgs"),
+        envVars,
+        // Denormalised display strings the backend emits for table renders.
+        targetUsersDisplay: t.targetUsers,
+        durationSecondsDisplay: t.durationSeconds,
+        // Derived convenience scalars (typed tunables under toolConfig.<tool>.tunables).
+        target_url: readTunable(toolBlock, "targetUrl"),
+        users: readTunable(toolBlock, "targetUsers"),
+        duration_sec: readTunable(toolBlock, "durationSeconds"),
+        ramp_up_sec: readTunable(toolBlock, "rampUpTimeSec"),
+        worker_count: readTunable(toolBlock, "workerCount"),
+        spawn_rate: readTunable(toolBlock, "spawnRate"),
+        host_url: readTunable(toolBlock, "hostUrl"),
+        iterations: readTunable(toolBlock, "iterations"),
+        rps_limit: readK6RpsLimit(toolBlock),
+        // Derived convenience scalars from toolConfig.<tool>.script (image mode).
+        script_image: readScriptField(toolBlock, "image"),
+        script_entrypoint: readScriptField(toolBlock, "entrypoint"),
+        load_args: readScriptField(toolBlock, "loadArgs"),
+        image_pull_secret: readScriptField(toolBlock, "imagePullSecret"),
+        recentRuns: t.recentRuns,
+        isSampleTest: t.isSampleTest,
+        isApiGenerated: t.isApiGenerated,
+        isAIUsed: t.isAIUsed,
         lastExecuted: t.lastExecuted,
         createdAt: t.createdAt,
+        createdBy: t.createdBy,
         updatedAt: t.updatedAt,
+        updatedBy: t.updatedBy,
+        yaml: t.yaml,
     };
 };
 /**
@@ -838,6 +913,16 @@ export const chaosLoadTestListExtract = (raw) => {
     const items = (r.items ?? []).map(chaosLoadTestExtract);
     return { items, total: r.pagination?.totalItems ?? items.length };
 };
+/**
+ * Chaos Service (v3) list response: { data: [...], correlationID, pagination: { index, limit, totalPages, totalItems } }.
+ * Distinct from chaos_loadtest's { items, pagination } envelope — the v3 chaos-services API
+ * wraps the array under `data` per shared PaginationResponse contract.
+ */
+export const chaosServiceListExtract = (raw) => {
+    const r = raw;
+    const items = r.data ?? [];
+    return { items, total: r.pagination?.totalItems ?? items.length };
+};
 /**
  * Extract chaos hub list response: { items: [...], pagination: { totalItems } }
  */
@@ -906,6 +991,20 @@ export function flattenTrafficType(item) {
         }
     }
 }
+/**
+ * Public v4 paginated lists (`EnvironmentListResponse`, `TrafficTypeListResponse` / `RolloutStatusListResponse`):
+ * `{ data, limit, offset, totalCount }`. Promote `data`→`items` and `totalCount`→`total`
+ * so harness_list compact/output schema see a full total, not the current page length.
+ */
+export const fmeV4PaginatedListExtract = (raw) => {
+    if (raw === null || typeof raw !== "object" || Array.isArray(raw))
+        return raw;
+    const r = raw;
+    if (!Array.isArray(r.data))
+        return raw;
+    const total = typeof r.totalCount === "number" ? r.totalCount : r.data.length;
+    return { ...r, items: r.data, total };
+};
 /** Extract FME feature flag list — passthrough with trafficType.id flattened on each item. */
 export const fmeListExtract = (raw) => {
     if (raw && typeof raw === "object") {
@@ -928,4 +1027,305 @@ export const fmeGetExtract = (raw) => {
     }
     return raw;
 };
+// ── Release Management (RMG) ──────────────────────────────────────────────
+const RMG_API_PREFIX = "/api";
+export const RMG_DEFAULT_DAYS_BACK = 30;
+export const RMG_MAX_DAYS_BACK = 365;
+/** Days of look-ahead included in the window so scheduled releases stay visible. */
+export const RMG_DAYS_FORWARD = 7;
+const RMG_DAY_MS = 86_400_000;
+export const RMG_DEFAULT_TASK_LIMIT = 50;
+export const RMG_MAX_TASK_LIMIT = 100;
+function rmgClampInt(value, min, max, fallback) {
+    const n = typeof value === "number" ? value : Number(value);
+    if (!Number.isFinite(n))
+        return fallback;
+    return Math.min(max, Math.max(min, Math.trunc(n)));
+}
+function rmgAsRecord(value) {
+    return value !== null && typeof value === "object" ? value : {};
+}
+/** First key holding an array — RMG list payloads vary by gateway version. */
+function rmgFirstArrayAt(source, keys) {
+    for (const key of keys) {
+        const value = source[key];
+        if (Array.isArray(value))
+            return value;
+    }
+    return undefined;
+}
+/**
+ * Copy HARNESS_ORG / HARNESS_PROJECT into input when scopeOptional resources
+ * omit explicit org_id/project_id (same pattern as release list preflight).
+ */
+export async function releaseFillScopeFromConfig({ input, registry }) {
+    if (!input.org_id && registry.orgId)
+        input.org_id = registry.orgId;
+    if (!input.project_id && registry.projectId)
+        input.project_id = registry.projectId;
+}
+/**
+ * Resolve the effective scope and time window before the body/query are built.
+ * The registry only merges HARNESS_ORG/HARNESS_PROJECT into `input` when the
+ * caller passes `resource_scope`, but the body always needs them.
+ */
+export async function releaseListPreflight(ctx) {
+    await releaseFillScopeFromConfig(ctx);
+    const { input } = ctx;
+    const now = Date.now();
+    const daysBack = rmgClampInt(input.days_back, 1, RMG_MAX_DAYS_BACK, RMG_DEFAULT_DAYS_BACK);
+    if (input.start_ts === undefined || input.start_ts === "") {
+        input.start_ts = now - daysBack * RMG_DAY_MS;
+    }
+    if (input.end_ts === undefined || input.end_ts === "") {
+        input.end_ts = now + RMG_DAYS_FORWARD * RMG_DAY_MS;
+    }
+}
+/** POST /api/release/list — scope travels in the body as `scopes`, not as query params. */
+export function releaseListBody(input) {
+    const scope = {};
+    if (typeof input.org_id === "string" && input.org_id)
+        scope.orgIdentifier = input.org_id;
+    if (typeof input.project_id === "string" && input.project_id) {
+        scope.projectIdentifier = input.project_id;
+    }
+    return { scopes: Object.keys(scope).length > 0 ? [scope] : [] };
+}
+/**
+ * Normalize the list payload and apply the optional status filter client-side
+ * (the endpoint takes no status param). Status matching is case-insensitive
+ * because RMG returns both `Running` and `RUNNING` depending on the field.
+ */
+export function releaseListExtract(raw, input) {
+    const root = rmgAsRecord(raw);
+    const payload = Array.isArray(raw)
+        ? { content: raw }
+        : rmgFirstArrayAt(root, ["content", "releases", "items"])
+            ? root
+            : rmgAsRecord(root.data);
+    let items = rmgFirstArrayAt(payload, ["content", "releases", "items"]) ?? [];
+    const pageItemCount = items.length;
+    const requestedStatus = typeof input?.status === "string" ? input.status.trim() : "";
+    if (requestedStatus) {
+        const wanted = requestedStatus.toLowerCase();
+        items = items.filter((rel) => {
+            const status = rel.status ?? rel.releaseStatus;
+            return typeof status === "string" && status.toLowerCase() === wanted;
+        });
+    }
+    const total = ["totalElements", "totalItems", "totalCount", "total"]
+        .map((key) => payload[key])
+        .find((value) => typeof value === "number");
+    return {
+        items,
+        total: requestedStatus ? items.length : (total ?? items.length),
+        ...(requestedStatus
+            ? {
+                status_filter: requestedStatus,
+                _hint: "status is filtered client-side on this page only; total is the filtered count for this page, " +
+                    `not the account (${pageItemCount} unfiltered items on this page). ` +
+                    "Increment page (keep size and other filters) if matches may exist on later pages.",
+            }
+            : {}),
+    };
+}
+/** Flatten GET /api/release/{id} → { release: releaseInfo, ... }. */
+export function releaseGetExtract(raw) {
+    const r = raw;
+    if (r.releaseInfo && typeof r.releaseInfo === "object") {
+        return { release: r.releaseInfo };
+    }
+    return raw;
+}
+function rmgSplitCsvFilter(value) {
+    if (typeof value !== "string" || !value.trim())
+        return undefined;
+    const parts = value.split(",").map((s) => s.trim()).filter(Boolean);
+    return parts.length > 0 ? parts : undefined;
+}
+/** Normalize sort/status/type filters before query param mapping (GET list). */
+export function normalizeReleaseActivityExecutionInput(input) {
+    const sortField = typeof input.sort_field === "string" && input.sort_field.length > 0
+        ? input.sort_field
+        : "start_ts";
+    const sortDirection = input.sort_direction === "asc" ? "asc" : "desc";
+    input.sort = [sortField, sortDirection];
+    const statusParts = rmgSplitCsvFilter(input.status);
+    if (statusParts)
+        input.status = statusParts;
+    const typeParts = rmgSplitCsvFilter(input.activity_type);
+    if (typeParts)
+        input.activity_type = typeParts;
+}
+export function normalizeReleaseTaskLimit(input) {
+    if (input.limit === undefined && input.size !== undefined) {
+        input.limit = input.size;
+    }
+    input.limit = rmgClampInt(input.limit, 1, RMG_MAX_TASK_LIMIT, RMG_DEFAULT_TASK_LIMIT);
+}
+/** GET /api/release/{id}/tasks → standard list envelope with cursor pagination. */
+export function releaseTaskListExtract(raw, input) {
+    const r = raw;
+    const items = Array.isArray(r.tasks) ? r.tasks : [];
+    const limit = rmgClampInt(input?.limit ?? input?.size, 1, RMG_MAX_TASK_LIMIT, RMG_DEFAULT_TASK_LIMIT);
+    return {
+        items,
+        total: items.length,
+        limit_applied: limit,
+        status_filter: typeof input?.status === "string" && input.status ? input.status : "all",
+        pagination: {
+            cursor: typeof input?.cursor === "string" ? input.cursor : undefined,
+            next_cursor: r.nextRequest?.cursor,
+            last: r.last,
+        },
+    };
+}
+/** GET /api/release/{id}/execution/activities — Spring page at root. */
+export function releaseActivityExecutionListExtract(raw) {
+    const r = raw;
+    const items = Array.isArray(r.content) ? r.content : [];
+    return {
+        items,
+        total: typeof r.totalElements === "number" ? r.totalElements : items.length,
+        pagination: {
+            page: r.number,
+            size: r.size,
+            total_pages: r.totalPages,
+            total_elements: r.totalElements,
+            number_of_elements: r.numberOfElements,
+            first: r.first,
+            last: r.last,
+        },
+    };
+}
+function requireReleaseAndPhase(input) {
+    const releaseId = input.release_id;
+    const phaseId = input.phase_identifier;
+    if (typeof releaseId !== "string" || !releaseId) {
+        throw new Error("release_id is required");
+    }
+    if (typeof phaseId !== "string" || !phaseId) {
+        throw new Error("phase_identifier is required — pass via params on harness_get (from harness_list release_execution_phase)");
+    }
+    return { releaseId, phaseId };
+}
+export function releaseExecutionPhaseOutputPath(input) {
+    const { releaseId, phaseId } = requireReleaseAndPhase(input);
+    const enc = encodeURIComponent;
+    return `${RMG_API_PREFIX}/orchestration/execution/release/${enc(releaseId)}/phase/${enc(phaseId)}/output`;
+}
+export function releaseExecutionPhaseInputPath(input) {
+    const { releaseId, phaseId } = requireReleaseAndPhase(input);
+    const enc = encodeURIComponent;
+    return `${RMG_API_PREFIX}/orchestration/execution/release/${enc(releaseId)}/phase/${enc(phaseId)}/input`;
+}
+export function releaseExecutionActivityOutputPath(input) {
+    const { releaseId, phaseId } = requireReleaseAndPhase(input);
+    const activityId = input.activity_identifier;
+    if (typeof activityId !== "string" || !activityId) {
+        throw new Error("activity_identifier is required — pass via params on harness_get (from harness_list release_execution_activity)");
+    }
+    const enc = encodeURIComponent;
+    return `${RMG_API_PREFIX}/orchestration/execution/release/${enc(releaseId)}/phase/${enc(phaseId)}/activity/${enc(activityId)}/output`;
+}
+function releasePhaseIoGetExtract(raw, input, field) {
+    const r = raw;
+    const items = Array.isArray(r[field]) ? r[field] : [];
+    return {
+        [field]: items,
+        phase_identifier: input?.phase_identifier,
+        [`total_${field}`]: items.length,
+    };
+}
+export function releasePhaseOutputGetExtract(raw, input) {
+    return releasePhaseIoGetExtract(raw, input, "outputs");
+}
+export function releasePhaseInputGetExtract(raw, input) {
+    return releasePhaseIoGetExtract(raw, input, "inputs");
+}
+export function releaseActivityOutputGetExtract(raw, input) {
+    const r = raw;
+    const items = Array.isArray(r.outputs) ? r.outputs : [];
+    return {
+        outputs: items,
+        phase_identifier: input?.phase_identifier,
+        activity_identifier: input?.activity_identifier,
+        total_outputs: items.length,
+    };
+}
+export function releaseActivityInputGetExtract(raw) {
+    const r = raw;
+    const items = Array.isArray(r.inputs) ? r.inputs : [];
+    return {
+        inputs: items,
+        total_inputs: items.length,
+    };
+}
+export function releaseInputGetExtract(raw) {
+    const r = raw;
+    return {
+        release_id: r.release_id,
+        process_execution_id: r.process_execution_id,
+        yaml: r.yaml,
+    };
+}
+/** GET /api/orchestration/execution/{id}/phases → standard list envelope. */
+export function releasePhaseListExtract(raw) {
+    const r = raw;
+    const items = Array.isArray(r.phases) ? r.phases : [];
+    return {
+        items,
+        total: items.length,
+        ...(r.release_id ? { release_id: r.release_id } : {}),
+        ...(typeof r.total_running_phases === "number" ? { total_running_phases: r.total_running_phases } : {}),
+    };
+}
+/** Project RMG process/activity YAML entity responses to a stable agent shape. */
+export function rmgYamlEntityExtract(raw) {
+    if (!isRecord(raw))
+        return raw;
+    const gitDetails = raw.git_details ?? raw.gitDetails;
+    const out = {};
+    if (typeof raw.identifier === "string")
+        out.identifier = raw.identifier;
+    if (typeof raw.name === "string")
+        out.name = raw.name;
+    if (typeof raw.yaml === "string")
+        out.yaml = raw.yaml;
+    if (typeof raw.orgIdentifier === "string")
+        out.orgIdentifier = raw.orgIdentifier;
+    if (typeof raw.projectIdentifier === "string")
+        out.projectIdentifier = raw.projectIdentifier;
+    if (gitDetails !== undefined)
+        out.git_details = gitDetails;
+    if (Object.keys(out).length > 0)
+        return out;
+    return raw;
+}
+/** Normalize RMG delete responses to a stable confirmation shape. */
+export function rmgYamlEntityDeleteExtract(raw) {
+    if (raw === null || raw === undefined)
+        return { deleted: true };
+    if (!isRecord(raw))
+        return { deleted: true };
+    const out = { deleted: true };
+    if (typeof raw.identifier === "string")
+        out.identifier = raw.identifier;
+    if (raw.status !== undefined)
+        out.status = raw.status;
+    return out;
+}
+export function yamlWriteBody(input) {
+    const b = input.body;
+    if (!b || typeof b !== "object") {
+        throw new Error("body is required and must be an object with yaml (and optional git_details)");
+    }
+    if (typeof b.yaml !== "string" || b.yaml.length === 0) {
+        throw new Error("body.yaml is required (non-empty YAML string)");
+    }
+    const out = { yaml: b.yaml };
+    if (b.git_details !== undefined)
+        out.git_details = b.git_details;
+    return out;
+}
 //# sourceMappingURL=extractors.js.map