@noodleseed/one 0.175.1 → 0.177.0

package/node_modules/@noodle-borg/service/dist/business-information/validation.js

@@ -1,3 +1,4 @@
+import { looksLikePaymentCard } from '../payment-card.js';
 import { MANAGED_RETENTION_DAYS } from './contracts.js';
 export const MAX_PAYLOAD_BYTES = 32 * 1024;
 export const MAX_PAYLOAD_DEPTH = 6;
@@ -113,28 +114,6 @@ function validateString(value, path) {
         throw new PayloadValidationError('health_biometric_value', `${path} contains health or biometric data`);
     }
 }
-function looksLikePaymentCard(value) {
-    const candidates = value.match(/(?:\d[ -]?){13,19}/g) ?? [];
-    return candidates.some((candidate) => {
-        const digits = candidate.replace(/\D/g, '');
-        return digits.length >= 13 && digits.length <= 19 && luhnValid(digits);
-    });
-}
-function luhnValid(digits) {
-    let sum = 0;
-    let double = false;
-    for (let index = digits.length - 1; index >= 0; index -= 1) {
-        let digit = Number(digits[index]);
-        if (double) {
-            digit *= 2;
-            if (digit > 9)
-                digit -= 9;
-        }
-        sum += digit;
-        double = !double;
-    }
-    return sum % 10 === 0;
-}
 function isPlainObject(value) {
     if (typeof value !== 'object' || value === null || Array.isArray(value))
         return false;

package/node_modules/@noodle-borg/service/dist/channels/360dialog.js

@@ -2,6 +2,7 @@ import { timingSafeEqual } from 'node:crypto';
 import { ChannelError, } from '@noodle-borg/assistant-gateway/portable';
 import { guardedFetch } from '@noodle-borg/connector-http';
 import { z } from 'zod';
+import { boundedJson, cloudApiHealth, cloudApiSend, cloudApiSetBlocked, } from './provider.js';
 export const WHATSAPP_CALLBACK_HEADER = 'x-noodle-webhook-secret';
 const identifier = z.string().min(1).max(512);
 const timestamp = z
@@ -17,6 +18,10 @@ const valueSchema = z.object({
         id: identifier,
         from: z.string().max(128).optional(),
         user_id: z.string().max(128).optional(),
+        // Meta's business-scoped user id field for senders who adopted usernames (Meta BSUID guide,
+        // https://developers.facebook.com/documentation/business-messaging/whatsapp/business-scoped-user-ids/,
+        // read 2026-09-22); `from` still wins whenever the phone number is present.
+        from_user_id: z.string().max(128).optional(),
         timestamp,
         type: z.string().max(64),
         text: z.object({ body: z.string().max(1 << 20) }).optional(),
@@ -79,10 +84,11 @@ export function parseWhatsAppWebhook(input, phoneNumberId) {
                 throw new ChannelError('asset_mismatch');
             for (const message of value.messages ?? []) {
                 let address;
+                const opaque = message.user_id ?? message.from_user_id;
                 if (message.from && /^[1-9]\d{5,14}$/.test(message.from))
                     address = { kind: 'phone', value: message.from };
-                else if (message.user_id && /^[A-Z]{2}\.[A-Za-z0-9]{1,124}$/.test(message.user_id))
-                    address = { kind: 'opaque', value: message.user_id };
+                else if (opaque && /^[A-Z]{2}\.[A-Za-z0-9]{1,124}$/.test(opaque))
+                    address = { kind: 'opaque', value: opaque };
                 else
                     throw new ChannelError('recipient_invalid');
                 const button = message.type === 'interactive' && message.interactive?.type === 'button_reply'
@@ -103,32 +109,6 @@ export function parseWhatsAppWebhook(input, phoneNumberId) {
         }
     return { messages, statuses };
 }
-/** A 4xx that judges the payload itself; auth, throttling and timeouts are no reason to resend differently. */
-function rejectedPayload(status) {
-    return status >= 400 && status < 500 && ![401, 403, 408, 429].includes(status);
-}
-async function boundedJson(response) {
-    const reader = response.body?.getReader();
-    if (!reader)
-        throw new ChannelError('provider_response_invalid');
-    const chunks = [];
-    let size = 0;
-    try {
-        for (;;) {
-            const result = await reader.read();
-            if (result.done)
-                break;
-            size += result.value.byteLength;
-            if (size > 65_536)
-                throw new ChannelError('provider_response_invalid');
-            chunks.push(result.value);
-        }
-        return JSON.parse(Buffer.concat(chunks).toString('utf8'));
-    }
-    finally {
-        await reader.cancel().catch(() => undefined);
-    }
-}
 export class Dialog360 {
     apiKey;
     fetcher;
@@ -146,23 +126,7 @@ export class Dialog360 {
         });
     }
     async health() {
-        const response = await this.request('/health_status?fields=id');
-        if (!response.ok)
-            throw new ChannelError('provider_unavailable');
-        const parsed = z
-            .object({
-            id: identifier,
-            health_status: z.object({ can_send_message: z.enum(['AVAILABLE', 'LIMITED', 'BLOCKED']) }),
-        })
-            .safeParse(await boundedJson(response));
-        if (!parsed.success)
-            throw new ChannelError('provider_response_invalid');
-        return {
-            phoneNumberId: parsed.data.id,
-            // LIMITED meets provider messaging requirements; provider limits still govern each send.
-            canSend: parsed.data.health_status.can_send_message !== 'BLOCKED',
-            status: parsed.data.health_status.can_send_message,
-        };
+        return cloudApiHealth(await this.request('/health_status?fields=id'));
     }
     async webhook() {
         const response = await this.request('/v1/configs/webhook');
@@ -194,107 +158,39 @@ export class Dialog360 {
             throw new ChannelError('webhook_configuration_failed');
         await response.body?.cancel();
     }
-    async setBlocked(phone, blocked) {
-        try {
-            const response = await this.request('/block_users', blocked ? 'POST' : 'DELETE', {
-                messaging_product: 'whatsapp',
-                block_users: [{ user: phone }],
-            });
-            if (!response.ok) {
-                await response.body?.cancel();
-                return {
-                    state: response.status >= 500 ? 'unknown' : 'error',
-                    code: `provider_http_${response.status}`,
-                };
-            }
-            const field = blocked ? 'added_users' : 'removed_users';
-            const parsed = z
-                .object({
-                block_users: z.object({
-                    [field]: z.array(z.object({ input: z.string(), wa_id: z.string() })),
-                }),
-            })
-                .safeParse(await boundedJson(response));
-            return parsed.success &&
-                parsed.data.block_users[field]?.some((user) => user.input === phone || user.wa_id === phone)
-                ? { state: 'confirmed' }
-                : { state: 'unknown', code: 'provider_receipt_invalid' };
-        }
-        catch {
-            return { state: 'unknown', code: 'provider_outcome_unknown' };
-        }
+    setBlocked(phone, blocked) {
+        return cloudApiSetBlocked((...args) => this.request(...args), phone, blocked);
     }
-    /**
-     * One reply. With buttons the review goes as an interactive reply-button message: at most three
-     * buttons, titles up to 20 characters, ids up to 256 and a body up to 1024 characters, per the
-     * Meta Cloud API reply-buttons reference that the 360dialog Cloud API host relays (360dialog's own
-     * interactive-messages page states only the three-button limit; its webhook reference gives the
-     * inbound shape); all checked 2026-09-21. A payload the provider rejects outright dispatched
-     * nothing, so the same text goes plain instead; an ambiguous outcome is never retried.
-     */
-    async send(input) {
-        if (!input.text || input.text.length > 4096)
-            return { state: 'failed', code: 'reply_invalid' };
-        const buttons = input.buttons ?? [];
-        const interactive = buttons.length > 0 &&
-            buttons.length <= 3 &&
-            input.text.length <= 1024 &&
-            buttons.every((button) => button.id.length <= 256 && button.title.length <= 20);
-        const envelope = {
-            messaging_product: 'whatsapp',
-            recipient_type: 'individual',
-            ...(input.to.kind === 'phone' ? { to: input.to.value } : { recipient: input.to.value }),
-        };
-        try {
-            let code;
-            let response = interactive
-                ? await this.request('/messages', 'POST', {
-                    ...envelope,
-                    type: 'interactive',
-                    interactive: {
-                        type: 'button',
-                        body: { text: input.text },
-                        action: {
-                            buttons: buttons.map((button) => ({
-                                type: 'reply',
-                                reply: { id: button.id, title: button.title },
-                            })),
-                        },
-                    },
-                })
-                : undefined;
-            if (response !== undefined && !response.ok && rejectedPayload(response.status)) {
-                await response.body?.cancel();
-                code = 'interactive_rejected';
-                response = undefined;
-            }
-            if (response === undefined)
-                response = await this.request('/messages', 'POST', {
-                    ...envelope,
-                    type: 'text',
-                    text: { body: input.text, preview_url: false },
-                });
-            if (!response.ok) {
-                await response.body?.cancel();
-                return {
-                    state: response.status >= 500 || response.status === 408 ? 'unknown' : 'failed',
-                    code: `provider_http_${response.status}`,
-                };
-            }
-            const parsed = z
-                .object({ messages: z.array(z.object({ id: identifier })).length(1) })
-                .safeParse(await boundedJson(response));
-            return parsed.success
-                ? {
-                    state: 'accepted',
-                    providerMessageId: parsed.data.messages[0].id,
-                    ...(code === undefined ? {} : { code }),
-                }
-                : { state: 'unknown', code: 'provider_receipt_invalid' };
-        }
-        catch {
-            return { state: 'unknown', code: 'send_outcome_unknown' };
-        }
+    /** One reply; request bodies and fallback semantics are shared in `cloudApiSend`. */
+    send(input) {
+        return cloudApiSend((...args) => this.request(...args), input);
     }
 }
+/**
+ * One 360dialog binding as a provider: its channel key's adapter plus its per-binding callback secret.
+ * The callback carries the secret as a header; an existing callback owned by another URL is never
+ * taken over.
+ */
+export function dialog360Provider(adapter, webhookSecret) {
+    return {
+        health: () => adapter.health(),
+        setBlocked: (phone, blocked) => adapter.setBlocked(phone, blocked),
+        send: (input) => adapter.send(input),
+        async inspectWebhook(url) {
+            const current = await adapter.webhook();
+            return {
+                matches: current.url === url,
+                authenticated: verifyWhatsAppWebhookSecret(current.headers?.[WHATSAPP_CALLBACK_HEADER], webhookSecret),
+            };
+        },
+        async configureWebhook(url) {
+            const existing = await adapter.webhook();
+            if (existing.url && existing.url !== url)
+                throw new ChannelError('webhook_ownership_conflict');
+            if (existing.url !== url ||
+                !verifyWhatsAppWebhookSecret(existing.headers?.[WHATSAPP_CALLBACK_HEADER], webhookSecret))
+                await adapter.configureWebhook(url, webhookSecret);
+        },
+    };
+}
 //# sourceMappingURL=360dialog.js.map

package/node_modules/@noodle-borg/service/dist/channels/composition.js

@@ -11,6 +11,7 @@ export async function createPostgresWhatsApp(pool, secretBox, options) {
     return {
         store,
         worker: new ChannelWorkerLoop((code) => (options.logger ?? noopLogger).warn('assistant.channel.worker', { code })),
+        ...(options.whatsappMeta ? { meta: options.whatsappMeta } : {}),
     };
 }
 export function createWhatsAppRuntime(options, deps, history) {

package/node_modules/@noodle-borg/service/dist/channels/meta-cloud.js

@@ -0,0 +1,102 @@
+import { ChannelError } from '@noodle-borg/assistant-gateway/portable';
+import { guardedFetch } from '@noodle-borg/connector-http';
+import { z } from 'zod';
+import { boundedJson, cloudApiHealth, cloudApiSend, cloudApiSetBlocked, } from './provider.js';
+/**
+ * Graph API version for every Meta call. Graph API changelog (read 2026-09-22,
+ * https://developers.facebook.com/docs/graph-api/changelog): v25.0 released 2026-02-18 and available
+ * until 2028-07-29; v26.0 (2026-07-29) is newer, but Meta's WhatsApp references and Noodle Seed's
+ * App Dashboard examples use v25.0. Operators may pin another with NOODLE_WHATSAPP_META_GRAPH_VERSION.
+ */
+export const WHATSAPP_META_GRAPH_VERSION = 'v25.0';
+/** The one callback every Meta-connected number shares; bindings are found by phone-number id. */
+export const WHATSAPP_META_CALLBACK_PATH = '/v1/channels/whatsapp/meta';
+const node = /^\d{1,32}$/;
+const subscriptions = z.object({
+    data: z
+        .array(z.object({ whatsapp_business_api_data: z.object({ id: z.string().max(64) }) }))
+        .max(100),
+});
+/**
+ * One Meta-connected number, called directly on graph.facebook.com with the business's token.
+ * Sources, all read 2026-09-22 and using v25.0 in their examples:
+ * - send: POST /{phone_number_id}/messages, Bearer token, `messages[].id` receipt
+ *   (https://developers.facebook.com/docs/whatsapp/cloud-api/reference/messages); a business-scoped
+ *   user id goes in `recipient` instead of `to`
+ *   (https://developers.facebook.com/documentation/business-messaging/whatsapp/business-scoped-user-ids/).
+ * - health: GET /{node}?fields=health_status returns `id` and `health_status.can_send_message`
+ *   AVAILABLE | LIMITED | BLOCKED (https://developers.facebook.com/docs/whatsapp/cloud-api/health-status).
+ * - block: POST | DELETE /{phone_number_id}/block_users, receipts in `block_users.added_users` /
+ *   `removed_users` (https://developers.facebook.com/docs/whatsapp/cloud-api/block-users).
+ * - webhooks: GET | POST /{waba_id}/subscribed_apps; the GET lists
+ *   `data[].whatsapp_business_api_data.id`, the POST answers `{"success": true}`
+ *   (https://developers.facebook.com/docs/whatsapp/embedded-signup/webhooks).
+ */
+export class MetaCloud {
+    token;
+    asset;
+    app;
+    fetcher;
+    phone;
+    constructor(token, asset, app, fetcher = (url, init) => guardedFetch(new URL(url), init)) {
+        this.token = token;
+        this.asset = asset;
+        this.app = app;
+        this.fetcher = fetcher;
+        if (!/^v\d{1,3}\.\d{1,2}$/.test(app.graphVersion) || !node.test(app.appId))
+            throw new ChannelError('provider_configuration_invalid');
+        this.phone = (path, method, body) => this.request(asset.phoneNumberId, path, method, body);
+    }
+    async request(id, path, method = 'GET', body) {
+        if (!node.test(id))
+            throw new ChannelError('provider_asset_invalid');
+        return this.fetcher(`https://graph.facebook.com/${this.app.graphVersion}/${id}${path}`, {
+            method,
+            headers: { authorization: `Bearer ${this.token}`, 'content-type': 'application/json' },
+            ...(body === undefined ? {} : { body: JSON.stringify(body) }),
+            redirect: 'manual',
+            signal: AbortSignal.timeout(15_000),
+        });
+    }
+    async health() {
+        return cloudApiHealth(await this.phone('?fields=id,health_status'));
+    }
+    setBlocked(phone, blocked) {
+        return cloudApiSetBlocked(this.phone, phone, blocked);
+    }
+    send(input) {
+        return cloudApiSend(this.phone, input);
+    }
+    async subscribed() {
+        const response = await this.request(this.asset.wabaId, '/subscribed_apps');
+        if (!response.ok) {
+            await response.body?.cancel();
+            throw new ChannelError('provider_unavailable');
+        }
+        const parsed = subscriptions.safeParse(await boundedJson(response));
+        if (!parsed.success)
+            throw new ChannelError('provider_response_invalid');
+        return parsed.data.data.some((app) => app.whatsapp_business_api_data.id === this.app.appId);
+    }
+    /**
+     * `matches` means the WABA delivers to this Meta app; `authenticated` means the platform holds the
+     * app secret that signs callbacks, which constructing this adapter requires. The app-level
+     * callback URL is set once in the Meta App Dashboard and is not read here.
+     */
+    async inspectWebhook(_url) {
+        return { matches: await this.subscribed(), authenticated: true };
+    }
+    async configureWebhook(_url) {
+        if (await this.subscribed())
+            return;
+        const response = await this.request(this.asset.wabaId, '/subscribed_apps', 'POST');
+        const parsed = response.ok
+            ? z.object({ success: z.literal(true) }).safeParse(await boundedJson(response))
+            : undefined;
+        if (!response.ok)
+            await response.body?.cancel();
+        if (!parsed?.success)
+            throw new ChannelError('webhook_configuration_failed');
+    }
+}
+//# sourceMappingURL=meta-cloud.js.map

package/node_modules/@noodle-borg/service/dist/channels/provider.js

@@ -0,0 +1,187 @@
+import { ChannelError, } from '@noodle-borg/assistant-gateway/portable';
+import { z } from 'zod';
+const identifier = z.string().min(1).max(512);
+/** A 4xx that judges the payload itself; auth, throttling and timeouts are no reason to resend differently. */
+function rejectedPayload(status) {
+    return status >= 400 && status < 500 && ![401, 403, 408, 429].includes(status);
+}
+export async function boundedJson(response) {
+    const reader = response.body?.getReader();
+    if (!reader)
+        throw new ChannelError('provider_response_invalid');
+    const chunks = [];
+    let size = 0;
+    try {
+        for (;;) {
+            const result = await reader.read();
+            if (result.done)
+                break;
+            size += result.value.byteLength;
+            if (size > 65_536)
+                throw new ChannelError('provider_response_invalid');
+            chunks.push(result.value);
+        }
+        return JSON.parse(Buffer.concat(chunks).toString('utf8'));
+    }
+    finally {
+        await reader.cancel().catch(() => undefined);
+    }
+}
+const sendState = z.enum(['AVAILABLE', 'LIMITED', 'BLOCKED']);
+/**
+ * Health errors that block only business-initiated conversations. 141006 reads "There is an error
+ * with the payment method. This will block business initiated conversations." (observed on a WABA
+ * with no payment method, 2026-09-22). Channels only reply inside the customer service window,
+ * where non-template messages are free (https://developers.facebook.com/docs/whatsapp/pricing/).
+ */
+const REPLY_SAFE_BLOCKS = new Set([141006]);
+/**
+ * Parse a Cloud API health read. The aggregate `can_send_message` is BLOCKED when any entity is;
+ * it is downgraded to LIMITED only when the phone number itself can send and every blocked entity
+ * names nothing but reply-safe errors.
+ */
+export async function cloudApiHealth(response) {
+    if (!response.ok)
+        throw new ChannelError('provider_unavailable');
+    const parsed = z
+        .object({
+        id: identifier,
+        health_status: z.object({
+            can_send_message: sendState,
+            entities: z
+                .array(z.object({
+                entity_type: z.string().max(64),
+                can_send_message: sendState.optional(),
+                errors: z
+                    .array(z.object({ error_code: z.number().int() }))
+                    .max(50)
+                    .optional(),
+            }))
+                .max(20)
+                .optional(),
+        }),
+    })
+        .safeParse(await boundedJson(response));
+    if (!parsed.success)
+        throw new ChannelError('provider_response_invalid');
+    const { can_send_message: aggregate, entities = [] } = parsed.data.health_status;
+    const phone = entities.find((entity) => entity.entity_type === 'PHONE_NUMBER');
+    const replySafe = aggregate === 'BLOCKED' &&
+        phone !== undefined &&
+        phone.can_send_message !== 'BLOCKED' &&
+        entities
+            .filter((entity) => entity.can_send_message === 'BLOCKED')
+            .every(({ errors = [] }) => {
+            return (errors.length > 0 && errors.every((error) => REPLY_SAFE_BLOCKS.has(error.error_code)));
+        });
+    const status = replySafe ? 'LIMITED' : aggregate;
+    return {
+        phoneNumberId: parsed.data.id,
+        // LIMITED meets provider messaging requirements; provider limits still govern each send.
+        canSend: status !== 'BLOCKED',
+        status,
+    };
+}
+export async function cloudApiSetBlocked(request, phone, blocked) {
+    try {
+        const response = await request('/block_users', blocked ? 'POST' : 'DELETE', {
+            messaging_product: 'whatsapp',
+            block_users: [{ user: phone }],
+        });
+        if (!response.ok) {
+            await response.body?.cancel();
+            return {
+                state: response.status >= 500 ? 'unknown' : 'error',
+                code: `provider_http_${response.status}`,
+            };
+        }
+        const field = blocked ? 'added_users' : 'removed_users';
+        const parsed = z
+            .object({
+            block_users: z.object({
+                [field]: z.array(z.object({ input: z.string(), wa_id: z.string() })),
+            }),
+        })
+            .safeParse(await boundedJson(response));
+        return parsed.success &&
+            parsed.data.block_users[field]?.some((user) => user.input === phone || user.wa_id === phone)
+            ? { state: 'confirmed' }
+            : { state: 'unknown', code: 'provider_receipt_invalid' };
+    }
+    catch {
+        return { state: 'unknown', code: 'provider_outcome_unknown' };
+    }
+}
+/**
+ * One reply. With buttons the review goes as an interactive reply-button message: at most three
+ * buttons, titles up to 20 characters, ids up to 256 and a body up to 1024 characters, per the
+ * Meta Cloud API reply-buttons reference that the 360dialog Cloud API host relays (360dialog's own
+ * interactive-messages page states only the three-button limit; its webhook reference gives the
+ * inbound shape); all checked 2026-09-21. A payload the provider rejects outright dispatched
+ * nothing, so the same text goes plain instead; an ambiguous outcome is never retried.
+ */
+export async function cloudApiSend(request, input) {
+    if (!input.text || input.text.length > 4096)
+        return { state: 'failed', code: 'reply_invalid' };
+    const buttons = input.buttons ?? [];
+    const interactive = buttons.length > 0 &&
+        buttons.length <= 3 &&
+        input.text.length <= 1024 &&
+        buttons.every((button) => button.id.length <= 256 && button.title.length <= 20);
+    const envelope = {
+        messaging_product: 'whatsapp',
+        recipient_type: 'individual',
+        ...(input.to.kind === 'phone' ? { to: input.to.value } : { recipient: input.to.value }),
+    };
+    try {
+        let code;
+        let response = interactive
+            ? await request('/messages', 'POST', {
+                ...envelope,
+                type: 'interactive',
+                interactive: {
+                    type: 'button',
+                    body: { text: input.text },
+                    action: {
+                        buttons: buttons.map((button) => ({
+                            type: 'reply',
+                            reply: { id: button.id, title: button.title },
+                        })),
+                    },
+                },
+            })
+            : undefined;
+        if (response !== undefined && !response.ok && rejectedPayload(response.status)) {
+            await response.body?.cancel();
+            code = 'interactive_rejected';
+            response = undefined;
+        }
+        if (response === undefined)
+            response = await request('/messages', 'POST', {
+                ...envelope,
+                type: 'text',
+                text: { body: input.text, preview_url: false },
+            });
+        if (!response.ok) {
+            await response.body?.cancel();
+            return {
+                state: response.status >= 500 || response.status === 408 ? 'unknown' : 'failed',
+                code: `provider_http_${response.status}`,
+            };
+        }
+        const parsed = z
+            .object({ messages: z.array(z.object({ id: identifier })).length(1) })
+            .safeParse(await boundedJson(response));
+        return parsed.success
+            ? {
+                state: 'accepted',
+                providerMessageId: parsed.data.messages[0].id,
+                ...(code === undefined ? {} : { code }),
+            }
+            : { state: 'unknown', code: 'provider_receipt_invalid' };
+    }
+    catch {
+        return { state: 'unknown', code: 'send_outcome_unknown' };
+    }
+}
+//# sourceMappingURL=provider.js.map