@vinaystwt/xmpp-http-interceptor 0.1.0

package/dist/http-interceptor/src/agents.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/http-interceptor/src/agents.test.js

@@ -0,0 +1,35 @@
+import { describe, expect, it } from 'vitest';
+import { applyAgentPolicy } from './agents.js';
+describe('agent policy merge', () => {
+    it('overlays contract-backed budget, routes, services, and methods on the local agent profile', () => {
+        const profile = {
+            agentId: 'research-agent',
+            displayName: 'Research Agent',
+            role: 'research',
+            description: 'Local profile',
+            dailyBudgetUsd: 0.15,
+            allowedServices: ['research-api'],
+            preferredRoutes: ['x402'],
+            autopayMethods: ['GET'],
+            enabled: true,
+            policySource: 'local',
+        };
+        const policy = {
+            agentId: 'research-agent',
+            enabled: false,
+            dailyBudgetUsd: 0.2,
+            allowedServices: ['research-api', 'stream-api'],
+            preferredRoutes: ['x402', 'mpp-session-reuse'],
+            autopayMethods: ['get', 'head'],
+            source: 'contract',
+        };
+        expect(applyAgentPolicy(profile, policy)).toMatchObject({
+            enabled: false,
+            dailyBudgetUsd: 0.2,
+            allowedServices: ['research-api', 'stream-api'],
+            preferredRoutes: ['x402', 'mpp-session-reuse'],
+            autopayMethods: ['GET', 'HEAD'],
+            policySource: 'merged',
+        });
+    });
+});

package/dist/http-interceptor/src/idempotency.d.ts

@@ -0,0 +1,68 @@
+import type { XmppFetchMetadata, XmppFetchOptions } from '@xmpp/types';
+type IdempotencySnapshot = {
+    fingerprint: string;
+    storedAt: number;
+    inflight: boolean;
+    response?: {
+        status: number;
+        statusText: string;
+        headers: Record<string, string>;
+        body: string;
+        metadata: XmppFetchMetadata;
+    };
+};
+export declare function inspectIdempotency(url: string, method: string, init?: RequestInit, options?: XmppFetchOptions): {
+    allowed: true;
+    code?: undefined;
+    reason?: undefined;
+    idempotencyKey?: undefined;
+    fingerprint?: undefined;
+    replay?: undefined;
+    response?: undefined;
+} | {
+    allowed: false;
+    code: string;
+    reason: string;
+    idempotencyKey?: undefined;
+    fingerprint?: undefined;
+    replay?: undefined;
+    response?: undefined;
+} | {
+    allowed: true;
+    idempotencyKey: string;
+    fingerprint: string;
+    code?: undefined;
+    reason?: undefined;
+    replay?: undefined;
+    response?: undefined;
+} | {
+    allowed: true;
+    idempotencyKey: string;
+    fingerprint: string;
+    replay: true;
+    response: {
+        status: number;
+        statusText: string;
+        headers: Record<string, string>;
+        body: string;
+        metadata: XmppFetchMetadata;
+    };
+    code?: undefined;
+    reason?: undefined;
+};
+export declare function storeIdempotentResponse(idempotencyKey: string, fingerprint: string, response: Response, metadata: XmppFetchMetadata): Promise<void>;
+export declare function clearIdempotentReservation(idempotencyKey: string, fingerprint: string): void;
+export declare function buildIdempotentReplay(snapshot: IdempotencySnapshot['response']): {
+    response: Response;
+    metadata: {
+        idempotentReplay: boolean;
+        route: import("@xmpp/types").RouteKind;
+        challenge?: import("@xmpp/types").PaymentChallenge;
+        retried: boolean;
+        execution?: import("@xmpp/types").PaymentExecutionMetadata;
+        policy?: import("@xmpp/types").PolicyDecision;
+        budget?: import("@xmpp/types").XmppBudgetSnapshot;
+    };
+} | null;
+export declare function resetIdempotencyCache(): void;
+export {};

package/dist/http-interceptor/src/idempotency.js

@@ -0,0 +1,149 @@
+import { createHash } from 'node:crypto';
+const IDEMPOTENCY_TTL_MS = 60 * 60 * 1000;
+const idempotencyCache = new Map();
+function normalizeBody(body) {
+    if (body == null) {
+        return '';
+    }
+    if (typeof body === 'string') {
+        return body;
+    }
+    if (body instanceof URLSearchParams) {
+        return body.toString();
+    }
+    if (body instanceof FormData) {
+        const entries = [];
+        body.forEach((value, key) => {
+            entries.push(`${key}=${typeof value === 'string' ? value : value.name}`);
+        });
+        return entries.join('&');
+    }
+    return '[stream]';
+}
+function cleanupExpired() {
+    const cutoff = Date.now() - IDEMPOTENCY_TTL_MS;
+    for (const [key, snapshot] of idempotencyCache.entries()) {
+        if (snapshot.storedAt < cutoff) {
+            idempotencyCache.delete(key);
+        }
+    }
+}
+function buildFingerprint(url, method, init) {
+    const headers = new Headers(init?.headers);
+    const headerPairs = [];
+    headers.forEach((value, key) => {
+        headerPairs.push(`${key.toLowerCase()}=${value}`);
+    });
+    headerPairs.sort();
+    return createHash('sha256')
+        .update(JSON.stringify({
+        url,
+        method: method.toUpperCase(),
+        headers: headerPairs,
+        body: normalizeBody(init?.body),
+    }))
+        .digest('hex');
+}
+function resolveIdempotencyKey(init, options) {
+    const headers = new Headers(init?.headers);
+    return (options?.idempotencyKey ??
+        headers.get('idempotency-key') ??
+        headers.get('x-idempotency-key') ??
+        undefined);
+}
+export function inspectIdempotency(url, method, init, options) {
+    cleanupExpired();
+    const upperMethod = method.toUpperCase();
+    if (upperMethod === 'GET' || upperMethod === 'HEAD') {
+        return { allowed: true };
+    }
+    const idempotencyKey = resolveIdempotencyKey(init, options);
+    if (!idempotencyKey) {
+        return {
+            allowed: false,
+            code: 'missing-key',
+            reason: 'Automatic payment for non-GET requests requires an idempotency key.',
+        };
+    }
+    const fingerprint = buildFingerprint(url, upperMethod, init);
+    const existing = idempotencyCache.get(idempotencyKey);
+    if (!existing) {
+        idempotencyCache.set(idempotencyKey, {
+            fingerprint,
+            storedAt: Date.now(),
+            inflight: true,
+        });
+        return {
+            allowed: true,
+            idempotencyKey,
+            fingerprint,
+        };
+    }
+    if (existing.fingerprint !== fingerprint) {
+        return {
+            allowed: false,
+            code: 'mismatch',
+            reason: 'This idempotency key was already used for a different request payload.',
+        };
+    }
+    if (existing.inflight || !existing.response) {
+        return {
+            allowed: false,
+            code: 'inflight',
+            reason: 'An idempotent request with this key is already in progress.',
+        };
+    }
+    return {
+        allowed: true,
+        idempotencyKey,
+        fingerprint,
+        replay: true,
+        response: existing.response,
+    };
+}
+export async function storeIdempotentResponse(idempotencyKey, fingerprint, response, metadata) {
+    const body = await response.clone().text();
+    const headers = {};
+    response.headers.forEach((value, key) => {
+        headers[key] = value;
+    });
+    idempotencyCache.set(idempotencyKey, {
+        fingerprint,
+        storedAt: Date.now(),
+        inflight: false,
+        response: {
+            status: response.status,
+            statusText: response.statusText,
+            headers,
+            body,
+            metadata,
+        },
+    });
+}
+export function clearIdempotentReservation(idempotencyKey, fingerprint) {
+    const existing = idempotencyCache.get(idempotencyKey);
+    if (existing && existing.fingerprint === fingerprint && existing.inflight) {
+        idempotencyCache.delete(idempotencyKey);
+    }
+}
+export function buildIdempotentReplay(snapshot) {
+    if (!snapshot) {
+        return null;
+    }
+    const headers = new Headers(snapshot.headers);
+    headers.set('x-xmpp-idempotency-replay', 'true');
+    return {
+        response: new Response(snapshot.body, {
+            status: snapshot.status,
+            statusText: snapshot.statusText,
+            headers,
+        }),
+        metadata: {
+            ...snapshot.metadata,
+            idempotentReplay: true,
+        },
+    };
+}
+export function resetIdempotencyCache() {
+    idempotencyCache.clear();
+}

package/dist/http-interceptor/src/idempotency.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/http-interceptor/src/idempotency.test.js

@@ -0,0 +1,75 @@
+import { afterEach, describe, expect, it } from 'vitest';
+import { buildIdempotentReplay, inspectIdempotency, resetIdempotencyCache, storeIdempotentResponse, } from './idempotency.js';
+describe('idempotency', () => {
+    afterEach(() => {
+        resetIdempotencyCache();
+    });
+    it('requires an idempotency key for non-GET payment requests', () => {
+        const result = inspectIdempotency('http://localhost:4102/order', 'POST', {
+            body: JSON.stringify({ symbol: 'XLM' }),
+            headers: { 'content-type': 'application/json' },
+        });
+        expect(result).toMatchObject({
+            allowed: false,
+            code: 'missing-key',
+        });
+    });
+    it('replays a previously stored response for the same request fingerprint', async () => {
+        const first = inspectIdempotency('http://localhost:4102/order', 'POST', {
+            body: JSON.stringify({ symbol: 'XLM' }),
+            headers: { 'content-type': 'application/json' },
+        }, {
+            idempotencyKey: 'order-1',
+        });
+        expect(first.allowed).toBe(true);
+        if (!first.allowed ||
+            !('idempotencyKey' in first) ||
+            !('fingerprint' in first) ||
+            typeof first.idempotencyKey !== 'string' ||
+            typeof first.fingerprint !== 'string') {
+            throw new Error('expected idempotency reservation to succeed');
+        }
+        await storeIdempotentResponse(first.idempotencyKey, first.fingerprint, new Response(JSON.stringify({ ok: true }), {
+            status: 200,
+            headers: { 'content-type': 'application/json' },
+        }), {
+            route: 'mpp-charge',
+            retried: true,
+        });
+        const second = inspectIdempotency('http://localhost:4102/order', 'POST', {
+            body: JSON.stringify({ symbol: 'XLM' }),
+            headers: { 'content-type': 'application/json' },
+        }, {
+            idempotencyKey: 'order-1',
+        });
+        expect(second).toMatchObject({
+            allowed: true,
+            replay: true,
+            idempotencyKey: 'order-1',
+        });
+        if (!second.allowed || !('response' in second) || !second.response) {
+            throw new Error('expected idempotent replay to be available');
+        }
+        const replay = buildIdempotentReplay(second.response);
+        expect(replay?.metadata.idempotentReplay).toBe(true);
+    });
+    it('rejects idempotency key reuse with a different request body', () => {
+        const first = inspectIdempotency('http://localhost:4102/order', 'POST', {
+            body: JSON.stringify({ symbol: 'XLM' }),
+            headers: { 'content-type': 'application/json' },
+        }, {
+            idempotencyKey: 'order-1',
+        });
+        expect(first.allowed).toBe(true);
+        const second = inspectIdempotency('http://localhost:4102/order', 'POST', {
+            body: JSON.stringify({ symbol: 'BTC' }),
+            headers: { 'content-type': 'application/json' },
+        }, {
+            idempotencyKey: 'order-1',
+        });
+        expect(second).toMatchObject({
+            allowed: false,
+            code: 'mismatch',
+        });
+    });
+});

package/dist/http-interceptor/src/index.d.ts

@@ -0,0 +1,10 @@
+import type { XmppAgentProfile, XmppFetchMetadata, XmppFetchOptions } from '@xmpp/types';
+import { getXmppOperatorState, listLocalSessions } from './state.js';
+import { listXmppAgentProfiles } from './agents.js';
+export declare function getXmppMetadata(resp: Response): XmppFetchMetadata | undefined;
+export { getXmppOperatorState, listLocalSessions, listXmppAgentProfiles };
+export declare function resetXmppRuntimeState(): void;
+export { resetXmppRuntimeState as resetXmppOperatorState };
+export declare function getEffectiveXmppAgentProfile(agentId?: string): Promise<XmppAgentProfile>;
+export declare function listEffectiveXmppAgentProfiles(): Promise<XmppAgentProfile[]>;
+export declare function xmppFetch(input: RequestInfo | URL, init?: RequestInit, options?: XmppFetchOptions): Promise<Response>;