@sendinel/mcp-server 1.0.10 → 1.0.12

package/build/tools/content.js

@@ -2,6 +2,88 @@ import { z } from 'zod';
 import { adminDb, db } from '../db.js';
 import { getProjectId } from '../project.js';
 const j = (data) => ({ content: [{ type: 'text', text: JSON.stringify(data, null, 2) }] });
+const BLOG_IMAGE_FORMATS = ['square_image', 'story_image', 'animated_gif', 'short_video', 'carousel'];
+const BLOG_IMAGE_GOALS = ['generate_leads', 'educate', 'launch_offer', 'build_trust'];
+const BLOG_IMAGE_PLATFORMS = ['linkedin', 'x', 'instagram', 'tiktok', 'youtube_shorts'];
+const BLOG_IMAGE_COMPUTE_PATHS = ['managed', 'byok', 'codex_bridge'];
+const BLOG_IMAGE_SCENES = [
+    { id: 'two-paths', name: 'The Two Paths', narrative_type: 'education', description: 'Fork in the road: old way is overgrown, synchronized path is clear.', formats: ['square_image', 'carousel'], tags: ['framework', 'choice', 'education'] },
+    { id: 'signal-vs-noise', name: 'Signal vs. Noise', narrative_type: 'education', description: 'Character turns a radio dial through static until a clean signal emerges.', formats: ['square_image', 'animated_gif'], tags: ['signal', 'intelligence', 'clarity'] },
+    { id: 'strategy-session', name: 'The Strategy Session', narrative_type: 'education', description: 'Whiteboard covered in connected nodes, arrows, and campaign logic.', formats: ['square_image'], tags: ['strategy', 'planning', 'education'] },
+    { id: 'five-step-framework', name: 'The 5-Step Framework', narrative_type: 'education', description: 'Five-panel deck with one concept per slide.', formats: ['carousel', 'square_image'], tags: ['framework', 'education', 'slides'] },
+    { id: 'comparison-matrix', name: 'The Comparison Matrix', narrative_type: 'education', description: 'Clean table comparing the old approach against the new system.', formats: ['carousel', 'square_image'], tags: ['comparison', 'education', 'sales'] },
+    { id: 'focused-founder', name: 'The Focused Founder', narrative_type: 'identity', description: 'Clean desk, coffee, laptop, and morning focus with warm light.', formats: ['square_image', 'story_image'], tags: ['founder', 'focus', 'lifestyle'] },
+    { id: 'dashboard-reveal', name: 'Dashboard Reveal', narrative_type: 'identity', description: 'Dark screen animates into a clean, organized product dashboard.', formats: ['short_video', 'animated_gif', 'square_image'], tags: ['dashboard', 'product', 'ui'] },
+    { id: 'command-center-boot', name: 'Command Center Boot', narrative_type: 'identity', description: 'System boot sequence reveals an organized founder command center.', formats: ['short_video', 'animated_gif', 'square_image'], tags: ['command-center', 'identity', 'systems'] },
+    { id: 'breakthrough-moment', name: 'The Breakthrough Moment', narrative_type: 'transformation', description: 'Person looks up from the screen with sudden clarity.', formats: ['square_image'], tags: ['clarity', 'breakthrough', 'transformation'] },
+    { id: 'chaos-to-campaign', name: 'Chaos to Campaign', narrative_type: 'transformation', description: 'Messy wall of sticky notes reorganizes into a clean campaign calendar.', formats: ['square_image', 'animated_gif'], tags: ['campaign', 'planning', 'marketing'] },
+    { id: 'before-after-desk', name: 'Before/After Desk', narrative_type: 'transformation', description: 'Split panel shows a chaotic desk beside the same desk with one organized system.', formats: ['square_image', 'carousel'], tags: ['before-after', 'systems', 'clarity'] },
+    { id: 'number-breakdown', name: 'The Number Breakdown', narrative_type: 'proof', description: 'Key metrics become bold visual stats across four slides.', formats: ['carousel', 'square_image'], tags: ['metrics', 'proof', 'analytics'] },
+];
+function clean(value) {
+    return typeof value === 'string' ? value.trim() : '';
+}
+function record(value) {
+    return value && typeof value === 'object' && !Array.isArray(value) ? value : {};
+}
+function scoreBlogImageScene(scene, text, tags) {
+    let score = 0;
+    if (/\b(how|guide|framework|teach|explain|tip|educat|learn)\b/i.test(text) && scene.narrative_type === 'education')
+        score += 3;
+    if (/\b(transform|switch|migrat|before.?after|pivot|fix|solve)\b/i.test(text) && scene.narrative_type === 'transformation')
+        score += 3;
+    if (/\b(proof|result|metric|case study|testimonial|revenue|customer|win)\b/i.test(text) && scene.narrative_type === 'proof')
+        score += 3;
+    if (/\b(launch|announc|founder|story|brand|vision|identity)\b/i.test(text) && scene.narrative_type === 'identity')
+        score += 2;
+    for (const tag of scene.tags) {
+        if (tags.includes(tag))
+            score += 2;
+        else if (text.includes(tag))
+            score += 1;
+    }
+    return score;
+}
+async function resolveSynchronexUserId(projectId) {
+    const { data: bundle } = await adminDb()
+        .from('synchronex_bundle_projects')
+        .select('synchronex_user_id')
+        .eq('project_id', projectId)
+        .eq('status', 'active')
+        .maybeSingle();
+    if (bundle?.synchronex_user_id)
+        return bundle.synchronex_user_id;
+    const { data: project } = await adminDb()
+        .from('projects')
+        .select('account:accounts(synchronex_account_id)')
+        .eq('id', projectId)
+        .maybeSingle();
+    const account = Array.isArray(project?.account) ? project.account[0] : project?.account;
+    return typeof account?.synchronex_account_id === 'string' && account.synchronex_account_id ? account.synchronex_account_id : null;
+}
+async function generateSynchronexVisual(synchronexUserId, params) {
+    const serviceToken = process.env.SYNCHRONEX_SERVICE_TOKEN ?? '';
+    if (!serviceToken)
+        throw new Error('SYNCHRONEX_SERVICE_TOKEN is not configured');
+    const baseUrl = process.env.SYNCHRONEX_BASE_URL ?? 'https://synchronex.ai';
+    const res = await fetch(`${baseUrl.replace(/\/$/, '')}/api/marketing/studio/generate-visual`, {
+        method: 'POST',
+        headers: {
+            'Content-Type': 'application/json',
+            Authorization: `Bearer ${serviceToken}`,
+            'x-synchronex-user-id': synchronexUserId,
+        },
+        body: JSON.stringify(params),
+    });
+    if (!res.ok) {
+        const text = await res.text().catch(() => '');
+        throw new Error(`Synchronex generate-visual failed (${res.status}): ${text}`);
+    }
+    const body = await res.json();
+    if (!body.asset?.signed_url)
+        throw new Error('Synchronex generate-visual returned no asset.');
+    return { asset: { signed_url: body.asset.signed_url }, prompt: body.prompt ?? '' };
+}
 export function registerContentTools(server) {
     server.registerTool('create_asset_link', {
         title: 'Create Asset Link',
@@ -310,6 +392,152 @@ export function registerContentTools(server) {
             return j({ error: error.message });
         return j({ blog_posts: data ?? [] });
     });
+    server.registerTool('get_blog_post', {
+        title: 'Get Blog Post',
+        annotations: {
+            readOnlyHint: true,
+            destructiveHint: false,
+            idempotentHint: true,
+            openWorldHint: false,
+        },
+        description: 'Get one ingested blog post for this project, including cover image and publish fields.',
+        inputSchema: {
+            blog_post_id: z.string().uuid(),
+        },
+    }, async ({ blog_post_id }) => {
+        const { data, error } = await db().from('blog_posts')
+            .select('*')
+            .eq('project_id', getProjectId())
+            .eq('id', blog_post_id)
+            .maybeSingle();
+        if (error)
+            return j({ error: error.message });
+        if (!data)
+            return j({ error: 'Blog post not found', code: 'NOT_FOUND' });
+        return j({ blog_post: data });
+    });
+    server.registerTool('recommend_blog_post_images', {
+        title: 'Recommend Blog Post Images',
+        annotations: {
+            readOnlyHint: true,
+            destructiveHint: false,
+            idempotentHint: true,
+            openWorldHint: false,
+        },
+        description: 'Recommend Content Studio scenes for a blog post featured image using the post title, excerpt, and tags.',
+        inputSchema: {
+            blog_post_id: z.string().uuid(),
+            format: z.enum(BLOG_IMAGE_FORMATS).optional(),
+            goal: z.enum(BLOG_IMAGE_GOALS).optional().default('educate'),
+            audience: z.string().max(240).optional(),
+            limit: z.number().int().min(1).max(12).optional().default(6),
+        },
+    }, async ({ blog_post_id, format, goal = 'educate', audience, limit = 6 }) => {
+        const { data: post, error } = await db().from('blog_posts')
+            .select('id, title, excerpt, tags')
+            .eq('project_id', getProjectId())
+            .eq('id', blog_post_id)
+            .maybeSingle();
+        if (error)
+            return j({ error: error.message });
+        if (!post)
+            return j({ error: 'Blog post not found', code: 'NOT_FOUND' });
+        const tags = Array.isArray(post.tags) ? post.tags.map((tag) => String(tag).toLowerCase()) : [];
+        const text = `${goal} ${post.title ?? ''} ${post.excerpt ?? ''} ${audience ?? ''}`.toLowerCase();
+        const scenes = BLOG_IMAGE_SCENES
+            .filter((scene) => (format ? scene.formats.includes(format) : true))
+            .map((scene) => ({ ...scene, score: scoreBlogImageScene(scene, text, tags) }))
+            .sort((a, b) => b.score - a.score || a.name.localeCompare(b.name))
+            .slice(0, limit);
+        return j({ scenes, blog_post: { id: post.id, title: post.title, tags: post.tags ?? [] } });
+    });
+    server.registerTool('generate_blog_post_image', {
+        title: 'Generate Blog Post Image',
+        annotations: {
+            readOnlyHint: false,
+            destructiveHint: false,
+            idempotentHint: false,
+            openWorldHint: true,
+        },
+        description: 'Generate and persist a featured image for a blog post using the Content Studio image pipeline.',
+        inputSchema: {
+            blog_post_id: z.string().uuid(),
+            scene_id: z.string().min(1),
+            format: z.enum(BLOG_IMAGE_FORMATS).optional(),
+            topic: z.string().max(500).optional(),
+            audience: z.string().max(240).optional(),
+            goal: z.enum(BLOG_IMAGE_GOALS).optional().default('educate'),
+            platform: z.enum(BLOG_IMAGE_PLATFORMS).optional().default('linkedin'),
+            compute_path: z.enum(BLOG_IMAGE_COMPUTE_PATHS).optional().default('managed'),
+        },
+    }, async ({ blog_post_id, scene_id, format, topic, audience, goal = 'educate', platform = 'linkedin', compute_path = 'managed' }) => {
+        const projectId = getProjectId();
+        const { data: post, error } = await db().from('blog_posts')
+            .select('id, org_id, title, excerpt, tags, cover_image_url')
+            .eq('project_id', projectId)
+            .eq('id', blog_post_id)
+            .maybeSingle();
+        if (error)
+            return j({ error: error.message });
+        if (!post)
+            return j({ error: 'Blog post not found', code: 'NOT_FOUND' });
+        const scene = BLOG_IMAGE_SCENES.find((s) => s.id === scene_id);
+        const chosenFormat = format ?? scene?.formats[0] ?? 'square_image';
+        if (scene && !scene.formats.includes(chosenFormat)) {
+            return j({ error: `Scene "${scene_id}" does not support format "${chosenFormat}"`, code: 'INVALID_INPUT' });
+        }
+        const resolvedTopic = clean(topic) || [post.title, post.excerpt].filter(Boolean).join(': ');
+        if (!resolvedTopic || resolvedTopic.length < 3) {
+            return j({ error: 'Blog post title is required or topic must be >= 3 chars', code: 'INVALID_INPUT' });
+        }
+        const synchronexUserId = await resolveSynchronexUserId(projectId);
+        if (!synchronexUserId) {
+            return j({ error: 'This project has no active Synchronex bundle — image generation is a bundled-plan feature.', code: 'NO_SYNCHRONEX_BUNDLE' });
+        }
+        const { data: project } = await adminDb().from('projects').select('brand_settings').eq('id', projectId).maybeSingle();
+        const brandSettings = record(project?.brand_settings);
+        const brandContext = {};
+        if (typeof brandSettings.logo_url === 'string' && brandSettings.logo_url.trim())
+            brandContext.logo = brandSettings.logo_url.trim();
+        if (Array.isArray(brandSettings.brand_colors) && brandSettings.brand_colors.length)
+            brandContext.colors = brandSettings.brand_colors;
+        if (typeof brandSettings.visual_style === 'string' && brandSettings.visual_style.trim())
+            brandContext.visual_style = brandSettings.visual_style.trim();
+        try {
+            const generated = await generateSynchronexVisual(synchronexUserId, {
+                scene_id,
+                format: chosenFormat,
+                topic: resolvedTopic.slice(0, 500),
+                audience: (clean(audience) || 'general audience').slice(0, 240),
+                goal,
+                platform,
+                compute_path,
+                ...(Object.keys(brandContext).length ? { brand_context: brandContext } : {}),
+            });
+            const { data: updated, error: updateErr } = await db().from('blog_posts')
+                .update({ cover_image_url: generated.asset.signed_url, updated_at: new Date().toISOString() })
+                .eq('project_id', projectId)
+                .eq('id', blog_post_id)
+                .select('id, title, cover_image_url, updated_at')
+                .maybeSingle();
+            if (updateErr)
+                return j({ error: updateErr.message, code: updateErr.code });
+            await adminDb().from('audit_log').insert({
+                project_id: projectId,
+                org_id: post.org_id ?? null,
+                actor_type: 'mcp',
+                action: 'blog_post.image_generated',
+                resource_type: 'blog_post',
+                resource_id: blog_post_id,
+                details: { scene_id, format: chosenFormat },
+                channel: 'mcp',
+            }).catch(() => { });
+            return j({ scene_id, format: chosenFormat, asset: generated.asset, prompt: generated.prompt, blog_post: updated });
+        }
+        catch (err) {
+            return j({ error: err instanceof Error ? err.message : 'Image generation failed', code: 'IMAGE_GENERATION_FAILED' });
+        }
+    });
     server.registerTool('list_blog_destinations', {
         title: 'List Blog Destinations',
         annotations: {

package/build/tools/data-proposals.js

@@ -9,7 +9,7 @@ async function engagementSnapshot(projectId) {
     const [{ data: logs }, { count: audienceSize }, { data: segments }] = await Promise.all([
         db().from('email_log').select('status, created_at').eq('project_id', projectId).gte('created_at', since).limit(10000),
         db().from('subscribers').select('id', { count: 'exact', head: true }).eq('project_id', projectId).eq('is_test', false).eq('global_unsubscribed', false),
-        db().from('segments').select('id, name, subscriber_count, updated_at').eq('project_id', projectId).order('updated_at', { ascending: false }).limit(5),
+        db().from('segments').select('id, name, subscriber_count:cached_count, updated_at').eq('project_id', projectId).order('updated_at', { ascending: false }).limit(5),
     ]);
     const rows = logs ?? [];
     const sent = rows.filter((row) => ['sent', 'delivered', 'opened', 'clicked', 'bounced', 'complained'].includes(row.status)).length;