@mercuryo-ai/magicpay-cli 0.1.0

package/dist/otel-exporter.js

@@ -0,0 +1,241 @@
+import { buildMagicPayTelemetryTracesUrl, tryResolveMagicPayGatewayConfig, } from './gateway.js';
+import { projectRunRootToOtlpTraceRequest, projectStepToOtlpTraceRequest } from './otel-projector.js';
+import { loadRunRecord, loadStepRecord, setRunIngestState } from './run-store.js';
+const DEFAULT_HTTP_TIMEOUT_MS = 5_000;
+const DISABLE_TELEMETRY_ENV = 'MAGICPAY_DISABLE_TELEMETRY';
+function trimEnv(value) {
+    const trimmed = value?.trim();
+    return trimmed ? trimmed : undefined;
+}
+function telemetryDisabled(env) {
+    const value = trimEnv(env[DISABLE_TELEMETRY_ENV]);
+    if (!value) {
+        return false;
+    }
+    const normalized = value.toLowerCase();
+    return normalized === '1' || normalized === 'true' || normalized === 'yes' || normalized === 'on';
+}
+function parseHeaderList(value) {
+    if (!value) {
+        return {};
+    }
+    const headers = {};
+    for (const chunk of value.split(',')) {
+        const separatorIndex = chunk.indexOf('=');
+        if (separatorIndex === -1) {
+            continue;
+        }
+        const key = chunk.slice(0, separatorIndex).trim();
+        const headerValue = chunk.slice(separatorIndex + 1).trim();
+        if (!key || !headerValue) {
+            continue;
+        }
+        headers[key] = headerValue;
+    }
+    return headers;
+}
+function parseTimeoutMs(value) {
+    const parsed = value ? Number(value) : Number.NaN;
+    return Number.isFinite(parsed) && parsed > 0 ? parsed : DEFAULT_HTTP_TIMEOUT_MS;
+}
+function buildTracesEndpoint(base) {
+    return `${base.replace(/\/+$/, '')}/v1/traces`;
+}
+async function postOtlpTraceRequest(params) {
+    const controller = new AbortController();
+    const timeout = setTimeout(() => controller.abort(), params.config.timeoutMs);
+    try {
+        return await params.fetchImpl(params.config.tracesEndpoint, {
+            method: 'POST',
+            headers: {
+                'content-type': 'application/json',
+                ...params.config.headers,
+            },
+            body: JSON.stringify(params.payload),
+            signal: controller.signal,
+        });
+    }
+    finally {
+        clearTimeout(timeout);
+    }
+}
+export function loadOtlpHttpJsonExporterConfig(env = process.env) {
+    if (telemetryDisabled(env)) {
+        return null;
+    }
+    const protocol = trimEnv(env.OTEL_EXPORTER_OTLP_TRACES_PROTOCOL) ??
+        trimEnv(env.OTEL_EXPORTER_OTLP_PROTOCOL) ??
+        'http/json';
+    if (protocol !== 'http/json') {
+        return null;
+    }
+    const tracesEndpoint = trimEnv(env.OTEL_EXPORTER_OTLP_TRACES_ENDPOINT);
+    const baseEndpoint = trimEnv(env.OTEL_EXPORTER_OTLP_ENDPOINT);
+    const gateway = tryResolveMagicPayGatewayConfig();
+    const resolvedEndpoint = tracesEndpoint ??
+        (baseEndpoint ? buildTracesEndpoint(baseEndpoint) : null) ??
+        (gateway ? buildMagicPayTelemetryTracesUrl(gateway.apiUrl) : null);
+    if (!resolvedEndpoint) {
+        return null;
+    }
+    const timeoutMs = parseTimeoutMs(trimEnv(env.OTEL_EXPORTER_OTLP_TRACES_TIMEOUT) ??
+        trimEnv(env.OTEL_EXPORTER_OTLP_TIMEOUT));
+    const headers = {
+        ...parseHeaderList(trimEnv(env.OTEL_EXPORTER_OTLP_HEADERS)),
+        ...parseHeaderList(trimEnv(env.OTEL_EXPORTER_OTLP_TRACES_HEADERS)),
+    };
+    if (!headers.authorization && gateway) {
+        headers.authorization = `Bearer ${gateway.apiKey}`;
+    }
+    return {
+        tracesEndpoint: resolvedEndpoint,
+        headers,
+        timeoutMs,
+        protocol: 'http/json',
+    };
+}
+export function buildRunStepOtlpTraceRequest(runId, stepId) {
+    const run = loadRunRecord(runId);
+    if (!run) {
+        return null;
+    }
+    const step = loadStepRecord(runId, stepId);
+    if (!step) {
+        return null;
+    }
+    return projectStepToOtlpTraceRequest({
+        run,
+        step,
+    });
+}
+export async function exportRunStepToOtlpHttpJson(params = {
+    runId: '',
+    stepId: '',
+}) {
+    const run = loadRunRecord(params.runId);
+    if (!run) {
+        return { attempted: false, reason: 'run_missing' };
+    }
+    const step = loadStepRecord(params.runId, params.stepId);
+    if (!step) {
+        return { attempted: false, reason: 'step_missing' };
+    }
+    const payload = buildRunStepOtlpTraceRequest(params.runId, params.stepId);
+    if (!payload) {
+        return { attempted: false, reason: 'step_missing' };
+    }
+    const fetchImpl = params.fetchImpl ?? fetch;
+    const config = params.config ?? loadOtlpHttpJsonExporterConfig();
+    if (!config) {
+        return { attempted: false, reason: 'config_missing' };
+    }
+    try {
+        const response = await postOtlpTraceRequest({
+            payload,
+            config,
+            fetchImpl,
+        });
+        if (!response.ok) {
+            setRunIngestState(params.runId, 'export_failed');
+            return {
+                attempted: true,
+                success: false,
+                status: response.status,
+                reason: `otlp_http_status_${response.status}`,
+                payload,
+            };
+        }
+        setRunIngestState(params.runId, 'exported');
+        return {
+            attempted: true,
+            success: true,
+            status: response.status,
+            payload,
+        };
+    }
+    catch (error) {
+        setRunIngestState(params.runId, 'export_failed');
+        return {
+            attempted: true,
+            success: false,
+            reason: error instanceof Error ? error.message : String(error),
+            payload,
+        };
+    }
+}
+export function buildRunRootOtlpTraceRequest(runId) {
+    const run = loadRunRecord(runId);
+    if (!run) {
+        return null;
+    }
+    return projectRunRootToOtlpTraceRequest({ run });
+}
+export async function exportRunRootToOtlpHttpJson(params = {
+    runId: '',
+}) {
+    const config = params.config ?? loadOtlpHttpJsonExporterConfig();
+    if (!config) {
+        return { attempted: false, reason: 'config_missing' };
+    }
+    const run = loadRunRecord(params.runId);
+    if (!run) {
+        return { attempted: false, reason: 'run_missing' };
+    }
+    const payload = buildRunRootOtlpTraceRequest(params.runId);
+    if (!payload) {
+        return { attempted: false, reason: 'run_missing' };
+    }
+    const fetchImpl = params.fetchImpl ?? fetch;
+    try {
+        const response = await postOtlpTraceRequest({
+            payload,
+            config,
+            fetchImpl,
+        });
+        if (!response.ok) {
+            setRunIngestState(params.runId, 'export_failed');
+            return {
+                attempted: true,
+                success: false,
+                status: response.status,
+                reason: `otlp_http_status_${response.status}`,
+                payload,
+            };
+        }
+        setRunIngestState(params.runId, 'exported');
+        return {
+            attempted: true,
+            success: true,
+            status: response.status,
+            payload,
+        };
+    }
+    catch (error) {
+        setRunIngestState(params.runId, 'export_failed');
+        return {
+            attempted: true,
+            success: false,
+            reason: error instanceof Error ? error.message : String(error),
+            payload,
+        };
+    }
+}
+export async function exportRunStepToOtlpHttpJsonBestEffort(runId, stepId, options = {}) {
+    if (!runId || !stepId) {
+        return { attempted: false, reason: 'step_missing' };
+    }
+    return exportRunStepToOtlpHttpJson({
+        runId,
+        stepId,
+        fetchImpl: options.fetchImpl,
+    });
+}
+export async function exportRunRootToOtlpHttpJsonBestEffort(runId, options = {}) {
+    if (!runId) {
+        return { attempted: false, reason: 'run_missing' };
+    }
+    return exportRunRootToOtlpHttpJson({
+        runId,
+        fetchImpl: options.fetchImpl,
+    });
+}

package/dist/otel-projector.d.ts

@@ -0,0 +1,59 @@
+import type { RunRecord, StepRecord } from './run-store.js';
+type OtlpAnyValue = {
+    stringValue: string;
+} | {
+    boolValue: boolean;
+} | {
+    intValue: string;
+} | {
+    doubleValue: number;
+} | {
+    arrayValue: {
+        values: OtlpAnyValue[];
+    };
+} | {
+    kvlistValue: {
+        values: OtlpKeyValue[];
+    };
+};
+type OtlpKeyValue = {
+    key: string;
+    value: OtlpAnyValue;
+};
+type OtlpSpan = {
+    traceId: string;
+    spanId: string;
+    parentSpanId?: string;
+    name: string;
+    kind: number;
+    startTimeUnixNano: string;
+    endTimeUnixNano: string;
+    attributes?: OtlpKeyValue[];
+    status?: {
+        code: number;
+        message?: string;
+    };
+};
+export type OtlpTraceRequest = {
+    resourceSpans: Array<{
+        resource: {
+            attributes: OtlpKeyValue[];
+        };
+        scopeSpans: Array<{
+            scope: {
+                name: string;
+            };
+            spans: OtlpSpan[];
+        }>;
+    }>;
+};
+export declare function sanitizeUrlForTelemetry(url: string): string;
+export declare function projectStepToOtlpTraceRequest(params: {
+    run: RunRecord;
+    step: StepRecord;
+}): OtlpTraceRequest;
+export declare function projectRunRootToOtlpTraceRequest(params: {
+    run: RunRecord;
+}): OtlpTraceRequest;
+export {};
+//# sourceMappingURL=otel-projector.d.ts.map

package/dist/otel-projector.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"otel-projector.d.ts","sourceRoot":"","sources":["../src/otel-projector.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAuB,UAAU,EAAE,MAAM,gBAAgB,CAAC;AAEjF,KAAK,YAAY,GACb;IAAE,WAAW,EAAE,MAAM,CAAA;CAAE,GACvB;IAAE,SAAS,EAAE,OAAO,CAAA;CAAE,GACtB;IAAE,QAAQ,EAAE,MAAM,CAAA;CAAE,GACpB;IAAE,WAAW,EAAE,MAAM,CAAA;CAAE,GACvB;IAAE,UAAU,EAAE;QAAE,MAAM,EAAE,YAAY,EAAE,CAAA;KAAE,CAAA;CAAE,GAC1C;IAAE,WAAW,EAAE;QAAE,MAAM,EAAE,YAAY,EAAE,CAAA;KAAE,CAAA;CAAE,CAAC;AAEhD,KAAK,YAAY,GAAG;IAClB,GAAG,EAAE,MAAM,CAAC;IACZ,KAAK,EAAE,YAAY,CAAC;CACrB,CAAC;AAEF,KAAK,QAAQ,GAAG;IACd,OAAO,EAAE,MAAM,CAAC;IAChB,MAAM,EAAE,MAAM,CAAC;IACf,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,CAAC;IACb,iBAAiB,EAAE,MAAM,CAAC;IAC1B,eAAe,EAAE,MAAM,CAAC;IACxB,UAAU,CAAC,EAAE,YAAY,EAAE,CAAC;IAC5B,MAAM,CAAC,EAAE;QACP,IAAI,EAAE,MAAM,CAAC;QACb,OAAO,CAAC,EAAE,MAAM,CAAC;KAClB,CAAC;CACH,CAAC;AAEF,MAAM,MAAM,gBAAgB,GAAG;IAC7B,aAAa,EAAE,KAAK,CAAC;QACnB,QAAQ,EAAE;YACR,UAAU,EAAE,YAAY,EAAE,CAAC;SAC5B,CAAC;QACF,UAAU,EAAE,KAAK,CAAC;YAChB,KAAK,EAAE;gBACL,IAAI,EAAE,MAAM,CAAC;aACd,CAAC;YACF,KAAK,EAAE,QAAQ,EAAE,CAAC;SACnB,CAAC,CAAC;KACJ,CAAC,CAAC;CACJ,CAAC;AAwBF,wBAAgB,uBAAuB,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CAW3D;AAgQD,wBAAgB,6BAA6B,CAAC,MAAM,EAAE;IACpD,GAAG,EAAE,SAAS,CAAC;IACf,IAAI,EAAE,UAAU,CAAC;CAClB,GAAG,gBAAgB,CA0CnB;AAED,wBAAgB,gCAAgC,CAAC,MAAM,EAAE;IAAE,GAAG,EAAE,SAAS,CAAA;CAAE,GAAG,gBAAgB,CA2C7F"}

package/dist/otel-projector.js

@@ -0,0 +1,325 @@
+const INTERNAL_SPAN_KIND = 1;
+const CLIENT_SPAN_KIND = 3;
+const STATUS_CODE_UNSET = 0;
+const STATUS_CODE_OK = 1;
+const STATUS_CODE_ERROR = 2;
+const MAX_ATTRIBUTE_STRING_LENGTH = 256;
+const MAX_REASON_LENGTH = 512;
+const SENSITIVE_KEY_PATTERN = /(secret|token|password|authorization|cookie|api[-_]?key|raw[-_]?value|raw[-_]?values|resolved[-_]?values|protected[-_]?values)/i;
+function isoToUnixNano(value, fallback) {
+    const source = value ?? fallback;
+    const millis = new Date(source).getTime();
+    const safeMillis = Number.isFinite(millis) ? millis : new Date(fallback).getTime();
+    return `${Math.max(0, safeMillis) * 1_000_000}`;
+}
+function truncateString(value, maxLength = MAX_ATTRIBUTE_STRING_LENGTH) {
+    return value.length <= maxLength ? value : `${value.slice(0, maxLength)}...`;
+}
+export function sanitizeUrlForTelemetry(url) {
+    try {
+        const parsed = new URL(url);
+        parsed.username = '';
+        parsed.password = '';
+        parsed.search = '';
+        parsed.hash = '';
+        return parsed.toString();
+    }
+    catch {
+        return truncateString(url);
+    }
+}
+function isSensitiveKey(key) {
+    return SENSITIVE_KEY_PATTERN.test(key);
+}
+function normalizePrimitiveForTelemetry(key, value) {
+    if (value === null || value === undefined) {
+        return undefined;
+    }
+    if (isSensitiveKey(key)) {
+        return '[redacted]';
+    }
+    if (typeof value === 'string') {
+        if (key.toLowerCase().includes('url')) {
+            return sanitizeUrlForTelemetry(value);
+        }
+        if (key.toLowerCase().includes('reason')) {
+            return truncateString(value, MAX_REASON_LENGTH);
+        }
+        if (key.toLowerCase().includes('message')) {
+            return truncateString(value, MAX_ATTRIBUTE_STRING_LENGTH);
+        }
+        return truncateString(value);
+    }
+    if (typeof value === 'boolean' || typeof value === 'number') {
+        return value;
+    }
+    return undefined;
+}
+function flattenTelemetryAttributes(prefix, value, target) {
+    if (value === null || value === undefined) {
+        return;
+    }
+    if (Array.isArray(value)) {
+        if (value.length === 0) {
+            return;
+        }
+        const normalized = value
+            .map((entry, index) => normalizePrimitiveForTelemetry(`${prefix}[${index}]`, entry))
+            .filter((entry) => entry !== undefined);
+        if (normalized.length > 0) {
+            target[prefix] = normalized;
+        }
+        return;
+    }
+    if (typeof value === 'object') {
+        for (const [key, nested] of Object.entries(value)) {
+            const nextPrefix = prefix.length > 0 ? `${prefix}.${key}` : key;
+            flattenTelemetryAttributes(nextPrefix, nested, target);
+        }
+        return;
+    }
+    const normalized = normalizePrimitiveForTelemetry(prefix, value);
+    if (normalized !== undefined) {
+        target[prefix] = normalized;
+    }
+}
+function toAnyValue(value) {
+    if (typeof value === 'string') {
+        return { stringValue: value };
+    }
+    if (typeof value === 'boolean') {
+        return { boolValue: value };
+    }
+    if (typeof value === 'number') {
+        if (Number.isInteger(value)) {
+            return { intValue: String(value) };
+        }
+        return { doubleValue: value };
+    }
+    if (Array.isArray(value)) {
+        const values = value.map(toAnyValue).filter((entry) => entry !== null);
+        return { arrayValue: { values } };
+    }
+    if (value && typeof value === 'object') {
+        const values = Object.entries(value)
+            .map(([key, nested]) => {
+            const nestedValue = toAnyValue(nested);
+            return nestedValue ? { key, value: nestedValue } : null;
+        })
+            .filter((entry) => entry !== null);
+        return { kvlistValue: { values } };
+    }
+    return null;
+}
+function toKeyValues(values) {
+    return Object.entries(values)
+        .map(([key, value]) => {
+        const anyValue = toAnyValue(value);
+        return anyValue ? { key, value: anyValue } : null;
+    })
+        .filter((entry) => entry !== null);
+}
+function getPrimaryRunSiteHost(run) {
+    return run.hostHints?.find((entry) => typeof entry === 'string' && entry.length > 0);
+}
+function buildResourceAttributes(run) {
+    const siteHost = getPrimaryRunSiteHost(run);
+    const values = {
+        'service.name': run.resource.serviceName,
+        'service.version': run.resource.serviceVersion,
+        'service.instance.id': run.resource.serviceInstanceId,
+        'telemetry.sdk.language': run.resource.telemetrySdkLanguage,
+        'agentbrowse.session.id': run.sessionId,
+        'agentbrowse.run.id': run.runId,
+        'agentbrowse.run.source': run.source,
+        'agentbrowse.run.entry_command': run.entryCommand,
+        'agentbrowse.run.display_name': run.displayName,
+        'agentbrowse.run.profile': run.profile,
+        'agentbrowse.run.site_host': siteHost,
+        'agentbrowse.run.started_at': run.startedAt,
+        'agentbrowse.run.ended_at': run.endedAt,
+        'agentbrowse.run.status': run.status,
+        'agentbrowse.run.protected': run.protectedRun,
+        'agentbrowse.run.final_outcome_type': run.finalOutcome?.outcomeType,
+        'agentbrowse.run.final_message': run.finalOutcome?.message,
+        'agentbrowse.run.final_reason': run.finalOutcome?.reason,
+    };
+    if (run.hostHints && run.hostHints.length > 0) {
+        values['agentbrowse.run.host_hints'] = run.hostHints.map((host) => truncateString(host));
+    }
+    return toKeyValues(values);
+}
+function buildStepAttributes(run, step) {
+    const values = {
+        'agentbrowse.run.id': run.runId,
+        'agentbrowse.session.id': run.sessionId,
+        'agentbrowse.step.id': step.stepId,
+        'agentbrowse.step.ordinal': step.ordinal,
+        'agentbrowse.step.command': step.command,
+        'agentbrowse.step.protected': step.protectedStep,
+        'agentbrowse.step.page_ref': step.refs?.pageRef,
+        'agentbrowse.step.target_ref': step.refs?.targetRef,
+        'agentbrowse.step.surface_ref': step.refs?.surfaceRef,
+        'agentbrowse.step.fill_ref': step.refs?.fillRef,
+        'agentbrowse.step.request_id': step.refs?.requestId,
+        'agentbrowse.step.success': step.outputSummary?.success,
+        'agentbrowse.step.outcome_type': step.outputSummary?.outcomeType,
+        'agentbrowse.step.message': step.outputSummary?.message,
+        'agentbrowse.step.reason': step.outputSummary?.reason,
+        'agentbrowse.step.event_count': step.eventIds.length,
+        'agentbrowse.step.child_span_count': step.childSpans.length,
+        'agentbrowse.trace.propagation_mode': run.traceContext.propagationMode,
+    };
+    const flattenedInput = {};
+    flattenTelemetryAttributes('agentbrowse.step.input', step.input, flattenedInput);
+    Object.assign(values, flattenedInput);
+    return toKeyValues(values);
+}
+function buildRunRootSpanName(run) {
+    const siteHost = getPrimaryRunSiteHost(run);
+    const displayName = typeof run.displayName === 'string' && run.displayName.trim().length > 0
+        ? run.displayName.trim()
+        : undefined;
+    if (siteHost && displayName) {
+        return truncateString(`${siteHost} - ${displayName}`);
+    }
+    if (displayName) {
+        return truncateString(displayName);
+    }
+    if (siteHost) {
+        return truncateString(siteHost);
+    }
+    if (run.entryCommand) {
+        return `magicpay.${truncateString(run.entryCommand)}`;
+    }
+    return 'magicpay.run';
+}
+function buildRunRootSpanAttributes(run) {
+    const siteHost = getPrimaryRunSiteHost(run);
+    const values = {
+        'agentbrowse.run.id': run.runId,
+        'agentbrowse.session.id': run.sessionId,
+        'agentbrowse.run.entry_command': run.entryCommand,
+        'agentbrowse.run.display_name': run.displayName,
+        'agentbrowse.run.site_host': siteHost,
+        'agentbrowse.run.status': run.status,
+        'agentbrowse.run.protected': run.protectedRun,
+        'agentbrowse.run.step_count': run.stepIds.length,
+        'agentbrowse.run.final_outcome_type': run.finalOutcome?.outcomeType,
+        'agentbrowse.run.final_message': run.finalOutcome?.message,
+        'agentbrowse.run.final_reason': run.finalOutcome?.reason,
+    };
+    if (run.hostHints && run.hostHints.length > 0) {
+        values['agentbrowse.run.host_hints'] = run.hostHints.map((host) => truncateString(host));
+    }
+    return toKeyValues(values);
+}
+function buildStepStatus(step) {
+    const code = step.otel.statusCode === 'ok'
+        ? STATUS_CODE_OK
+        : step.otel.statusCode === 'error'
+            ? STATUS_CODE_ERROR
+            : STATUS_CODE_UNSET;
+    return {
+        code,
+        ...(step.otel.statusMessage ? { message: truncateString(step.otel.statusMessage) } : {}),
+    };
+}
+function buildChildSpanStatus(childSpan) {
+    const code = childSpan.statusCode === 'ok'
+        ? STATUS_CODE_OK
+        : childSpan.statusCode === 'error'
+            ? STATUS_CODE_ERROR
+            : STATUS_CODE_UNSET;
+    return {
+        code,
+        ...(childSpan.statusMessage ? { message: truncateString(childSpan.statusMessage) } : {}),
+    };
+}
+function buildChildSpanAttributes(childSpan) {
+    const flattened = {};
+    flattenTelemetryAttributes('', childSpan.attributes, flattened);
+    return toKeyValues(flattened);
+}
+export function projectStepToOtlpTraceRequest(params) {
+    const stepSpan = {
+        traceId: params.step.otel.traceId,
+        spanId: params.step.otel.spanId,
+        ...(params.step.otel.parentSpanId ? { parentSpanId: params.step.otel.parentSpanId } : {}),
+        name: params.step.otel.spanName,
+        kind: INTERNAL_SPAN_KIND,
+        startTimeUnixNano: isoToUnixNano(params.step.startedAt, params.run.startedAt),
+        endTimeUnixNano: isoToUnixNano(params.step.endedAt, params.step.startedAt),
+        attributes: buildStepAttributes(params.run, params.step),
+        status: buildStepStatus(params.step),
+    };
+    const childSpans = params.step.childSpans.map((childSpan) => ({
+        traceId: params.step.otel.traceId,
+        spanId: childSpan.spanId,
+        parentSpanId: childSpan.parentSpanId,
+        name: childSpan.name,
+        kind: CLIENT_SPAN_KIND,
+        startTimeUnixNano: isoToUnixNano(childSpan.startedAt, params.step.startedAt),
+        endTimeUnixNano: isoToUnixNano(childSpan.endedAt, childSpan.startedAt),
+        attributes: buildChildSpanAttributes(childSpan),
+        status: buildChildSpanStatus(childSpan),
+    }));
+    return {
+        resourceSpans: [
+            {
+                resource: {
+                    attributes: buildResourceAttributes(params.run),
+                },
+                scopeSpans: [
+                    {
+                        scope: {
+                            name: params.step.otel.instrumentationScope,
+                        },
+                        spans: [stepSpan, ...childSpans],
+                    },
+                ],
+            },
+        ],
+    };
+}
+export function projectRunRootToOtlpTraceRequest(params) {
+    const statusCode = params.run.finalOutcome?.success === true || params.run.status === 'completed'
+        ? STATUS_CODE_OK
+        : params.run.finalOutcome?.success === false ||
+            params.run.status === 'failed' ||
+            params.run.status === 'aborted'
+            ? STATUS_CODE_ERROR
+            : STATUS_CODE_UNSET;
+    const span = {
+        traceId: params.run.traceContext.traceId,
+        spanId: params.run.traceContext.rootSpanId,
+        name: buildRunRootSpanName(params.run),
+        kind: INTERNAL_SPAN_KIND,
+        startTimeUnixNano: isoToUnixNano(params.run.startedAt, params.run.startedAt),
+        endTimeUnixNano: isoToUnixNano(params.run.endedAt, params.run.startedAt),
+        attributes: buildRunRootSpanAttributes(params.run),
+        status: {
+            code: statusCode,
+            ...(params.run.finalOutcome?.reason
+                ? { message: truncateString(params.run.finalOutcome.reason) }
+                : {}),
+        },
+    };
+    return {
+        resourceSpans: [
+            {
+                resource: {
+                    attributes: buildResourceAttributes(params.run),
+                },
+                scopeSpans: [
+                    {
+                        scope: {
+                            name: 'magicpay.local-run-store',
+                        },
+                        spans: [span],
+                    },
+                ],
+            },
+        ],
+    };
+}

package/dist/output.d.ts

@@ -0,0 +1,10 @@
+export interface CliResult {
+    success: boolean;
+    error?: string;
+}
+export declare function outputJSON<T extends CliResult>(result: T): never;
+export declare function outputError(error: string): never;
+export declare function writeInfo(message: string): void;
+export declare function info(message: string): never;
+export declare function fatal(message: string): never;
+//# sourceMappingURL=output.d.ts.map

package/dist/output.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"output.d.ts","sourceRoot":"","sources":["../src/output.ts"],"names":[],"mappings":"AAEA,MAAM,WAAW,SAAS;IACxB,OAAO,EAAE,OAAO,CAAC;IACjB,KAAK,CAAC,EAAE,MAAM,CAAC;CAChB;AAWD,wBAAgB,UAAU,CAAC,CAAC,SAAS,SAAS,EAAE,MAAM,EAAE,CAAC,GAAG,KAAK,CAMhE;AAED,wBAAgB,WAAW,CAAC,KAAK,EAAE,MAAM,GAAG,KAAK,CAEhD;AAED,wBAAgB,SAAS,CAAC,OAAO,EAAE,MAAM,GAAG,IAAI,CAE/C;AAED,wBAAgB,IAAI,CAAC,OAAO,EAAE,MAAM,GAAG,KAAK,CAG3C;AAED,wBAAgB,KAAK,CAAC,OAAO,EAAE,MAAM,GAAG,KAAK,CAG5C"}

package/dist/output.js

@@ -0,0 +1,29 @@
+const DEFAULT_COMMAND_NAME = 'magicpay';
+function serializeResult(result) {
+    return `${JSON.stringify(result, null, 2)}\n`;
+}
+function commandName() {
+    const normalized = process.env.MAGICPAY_COMMAND?.trim();
+    return normalized && normalized.length > 0 ? normalized : DEFAULT_COMMAND_NAME;
+}
+export function outputJSON(result) {
+    const normalizedResult = result.success
+        ? result
+        : { ...result, error: result.error ?? 'Unknown error' };
+    process.stdout.write(serializeResult(normalizedResult));
+    process.exit(result.success ? 0 : 1);
+}
+export function outputError(error) {
+    outputJSON({ success: false, error });
+}
+export function writeInfo(message) {
+    process.stderr.write(`${message}\n`);
+}
+export function info(message) {
+    process.stdout.write(`${message}\n`);
+    process.exit(0);
+}
+export function fatal(message) {
+    process.stderr.write(`[${commandName()}] Fatal: ${message}\n`);
+    process.exit(1);
+}

package/dist/package-version.d.ts

@@ -0,0 +1,2 @@
+export declare function readCurrentPackageVersion(): string;
+//# sourceMappingURL=package-version.d.ts.map

package/dist/package-version.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"package-version.d.ts","sourceRoot":"","sources":["../src/package-version.ts"],"names":[],"mappings":"AAMA,wBAAgB,yBAAyB,IAAI,MAAM,CAYlD"}

package/dist/package-version.js

@@ -0,0 +1,14 @@
+import { readFileSync } from 'node:fs';
+const PACKAGE_JSON_URL = new URL('../package.json', import.meta.url);
+let cachedPackageVersion = null;
+export function readCurrentPackageVersion() {
+    if (cachedPackageVersion) {
+        return cachedPackageVersion;
+    }
+    const raw = JSON.parse(readFileSync(PACKAGE_JSON_URL, 'utf-8'));
+    if (!raw.version || typeof raw.version !== 'string') {
+        throw new Error('Package version is missing from package.json.');
+    }
+    cachedPackageVersion = raw.version;
+    return cachedPackageVersion;
+}