@ouro.bot/cli 0.1.0-alpha.696 → 0.1.0-alpha.697

package/dist/rsvp/aisleplanner-client.js

@@ -0,0 +1,354 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AISLEPLANNER_DEFAULT_TIMEOUT_MS = exports.AISLEPLANNER_DEFAULT_BASE_URL = exports.AISLEPLANNER_API_VERSION = void 0;
+exports.fetchAislePlannerRsvps = fetchAislePlannerRsvps;
+const runtime_1 = require("../nerves/runtime");
+exports.AISLEPLANNER_API_VERSION = "2019-06-10";
+exports.AISLEPLANNER_DEFAULT_BASE_URL = "https://www.aisleplanner.com";
+exports.AISLEPLANNER_DEFAULT_TIMEOUT_MS = 30_000;
+function createCookieJar() {
+    const cookies = new Map();
+    return {
+        setFromResponse(response) {
+            for (const header of setCookieHeaders(response.headers)) {
+                const pair = header.split(";", 1)[0].trim();
+                const separator = pair.indexOf("=");
+                if (separator <= 0)
+                    continue;
+                cookies.set(pair.slice(0, separator), pair.slice(separator + 1));
+            }
+        },
+        get(name) {
+            return cookies.get(name);
+        },
+        header() {
+            return [...cookies.entries()].map(([key, value]) => `${key}=${value}`).join("; ");
+        },
+    };
+}
+function setCookieHeaders(headers) {
+    const combined = headers.get("set-cookie");
+    return combined ? splitCombinedSetCookie(combined) : [];
+}
+function splitCombinedSetCookie(header) {
+    const parts = [];
+    let start = 0;
+    for (let index = 0; index < header.length; index += 1) {
+        if (header[index] !== ",")
+            continue;
+        const remainder = header.slice(index + 1);
+        if (/^\s*[^=;,\s]+=/.test(remainder)) {
+            parts.push(header.slice(start, index).trim());
+            start = index + 1;
+        }
+    }
+    parts.push(header.slice(start).trim());
+    return parts.filter(Boolean);
+}
+function decodedCookie(value) {
+    if (!value)
+        return undefined;
+    try {
+        return decodeURIComponent(value);
+    }
+    catch {
+        return value;
+    }
+}
+function baseUrlFor(input) {
+    const base = input.baseUrl ?? exports.AISLEPLANNER_DEFAULT_BASE_URL;
+    return base.endsWith("/") ? base : `${base}/`;
+}
+function apiUrl(baseUrl, path) {
+    return new URL(path.replace(/^\//, ""), baseUrl).toString();
+}
+function requestHeaders(jar, xsrfToken, json = false) {
+    return {
+        ...(json ? { "Content-Type": "application/json" } : {}),
+        "X-Requested-With": "XMLHttpRequest",
+        "X-AP-API-Version": exports.AISLEPLANNER_API_VERSION,
+        "X-XSRF-TOKEN": xsrfToken,
+        Cookie: jar.header(),
+    };
+}
+async function readBody(response) {
+    const text = await response.text();
+    if (!text.trim())
+        return null;
+    try {
+        return JSON.parse(text);
+    }
+    catch {
+        return text;
+    }
+}
+function bodyText(body) {
+    return typeof body === "string" ? body : JSON.stringify(body);
+}
+function hasMfaOrCaptcha(body) {
+    return /captcha|mfa|multi-factor|additional verification/i.test(bodyText(body));
+}
+function classifyHttpFailure(response, body, context) {
+    if (hasMfaOrCaptcha(body)) {
+        return {
+            reason: "mfa_or_captcha",
+            actor: "human-required",
+            message: "AislePlanner requires human verification before API access can continue",
+            httpStatus: response.status,
+        };
+    }
+    if (response.status === 401 || response.status === 403) {
+        return {
+            reason: "auth_denied",
+            actor: "human-required",
+            message: "AislePlanner rejected the configured credentials",
+            httpStatus: response.status,
+        };
+    }
+    if (response.status === 429) {
+        return {
+            reason: "rate_limited",
+            actor: "agent-runnable",
+            message: "AislePlanner rate limited the RSVP fetch",
+            httpStatus: response.status,
+        };
+    }
+    return {
+        reason: "http_error",
+        actor: "agent-runnable",
+        message: `AislePlanner ${context} request failed with HTTP ${response.status}`,
+        httpStatus: response.status,
+    };
+}
+function classifyThrown(error) {
+    const name = error instanceof Error ? error.name : "";
+    const message = error instanceof Error ? error.message : String(error);
+    if (/AbortError|TimeoutError|timed out|aborted/i.test(`${name} ${message}`)) {
+        return {
+            reason: "network_timeout",
+            actor: "agent-runnable",
+            message: "AislePlanner request timed out",
+        };
+    }
+    return {
+        reason: "network_error",
+        actor: "agent-runnable",
+        message: "AislePlanner request failed before a response was received",
+    };
+}
+async function request(fetchFn, jar, url, init, context) {
+    try {
+        const response = await fetchFn(url, init);
+        jar.setFromResponse(response);
+        const body = await readBody(response);
+        if (!response.ok) {
+            return { ok: false, failure: classifyHttpFailure(response, body, context) };
+        }
+        return { ok: true, response, body };
+    }
+    catch (error) {
+        return { ok: false, failure: classifyThrown(error) };
+    }
+}
+function asRecord(value) {
+    return value && typeof value === "object" && !Array.isArray(value) ? value : null;
+}
+function readString(value) {
+    return typeof value === "string" ? value : "";
+}
+function readGroupId(value) {
+    return typeof value === "string" || typeof value === "number" ? value : null;
+}
+function idString(value) {
+    if (typeof value === "string" || typeof value === "number") {
+        const id = String(value).trim();
+        if (id)
+            return id;
+    }
+    return null;
+}
+function normalizeGuestRows(body) {
+    if (!Array.isArray(body))
+        return null;
+    const guests = {};
+    for (const entry of body) {
+        const row = asRecord(entry);
+        const id = idString(row?.id);
+        if (!row || !id)
+            return null;
+        guests[id] = {
+            first_name: readString(row.first_name),
+            last_name: readString(row.last_name),
+            group_id: readGroupId(row.group_id),
+        };
+    }
+    return guests;
+}
+function normalizeEventGuestRows(body) {
+    if (!Array.isArray(body))
+        return null;
+    const eventGuests = new Map();
+    for (const entry of body) {
+        const row = asRecord(entry);
+        const id = idString(row?.wedding_guest_id);
+        const status = row?.attending_status;
+        if (!row || !id || !(status === undefined || status === null || typeof status === "string"))
+            return null;
+        eventGuests.set(id, status ?? null);
+    }
+    return eventGuests;
+}
+function joinGuests(allGuests, eventGuests) {
+    const guests = {};
+    for (const [id, status] of eventGuests) {
+        const guest = allGuests[id];
+        if (!guest)
+            return null;
+        guests[id] = {
+            first_name: guest.first_name,
+            last_name: guest.last_name,
+            group_id: guest.group_id,
+            attending_status: status,
+        };
+    }
+    return guests;
+}
+function canUseStaleFallback(reason) {
+    return ["network_timeout", "network_error", "rate_limited"].includes(reason);
+}
+function withStaleFallback(input, liveFailure) {
+    if (!input.staleFallback || !canUseStaleFallback(liveFailure.reason))
+        return null;
+    (0, runtime_1.emitNervesEvent)({
+        component: "rsvp",
+        event: "rsvp.aisleplanner_stale_fallback",
+        message: "using stale RSVP snapshot after live AislePlanner fetch failure",
+        meta: {
+            agent: input.agent,
+            reason: liveFailure.reason,
+            staleSnapshotId: input.staleFallback.snapshotId,
+        },
+    });
+    return {
+        ok: true,
+        source: "stale-fallback",
+        fetchedAt: input.staleFallback.fetchedAt,
+        staleSnapshotId: input.staleFallback.snapshotId,
+        liveFailure,
+        guests: input.staleFallback.guests,
+        allGuests: input.staleFallback.allGuests,
+    };
+}
+function finalizeFailure(input, liveFailure) {
+    (0, runtime_1.emitNervesEvent)({
+        component: "rsvp",
+        event: "rsvp.aisleplanner_fetch_error",
+        message: "AislePlanner RSVP fetch failed",
+        meta: {
+            agent: input.agent,
+            reason: liveFailure.reason,
+            httpStatus: liveFailure.httpStatus ?? null,
+        },
+    });
+    return withStaleFallback(input, liveFailure) ?? { ok: false, ...liveFailure };
+}
+async function fetchAislePlannerRsvps(input) {
+    const fetchFn = input.fetchFn ?? fetch;
+    const timeoutMs = input.timeoutMs ?? exports.AISLEPLANNER_DEFAULT_TIMEOUT_MS;
+    const baseUrl = baseUrlFor(input);
+    const jar = createCookieJar();
+    (0, runtime_1.emitNervesEvent)({
+        component: "rsvp",
+        event: "rsvp.aisleplanner_fetch_start",
+        message: "fetching RSVP state from AislePlanner",
+        meta: {
+            agent: input.agent,
+            weddingId: input.weddingId,
+            eventId: input.eventId,
+        },
+    });
+    const signinPage = await request(fetchFn, jar, apiUrl(baseUrl, "/signin"), {
+        method: "GET",
+        signal: AbortSignal.timeout(timeoutMs),
+    }, "signin");
+    if (!signinPage.ok)
+        return finalizeFailure(input, signinPage.failure);
+    const initialXsrf = decodedCookie(jar.get("XSRF-TOKEN"));
+    if (!initialXsrf) {
+        return finalizeFailure(input, {
+            reason: "missing_xsrf",
+            actor: "agent-runnable",
+            message: "AislePlanner signin did not return an XSRF token",
+            httpStatus: signinPage.response.status,
+        });
+    }
+    const signin = await request(fetchFn, jar, apiUrl(baseUrl, "/api/account/signin"), {
+        method: "POST",
+        headers: requestHeaders(jar, initialXsrf, true),
+        body: JSON.stringify({
+            username: input.credentials.username,
+            password: input.credentials.password,
+        }),
+        signal: AbortSignal.timeout(timeoutMs),
+    }, "signin");
+    if (!signin.ok)
+        return finalizeFailure(input, signin.failure);
+    const liveXsrf = decodedCookie(jar.get("XSRF-TOKEN")) ?? initialXsrf;
+    const guestsResponse = await request(fetchFn, jar, apiUrl(baseUrl, `/api/wedding/${input.weddingId}/guests`), {
+        method: "GET",
+        headers: requestHeaders(jar, liveXsrf),
+        signal: AbortSignal.timeout(timeoutMs),
+    }, "read");
+    if (!guestsResponse.ok)
+        return finalizeFailure(input, guestsResponse.failure);
+    const allGuests = normalizeGuestRows(guestsResponse.body);
+    if (!allGuests) {
+        return finalizeFailure(input, {
+            reason: "schema_drift",
+            actor: "agent-runnable",
+            message: "AislePlanner guest payload no longer matches the expected schema",
+        });
+    }
+    const eventGuestsResponse = await request(fetchFn, jar, apiUrl(baseUrl, `/api/wedding/${input.weddingId}/events/${input.eventId}/guests`), {
+        method: "GET",
+        headers: requestHeaders(jar, liveXsrf),
+        signal: AbortSignal.timeout(timeoutMs),
+    }, "read");
+    if (!eventGuestsResponse.ok)
+        return finalizeFailure(input, eventGuestsResponse.failure);
+    const eventGuests = normalizeEventGuestRows(eventGuestsResponse.body);
+    if (!eventGuests) {
+        return finalizeFailure(input, {
+            reason: "schema_drift",
+            actor: "agent-runnable",
+            message: "AislePlanner event guest payload no longer matches the expected schema",
+        });
+    }
+    const guests = joinGuests(allGuests, eventGuests);
+    if (!guests) {
+        return finalizeFailure(input, {
+            reason: "schema_drift",
+            actor: "agent-runnable",
+            message: "AislePlanner event guest payload references guests absent from the wedding guest list",
+        });
+    }
+    (0, runtime_1.emitNervesEvent)({
+        component: "rsvp",
+        event: "rsvp.aisleplanner_fetch_end",
+        message: "fetched RSVP state from AislePlanner",
+        meta: {
+            agent: input.agent,
+            weddingId: input.weddingId,
+            eventId: input.eventId,
+            guestCount: Object.keys(guests).length,
+            allGuestCount: Object.keys(allGuests).length,
+        },
+    });
+    return {
+        ok: true,
+        source: "live",
+        fetchedAt: input.fetchedAt ?? new Date().toISOString(),
+        guests,
+        allGuests,
+    };
+}