@sendinel/mcp-server 1.0.3 → 1.0.5

package/build/tools/brand-kit.js

@@ -0,0 +1,277 @@
+import { z } from 'zod';
+import { adminDb } from '../db.js';
+import { getProjectId } from '../project.js';
+import { downloadPublicAsset } from '../lib/ssrf-pinned-fetch.js';
+import { BRAND_ASSET_KINDS, isValidKind, persistBrandAsset, resolveKind, resolveMime, } from '../lib/brand-asset-persist.js';
+const j = (data) => ({ content: [{ type: 'text', text: JSON.stringify(data, null, 2) }] });
+function brandKitApiBase() {
+    return (process.env.NEXT_PUBLIC_APP_URL ?? process.env.SENDINEL_APP_URL ?? process.env.APP_URL ?? 'https://sendinel.ai').replace(/\/$/, '');
+}
+// import_brand_kit_text parses free-form Brand Core/Brand Brain/Content Library
+// markdown into voice fields, colors, templates, and social posts — a different,
+// more complex capability than the media-library asset tools below. Left on the
+// HTTP-proxy path (still requires SENDINEL_API_KEY) rather than re-implemented
+// here; see #2356 for the media-library-scoped fix this file otherwise contains.
+async function callBrandKitApi(path, body) {
+    const apiKey = process.env.SENDINEL_API_KEY;
+    if (!apiKey)
+        return { ok: false, error: 'SENDINEL_API_KEY is required to drive this brand_kit tool from MCP' };
+    const res = await fetch(`${brandKitApiBase()}${path}`, {
+        method: 'POST',
+        headers: {
+            Authorization: `Bearer ${apiKey}`,
+            'X-Sendinel-Project-Id': getProjectId(),
+            'Content-Type': 'application/json',
+        },
+        body: JSON.stringify(body),
+    });
+    const text = await res.text();
+    let parsed = text;
+    try {
+        parsed = JSON.parse(text);
+    }
+    catch { }
+    if (!res.ok)
+        return { ok: false, error: parsed || `HTTP ${res.status}` };
+    return { ok: true, data: parsed };
+}
+async function getProjectOrgId(projectId) {
+    const { data, error } = await adminDb()
+        .schema('email')
+        .from('projects')
+        .select('org_id')
+        .eq('id', projectId)
+        .maybeSingle();
+    if (error)
+        throw new Error(error.message);
+    if (!data?.org_id)
+        throw new Error('Project not found');
+    return data.org_id;
+}
+const kindSchema = z.enum(BRAND_ASSET_KINDS);
+export function registerBrandKitTools(server) {
+    server.registerTool('import_brand_kit_text', {
+        title: 'Import Brand Kit Text',
+        annotations: {
+            readOnlyHint: false,
+            destructiveHint: false,
+            idempotentHint: false,
+            openWorldHint: false,
+        },
+        description: 'Import raw Brand Core / Brand Brain / Content Library / Brand Kit markdown text into the current project.',
+        inputSchema: {
+            text: z.string().min(1).describe('Raw markdown text from the Brand Core / Brand Kit companion output.'),
+        },
+    }, async ({ text }) => {
+        const result = await callBrandKitApi('/api/v1/brand-kit/import-text', { text });
+        return result.ok ? j(result.data) : j({ error: result.error });
+    });
+    server.registerTool('list_brand_assets', {
+        title: 'List Brand Assets',
+        annotations: {
+            readOnlyHint: true,
+            destructiveHint: false,
+            idempotentHint: true,
+            openWorldHint: false,
+        },
+        description: 'List the current project\'s confirmed brand assets (logos, images, avatars, documents, fonts, videos) from the media library, with download URLs. Call this before recommending or generating content so suggestions can reference real uploaded assets instead of guessing what exists.',
+        inputSchema: {
+            kind: kindSchema.optional().describe('Filter to one asset kind'),
+            collection: z.string().optional().describe('Filter to one collection name'),
+            tag: z.string().optional().describe('Filter to assets carrying this tag'),
+            limit: z.number().int().min(1).max(100).optional().describe('Max assets to return (default 50, max 100)'),
+        },
+    }, async ({ kind, collection, tag, limit }) => {
+        const projectId = getProjectId();
+        const sb = adminDb();
+        const cappedLimit = Math.min(100, Math.max(1, limit ?? 50));
+        const { data, error } = await sb
+            .schema('email')
+            .from('brand_media_assets')
+            .select('id, kind, filename, storage_path, mime_type, size_bytes, collection, tags, last_referenced_at, last_referenced_source, last_referenced_resource_id, reference_count, created_at, storage_backend')
+            .eq('project_id', projectId)
+            .eq('review_status', 'confirmed')
+            .order('created_at', { ascending: false });
+        if (error)
+            return j({ error: error.message });
+        // Project-wide across ALL brand kits — deliberately not scoped to a single
+        // kit_id, so projects with more than one kit aren't silently truncated.
+        let rows = (data ?? []);
+        if (kind)
+            rows = rows.filter((r) => r.kind === kind);
+        if (collection)
+            rows = rows.filter((r) => r.collection === collection);
+        if (tag)
+            rows = rows.filter((r) => Array.isArray(r.tags) && r.tags.includes(tag));
+        const countsByKind = {};
+        for (const r of data ?? []) {
+            const k = String(r.kind);
+            countsByKind[k] = (countsByKind[k] ?? 0) + 1;
+        }
+        const totalMatching = rows.length;
+        const page = rows.slice(0, cappedLimit);
+        const paths = page.filter((r) => r.storage_backend !== 'r2').map((r) => r.storage_path);
+        const signedByPath = new Map();
+        if (paths.length > 0) {
+            const { data: signed } = await sb.storage.from('brand-assets').createSignedUrls(paths, 3600, { download: true });
+            for (const entry of signed ?? []) {
+                if (entry.path && entry.signedUrl)
+                    signedByPath.set(entry.path, entry.signedUrl);
+            }
+        }
+        return j({
+            assets: page.map((r) => ({
+                id: r.id,
+                kind: r.kind,
+                filename: r.filename,
+                collection: r.collection,
+                tags: r.tags ?? [],
+                mime_type: r.mime_type,
+                size_bytes: r.size_bytes,
+                created_at: r.created_at,
+                last_referenced_at: r.last_referenced_at,
+                last_referenced_source: r.last_referenced_source,
+                last_referenced_resource_id: r.last_referenced_resource_id,
+                reference_count: r.reference_count ?? 0,
+                unused: !r.last_referenced_at && !(r.reference_count ?? 0),
+                url: signedByPath.get(r.storage_path) ?? null,
+            })),
+            total_confirmed_assets: (data ?? []).length,
+            total_matching_filters: totalMatching,
+            returned: page.length,
+            truncated: totalMatching > page.length,
+            counts_by_kind: countsByKind,
+        });
+    });
+    server.registerTool('upload_brand_asset', {
+        title: 'Upload Brand Asset',
+        annotations: {
+            readOnlyHint: false,
+            destructiveHint: false,
+            idempotentHint: false,
+            openWorldHint: true,
+        },
+        description: 'Upload a file to the current project\'s media library directly (base64-encoded bytes). For assets already hosted at a public HTTPS URL, use ingest_brand_assets_by_url instead. Video uploads are not supported via MCP yet.',
+        inputSchema: {
+            filename: z.string().min(1).max(255).describe('Original filename, including extension (e.g. logo.png)'),
+            content_base64: z.string().min(1).describe('Base64-encoded file bytes (no data: prefix)'),
+            kind: kindSchema.optional().describe('Asset kind. Inferred from filename/mime if omitted.'),
+            collection: z.string().max(120).optional(),
+            tags: z.array(z.string()).max(50).optional(),
+            brand_kit_id: z.string().uuid().optional(),
+        },
+    }, async ({ filename, content_base64, kind, collection, tags, brand_kit_id }) => {
+        const projectId = getProjectId();
+        let bytes;
+        try {
+            bytes = Buffer.from(content_base64, 'base64');
+        }
+        catch {
+            return j({ error: 'content_base64 is not valid base64' });
+        }
+        if (bytes.byteLength === 0)
+            return j({ error: 'Decoded file is empty' });
+        try {
+            const orgId = await getProjectOrgId(projectId);
+            if (brand_kit_id) {
+                const { data: kitRow } = await adminDb().schema('email').from('brand_kits')
+                    .select('id').eq('id', brand_kit_id).eq('project_id', projectId).maybeSingle();
+                if (!kitRow)
+                    return j({ error: 'brand_kit_id not found in this project' });
+            }
+            const mimeType = resolveMime(filename);
+            const resolvedKind = resolveKind(kind, filename, mimeType);
+            const persisted = await persistBrandAsset({
+                sb: adminDb(),
+                orgId,
+                projectId,
+                bytes,
+                filename,
+                mimeType,
+                kind: resolvedKind,
+                source: 'uploaded',
+                collection: collection ?? null,
+                tags: tags ?? [],
+                brandKitId: brand_kit_id ?? null,
+            });
+            return j({
+                ok: true,
+                asset_id: persisted.assetId,
+                filename,
+                kind: resolvedKind,
+                mime_type: mimeType,
+                skipped_existing: persisted.skippedExisting,
+            });
+        }
+        catch (error) {
+            return j({ error: error instanceof Error ? error.message : 'Upload failed' });
+        }
+    });
+    server.registerTool('ingest_brand_assets_by_url', {
+        title: 'Ingest Brand Assets By URL',
+        annotations: {
+            readOnlyHint: false,
+            destructiveHint: false,
+            idempotentHint: false,
+            openWorldHint: true,
+        },
+        description: 'Ingest public HTTPS brand asset URLs into the current project media library. Raw bytes are not accepted here — use upload_brand_asset for that.',
+        inputSchema: {
+            assets: z.array(z.object({
+                url: z.string().url().describe('Public HTTPS asset URL. Private/internal addresses and redirects are rejected.'),
+                kind: kindSchema.optional(),
+                filename: z.string().optional(),
+            })).min(1).max(25),
+            collection: z.string().optional(),
+            tags: z.array(z.string()).optional(),
+            brand_kit_id: z.string().uuid().optional(),
+        },
+    }, async ({ assets, collection, tags, brand_kit_id }) => {
+        const projectId = getProjectId();
+        let orgId;
+        try {
+            orgId = await getProjectOrgId(projectId);
+            if (brand_kit_id) {
+                const { data: kitRow } = await adminDb().schema('email').from('brand_kits')
+                    .select('id').eq('id', brand_kit_id).eq('project_id', projectId).maybeSingle();
+                if (!kitRow)
+                    return j({ error: 'brand_kit_id not found in this project' });
+            }
+        }
+        catch (error) {
+            return j({ error: error instanceof Error ? error.message : 'Project lookup failed' });
+        }
+        const results = [];
+        for (const asset of assets) {
+            try {
+                const downloaded = await downloadPublicAsset(asset.url);
+                const filename = (asset.filename?.trim() || decodeURIComponent(downloaded.url.pathname).split('/').pop() || 'asset')
+                    .replace(/[^\w.\- ()]/g, '_').slice(0, 255) || 'asset';
+                const mimeType = resolveMime(filename, downloaded.mimeType);
+                const resolvedKind = isValidKind(asset.kind) ? asset.kind : resolveKind(undefined, filename, mimeType);
+                const persisted = await persistBrandAsset({
+                    sb: adminDb(),
+                    orgId,
+                    projectId,
+                    bytes: downloaded.bytes,
+                    filename,
+                    mimeType,
+                    kind: resolvedKind,
+                    source: 'imported',
+                    collection: collection ?? null,
+                    tags: tags ?? [],
+                    brandKitId: brand_kit_id ?? null,
+                });
+                results.push({ url: asset.url, ok: true, filename, mime_type: mimeType, asset_id: persisted.assetId, skipped_existing: persisted.skippedExisting });
+            }
+            catch (error) {
+                results.push({ url: asset.url, ok: false, error: error instanceof Error ? error.message : 'Asset ingest failed' });
+            }
+        }
+        return j({
+            imported: results.filter((r) => r.ok).length,
+            failed: results.filter((r) => !r.ok).length,
+            results,
+        });
+    });
+}