experimental-ash 0.26.0 → 0.28.0

package/dist/src/public/channels/twilio/twilioChannel.js

@@ -1,316 +1 @@
-import { createLogger } from "#internal/logging.js";
-import { callTwilioApi, sendTwilioMessage, twilioContinuationToken, updateTwilioCall, } from "#public/channels/twilio/api.js";
-import { defaultEvents, defaultOnText, defaultOnVoice, defaultOnVoiceTranscription, } from "#public/channels/twilio/defaults.js";
-import { parseTwilioTextMessage, parseTwilioVoiceCall, parseTwilioVoiceTranscription, prependTwilioContext, } from "#public/channels/twilio/inbound.js";
-import { emptyTwilioResponse, gatherSpeechTwilioResponse, sayTwilioResponse, } from "#public/channels/twilio/twiml.js";
-import { verifyTwilioRequest, } from "#public/channels/twilio/verify.js";
-import { defineChannel, POST, } from "#public/definitions/defineChannel.js";
-const log = createLogger("twilio.channel");
-/** Twilio channel factory for SMS and speech-transcribed inbound calls. */
-export function twilioChannel(config) {
-    assertAllowFromConfigured(config);
-    const routes = buildRoutes(config.route ?? "/ash/v1/twilio");
-    const onText = config.onText ?? defaultOnText;
-    const onVoice = config.onVoice ?? defaultOnVoice;
-    const onVoiceTranscription = config.onVoiceTranscription ?? defaultOnVoiceTranscription;
-    const mergedEvents = { ...defaultEvents, ...config.events };
-    return defineChannel({
-        kindHint: "twilio",
-        state: {
-            from: null,
-            to: null,
-            lastCallSid: null,
-            lastMessageSid: null,
-        },
-        context(state, session) {
-            return rebuildTwilioContext(state, session, config);
-        },
-        routes: [
-            POST(routes.messages, async (req, { send, waitUntil }) => {
-                const verified = await verifyInbound(req, config);
-                if (verified === null)
-                    return new Response("unauthorized", { status: 401 });
-                const message = parseTwilioTextMessage(verified.params);
-                if (!message)
-                    return emptyTwilioResponse();
-                if (!(await isAllowed(message.from, config.allowFrom)))
-                    return new Response("forbidden", { status: 403 });
-                waitUntil(dispatchText({ config, message, onText, send }));
-                return emptyTwilioResponse();
-            }),
-            POST(routes.voice, async (req) => {
-                const verified = await verifyInbound(req, config);
-                if (verified === null)
-                    return new Response("unauthorized", { status: 401 });
-                const call = parseTwilioVoiceCall(verified.params);
-                if (!call)
-                    return sayTwilioResponse("Missing caller information.");
-                if (!(await isAllowed(call.from, config.allowFrom)))
-                    return new Response("forbidden", { status: 403 });
-                const voiceResult = await acceptVoiceCall({
-                    call,
-                    config,
-                    onVoice,
-                });
-                if (voiceResult === null)
-                    return new Response("forbidden", { status: 403 });
-                const voiceOptions = voiceResult ?? {};
-                return gatherSpeechTwilioResponse({
-                    actionUrl: await buildActionUrl(req, config, routes.transcription),
-                    hints: voiceOptions.hints ?? config.voice?.hints,
-                    language: voiceOptions.language ?? config.voice?.language,
-                    profanityFilter: voiceOptions.profanityFilter ?? config.voice?.profanityFilter,
-                    prompt: voiceOptions.prompt ??
-                        config.voice?.prompt ??
-                        "Please say your message after the tone.",
-                    speechModel: voiceOptions.speechModel ?? config.voice?.speechModel,
-                    speechTimeout: voiceOptions.speechTimeout ?? config.voice?.speechTimeout ?? "auto",
-                    timeoutSeconds: voiceOptions.timeoutSeconds ?? config.voice?.timeoutSeconds,
-                    voice: voiceOptions.voice ?? config.voice?.voice,
-                });
-            }),
-            POST(routes.transcription, async (req, { send, waitUntil }) => {
-                const verified = await verifyInbound(req, config);
-                if (verified === null)
-                    return new Response("unauthorized", { status: 401 });
-                const transcription = parseTwilioVoiceTranscription(verified.params);
-                if (!transcription) {
-                    return gatherSpeechTwilioResponse({
-                        actionUrl: await buildActionUrl(req, config, routes.transcription),
-                        language: config.voice?.language,
-                        prompt: config.voice?.prompt ?? "Please say your message after the tone.",
-                        speechTimeout: config.voice?.speechTimeout ?? "auto",
-                        timeoutSeconds: config.voice?.timeoutSeconds,
-                    });
-                }
-                if (!(await isAllowed(transcription.from, config.allowFrom))) {
-                    return new Response("forbidden", { status: 403 });
-                }
-                waitUntil(dispatchVoiceTranscription({ config, onVoiceTranscription, send, transcription }));
-                return sayTwilioResponse(config.voice?.acknowledgement ?? "Thanks. I'll follow up by text.");
-            }),
-        ],
-        async receive(input, { send }) {
-            const phoneNumber = readString(input.args.phoneNumber);
-            if (!phoneNumber) {
-                throw new Error("twilioChannel().receive requires args.phoneNumber.");
-            }
-            const from = readString(input.args.from) ?? config.messaging?.from ?? null;
-            return send(input.message, {
-                auth: input.auth,
-                continuationToken: twilioContinuationToken(phoneNumber, from ?? undefined),
-                state: {
-                    from: phoneNumber,
-                    lastCallSid: null,
-                    lastMessageSid: null,
-                    to: from,
-                },
-            });
-        },
-        events: mergedEvents,
-    });
-}
-function rebuildTwilioContext(state, session, config) {
-    return {
-        session,
-        state,
-        twilio: buildTwilioHandle({
-            callSid: state.lastCallSid ?? undefined,
-            config,
-            from: state.from ?? "",
-            to: state.to ?? undefined,
-        }),
-    };
-}
-function buildTwilioHandle(input) {
-    const api = input.config.api;
-    const credentials = input.config.credentials;
-    const defaultFrom = input.config.messaging?.from ?? input.to;
-    const defaultMessagingServiceSid = input.config.messaging?.messagingServiceSid;
-    const defaultStatusCallbackUrl = input.config.messaging?.statusCallbackUrl;
-    return {
-        callSid: input.callSid,
-        from: input.from,
-        to: input.to,
-        request(path, body) {
-            return callTwilioApi({
-                apiBaseUrl: api?.apiBaseUrl,
-                body,
-                credentials,
-                fetch: api?.fetch,
-                path,
-            });
-        },
-        sendMessage(message, options) {
-            return sendTwilioMessage({
-                apiBaseUrl: api?.apiBaseUrl,
-                body: message,
-                credentials,
-                fetch: api?.fetch,
-                from: options?.from ?? defaultFrom,
-                messagingServiceSid: options?.messagingServiceSid ?? defaultMessagingServiceSid,
-                statusCallbackUrl: options?.statusCallbackUrl ?? defaultStatusCallbackUrl,
-                to: options?.to ?? input.from,
-            });
-        },
-        updateCall(callSid, twiml) {
-            return updateTwilioCall({
-                apiBaseUrl: api?.apiBaseUrl,
-                callSid,
-                credentials,
-                fetch: api?.fetch,
-                twiml,
-            });
-        },
-    };
-}
-function buildRoutes(baseRoute) {
-    const base = baseRoute.endsWith("/") ? baseRoute.slice(0, -1) : baseRoute;
-    return {
-        messages: `${base}/messages`,
-        transcription: `${base}/voice/transcription`,
-        voice: `${base}/voice`,
-    };
-}
-function assertAllowFromConfigured(config) {
-    if (config?.allowFrom === undefined) {
-        throw new Error('twilioChannel requires allowFrom. Use allowFrom: "*" to allow all numbers.');
-    }
-}
-async function verifyInbound(req, config) {
-    try {
-        return await verifyTwilioRequest(req, {
-            authToken: config.credentials?.authToken,
-            webhookUrl: config.webhookUrl,
-        });
-    }
-    catch (error) {
-        log.warn("twilio inbound verification failed", { error });
-        return null;
-    }
-}
-async function dispatchText(input) {
-    const { message } = input;
-    const twilio = {
-        twilio: buildTwilioHandle({
-            callSid: undefined,
-            config: input.config,
-            from: message.from,
-            to: message.to,
-        }),
-    };
-    let result;
-    try {
-        result = await input.onText(twilio, message);
-    }
-    catch (error) {
-        log.error("text handler failed", { error });
-        return;
-    }
-    if (result === null || result === undefined)
-        return;
-    const turnMessage = prependTwilioContext(message.body, {
-        channel: "text",
-        from: message.from,
-        messageSid: message.messageSid,
-        to: message.to,
-    });
-    try {
-        await input.send(turnMessage, {
-            auth: result.auth,
-            continuationToken: twilioContinuationToken(message.from, message.to),
-            state: {
-                from: message.from,
-                lastCallSid: null,
-                lastMessageSid: message.messageSid ?? null,
-                to: message.to ?? null,
-            },
-        });
-    }
-    catch (error) {
-        log.error("text delivery failed", { error });
-    }
-}
-async function acceptVoiceCall(input) {
-    const { call } = input;
-    const twilio = {
-        twilio: buildTwilioHandle({
-            callSid: call.callSid,
-            config: input.config,
-            from: call.from,
-            to: call.to,
-        }),
-    };
-    try {
-        return await input.onVoice(twilio, call);
-    }
-    catch (error) {
-        log.error("voice handler failed", { error });
-        return null;
-    }
-}
-async function dispatchVoiceTranscription(input) {
-    const { transcription } = input;
-    const twilio = {
-        twilio: buildTwilioHandle({
-            callSid: transcription.callSid,
-            config: input.config,
-            from: transcription.from,
-            to: transcription.to,
-        }),
-    };
-    let result;
-    try {
-        result = await input.onVoiceTranscription(twilio, transcription);
-    }
-    catch (error) {
-        log.error("voice transcription handler failed", { error });
-        return;
-    }
-    if (result === null || result === undefined)
-        return;
-    const turnMessage = prependTwilioContext(transcription.text, {
-        callSid: transcription.callSid,
-        channel: "voice",
-        from: transcription.from,
-        to: transcription.to,
-    });
-    try {
-        await input.send(turnMessage, {
-            auth: result.auth,
-            continuationToken: twilioContinuationToken(transcription.from, transcription.to),
-            state: {
-                from: transcription.from,
-                lastCallSid: transcription.callSid ?? null,
-                lastMessageSid: null,
-                to: transcription.to ?? null,
-            },
-        });
-    }
-    catch (error) {
-        log.error("voice transcription delivery failed", { error });
-    }
-}
-async function isAllowed(from, allowFrom) {
-    const resolved = typeof allowFrom === "function" ? await allowFrom() : allowFrom;
-    if (resolved === "*")
-        return true;
-    return typeof resolved === "string" ? resolved === from : resolved.includes(from);
-}
-async function buildActionUrl(request, config, route) {
-    const base = typeof config.publicBaseUrl === "function"
-        ? await config.publicBaseUrl(request)
-        : config.publicBaseUrl;
-    if (base)
-        return new URL(route, ensureTrailingSlash(base)).toString();
-    const url = new URL(request.url);
-    url.pathname = route;
-    url.search = "";
-    return url.toString();
-}
-function ensureTrailingSlash(value) {
-    return value.endsWith("/") ? value : `${value}/`;
-}
-function readString(value) {
-    return typeof value === "string" && value.length > 0 ? value : undefined;
-}
+import{createLogger}from"#internal/logging.js";import{POST,defineChannel}from"#public/definitions/defineChannel.js";import{verifyTwilioRequest}from"#public/channels/twilio/verify.js";import{callTwilioApi,sendTwilioMessage,twilioContinuationToken,updateTwilioCall}from"#public/channels/twilio/api.js";import{emptyTwilioResponse,gatherSpeechTwilioResponse,sayTwilioResponse}from"#public/channels/twilio/twiml.js";import{defaultEvents,defaultOnText,defaultOnVoice,defaultOnVoiceTranscription}from"#public/channels/twilio/defaults.js";import{parseTwilioTextMessage,parseTwilioVoiceCall,parseTwilioVoiceTranscription,prependTwilioContext}from"#public/channels/twilio/inbound.js";var log=createLogger(`twilio.channel`);function twilioChannel(e){assertAllowFromConfigured(e);let r=buildRoutes(e.route??`/ash/v1/twilio`),i=e.onText??defaultOnText,a=e.onVoice??defaultOnVoice,s=e.onVoiceTranscription??defaultOnVoiceTranscription,l={...defaultEvents,...e.events};return defineChannel({kindHint:`twilio`,state:{from:null,to:null,lastCallSid:null,lastMessageSid:null},context(t,n){return rebuildTwilioContext(t,n,e)},routes:[POST(r.messages,async(t,{send:n,waitUntil:r})=>{let a=await verifyInbound(t,e);if(a===null)return new Response(`unauthorized`,{status:401});let o=parseTwilioTextMessage(a.params);return o?await isAllowed(o.from,e.allowFrom)?(r(dispatchText({config:e,message:o,onText:i,send:n})),emptyTwilioResponse()):new Response(`forbidden`,{status:403}):emptyTwilioResponse()}),POST(r.voice,async t=>{let n=await verifyInbound(t,e);if(n===null)return new Response(`unauthorized`,{status:401});let i=parseTwilioVoiceCall(n.params);if(!i)return sayTwilioResponse(`Missing caller information.`);if(!await isAllowed(i.from,e.allowFrom))return new Response(`forbidden`,{status:403});let o=await acceptVoiceCall({call:i,config:e,onVoice:a});if(o===null)return new Response(`forbidden`,{status:403});let s=o??{};return gatherSpeechTwilioResponse({actionUrl:await buildActionUrl(t,e,r.transcription),hints:s.hints??e.voice?.hints,language:s.language??e.voice?.language,profanityFilter:s.profanityFilter??e.voice?.profanityFilter,prompt:s.prompt??e.voice?.prompt??`Please say your message after the tone.`,speechModel:s.speechModel??e.voice?.speechModel,speechTimeout:s.speechTimeout??e.voice?.speechTimeout??`auto`,timeoutSeconds:s.timeoutSeconds??e.voice?.timeoutSeconds,voice:s.voice??e.voice?.voice})}),POST(r.transcription,async(t,{send:n,waitUntil:i})=>{let a=await verifyInbound(t,e);if(a===null)return new Response(`unauthorized`,{status:401});let o=parseTwilioVoiceTranscription(a.params);return o?await isAllowed(o.from,e.allowFrom)?(i(dispatchVoiceTranscription({config:e,onVoiceTranscription:s,send:n,transcription:o})),sayTwilioResponse(e.voice?.acknowledgement??`Thanks. I'll follow up by text.`)):new Response(`forbidden`,{status:403}):gatherSpeechTwilioResponse({actionUrl:await buildActionUrl(t,e,r.transcription),language:e.voice?.language,prompt:e.voice?.prompt??`Please say your message after the tone.`,speechTimeout:e.voice?.speechTimeout??`auto`,timeoutSeconds:e.voice?.timeoutSeconds})})],async receive(t,{send:n}){let r=readString(t.args.phoneNumber);if(!r)throw Error(`twilioChannel().receive requires args.phoneNumber.`);let i=readString(t.args.from)??e.messaging?.from??null;return n(t.message,{auth:t.auth,continuationToken:twilioContinuationToken(r,i??void 0),state:{from:r,lastCallSid:null,lastMessageSid:null,to:i}})},events:l})}function rebuildTwilioContext(e,t,n){return{session:t,state:e,twilio:buildTwilioHandle({callSid:e.lastCallSid??void 0,config:n,from:e.from??``,to:e.to??void 0})}}function buildTwilioHandle(e){let t=e.config.api,n=e.config.credentials,r=e.config.messaging?.from??e.to,o=e.config.messaging?.messagingServiceSid,c=e.config.messaging?.statusCallbackUrl;return{callSid:e.callSid,from:e.from,to:e.to,request(e,r){return callTwilioApi({apiBaseUrl:t?.apiBaseUrl,body:r,credentials:n,fetch:t?.fetch,path:e})},sendMessage(i,s){return sendTwilioMessage({apiBaseUrl:t?.apiBaseUrl,body:i,credentials:n,fetch:t?.fetch,from:s?.from??r,messagingServiceSid:s?.messagingServiceSid??o,statusCallbackUrl:s?.statusCallbackUrl??c,to:s?.to??e.from})},updateCall(e,r){return updateTwilioCall({apiBaseUrl:t?.apiBaseUrl,callSid:e,credentials:n,fetch:t?.fetch,twiml:r})}}}function buildRoutes(e){let t=e.endsWith(`/`)?e.slice(0,-1):e;return{messages:`${t}/messages`,transcription:`${t}/voice/transcription`,voice:`${t}/voice`}}function assertAllowFromConfigured(e){if(e?.allowFrom===void 0)throw Error(`twilioChannel requires allowFrom. Use allowFrom: "*" to allow all numbers.`)}async function verifyInbound(e,t){try{return await verifyTwilioRequest(e,{authToken:t.credentials?.authToken,webhookUrl:t.webhookUrl})}catch(e){return log.warn(`twilio inbound verification failed`,{error:e}),null}}async function dispatchText(e){let{message:t}=e,n={twilio:buildTwilioHandle({callSid:void 0,config:e.config,from:t.from,to:t.to})},r;try{r=await e.onText(n,t)}catch(e){log.error(`text handler failed`,{error:e});return}if(r==null)return;let i=prependTwilioContext(t.body,{channel:`text`,from:t.from,messageSid:t.messageSid,to:t.to});try{await e.send(i,{auth:r.auth,continuationToken:twilioContinuationToken(t.from,t.to),state:{from:t.from,lastCallSid:null,lastMessageSid:t.messageSid??null,to:t.to??null}})}catch(e){log.error(`text delivery failed`,{error:e})}}async function acceptVoiceCall(e){let{call:t}=e,n={twilio:buildTwilioHandle({callSid:t.callSid,config:e.config,from:t.from,to:t.to})};try{return await e.onVoice(n,t)}catch(e){return log.error(`voice handler failed`,{error:e}),null}}async function dispatchVoiceTranscription(e){let{transcription:t}=e,n={twilio:buildTwilioHandle({callSid:t.callSid,config:e.config,from:t.from,to:t.to})},r;try{r=await e.onVoiceTranscription(n,t)}catch(e){log.error(`voice transcription handler failed`,{error:e});return}if(r==null)return;let i=prependTwilioContext(t.text,{callSid:t.callSid,channel:`voice`,from:t.from,to:t.to});try{await e.send(i,{auth:r.auth,continuationToken:twilioContinuationToken(t.from,t.to),state:{from:t.from,lastCallSid:t.callSid??null,lastMessageSid:null,to:t.to??null}})}catch(e){log.error(`voice transcription delivery failed`,{error:e})}}async function isAllowed(e,t){let n=typeof t==`function`?await t():t;return n===`*`?!0:typeof n==`string`?n===e:n.includes(e)}async function buildActionUrl(e,t,n){let r=typeof t.publicBaseUrl==`function`?await t.publicBaseUrl(e):t.publicBaseUrl;if(r)return new URL(n,ensureTrailingSlash(r)).toString();let i=new URL(e.url);return i.pathname=n,i.search=``,i.toString()}function ensureTrailingSlash(e){return e.endsWith(`/`)?e:`${e}/`}function readString(e){return typeof e==`string`&&e.length>0?e:void 0}export{twilioChannel};

package/dist/src/public/channels/twilio/twiml.js

@@ -1,58 +1 @@
-/**
- * Tiny TwiML builders for Twilio webhook responses.
- *
- * The channel keeps TwiML generation local so callers do not need the
- * Twilio SDK just to acknowledge a webhook or gather speech.
- */
-/** Returns an empty TwiML response, useful for acknowledging inbound SMS without replying. */
-export function emptyTwilioResponse() {
-    return twimlResponse("<Response></Response>");
-}
-/** Returns a TwiML response that speaks `message` and then ends the call. */
-export function sayTwilioResponse(message) {
-    return twimlResponse(`<Response><Say>${escapeXml(message)}</Say></Response>`);
-}
-/** Returns a TwiML response that asks the caller to speak and posts the transcript to `actionUrl`. */
-export function gatherSpeechTwilioResponse(options) {
-    const hints = typeof options.hints === "string" ? options.hints : options.hints?.join(",");
-    const attributes = [
-        `input="speech"`,
-        `action="${escapeXml(options.actionUrl)}"`,
-        `method="POST"`,
-        `actionOnEmptyResult="true"`,
-        options.language ? `language="${escapeXml(options.language)}"` : undefined,
-        options.speechModel ? `speechModel="${escapeXml(options.speechModel)}"` : undefined,
-        options.timeoutSeconds !== undefined ? `timeout="${options.timeoutSeconds}"` : undefined,
-        options.speechTimeout ? `speechTimeout="${escapeXml(options.speechTimeout)}"` : undefined,
-        hints ? `hints="${escapeXml(hints)}"` : undefined,
-        options.profanityFilter !== undefined
-            ? `profanityFilter="${options.profanityFilter ? "true" : "false"}"`
-            : undefined,
-    ]
-        .filter((value) => value !== undefined)
-        .join(" ");
-    const sayAttributes = [
-        options.voice ? `voice="${escapeXml(options.voice)}"` : undefined,
-        options.language ? `language="${escapeXml(options.language)}"` : undefined,
-    ]
-        .filter((value) => value !== undefined)
-        .join(" ");
-    const sayOpen = sayAttributes ? `<Say ${sayAttributes}>` : "<Say>";
-    return twimlResponse(`<Response><Gather ${attributes}>${sayOpen}${escapeXml(options.prompt)}</Say></Gather></Response>`);
-}
-/** Wraps a TwiML string in a Twilio-compatible XML response. */
-export function twimlResponse(twiml) {
-    return new Response(twiml, {
-        status: 200,
-        headers: { "content-type": "text/xml;charset=UTF-8" },
-    });
-}
-/** Escapes text for XML element content or attribute values. */
-export function escapeXml(value) {
-    return value
-        .replaceAll("&", "&amp;")
-        .replaceAll("<", "&lt;")
-        .replaceAll(">", "&gt;")
-        .replaceAll('"', "&quot;")
-        .replaceAll("'", "&apos;");
-}
+function emptyTwilioResponse(){return twimlResponse(`<Response></Response>`)}function sayTwilioResponse(e){return twimlResponse(`<Response><Say>${escapeXml(e)}</Say></Response>`)}function gatherSpeechTwilioResponse(e){let t=typeof e.hints==`string`?e.hints:e.hints?.join(`,`),n=[`input="speech"`,`action="${escapeXml(e.actionUrl)}"`,`method="POST"`,`actionOnEmptyResult="true"`,e.language?`language="${escapeXml(e.language)}"`:void 0,e.speechModel?`speechModel="${escapeXml(e.speechModel)}"`:void 0,e.timeoutSeconds===void 0?void 0:`timeout="${e.timeoutSeconds}"`,e.speechTimeout?`speechTimeout="${escapeXml(e.speechTimeout)}"`:void 0,t?`hints="${escapeXml(t)}"`:void 0,e.profanityFilter===void 0?void 0:`profanityFilter="${e.profanityFilter?`true`:`false`}"`].filter(e=>e!==void 0).join(` `),r=[e.voice?`voice="${escapeXml(e.voice)}"`:void 0,e.language?`language="${escapeXml(e.language)}"`:void 0].filter(e=>e!==void 0).join(` `);return twimlResponse(`<Response><Gather ${n}>${r?`<Say ${r}>`:`<Say>`}${escapeXml(e.prompt)}</Say></Gather></Response>`)}function twimlResponse(e){return new Response(e,{status:200,headers:{"content-type":`text/xml;charset=UTF-8`}})}function escapeXml(e){return e.replaceAll(`&`,`&amp;`).replaceAll(`<`,`&lt;`).replaceAll(`>`,`&gt;`).replaceAll(`"`,`&quot;`).replaceAll(`'`,`&apos;`)}export{emptyTwilioResponse,escapeXml,gatherSpeechTwilioResponse,sayTwilioResponse,twimlResponse};

package/dist/src/public/channels/twilio/verify.js

@@ -1,73 +1 @@
-/**
- * Twilio inbound-webhook verification.
- *
- * Twilio signs webhook requests with `X-Twilio-Signature`. For form
- * posts, the signed payload is the exact public URL Twilio called plus
- * every POST parameter sorted by name and appended as `name + value`.
- */
-import { createHmac, timingSafeEqual } from "node:crypto";
-import { createLogger } from "#internal/logging.js";
-const log = createLogger("twilio.verify");
-/** Resolves a Twilio auth token, falling back to `TWILIO_AUTH_TOKEN`. */
-export async function resolveTwilioAuthToken(authToken) {
-    const source = authToken ?? process.env.TWILIO_AUTH_TOKEN;
-    if (!source)
-        throw new Error("TWILIO_AUTH_TOKEN is required.");
-    return typeof source === "function" ? await source() : source;
-}
-/**
- * Verifies an inbound Twilio webhook and returns the raw body plus form params.
- *
- * Throws when the auth token is missing, the signature header is missing,
- * or the computed signature does not match `X-Twilio-Signature`.
- */
-export async function verifyTwilioRequest(request, options) {
-    const body = await request.text();
-    const params = new URLSearchParams(body);
-    const authToken = await resolveTwilioAuthToken(options.authToken);
-    const signature = request.headers.get("x-twilio-signature") ?? "";
-    if (!signature) {
-        throw new Error("twilioChannel: inbound request missing X-Twilio-Signature.");
-    }
-    const url = await resolveWebhookUrl(request, options.webhookUrl);
-    const expected = signTwilioRequest({ authToken, params, url });
-    if (!constantTimeCompare(expected, signature)) {
-        throw new Error("twilioChannel: inbound request signature mismatch.");
-    }
-    return { body, params };
-}
-/** Computes Twilio's HMAC-SHA1 request signature. */
-export function signTwilioRequest(input) {
-    const base = buildTwilioSignatureBase(input.url, input.params);
-    return createHmac("sha1", input.authToken).update(base).digest("base64");
-}
-/** Builds the string Twilio signs for a form POST webhook. */
-export function buildTwilioSignatureBase(url, params) {
-    const entries = Array.from(params.entries()).sort(([aName, aValue], [bName, bValue]) => {
-        const nameOrder = aName < bName ? -1 : aName > bName ? 1 : 0;
-        if (nameOrder !== 0)
-            return nameOrder;
-        return aValue < bValue ? -1 : aValue > bValue ? 1 : 0;
-    });
-    let base = url;
-    for (const [name, value] of entries) {
-        base += `${name}${value}`;
-    }
-    return base;
-}
-async function resolveWebhookUrl(request, webhookUrl) {
-    if (typeof webhookUrl === "function")
-        return webhookUrl(request);
-    return webhookUrl ?? request.url;
-}
-function constantTimeCompare(a, b) {
-    if (a.length !== b.length)
-        return false;
-    try {
-        return timingSafeEqual(Buffer.from(a), Buffer.from(b));
-    }
-    catch (error) {
-        log.debug("timingSafeEqual threw", { error });
-        return false;
-    }
-}
+import{createLogger}from"#internal/logging.js";import{createHmac,timingSafeEqual}from"node:crypto";var log=createLogger(`twilio.verify`);async function resolveTwilioAuthToken(e){let t=e??process.env.TWILIO_AUTH_TOKEN;if(!t)throw Error(`TWILIO_AUTH_TOKEN is required.`);return typeof t==`function`?await t():t}async function verifyTwilioRequest(e,t){let n=await e.text(),r=new URLSearchParams(n),i=await resolveTwilioAuthToken(t.authToken),a=e.headers.get(`x-twilio-signature`)??``;if(!a)throw Error(`twilioChannel: inbound request missing X-Twilio-Signature.`);if(!constantTimeCompare(signTwilioRequest({authToken:i,params:r,url:await resolveWebhookUrl(e,t.webhookUrl)}),a))throw Error(`twilioChannel: inbound request signature mismatch.`);return{body:n,params:r}}function signTwilioRequest(e){let n=buildTwilioSignatureBase(e.url,e.params);return createHmac(`sha1`,e.authToken).update(n).digest(`base64`)}function buildTwilioSignatureBase(e,t){let n=Array.from(t.entries()).sort(([e,t],[n,r])=>{let i=e<n?-1:+(e>n);return i===0?t<r?-1:+(t>r):i}),r=e;for(let[e,t]of n)r+=`${e}${t}`;return r}async function resolveWebhookUrl(e,t){return typeof t==`function`?t(e):t??e.url}function constantTimeCompare(e,t){if(e.length!==t.length)return!1;try{return timingSafeEqual(Buffer.from(e),Buffer.from(t))}catch(e){return log.debug(`timingSafeEqual threw`,{error:e}),!1}}export{buildTwilioSignatureBase,resolveTwilioAuthToken,signTwilioRequest,verifyTwilioRequest};

package/dist/src/public/channels/upload-policy.js

@@ -1,170 +1 @@
-/**
- * Upload-policy authoring helpers for channel routes.
- */
-import { getKnownByteLength } from "#internal/attachments/data.js";
-/**
- * Framework default: 25 MB cap, unrestricted media types. Channels
- * override this per-route; authors override per-channel /
- * channel factory call via the `uploadPolicy` option.
- */
-export const DEFAULT_UPLOAD_POLICY = Object.freeze({
-    allowedMediaTypes: "*",
-    maxBytes: 25 * 1024 * 1024,
-});
-/**
- * Produces a final {@link UploadPolicy} by merging an optional partial
- * override on top of `base` (default: {@link DEFAULT_UPLOAD_POLICY}).
- * Returns `"disabled"` unchanged when passed as the override.
- */
-export function mergeUploadPolicy(override, base = DEFAULT_UPLOAD_POLICY) {
-    if (override === "disabled")
-        return "disabled";
-    if (override === undefined)
-        return base;
-    const maxBytes = override.maxBytes ?? base.maxBytes;
-    const allowedMediaTypes = override.allowedMediaTypes ?? base.allowedMediaTypes;
-    if (maxBytes < 0 || !Number.isFinite(maxBytes)) {
-        throw new RangeError(`UploadPolicy.maxBytes must be a non-negative finite number. Received: ${String(maxBytes)}.`);
-    }
-    return { allowedMediaTypes, maxBytes };
-}
-/**
- * Returns `true` when `policy` rejects every attachment — the explicit
- * `"disabled"` literal, `maxBytes: 0`, or an empty `allowedMediaTypes`
- * array. Channels use this to skip attachment-discovery work.
- */
-export function isUploadsDisabled(policy) {
-    if (policy === "disabled")
-        return true;
-    if (policy.maxBytes === 0)
-        return true;
-    if (Array.isArray(policy.allowedMediaTypes) && policy.allowedMediaTypes.length === 0)
-        return true;
-    return false;
-}
-/**
- * Returns `true` if `mediaType` is accepted under `policy`.
- */
-export function isMediaTypeAllowed(mediaType, policy) {
-    if (policy === "disabled")
-        return false;
-    if (policy.allowedMediaTypes === "*") {
-        return true;
-    }
-    const normalized = mediaType.toLowerCase();
-    for (const pattern of policy.allowedMediaTypes) {
-        const normalizedPattern = pattern.toLowerCase();
-        if (normalizedPattern === normalized) {
-            return true;
-        }
-        if (normalizedPattern.endsWith("/*")) {
-            const prefix = normalizedPattern.slice(0, -1);
-            if (normalized.startsWith(prefix)) {
-                return true;
-            }
-        }
-    }
-    return false;
-}
-/**
- * Evaluates a single `FilePart` against a {@link UploadPolicy}. Returns
- * a {@link UploadPolicyViolation} on rejection, or `null` when the
- * part is either accepted or has a non-local payload (remote URL) whose
- * size cannot be determined without fetching.
- *
- * Order of checks is stable: media-type first (cheap), size second.
- * This keeps channel error responses consistent — a 25 MB disallowed
- * CSV surfaces a 415 instead of a 413 — and mirrors how most HTTP
- * proxies enforce policy.
- */
-export function evaluateFilePart(part, policy) {
-    if (policy === "disabled" || !isMediaTypeAllowed(part.mediaType, policy)) {
-        const allowedMediaTypes = policy === "disabled" || policy.allowedMediaTypes === "*"
-            ? []
-            : [...policy.allowedMediaTypes];
-        const violation = {
-            allowedMediaTypes,
-            kind: "disallowed-media-type",
-            mediaType: part.mediaType,
-        };
-        if (part.filename !== undefined) {
-            return { ...violation, filename: part.filename };
-        }
-        return violation;
-    }
-    const byteLength = getKnownByteLength(part.data);
-    if (byteLength !== null && byteLength > policy.maxBytes) {
-        const violation = {
-            byteLength,
-            kind: "too-large",
-            limit: policy.maxBytes,
-            mediaType: part.mediaType,
-        };
-        if (part.filename !== undefined) {
-            return { ...violation, filename: part.filename };
-        }
-        return violation;
-    }
-    return null;
-}
-/**
- * Walks a `UserContent` array and returns every policy violation, in
- * iteration order. Non-file parts (text, image) are skipped.
- *
- * Returns an empty array when the message is a plain string or when
- * every file part passes. Channels use this to decide between
- * rejecting an inbound request (HTTP) and dropping individual attachments
- * (Slack).
- */
-export function collectUploadPolicyViolations(content, policy) {
-    if (typeof content === "string") {
-        return [];
-    }
-    const violations = [];
-    for (const part of content) {
-        if (part.type !== "file") {
-            continue;
-        }
-        const violation = evaluateFilePart(part, policy);
-        if (violation !== null) {
-            violations.push(violation);
-        }
-    }
-    return violations;
-}
-/**
- * Returns a copy of `content` with every {@link FilePart} that violates
- * `policy` removed.
- *
- * Callers that want a hard-fail contract (HTTP) should use
- * {@link collectUploadPolicyViolations} and return a 4xx response
- * instead. Callers that want best-effort delivery (Slack: drop the bad
- * upload, keep the turn going) use this helper and log the dropped
- * attachments.
- */
-export function stripDisallowedFileParts(content, policy) {
-    if (typeof content === "string") {
-        return content;
-    }
-    const filtered = content.filter((part) => {
-        if (part.type !== "file") {
-            return true;
-        }
-        return evaluateFilePart(part, policy) === null;
-    });
-    return filtered;
-}
-/**
- * Renders a {@link UploadPolicyViolation} as a short human-readable
- * string. Used by channel error responses and warning logs.
- */
-export function formatUploadPolicyViolation(violation) {
-    const fileLabel = violation.filename ?? violation.mediaType;
-    if (violation.kind === "too-large") {
-        return `${fileLabel} (${violation.byteLength} bytes) exceeds the ${violation.limit}-byte upload limit.`;
-    }
-    const allowed = violation.allowedMediaTypes.length > 0
-        ? ` Allowed: ${violation.allowedMediaTypes.join(", ")}.`
-        : "";
-    return `${fileLabel} has media type "${violation.mediaType}" which is not allowed by this route.${allowed}`;
-}
+import{getKnownByteLength}from"#internal/attachments/data.js";var DEFAULT_UPLOAD_POLICY=Object.freeze({allowedMediaTypes:`*`,maxBytes:25*1024*1024});function mergeUploadPolicy(e,n=DEFAULT_UPLOAD_POLICY){if(e===`disabled`)return`disabled`;if(e===void 0)return n;let r=e.maxBytes??n.maxBytes,i=e.allowedMediaTypes??n.allowedMediaTypes;if(r<0||!Number.isFinite(r))throw RangeError(`UploadPolicy.maxBytes must be a non-negative finite number. Received: ${String(r)}.`);return{allowedMediaTypes:i,maxBytes:r}}function isUploadsDisabled(e){return!!(e===`disabled`||e.maxBytes===0||Array.isArray(e.allowedMediaTypes)&&e.allowedMediaTypes.length===0)}function isMediaTypeAllowed(e,t){if(t===`disabled`)return!1;if(t.allowedMediaTypes===`*`)return!0;let n=e.toLowerCase();for(let e of t.allowedMediaTypes){let t=e.toLowerCase();if(t===n)return!0;if(t.endsWith(`/*`)){let e=t.slice(0,-1);if(n.startsWith(e))return!0}}return!1}function evaluateFilePart(t,n){if(n===`disabled`||!isMediaTypeAllowed(t.mediaType,n)){let e={allowedMediaTypes:n===`disabled`||n.allowedMediaTypes===`*`?[]:[...n.allowedMediaTypes],kind:`disallowed-media-type`,mediaType:t.mediaType};return t.filename===void 0?e:{...e,filename:t.filename}}let r=getKnownByteLength(t.data);if(r!==null&&r>n.maxBytes){let e={byteLength:r,kind:`too-large`,limit:n.maxBytes,mediaType:t.mediaType};return t.filename===void 0?e:{...e,filename:t.filename}}return null}function collectUploadPolicyViolations(e,t){if(typeof e==`string`)return[];let n=[];for(let r of e){if(r.type!==`file`)continue;let e=evaluateFilePart(r,t);e!==null&&n.push(e)}return n}function stripDisallowedFileParts(e,t){return typeof e==`string`?e:e.filter(e=>e.type===`file`?evaluateFilePart(e,t)===null:!0)}function formatUploadPolicyViolation(e){let t=e.filename??e.mediaType;if(e.kind===`too-large`)return`${t} (${e.byteLength} bytes) exceeds the ${e.limit}-byte upload limit.`;let n=e.allowedMediaTypes.length>0?` Allowed: ${e.allowedMediaTypes.join(`, `)}.`:``;return`${t} has media type "${e.mediaType}" which is not allowed by this route.${n}`}export{DEFAULT_UPLOAD_POLICY,collectUploadPolicyViolations,evaluateFilePart,formatUploadPolicyViolation,isMediaTypeAllowed,isUploadsDisabled,mergeUploadPolicy,stripDisallowedFileParts};