@copado/agentia-cli 0.122.0-alpha.1 → 1.0.0-beta.0

package/dist/lib/cicd-gateway.js

@@ -1,834 +1,43 @@
-import { AsyncLocalStorage } from 'node:async_hooks';
-import * as http from 'node:http';
-import * as https from 'node:https';
-import { createRequire } from 'node:module';
-import { URL } from 'node:url';
-import { v7 as uuidv7 } from 'uuid';
-import { readAuthProfile } from './auth-profile.js';
-import { CICD_REGIONS, cicdBaseUrl } from './cicd-region.js';
-import { getCicdBaseUrl, getCredential, getCredentialForKey } from './credential-store.js';
-import { formatDebugBody, isVerboseDebug, logVerboseDebug } from './debug.js';
-import { loadEnvFile } from './env-file.js';
-import { normalizeLocalGatewayBaseUrl, readLocalGatewayConfig } from './local-gateway-config.js';
-import { getMcpRequestSignal } from './mcp/request-context.js';
-import { preferSalesforceId } from './salesforce-id.js';
-import { getSfOrgContext } from './sf-org-context.js';
-const require = createRequire(import.meta.url);
-const packageJson = require('../../package.json');
-const CICD_API_PATH = '/json/v1/webhook/cicd-api';
-const CICD_VALIDATION_ENDPOINT = '/health';
-export const CICD_ENV = {
-    apiKey: 'AGENTIA_CICD_API_KEY',
-    baseUrl: 'AGENTIA_CICD_BASE_URL',
-    mcpRequestTimeoutMs: 'AGENTIA_MCP_CICD_REQUEST_TIMEOUT_MS',
-};
-export const MCP_CICD_DEFAULT_REQUEST_TIMEOUT_MS = 120_000;
-let activeHttpRequestOptions = {};
-export const AGENTIA_CLIENT_ORIGIN_ENV = 'AGENTIA_CLIENT_ORIGIN';
-export const AGENTIA_IDE_VERSION_ENV = 'AGENTIA_IDE_VERSION';
-const gatewayTransactionStore = new AsyncLocalStorage();
-export function getGatewayTransactionId() {
-    return gatewayTransactionStore.getStore()?.transactionId;
-}
-export function getGatewayReferer() {
-    const referer = gatewayTransactionStore.getStore()?.referer;
-    if (referer === undefined || referer.trim().length === 0) {
-        return undefined;
-    }
-    return referer;
-}
-export function getGatewayClientOrigin() {
-    const fromEnv = process.env[AGENTIA_CLIENT_ORIGIN_ENV]?.trim().toLowerCase();
-    if (fromEnv === 'ide') {
-        return 'ide';
-    }
-    return gatewayTransactionStore.getStore()?.origin ?? 'cli';
-}
-export function resolveCicdRequestTimeoutMs(options = {}) {
-    if (options.timeoutMs !== undefined) {
-        return options.timeoutMs;
-    }
-    if (getGatewayClientOrigin() !== 'mcp') {
-        return undefined;
-    }
-    const configuredTimeout = Number.parseInt(process.env[CICD_ENV.mcpRequestTimeoutMs] ?? '', 10);
-    return Number.isFinite(configuredTimeout) && configuredTimeout > 0
-        ? configuredTimeout
-        : MCP_CICD_DEFAULT_REQUEST_TIMEOUT_MS;
-}
-function gatewayProductName() {
-    switch (getGatewayClientOrigin()) {
-        case 'ide': {
-            return 'agentia-ide';
-        }
-        case 'mcp': {
-            return 'agentia-mcp';
-        }
-        default: {
-            return 'agentia-cli';
-        }
-    }
-}
-function ideVersion() {
-    if (getGatewayClientOrigin() !== 'ide') {
-        return undefined;
-    }
-    const version = process.env[AGENTIA_IDE_VERSION_ENV]?.trim();
-    return version !== undefined && /^[0-9A-Za-z.-]{1,64}$/u.test(version) ? version : undefined;
-}
-export function gatewayRefererHeaders() {
-    const referer = getGatewayReferer();
-    return referer === undefined ? {} : { Referer: referer };
-}
-export function runWithGatewayTransactionContext(context, fn) {
-    const store = typeof context === 'string' ? { transactionId: context } : context;
-    return gatewayTransactionStore.run(store, fn);
-}
-function transactionIdForGatewayRequest() {
-    const active = getGatewayTransactionId();
-    return active ?? createTransactionId();
-}
-export class CicdGatewayError extends Error {
-    categories;
-    code;
-    jobId;
-    requestMethod;
-    requestUrl;
-    retryAfterSeconds;
-    statusCode;
-    constructor(message, options = {}) {
-        super(message);
-        this.name = 'CicdGatewayError';
-        this.categories = options.categories ?? [];
-        this.code = options.code;
-        this.jobId = options.jobId;
-        this.requestMethod = options.request?.method;
-        this.requestUrl =
-            options.request?.url !== undefined && options.request.url.trim().length > 0
-                ? maskUrlSecrets(options.request.url)
-                : undefined;
-        this.retryAfterSeconds = options.retryAfterSeconds;
-        this.statusCode = options.statusCode;
-    }
-}
-export function gatewayUserAgent() {
-    const productName = gatewayProductName();
-    const version = ideVersion();
-    if (productName === 'agentia-ide' && version !== undefined) {
-        return `${productName}/${version} (agentia-cli/${packageJson.version})`;
-    }
-    return `${productName}/${packageJson.version}`;
-}
-export function gatewayEventSource() {
-    return gatewayProductName();
-}
-export function createTransactionId() {
-    return uuidv7();
-}
-export const GATEWAY_EVENT_API_CALL = 'api_call';
-export const GATEWAY_EVENT_UNKNOWN = 'UNKNOWN';
-export const AI_GATEWAY_EVENT_SERVICE = 'copado-ai-gateway';
-export const CRT_GATEWAY_EVENT_SERVICE = 'copado-crt-gateway';
-const GATEWAY_EVENTLOG_ENDPOINT = '/eventlog';
-let eventLogSender = sendGatewayEventLog;
-let eventLogGeneration = 0;
-let pendingEventLogs = [];
-export function formatGatewayEventTimestamp(date = new Date()) {
-    return date.toISOString();
-}
-export function buildGatewayEventLogPayload(input) {
-    const payload = {
-        data: {
-            eventSource: gatewayEventSource(),
-            method: input.method,
-            service: input.service,
-            url: maskUrlSecrets(input.url),
-            userAgent: gatewayUserAgent(),
-        },
-        event: GATEWAY_EVENT_API_CALL,
-        eventId: input.eventId,
-        location: getGatewayReferer() ?? GATEWAY_EVENT_UNKNOWN,
-        orgId: GATEWAY_EVENT_UNKNOWN,
-        timestamp: formatGatewayEventTimestamp(input.timestamp ?? new Date()),
-        userId: GATEWAY_EVENT_UNKNOWN,
-    };
-    if (input.status !== undefined) {
-        payload.data.status = input.status;
-    }
-    const orgId = normalizeGatewayEventIdentity(input.orgId);
-    if (orgId !== undefined) {
-        payload.orgId = orgId;
-    }
-    const userId = normalizeGatewayEventIdentity(input.userId);
-    if (userId !== undefined) {
-        payload.userId = userId;
-    }
-    return payload;
-}
-function normalizeGatewayEventIdentity(value) {
-    if (value === undefined)
-        return undefined;
-    const normalized = value.toString().trim();
-    return normalized.length > 0 ? normalized : undefined;
-}
-async function sendGatewayEventLog(payload) {
-    await CicdGateway.call({
-        body: payload,
-        endpoint: GATEWAY_EVENTLOG_ENDPOINT,
-        headers: { 'Content-Type': 'application/json' },
-        method: 'POST',
-    }, undefined, { detached: true });
-}
-export function scheduleGatewayEventLog(input) {
-    try {
-        const payload = buildGatewayEventLogPayload(input);
-        const sender = eventLogSender;
-        const generation = eventLogGeneration;
-        const task = Promise.resolve()
-            .then(() => {
-            if (generation !== eventLogGeneration) {
-                return;
-            }
-            return sender(payload);
-        })
-            .catch(() => {
-            // Event log delivery is best-effort.
-        });
-        pendingEventLogs.push(task);
-    }
-    catch {
-        // Event log scheduling is best-effort.
-    }
-}
-export async function flushGatewayEventLogsForTests() {
-    await Promise.all(pendingEventLogs);
-    pendingEventLogs = [];
-}
-export function setGatewayEventLogSenderForTests(sender) {
-    eventLogSender = sender;
-}
-export function resetGatewayEventLogSenderForTests() {
-    eventLogGeneration += 1;
-    eventLogSender = sendGatewayEventLog;
-    pendingEventLogs = [];
-}
-export function normalizeCicdBaseUrl(value) {
-    let url;
-    try {
-        url = new URL(value);
-    }
-    catch {
-        throw new Error('CICD base URL must be a valid absolute HTTPS URL.');
-    }
-    if (url.protocol !== 'https:') {
-        throw new Error('CICD base URL must use HTTPS.');
-    }
-    return url.origin;
-}
-function extractCicdErrorDetailMessage(details) {
-    if (details === undefined) {
-        return undefined;
-    }
-    if (Array.isArray(details)) {
-        const messages = details
-            .map((detail) => detail?.message)
-            .filter((message) => typeof message === 'string' && message.trim().length > 0);
-        return messages.length > 0 ? messages.join('\n') : undefined;
-    }
-    if (typeof details.message === 'string' && details.message.trim().length > 0) {
-        return details.message;
-    }
-    return undefined;
-}
-function extractCicdErrorCategories(details) {
-    if (details === undefined) {
-        return [];
-    }
-    const values = Array.isArray(details) ? details : [details];
-    return values
-        .map((detail) => detail.category)
-        .filter((category) => typeof category === 'string' && category.trim().length > 0);
-}
-export function maskUrlSecrets(url) {
-    let parsed;
-    try {
-        parsed = typeof url === 'string' ? new URL(url) : new URL(url.toString());
-    }
-    catch {
-        return typeof url === 'string' ? url : url.toString();
-    }
-    if (parsed.searchParams.has('api_key')) {
-        parsed.searchParams.set('api_key', '<masked>');
-    }
-    return parsed.toString();
-}
-function formatRequestSuffix(request) {
-    if (request?.url === undefined || request.url.trim().length === 0) {
-        return '';
-    }
-    const url = maskUrlSecrets(request.url);
-    const method = request.method !== undefined && request.method.trim().length > 0 ? `${request.method} ` : '';
-    return ` Request: ${method}${url}`;
-}
-function withRequestSuffix(message, request) {
-    const suffix = formatRequestSuffix(request);
-    if (suffix.length === 0) {
-        return message;
-    }
-    return message.endsWith('.') ? `${message}${suffix}` : `${message}.${suffix}`;
-}
-export function parseRetryAfterHeader(value) {
-    if (value === undefined) {
-        return undefined;
-    }
-    const raw = Array.isArray(value) ? value[0] : value;
-    if (raw === undefined) {
-        return undefined;
-    }
-    if (typeof raw === 'number') {
-        return Number.isFinite(raw) && raw >= 0 ? Math.ceil(raw) : undefined;
-    }
-    const trimmed = raw.trim();
-    if (trimmed.length === 0) {
-        return undefined;
-    }
-    if (/^\d+$/u.test(trimmed)) {
-        return Number.parseInt(trimmed, 10);
-    }
-    const dateMs = Date.parse(trimmed);
-    if (Number.isNaN(dateMs)) {
-        return undefined;
-    }
-    return Math.max(0, Math.ceil((dateMs - Date.now()) / 1000));
-}
-function extractJobIdFromErrorBody(parsed) {
-    if (parsed === null || typeof parsed !== 'object' || Array.isArray(parsed)) {
-        return undefined;
-    }
-    const { jobId } = parsed;
-    if (typeof jobId !== 'string') {
-        return undefined;
-    }
-    const trimmed = jobId.trim();
-    return trimmed.length > 0 ? trimmed : undefined;
-}
-export function formatCicdGatewayError(status, raw, request, retryAfterSeconds) {
-    try {
-        const parsed = JSON.parse(raw);
-        const jobId = extractJobIdFromErrorBody(parsed);
-        const detailMessage = extractCicdErrorDetailMessage(parsed.data?.details);
-        const message = detailMessage ?? parsed.message;
-        if (message !== undefined && message.trim().length > 0) {
-            return new CicdGatewayError(withRequestSuffix(message.trim(), request), {
-                categories: extractCicdErrorCategories(parsed.data?.details),
-                code: parsed.data?.code,
-                jobId,
-                request,
-                retryAfterSeconds,
-                statusCode: status,
-            });
-        }
-        if (jobId !== undefined) {
-            return new CicdGatewayError(withRequestSuffix(`CICD Gateway request failed (${status}).`, request), {
-                categories: extractCicdErrorCategories(parsed.data?.details),
-                code: parsed.data?.code,
-                jobId,
-                request,
-                retryAfterSeconds,
-                statusCode: status,
-            });
-        }
-    }
-    catch {
-        // Fall through to the generic error below.
-    }
-    return new CicdGatewayError(withRequestSuffix(`CICD Gateway request failed (${status}).`, request), {
-        request,
-        retryAfterSeconds,
-        statusCode: status,
-    });
-}
-function createCicdGatewayError(parsed, request) {
-    const detailMessage = extractCicdErrorDetailMessage(parsed.data?.details);
-    const message = detailMessage ?? parsed.message;
-    if (message !== undefined && message.trim().length > 0) {
-        return new CicdGatewayError(withRequestSuffix(message.trim(), request), {
-            categories: extractCicdErrorCategories(parsed.data?.details),
-            code: parsed.data?.code,
-            request,
-        });
-    }
-    return new CicdGatewayError(withRequestSuffix('CICD Gateway request failed.', request), {
-        categories: extractCicdErrorCategories(parsed.data?.details),
-        code: parsed.data?.code,
-        request,
-    });
-}
-function buildGatewayRequestHeaders(requestHeaders, userAgent) {
-    return {
-        ...requestHeaders,
-        'event-source': gatewayEventSource(),
-        ...gatewayRefererHeaders(),
-        'User-Agent': userAgent,
-        'x-transaction-id': transactionIdForGatewayRequest(),
-    };
-}
-export function cicdApiUrl(serverUrl, apiKey) {
-    const endpoint = new URL(CICD_API_PATH, serverUrl);
-    endpoint.searchParams.set('api_key', apiKey);
-    return endpoint;
-}
-export function maskedCicdApiUrl(serverUrl) {
-    const endpoint = new URL(CICD_API_PATH, serverUrl);
-    endpoint.searchParams.set('api_key', '<masked>');
-    return endpoint.toString();
-}
-// eslint-disable-next-line max-params
-function defaultHttpsJsonRequest(url, method, headers, body, options = activeHttpRequestOptions) {
-    const hasBody = body !== undefined;
-    const payload = hasBody ? JSON.stringify(body) : '';
-    const requestHeaders = {
-        Accept: 'application/json',
-        ...headers,
-    };
-    const { detached, rejectUnauthorized } = options;
-    const timeoutMs = resolveCicdRequestTimeoutMs(options);
-    const signal = options.signal ?? getMcpRequestSignal();
-    const transport = url.protocol === 'http:' ? http : https;
-    if (hasBody) {
-        requestHeaders['Content-Type'] = requestHeaders['Content-Type'] ?? 'application/json';
-        requestHeaders['Content-Length'] = Buffer.byteLength(payload).toString();
-    }
-    return new Promise((resolve, reject) => {
-        let settled = false;
-        const deadline = timeoutMs === undefined
-            ? undefined
-            : setTimeout(() => {
-                req.destroy(new Error(`CICD gateway request timed out after ${timeoutMs}ms.`));
-            }, timeoutMs);
-        const settle = (action) => {
-            if (settled)
-                return;
-            settled = true;
-            if (deadline !== undefined) {
-                clearTimeout(deadline);
-            }
-            signal?.removeEventListener('abort', abort);
-            action();
-        };
-        const abort = () => {
-            req.destroy(signal?.reason instanceof Error ? signal.reason : new Error('CICD gateway request cancelled.'));
-        };
-        const requestOptions = {
-            agent: detached ? false : undefined,
-            headers: requestHeaders,
-            hostname: url.hostname,
-            method,
-            path: `${url.pathname}${url.search}`,
-            port: url.port.length > 0 ? Number(url.port) : undefined,
-        };
-        if (url.protocol === 'https:' && rejectUnauthorized !== undefined) {
-            ;
-            requestOptions.rejectUnauthorized = rejectUnauthorized;
-        }
-        const req = transport.request(requestOptions, (res) => {
-            const chunks = [];
-            res.on('data', (chunk) => chunks.push(chunk));
-            res.on('end', () => {
-                const raw = Buffer.concat(chunks).toString('utf8');
-                const status = res.statusCode ?? 0;
-                if (status >= 400) {
-                    if (isCicdWarningResponseBody(raw)) {
-                        settle(() => resolve(raw));
-                        return;
-                    }
-                    logVerboseDebug('CICD response', {
-                        body: formatDebugBody(raw),
-                        status,
-                    });
-                    const retryAfterSeconds = status === 429 ? parseRetryAfterHeader(res.headers['retry-after']) : undefined;
-                    settle(() => reject(formatCicdGatewayError(status, raw, undefined, retryAfterSeconds)));
-                    return;
-                }
-                settle(() => resolve(raw));
-            });
-        });
-        req.on('error', (error) => settle(() => reject(error)));
-        if (signal?.aborted) {
-            abort();
-        }
-        else {
-            signal?.addEventListener('abort', abort, { once: true });
-        }
-        if (detached) {
-            req.on('socket', (socket) => socket.unref());
-        }
-        if (hasBody) {
-            req.write(payload);
-        }
-        req.end();
-    });
-}
-let httpRequestFn = defaultHttpsJsonRequest;
-const AUTOMATIC_GATEWAY_HEADER_NAMES = new Set([
-    'event-source',
-    'Referer',
-    'User-Agent',
-    'x-transaction-id',
-]);
-function withoutAutomaticGatewayHeaders(body) {
-    if (body === null || typeof body !== 'object' || Array.isArray(body)) {
-        return body;
-    }
-    const request = body;
-    const requestHeaders = request.headers;
-    if (requestHeaders === null || typeof requestHeaders !== 'object' || Array.isArray(requestHeaders)) {
-        return body;
-    }
-    const headers = Object.fromEntries(Object.entries(requestHeaders).filter(([name]) => !AUTOMATIC_GATEWAY_HEADER_NAMES.has(name)));
-    const sanitized = { ...request };
-    if (Object.keys(headers).length === 0) {
-        delete sanitized.headers;
-    }
-    else {
-        sanitized.headers = headers;
-    }
-    return sanitized;
-}
-function envCicdApiKey() {
-    const value = process.env[CICD_ENV.apiKey]?.trim();
-    return value === undefined || value.length === 0 ? undefined : value;
-}
-function envCicdBaseUrl() {
-    const value = process.env[CICD_ENV.baseUrl]?.trim();
-    return value === undefined || value.length === 0 ? undefined : normalizeCicdBaseUrl(value);
-}
-export function resolveConfiguredCicdBaseUrl(options = {}) {
-    loadEnvFile();
-    const localConfig = readLocalGatewayConfig();
-    if (!options.forceRemote && localConfig.enabled) {
-        return normalizeLocalGatewayBaseUrl(localConfig.url);
-    }
-    const local = readAuthProfile('local');
-    return envCicdBaseUrl() ?? local?.cicd?.baseUrl ?? readAuthProfile('global')?.cicd?.baseUrl ?? getCicdBaseUrl();
-}
-export function resolveCicdCredentials(options = {}) {
-    loadEnvFile();
-    const localConfig = readLocalGatewayConfig();
-    if (!options.forceRemote && localConfig.enabled) {
-        const local = readAuthProfile('local');
-        const apiKey = localConfig.apiKey ||
-            envCicdApiKey() ||
-            (local?.cicd === undefined ? getCredential('cicd') : getCredentialForKey('cicd', local.keychainId));
-        if (apiKey === null || apiKey === undefined || apiKey.trim().length === 0) {
-            throw new Error('CICD API key is not configured for local gateway mode. Set AGENTIA_LOCAL_API_KEY in .env or run `agentia auth set --cicd <key>`.');
-        }
-        return {
-            apiKey,
-            baseUrl: normalizeLocalGatewayBaseUrl(localConfig.url),
-        };
-    }
-    const local = readAuthProfile('local');
-    const localConfigured = local?.cicd !== undefined;
-    if (localConfigured && local?.cicd?.baseUrl === undefined) {
-        throw new Error('Local CICD authentication profile is incomplete. Configure a region or custom URL for this project.');
-    }
-    const apiKey = envCicdApiKey() ?? (localConfigured ? getCredentialForKey('cicd', local.keychainId) : getCredential('cicd'));
-    if (apiKey === null || apiKey === undefined || apiKey.trim().length === 0) {
-        throw new Error('CICD API key is not configured. Run `agentia auth set --cicd <key> [--region <region> | --custom-url <url>]` or set AGENTIA_CICD_API_KEY.');
-    }
-    const baseUrl = envCicdBaseUrl() ?? (localConfigured ? local?.cicd?.baseUrl : readAuthProfile('global')?.cicd?.baseUrl ?? getCicdBaseUrl());
-    if (baseUrl === null || baseUrl === undefined) {
-        throw new Error('CICD endpoint is not configured. Run `agentia auth set --cicd <key> [--region <region> | --custom-url <url>]` or set AGENTIA_CICD_BASE_URL.');
-    }
-    return { apiKey, baseUrl };
-}
-export function tryResolveCicdCredentials(options = {}) {
-    try {
-        return resolveCicdCredentials(options);
-    }
-    catch (error) {
-        if (error instanceof Error && error.message.startsWith('CICD API key is not configured')) {
-            return undefined;
-        }
-        throw error;
-    }
-}
-function maskSecret(value) {
-    if (value.length <= 8) {
-        return '<masked>';
-    }
-    return `${value.slice(0, 4)}...${value.slice(-4)}`;
-}
-function buildLocalGatewayHeaders(apiKey, sfContext, requestHeaders, transactionId) {
-    return {
-        'event-source': gatewayEventSource(),
-        ...gatewayRefererHeaders(),
-        'User-Agent': gatewayUserAgent(),
-        'x-api-key': apiKey,
-        'x-canvas-api-session': sfContext.accessToken,
-        'x-copado-api-url': sfContext.instanceUrl,
-        'x-organization-id': preferSalesforceId(sfContext.orgId),
-        'x-transaction-id': transactionId,
-        'x-user-id': preferSalesforceId(sfContext.userId),
-        ...requestHeaders,
-    };
-}
-function maskLocalGatewayHeaders(headers) {
-    const masked = { ...headers };
-    if (masked['x-api-key'] !== undefined) {
-        masked['x-api-key'] = maskSecret(masked['x-api-key']);
-    }
-    if (masked['x-canvas-api-session'] !== undefined) {
-        masked['x-canvas-api-session'] = '<masked>';
-    }
-    return masked;
-}
-function unwrapResponse(parsed) {
-    const data = (parsed && typeof parsed === 'object' && 'data' in parsed ? parsed.data : undefined) ?? parsed.result;
-    if (data === undefined) {
-        return parsed;
-    }
-    return data;
-}
-function isPlainObject(value) {
-    return value !== null && typeof value === 'object' && !Array.isArray(value);
-}
-/** True when a CICD envelope uses `status: "warning"` instead of failing. */
-export function isCicdWarningStatus(status) {
-    return status === 'warning';
-}
-export function isCicdWarningResponseBody(raw) {
-    try {
-        const parsed = JSON.parse(raw);
-        return isCicdWarningStatus(parsed.status);
-    }
-    catch {
-        return false;
-    }
-}
-function applyWarningStatus(parsed, data) {
-    if (!isCicdWarningStatus(parsed.status) || !isPlainObject(data)) {
-        return data;
-    }
-    const dataMessage = typeof data.message === 'string' ? data.message.trim() : '';
-    const envelopeMessage = typeof parsed.message === 'string' ? parsed.message.trim() : '';
-    const message = dataMessage.length > 0 ? data.message : envelopeMessage;
-    return {
-        ...data,
-        ...(typeof message === 'string' && message.length > 0 ? { message } : {}),
-        status: 'warning',
-    };
-}
-function composeDebugRequestHandler(onDebugRequest) {
-    if (!isVerboseDebug() && onDebugRequest === undefined) {
-        return undefined;
-    }
-    return (debugRequest) => {
-        logVerboseDebug('CICD request', debugRequest);
-        onDebugRequest?.(debugRequest);
-    };
-}
-async function executeRequest(credentials, request, onDebugRequest, options = {}) {
-    const errorRequest = buildErrorRequestInfo(credentials, request, options);
-    const raw = await sendRequest(credentials, request, composeDebugRequestHandler(onDebugRequest), options);
-    logVerboseDebug('CICD response', formatDebugBody(raw));
-    if (raw.trim().length === 0) {
-        return undefined;
-    }
-    if (request.responseType === 'text') {
-        try {
-            const possibleError = JSON.parse(raw);
-            if (possibleError.status === 'error') {
-                throw createCicdGatewayError(possibleError, errorRequest);
-            }
-        }
-        catch (error) {
-            if (error instanceof CicdGatewayError) {
-                throw error;
-            }
-        }
-        return raw;
-    }
-    let parsed;
-    try {
-        parsed = JSON.parse(raw);
-    }
-    catch {
-        throw new Error(`CICD Gateway returned non-JSON response: ${raw}`);
-    }
-    if (parsed.status === 'error') {
-        throw createCicdGatewayError(parsed, errorRequest);
-    }
-    return applyWarningStatus(parsed, unwrapResponse(parsed));
-}
-function buildErrorRequestInfo(credentials, request, options = {}) {
-    if (!options.forceRemote && readLocalGatewayConfig().enabled) {
-        return {
-            method: request.method,
-            url: maskUrlSecrets(new URL(request.endpoint, `${credentials.baseUrl}/`)),
-        };
-    }
-    return {
-        method: request.method,
-        url: `${request.endpoint}`,
-    };
-}
-async function sendRemoteRequest(credentials, request, onDebugRequest, options = {}) {
-    const endpoint = cicdApiUrl(credentials.baseUrl, credentials.apiKey);
-    const outerHeaders = { 'User-Agent': gatewayUserAgent() };
-    const gatewayRequest = {
-        ...request,
-        headers: buildGatewayRequestHeaders(request.headers, outerHeaders['User-Agent']),
-    };
-    delete gatewayRequest.responseType;
-    const errorRequest = {
-        method: request.method,
-        url: `${request.endpoint} via ${maskedCicdApiUrl(credentials.baseUrl)}`,
-    };
-    if (onDebugRequest) {
-        onDebugRequest({
-            body: gatewayRequest,
-            headers: {
-                Accept: 'application/json',
-                'Content-Type': 'application/json',
-                ...outerHeaders,
-            },
-            method: 'POST',
-            url: maskedCicdApiUrl(credentials.baseUrl),
-        });
-    }
-    try {
-        return await httpRequestFn(endpoint, 'POST', outerHeaders, gatewayRequest, {
-            detached: options.detached,
-        });
-    }
-    catch (error) {
-        throw enrichCicdGatewayError(error, errorRequest);
-    }
-}
-async function sendLocalRequest(credentials, request, onDebugRequest, options = {}) {
-    const localConfig = readLocalGatewayConfig();
-    const sfContext = await getSfOrgContext(localConfig.orgAlias);
-    const transactionId = transactionIdForGatewayRequest();
-    const headers = buildLocalGatewayHeaders(credentials.apiKey, sfContext, request.headers, transactionId);
-    const url = new URL(request.endpoint, `${credentials.baseUrl}/`);
-    const { body } = request;
-    const errorRequest = {
-        method: request.method,
-        url: maskUrlSecrets(url),
-    };
-    if (onDebugRequest) {
-        onDebugRequest({
-            body: body ?? null,
-            headers: {
-                Accept: 'application/json',
-                ...maskLocalGatewayHeaders(headers),
-            },
-            method: request.method,
-            url: url.toString(),
-        });
-    }
-    const previousOptions = activeHttpRequestOptions;
-    activeHttpRequestOptions = {
-        ...(options.detached === true ? { detached: true } : {}),
-        rejectUnauthorized: localConfig.tlsInsecure ? false : undefined,
-    };
-    try {
-        return await httpRequestFn(url, request.method, headers, body, activeHttpRequestOptions);
-    }
-    catch (error) {
-        throw enrichCicdGatewayError(error, errorRequest);
-    }
-    finally {
-        activeHttpRequestOptions = previousOptions;
-    }
-}
-function enrichCicdGatewayError(error, request) {
-    if (!(error instanceof CicdGatewayError)) {
-        return error;
-    }
-    const baseMessage = error.message.replace(/\.\s*Request: .+$/u, '.');
-    return new CicdGatewayError(withRequestSuffix(baseMessage, request), {
-        categories: error.categories,
-        code: error.code,
-        jobId: error.jobId,
-        request,
-        retryAfterSeconds: error.retryAfterSeconds,
-        statusCode: error.statusCode,
-    });
-}
-async function sendRequest(credentials, request, onDebugRequest, options = {}) {
-    if (!options.forceRemote && readLocalGatewayConfig().enabled) {
-        return sendLocalRequest(credentials, request, onDebugRequest, options);
-    }
-    return sendRemoteRequest(credentials, request, onDebugRequest, options);
-}
-export async function discoverCicdBaseUrl(apiKey) {
-    for (const region of CICD_REGIONS) {
-        const baseUrl = cicdBaseUrl(region);
-        try {
-            // Sequential probing is intentional: stop at the first region that validates.
-            // eslint-disable-next-line no-await-in-loop
-            await validateCredentialsAtBaseUrl(apiKey, baseUrl);
-            return baseUrl;
-        }
-        catch {
-            continue;
-        }
-    }
-    throw new Error('CICD API key could not be validated. Specify --region or --custom-url.');
-}
-export async function resolveAndValidateCicdEndpoint(apiKey, options) {
-    if (options.customUrl !== undefined) {
-        const baseUrl = normalizeCicdBaseUrl(options.customUrl);
-        await validateCredentialsAtBaseUrl(apiKey, baseUrl);
-        return baseUrl;
-    }
-    if (options.region !== undefined) {
-        const baseUrl = cicdBaseUrl(options.region);
-        await validateCredentialsAtBaseUrl(apiKey, baseUrl);
-        return baseUrl;
-    }
-    return discoverCicdBaseUrl(apiKey);
-}
-async function validateCredentialsAtBaseUrl(apiKey, baseUrl) {
-    await sendRequest({
-        apiKey,
-        baseUrl,
-    }, {
-        endpoint: CICD_VALIDATION_ENDPOINT,
-        method: 'GET',
-    }, undefined, { forceRemote: true });
-}
-// Test-only hook. Command tests receive stable request semantics by default;
-// gateway-boundary tests can opt in to the generated telemetry headers.
-export function setHttpRequestForTests(requestFn, options = {}) {
-    httpRequestFn = options.includeAutomaticHeaders
-        ? requestFn
-        : (...args) => {
-            const [url, method, headers, body, requestOptions] = args;
-            return requestFn(url, method, headers, withoutAutomaticGatewayHeaders(body), requestOptions);
-        };
-}
-// Test-only hook
-export function resetHttpRequestForTests() {
-    httpRequestFn = defaultHttpsJsonRequest;
-    activeHttpRequestOptions = {};
-}
-// Test-only hook
-export function getActiveHttpRequestOptionsForTests() {
-    return activeHttpRequestOptions;
-}
-export class CicdGateway {
-    static async call(request, onDebugRequest, options = {}) {
-        return executeRequest(resolveCicdCredentials(options), request, onDebugRequest, options);
-    }
-    static async resolveAndValidateEndpoint(apiKey, options) {
-        return resolveAndValidateCicdEndpoint(apiKey, options);
-    }
-    static async validateCredentials(apiKey, baseUrl) {
-        await validateCredentialsAtBaseUrl(apiKey, baseUrl);
-    }
-}
-//# sourceMappingURL=cicd-gateway.js.map
+import {modules} from './runtime.js';
+const AGENTIA_CLIENT_ORIGIN_ENV = modules["cicd-gateway.js"]["AGENTIA_CLIENT_ORIGIN_ENV"]
+const AGENTIA_IDE_VERSION_ENV = modules["cicd-gateway.js"]["AGENTIA_IDE_VERSION_ENV"]
+const AI_GATEWAY_EVENT_SERVICE = modules["cicd-gateway.js"]["AI_GATEWAY_EVENT_SERVICE"]
+const CICD_ENV = modules["cicd-gateway.js"]["CICD_ENV"]
+const CRT_GATEWAY_EVENT_SERVICE = modules["cicd-gateway.js"]["CRT_GATEWAY_EVENT_SERVICE"]
+const CicdGateway = modules["cicd-gateway.js"]["CicdGateway"]
+const CicdGatewayError = modules["cicd-gateway.js"]["CicdGatewayError"]
+const GATEWAY_EVENT_API_CALL = modules["cicd-gateway.js"]["GATEWAY_EVENT_API_CALL"]
+const GATEWAY_EVENT_UNKNOWN = modules["cicd-gateway.js"]["GATEWAY_EVENT_UNKNOWN"]
+const MCP_CICD_DEFAULT_REQUEST_TIMEOUT_MS = modules["cicd-gateway.js"]["MCP_CICD_DEFAULT_REQUEST_TIMEOUT_MS"]
+const buildGatewayEventLogPayload = modules["cicd-gateway.js"]["buildGatewayEventLogPayload"]
+const cicdApiUrl = modules["cicd-gateway.js"]["cicdApiUrl"]
+const createTransactionId = modules["cicd-gateway.js"]["createTransactionId"]
+const discoverCicdBaseUrl = modules["cicd-gateway.js"]["discoverCicdBaseUrl"]
+const flushGatewayEventLogsForTests = modules["cicd-gateway.js"]["flushGatewayEventLogsForTests"]
+const formatCicdGatewayError = modules["cicd-gateway.js"]["formatCicdGatewayError"]
+const formatGatewayEventTimestamp = modules["cicd-gateway.js"]["formatGatewayEventTimestamp"]
+const gatewayEventSource = modules["cicd-gateway.js"]["gatewayEventSource"]
+const gatewayRefererHeaders = modules["cicd-gateway.js"]["gatewayRefererHeaders"]
+const gatewayUserAgent = modules["cicd-gateway.js"]["gatewayUserAgent"]
+const getActiveHttpRequestOptionsForTests = modules["cicd-gateway.js"]["getActiveHttpRequestOptionsForTests"]
+const getGatewayClientOrigin = modules["cicd-gateway.js"]["getGatewayClientOrigin"]
+const getGatewayReferer = modules["cicd-gateway.js"]["getGatewayReferer"]
+const getGatewayTransactionId = modules["cicd-gateway.js"]["getGatewayTransactionId"]
+const isCicdWarningResponseBody = modules["cicd-gateway.js"]["isCicdWarningResponseBody"]
+const isCicdWarningStatus = modules["cicd-gateway.js"]["isCicdWarningStatus"]
+const maskUrlSecrets = modules["cicd-gateway.js"]["maskUrlSecrets"]
+const maskedCicdApiUrl = modules["cicd-gateway.js"]["maskedCicdApiUrl"]
+const normalizeCicdBaseUrl = modules["cicd-gateway.js"]["normalizeCicdBaseUrl"]
+const parseRetryAfterHeader = modules["cicd-gateway.js"]["parseRetryAfterHeader"]
+const resetGatewayEventLogSenderForTests = modules["cicd-gateway.js"]["resetGatewayEventLogSenderForTests"]
+const resetHttpRequestForTests = modules["cicd-gateway.js"]["resetHttpRequestForTests"]
+const resolveAndValidateCicdEndpoint = modules["cicd-gateway.js"]["resolveAndValidateCicdEndpoint"]
+const resolveCicdCredentials = modules["cicd-gateway.js"]["resolveCicdCredentials"]
+const resolveCicdRequestTimeoutMs = modules["cicd-gateway.js"]["resolveCicdRequestTimeoutMs"]
+const resolveConfiguredCicdBaseUrl = modules["cicd-gateway.js"]["resolveConfiguredCicdBaseUrl"]
+const runWithGatewayTransactionContext = modules["cicd-gateway.js"]["runWithGatewayTransactionContext"]
+const scheduleGatewayEventLog = modules["cicd-gateway.js"]["scheduleGatewayEventLog"]
+const setGatewayEventLogSenderForTests = modules["cicd-gateway.js"]["setGatewayEventLogSenderForTests"]
+const setHttpRequestForTests = modules["cicd-gateway.js"]["setHttpRequestForTests"]
+const tryResolveCicdCredentials = modules["cicd-gateway.js"]["tryResolveCicdCredentials"]
+export {AGENTIA_CLIENT_ORIGIN_ENV, AGENTIA_IDE_VERSION_ENV, AI_GATEWAY_EVENT_SERVICE, CICD_ENV, CRT_GATEWAY_EVENT_SERVICE, CicdGateway, CicdGatewayError, GATEWAY_EVENT_API_CALL, GATEWAY_EVENT_UNKNOWN, MCP_CICD_DEFAULT_REQUEST_TIMEOUT_MS, buildGatewayEventLogPayload, cicdApiUrl, createTransactionId, discoverCicdBaseUrl, flushGatewayEventLogsForTests, formatCicdGatewayError, formatGatewayEventTimestamp, gatewayEventSource, gatewayRefererHeaders, gatewayUserAgent, getActiveHttpRequestOptionsForTests, getGatewayClientOrigin, getGatewayReferer, getGatewayTransactionId, isCicdWarningResponseBody, isCicdWarningStatus, maskUrlSecrets, maskedCicdApiUrl, normalizeCicdBaseUrl, parseRetryAfterHeader, resetGatewayEventLogSenderForTests, resetHttpRequestForTests, resolveAndValidateCicdEndpoint, resolveCicdCredentials, resolveCicdRequestTimeoutMs, resolveConfiguredCicdBaseUrl, runWithGatewayTransactionContext, scheduleGatewayEventLog, setGatewayEventLogSenderForTests, setHttpRequestForTests, tryResolveCicdCredentials};