@sendinel/mcp-server 1.0.4 → 1.0.6

package/build/lib/brand-asset-persist.js

@@ -0,0 +1,161 @@
+// Self-contained port of packages/dashboard/lib/brand-kit/{asset-persist,asset-mutations,asset-persister}.ts
+// — see ssrf-pinned-fetch.ts for why this is a copy, not a cross-package import.
+// R2/video storage is deliberately NOT ported (out of scope) — video uploads via
+// this path are rejected with a clear error rather than silently mishandled.
+import crypto from 'node:crypto';
+import { fileTypeFromBuffer } from 'file-type';
+import { sanitizeSvgBytes } from './svg-sanitize.js';
+export const BRAND_ASSETS_BUCKET = 'brand-assets';
+export const MAX_ASSET_BYTES = 100 * 1024 * 1024;
+export const BRAND_ASSET_KINDS = ['logo', 'image', 'document', 'font', 'avatar', 'video'];
+const MIME_BY_EXT = {
+    '.png': 'image/png',
+    '.jpg': 'image/jpeg',
+    '.jpeg': 'image/jpeg',
+    '.gif': 'image/gif',
+    '.webp': 'image/webp',
+    '.svg': 'image/svg+xml',
+    '.pdf': 'application/pdf',
+    '.md': 'text/markdown',
+    '.txt': 'text/plain',
+    '.csv': 'text/csv',
+    '.json': 'application/json',
+    '.html': 'text/html',
+    '.woff': 'font/woff',
+    '.woff2': 'font/woff2',
+    '.ttf': 'font/ttf',
+    '.otf': 'font/otf',
+    '.mp4': 'video/mp4',
+    '.webm': 'video/webm',
+    '.mov': 'video/quicktime',
+};
+const MAGIC_MIME_ALIASES = {
+    'application/zip': ['application/x-zip-compressed'],
+    'application/x-zip-compressed': ['application/zip'],
+    'text/csv': ['application/vnd.ms-excel', 'text/plain'],
+    'application/vnd.ms-excel': ['text/csv', 'text/plain'],
+};
+export function extOf(filename) {
+    const slash = Math.max(filename.lastIndexOf('/'), filename.lastIndexOf('\\'));
+    const dot = filename.lastIndexOf('.');
+    return dot > slash ? filename.slice(dot).toLowerCase() : '';
+}
+export function resolveMime(filename, declared) {
+    const d = (declared ?? '').split(';')[0].trim().toLowerCase();
+    if (d)
+        return d;
+    return MIME_BY_EXT[extOf(filename)] ?? 'application/octet-stream';
+}
+export function isValidKind(value) {
+    return typeof value === 'string' && BRAND_ASSET_KINDS.includes(value);
+}
+export function inferKind(mime) {
+    if (mime.startsWith('video/'))
+        return 'video';
+    if (mime.startsWith('font/'))
+        return 'font';
+    if (mime.startsWith('image/'))
+        return 'image';
+    return 'document';
+}
+export function refineKindFromName(filename, mime) {
+    if (inferKind(mime) !== 'image')
+        return inferKind(mime);
+    if (/logo|wordmark|brandmark/i.test(filename))
+        return 'logo';
+    if (/avatar|headshot|profile/i.test(filename))
+        return 'avatar';
+    return 'image';
+}
+export function resolveKind(inputKind, filename, mimeType) {
+    if (isValidKind(inputKind))
+        return inputKind;
+    return refineKindFromName(filename, mimeType);
+}
+async function validateMagicBytes(buffer, declaredMime) {
+    const normalized = declaredMime.split(';')[0].trim().toLowerCase();
+    const detected = await fileTypeFromBuffer(buffer);
+    if (!detected) {
+        const prefix = buffer.subarray(0, 512).toString('utf8').trimStart().toLowerCase();
+        if (!normalized.startsWith('text/') &&
+            normalized !== 'application/json' &&
+            (prefix.startsWith('<!doctype html') || prefix.startsWith('<html') || prefix.startsWith('<script'))) {
+            return { ok: false, reason: `Declared MIME ${normalized} appears to contain HTML` };
+        }
+        return { ok: true, reason: null };
+    }
+    const compatible = detected.mime === normalized || (MAGIC_MIME_ALIASES[normalized] ?? []).includes(detected.mime);
+    if (compatible)
+        return { ok: true, reason: null };
+    return { ok: false, reason: `Declared MIME ${normalized} does not match detected MIME ${detected.mime}` };
+}
+function brandAssetStoragePath(projectId, sha256, extension) {
+    return `${projectId}/${sha256}${extension}`;
+}
+/**
+ * Uploads bytes to Sendinel's own Supabase Storage + inserts/dedupes the row
+ * in email.brand_media_assets, using the MCP server's own adminDb() client —
+ * no round-trip through the dashboard's v1 API, no separate SENDINEL_API_KEY.
+ * Video (R2-backed in the dashboard) is not supported via this path.
+ */
+export async function persistBrandAsset(input) {
+    if (input.kind === 'video') {
+        throw new Error('Video uploads are not supported via MCP yet — use the Sendinel dashboard for video assets.');
+    }
+    if (input.bytes.byteLength > MAX_ASSET_BYTES) {
+        throw new Error(`File exceeds the ${MAX_ASSET_BYTES / 1048576} MB limit`);
+    }
+    const mimeType = resolveMime(input.filename, input.mimeType);
+    const magic = await validateMagicBytes(input.bytes, mimeType);
+    if (!magic.ok)
+        throw new Error(magic.reason ?? 'Asset content does not match its declared file type');
+    let bytes = input.bytes;
+    if (mimeType === 'image/svg+xml')
+        bytes = sanitizeSvgBytes(bytes);
+    const sha256 = crypto.createHash('sha256').update(bytes).digest('hex');
+    const storagePath = brandAssetStoragePath(input.projectId, sha256, extOf(input.filename));
+    const existing = await input.sb.schema('email').from('brand_media_assets')
+        .select('id').eq('project_id', input.projectId).eq('sha256', sha256).maybeSingle();
+    if (existing.data?.id) {
+        if (input.brandKitId) {
+            await input.sb.schema('email').from('brand_media_assets')
+                .update({ brand_kit_id: input.brandKitId })
+                .eq('id', existing.data.id)
+                .is('brand_kit_id', null);
+        }
+        return { assetId: existing.data.id, skippedExisting: true, storagePath };
+    }
+    const upload = await input.sb.storage.from(BRAND_ASSETS_BUCKET).upload(storagePath, bytes, {
+        contentType: mimeType,
+        upsert: true,
+    });
+    if (upload.error)
+        throw new Error(upload.error.message);
+    const insert = await input.sb.schema('email').from('brand_media_assets').upsert({
+        org_id: input.orgId,
+        project_id: input.projectId,
+        import_job_id: null,
+        brand_kit_id: input.brandKitId ?? null,
+        folder_id: null,
+        review_status: 'confirmed',
+        kind: input.kind,
+        filename: input.filename.slice(0, 255),
+        original_path: null,
+        storage_path: storagePath,
+        mime_type: mimeType,
+        size_bytes: bytes.byteLength,
+        sha256,
+        source: input.source,
+        storage_backend: 'supabase',
+        collection: input.collection ?? null,
+        tags: input.tags ?? [],
+        metadata: {},
+    }, { onConflict: 'project_id,sha256', ignoreDuplicates: true }).select('id');
+    if (insert.error)
+        throw new Error(insert.error.message);
+    const assetId = insert.data?.[0]?.id || (await input.sb.schema('email').from('brand_media_assets')
+        .select('id').eq('project_id', input.projectId).eq('sha256', sha256).maybeSingle()).data?.id;
+    if (!assetId)
+        throw new Error('Asset was stored but its row could not be resolved');
+    return { assetId: assetId, skippedExisting: !insert.data?.length, storagePath };
+}

package/build/lib/brand-asset-usage.d.ts

@@ -0,0 +1,13 @@
+export declare function normalizeBrandAssetIds(value: unknown): string[];
+export declare function extractBrandAssetIdsFromHtml(html: unknown): string[];
+export declare function recordBrandAssetUsage(input: {
+    client: any;
+    projectId: string;
+    source: string;
+    resourceId: string;
+    html?: unknown;
+    assetIds?: unknown;
+}): Promise<{
+    tracked: number;
+    assetIds: string[];
+}>;

package/build/lib/brand-asset-usage.js

@@ -0,0 +1,46 @@
+const UUID_RE = /^[0-9a-f]{8}-[0-9a-f]{4}-[1-5][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i;
+const ASSET_ATTR_RE = /\b(?:data-brand-asset-id|data-sendinel-asset-id|data-asset-id)=["']([0-9a-f-]{36})["']/gi;
+function normalizeUuid(value) {
+    if (typeof value !== 'string')
+        return null;
+    const trimmed = value.trim();
+    return UUID_RE.test(trimmed) ? trimmed.toLowerCase() : null;
+}
+export function normalizeBrandAssetIds(value) {
+    const raw = Array.isArray(value) ? value : typeof value === 'string' ? [value] : [];
+    const ids = new Set();
+    for (const item of raw) {
+        const id = normalizeUuid(item);
+        if (id)
+            ids.add(id);
+    }
+    return Array.from(ids);
+}
+export function extractBrandAssetIdsFromHtml(html) {
+    const source = typeof html === 'string' ? html : '';
+    const ids = new Set();
+    let match;
+    while ((match = ASSET_ATTR_RE.exec(source)) !== null) {
+        const id = normalizeUuid(match[1]);
+        if (id)
+            ids.add(id);
+    }
+    return Array.from(ids);
+}
+export async function recordBrandAssetUsage(input) {
+    const assetIds = Array.from(new Set([
+        ...normalizeBrandAssetIds(input.assetIds),
+        ...extractBrandAssetIdsFromHtml(input.html),
+    ]));
+    if (assetIds.length === 0)
+        return { tracked: 0, assetIds: [] };
+    const { data, error } = await input.client.rpc('record_brand_asset_references', {
+        p_project_id: input.projectId,
+        p_asset_ids: assetIds,
+        p_source: input.source,
+        p_resource_id: input.resourceId,
+    });
+    if (error)
+        throw new Error(`Failed to record brand asset usage: ${error.message}`);
+    return { tracked: Number(data ?? 0), assetIds };
+}

package/build/lib/email-provider.d.ts

@@ -0,0 +1,19 @@
+export declare const EMAIL_PROVIDER_NAMES: readonly ["resend", "sendgrid", "ses", "postmark", "mailgun", "elastic-email"];
+export type EmailProviderName = (typeof EMAIL_PROVIDER_NAMES)[number];
+type SendArgs = {
+    from: string;
+    to: string;
+    subject: string;
+    html?: string;
+    text?: string;
+    replyTo?: string;
+    headers?: Record<string, string>;
+};
+type SendResult = {
+    provider: EmailProviderName;
+    messageId: string;
+};
+export declare function sendEmailForSite(projectId: string, siteId: string, args: SendArgs): Promise<SendResult>;
+export declare function dkimSelectorForProvider(provider: string | null | undefined): string | null;
+export declare function dkimRemediationText(provider: string | null | undefined): string;
+export {};

package/build/lib/email-provider.js

@@ -0,0 +1,281 @@
+import { Resend } from "resend";
+import { db } from "../db.js";
+import { decrypt } from "../crypto.js";
+export const EMAIL_PROVIDER_NAMES = [
+    "resend",
+    "sendgrid",
+    "ses",
+    "postmark",
+    "mailgun",
+    "elastic-email",
+];
+function normalizeProviderName(value) {
+    if (!value || value === "resend")
+        return "resend";
+    if (value === "elastic_email")
+        return "elastic-email";
+    if (EMAIL_PROVIDER_NAMES.includes(value))
+        return value;
+    throw new Error(`Unsupported email provider: ${value}`);
+}
+function parseFromAddress(from) {
+    const match = from.match(/^(.*?)\s*<([^>]+)>$/);
+    if (!match)
+        return { email: from.trim() };
+    return {
+        name: match[1].trim().replace(/^"|"$/g, ""),
+        email: match[2].trim(),
+    };
+}
+function fromEmailDomain(from) {
+    const { email } = parseFromAddress(from);
+    const domain = email.split("@")[1]?.replace(/[>"]/g, "").trim();
+    if (!domain)
+        throw new Error("Mailgun requires a from email with a domain");
+    return domain;
+}
+async function readError(res) {
+    const body = await res.json().catch(() => null);
+    return body?.Error ?? body?.Message ?? body?.error ?? body?.message ?? `Provider error: ${res.status}`;
+}
+async function resolveElasticTenantKey(projectId) {
+    const { data } = await db()
+        .from("channel_provisions")
+        .select("encrypted_provider_auth_token")
+        .eq("project_id", projectId)
+        .eq("channel", "email")
+        .eq("provider", "elastic_email")
+        .neq("status", "deprovisioned")
+        .order("created_at", { ascending: false })
+        .limit(1)
+        .maybeSingle();
+    const provision = data;
+    if (!provision?.encrypted_provider_auth_token)
+        return null;
+    return decrypt(provision.encrypted_provider_auth_token);
+}
+function providerEnvKey(provider) {
+    switch (provider) {
+        case "resend":
+            return process.env.RESEND_API_KEY ?? null;
+        case "sendgrid":
+            return process.env.SENDGRID_API_KEY ?? null;
+        case "postmark":
+            return process.env.POSTMARK_API_KEY ?? null;
+        case "mailgun":
+            return process.env.MAILGUN_API_KEY ?? null;
+        case "elastic-email":
+            return process.env.ELASTIC_EMAIL_API_KEY ?? null;
+        case "ses":
+            return null;
+    }
+}
+async function resolveProviderConfig(projectId, siteId) {
+    const { data: projectData } = await db()
+        .from("projects")
+        .select("plan, provider_api_key_enc, managed_provider")
+        .eq("id", projectId)
+        .maybeSingle();
+    const project = projectData;
+    const { data: siteData } = await db()
+        .from("sites")
+        .select("provider, provider_api_key_enc, is_shared_domain")
+        .eq("id", siteId)
+        .eq("project_id", projectId)
+        .maybeSingle();
+    const site = siteData;
+    if (!site)
+        throw new Error("Site not found");
+    const provider = normalizeProviderName(site.provider);
+    const siteKey = site.provider_api_key_enc ? decrypt(site.provider_api_key_enc) : null;
+    const projectKey = project?.provider_api_key_enc ? decrypt(project.provider_api_key_enc) : null;
+    if (site.is_shared_domain) {
+        const apiKey = process.env.RESEND_API_KEY;
+        if (!apiKey)
+            throw new Error("RESEND_API_KEY not configured");
+        return { name: "resend", apiKey };
+    }
+    if (project?.plan === "managed" && (!project.managed_provider || project.managed_provider === "sendinel_resend")) {
+        const apiKey = process.env.RESEND_MANAGED_API_KEY;
+        if (!apiKey)
+            throw new Error("RESEND_MANAGED_API_KEY not configured");
+        return { name: "resend", apiKey };
+    }
+    const directKey = siteKey ?? projectKey;
+    if (directKey)
+        return { name: provider, apiKey: directKey };
+    if (provider === "elastic-email") {
+        const tenantKey = await resolveElasticTenantKey(projectId);
+        if (tenantKey)
+            return { name: provider, apiKey: tenantKey };
+    }
+    const envKey = providerEnvKey(provider);
+    if (envKey)
+        return { name: provider, apiKey: envKey };
+    throw new Error(`No API key configured for ${provider}`);
+}
+async function sendViaResend(apiKey, args) {
+    const resend = new Resend(apiKey);
+    const payload = {
+        from: args.from,
+        to: args.to,
+        subject: args.subject,
+    };
+    if (args.html)
+        payload.html = args.html;
+    if (args.text)
+        payload.text = args.text;
+    if (args.replyTo)
+        payload.reply_to = args.replyTo;
+    if (args.headers)
+        payload.headers = args.headers;
+    const { data, error } = await resend.emails.send(payload);
+    if (error || !data?.id)
+        throw new Error(error?.message || "Resend send failed");
+    return data.id;
+}
+async function sendViaElasticEmail(apiKey, args) {
+    const from = parseFromAddress(args.from);
+    const res = await fetch("https://api.elasticemail.com/v4/emails/transactional", {
+        method: "POST",
+        headers: {
+            "Content-Type": "application/json",
+            "X-ElasticEmail-ApiKey": apiKey,
+        },
+        body: JSON.stringify({
+            Recipients: { To: [args.to] },
+            Content: {
+                From: from.email,
+                FromName: from.name,
+                Subject: args.subject,
+                Body: [
+                    ...(args.html ? [{ ContentType: "HTML", Content: args.html }] : []),
+                    ...(args.text ? [{ ContentType: "PlainText", Content: args.text }] : []),
+                ],
+                ReplyTo: args.replyTo,
+                Headers: args.headers,
+            },
+        }),
+    });
+    if (!res.ok)
+        throw new Error(await readError(res));
+    const json = await res.json().catch(() => ({}));
+    return json.MessageID ?? json.messageid ?? json.TransactionID ?? `ee_${Date.now()}`;
+}
+async function sendViaSendGrid(apiKey, args) {
+    const from = parseFromAddress(args.from);
+    const res = await fetch("https://api.sendgrid.com/v3/mail/send", {
+        method: "POST",
+        headers: {
+            Authorization: `Bearer ${apiKey}`,
+            "Content-Type": "application/json",
+        },
+        body: JSON.stringify({
+            personalizations: [{ to: [{ email: args.to }] }],
+            from: { email: from.email, name: from.name },
+            subject: args.subject,
+            content: [
+                ...(args.text ? [{ type: "text/plain", value: args.text }] : []),
+                ...(args.html ? [{ type: "text/html", value: args.html }] : []),
+            ],
+            ...(args.replyTo ? { reply_to: { email: args.replyTo } } : {}),
+            ...(args.headers ? { headers: args.headers } : {}),
+        }),
+    });
+    if (!res.ok)
+        throw new Error(await readError(res));
+    return res.headers.get("x-message-id") || `sg_${Date.now()}`;
+}
+async function sendViaPostmark(apiKey, args) {
+    const res = await fetch("https://api.postmarkapp.com/email", {
+        method: "POST",
+        headers: {
+            Accept: "application/json",
+            "Content-Type": "application/json",
+            "X-Postmark-Server-Token": apiKey,
+        },
+        body: JSON.stringify({
+            From: args.from,
+            To: args.to,
+            Subject: args.subject,
+            HtmlBody: args.html,
+            TextBody: args.text,
+            ...(args.replyTo ? { ReplyTo: args.replyTo } : {}),
+            ...(args.headers ? { Headers: Object.entries(args.headers).map(([Name, Value]) => ({ Name, Value })) } : {}),
+        }),
+    });
+    if (!res.ok)
+        throw new Error(await readError(res));
+    const data = await res.json().catch(() => ({}));
+    return data.MessageID || `pm_${Date.now()}`;
+}
+async function sendViaMailgun(apiKey, args) {
+    const form = new FormData();
+    form.set("from", args.from);
+    form.set("to", args.to);
+    form.set("subject", args.subject);
+    if (args.html)
+        form.set("html", args.html);
+    if (args.text)
+        form.set("text", args.text);
+    if (args.replyTo)
+        form.set("h:Reply-To", args.replyTo);
+    for (const [key, value] of Object.entries(args.headers ?? {})) {
+        form.set(`h:${key}`, value);
+    }
+    const res = await fetch(`https://api.mailgun.net/v3/${fromEmailDomain(args.from)}/messages`, {
+        method: "POST",
+        headers: {
+            Authorization: `Basic ${Buffer.from(`api:${apiKey}`).toString("base64")}`,
+        },
+        body: form,
+    });
+    if (!res.ok)
+        throw new Error(await readError(res));
+    const data = await res.json().catch(() => ({}));
+    const id = typeof data.id === "string" ? data.id.replace(/^<|>$/g, "") : "";
+    return id || `mg_${Date.now()}`;
+}
+export async function sendEmailForSite(projectId, siteId, args) {
+    const config = await resolveProviderConfig(projectId, siteId);
+    switch (config.name) {
+        case "resend":
+            return { provider: config.name, messageId: await sendViaResend(config.apiKey, args) };
+        case "elastic-email":
+            return { provider: config.name, messageId: await sendViaElasticEmail(config.apiKey, args) };
+        case "sendgrid":
+            return { provider: config.name, messageId: await sendViaSendGrid(config.apiKey, args) };
+        case "postmark":
+            return { provider: config.name, messageId: await sendViaPostmark(config.apiKey, args) };
+        case "mailgun":
+            return { provider: config.name, messageId: await sendViaMailgun(config.apiKey, args) };
+        case "ses":
+            throw new Error("SES sending is not yet supported from the MCP server");
+    }
+}
+export function dkimSelectorForProvider(provider) {
+    try {
+        switch (normalizeProviderName(provider)) {
+            case "resend":
+                return "resend._domainkey";
+            case "elastic-email":
+                return "api._domainkey";
+            case "mailgun":
+                return "k1._domainkey";
+            case "sendgrid":
+                return "s1._domainkey / s2._domainkey";
+            case "postmark":
+            case "ses":
+                return null;
+        }
+    }
+    catch {
+        return null;
+    }
+}
+export function dkimRemediationText(provider) {
+    const selector = dkimSelectorForProvider(provider);
+    if (selector)
+        return `Configure DKIM record for your sending provider (${selector})`;
+    return "Configure DKIM record for your sending provider";
+}

package/build/lib/ssrf-pinned-fetch.d.ts

@@ -0,0 +1,16 @@
+import { Agent } from 'undici';
+export type ResolvedPublicAddress = {
+    address: string;
+    family: 4 | 6;
+};
+export declare function createPinnedIpDispatcher(hostname: string, resolved: ResolvedPublicAddress): Agent;
+export declare function fetchPinnedToResolvedIp(url: URL, resolved: ResolvedPublicAddress, init?: RequestInit): Promise<Response>;
+export declare function validatePublicHttpsUrl(rawUrl: string): Promise<{
+    url: URL;
+    resolvedAddress: ResolvedPublicAddress;
+}>;
+export declare function downloadPublicAsset(rawUrl: string, maxBytes?: number): Promise<{
+    url: URL;
+    bytes: Buffer;
+    mimeType: string | null;
+}>;

package/build/lib/ssrf-pinned-fetch.js

@@ -0,0 +1,101 @@
+// Self-contained port of packages/dashboard/lib/ssrf-pinned-fetch.ts +
+// the private-IP/URL validation from app/api/v1/brand-kit/ingest-assets/route.ts.
+// mcp-server has no dependency on the dashboard package (separate deployable
+// app, separate build root), so this is a deliberate, faithful copy rather
+// than a cross-package import — keep both in sync if the SSRF guard changes.
+import dns from 'node:dns/promises';
+import net from 'node:net';
+import { Agent } from 'undici';
+export function createPinnedIpDispatcher(hostname, resolved) {
+    const expectedHost = hostname.toLowerCase();
+    return new Agent({
+        connect: {
+            lookup(requestedHost, _options, callback) {
+                if (String(requestedHost).toLowerCase() !== expectedHost) {
+                    callback(new Error('Pinned fetch attempted to resolve an unexpected host'), []);
+                    return;
+                }
+                callback(null, resolved.address, resolved.family);
+            },
+        },
+        connections: 1,
+    });
+}
+export function fetchPinnedToResolvedIp(url, resolved, init = {}) {
+    const dispatcher = createPinnedIpDispatcher(url.hostname, resolved);
+    return fetch(url, { ...init, dispatcher });
+}
+function isPrivateIp(address) {
+    if (net.isIPv4(address)) {
+        const parts = address.split('.').map((part) => Number(part));
+        const [a, b] = parts;
+        return a === 0 || a === 10 || a === 127 || a >= 224 ||
+            (a === 100 && b >= 64 && b <= 127) ||
+            (a === 169 && b === 254) ||
+            (a === 172 && b >= 16 && b <= 31) ||
+            (a === 192 && (b === 0 || b === 168)) ||
+            (a === 198 && (b === 18 || b === 19));
+    }
+    if (net.isIPv6(address)) {
+        const value = address.toLowerCase();
+        return value === '::1' || value === '::' || value.startsWith('fc') || value.startsWith('fd') ||
+            value.startsWith('fe8') || value.startsWith('fe9') || value.startsWith('fea') || value.startsWith('feb') ||
+            value.startsWith('::ffff:127.') || value.startsWith('::ffff:10.') || value.startsWith('::ffff:192.168.');
+    }
+    return true;
+}
+export async function validatePublicHttpsUrl(rawUrl) {
+    let parsed;
+    try {
+        parsed = new URL(rawUrl);
+    }
+    catch {
+        throw new Error('URL is invalid');
+    }
+    if (parsed.protocol !== 'https:')
+        throw new Error('Only https URLs are supported');
+    if (parsed.username || parsed.password)
+        throw new Error('Credentialed URLs are not supported');
+    const addresses = await dns.lookup(parsed.hostname, { all: true, verbatim: false });
+    if (!addresses.length || addresses.some((entry) => isPrivateIp(entry.address))) {
+        throw new Error('URL must resolve to a public address');
+    }
+    return { url: parsed, resolvedAddress: addresses[0] };
+}
+const FETCH_TIMEOUT_MS = 15_000;
+const MAX_DOWNLOAD_BYTES = 100 * 1024 * 1024;
+export async function downloadPublicAsset(rawUrl, maxBytes = MAX_DOWNLOAD_BYTES) {
+    const { url, resolvedAddress } = await validatePublicHttpsUrl(rawUrl);
+    const controller = new AbortController();
+    const timeout = setTimeout(() => controller.abort(), FETCH_TIMEOUT_MS);
+    try {
+        const response = await fetchPinnedToResolvedIp(url, resolvedAddress, { redirect: 'manual', signal: controller.signal });
+        if (response.status >= 300 && response.status < 400)
+            throw new Error('Redirects are not supported');
+        if (!response.ok)
+            throw new Error(`Fetch failed with HTTP ${response.status}`);
+        const length = Number(response.headers.get('content-length') || '0');
+        if (length > maxBytes)
+            throw new Error(`File exceeds the ${maxBytes / 1048576} MB limit`);
+        const reader = response.body?.getReader();
+        if (!reader)
+            throw new Error('Response body is empty');
+        const chunks = [];
+        let total = 0;
+        for (;;) {
+            const { done, value } = await reader.read();
+            if (done)
+                break;
+            if (!value)
+                continue;
+            total += value.byteLength;
+            if (total > maxBytes)
+                throw new Error(`File exceeds the ${maxBytes / 1048576} MB limit`);
+            chunks.push(value);
+        }
+        return { url, bytes: Buffer.concat(chunks.map((chunk) => Buffer.from(chunk))), mimeType: response.headers.get('content-type') };
+    }
+    finally {
+        clearTimeout(timeout);
+    }
+}

package/build/lib/survey-link-resolver.d.ts

@@ -0,0 +1,6 @@
+type ProjectDbClient = {
+    from: (table: string) => any;
+};
+export declare function renderTemplateString(input: string, vars?: Record<string, string>): string;
+export declare function resolveSurveyShortLink(sb: ProjectDbClient, projectId: string, surveyId: string): Promise<string | null>;
+export {};

package/build/lib/survey-link-resolver.js

@@ -0,0 +1,23 @@
+export function renderTemplateString(input, vars = {}) {
+    return String(input ?? '').replace(/\{\{(\w+)\}\}/g, (_, key) => vars[key] ?? `{{${key}}}`);
+}
+function appBaseUrl() {
+    return (process.env.NEXT_PUBLIC_APP_URL ?? process.env.SENDINEL_APP_URL ?? process.env.APP_URL ?? 'https://sendinel.ai').replace(/\/$/, '');
+}
+export async function resolveSurveyShortLink(sb, projectId, surveyId) {
+    const { data: survey } = await sb
+        .from('surveys')
+        .select('id, short_link_id')
+        .eq('id', surveyId)
+        .eq('project_id', projectId)
+        .maybeSingle();
+    if (!survey?.short_link_id)
+        return null;
+    const { data: link } = await sb
+        .from('short_links')
+        .select('id, slug, project_id')
+        .eq('id', survey.short_link_id)
+        .eq('project_id', projectId)
+        .maybeSingle();
+    return link?.slug ? `${appBaseUrl()}/s/${link.slug}` : null;
+}

package/build/lib/svg-sanitize.d.ts

@@ -0,0 +1,2 @@
+export declare function sanitizeSvg(svg: string): string;
+export declare function sanitizeSvgBytes(bytes: Buffer | Uint8Array): Buffer;