openhive-mcp-server 1.0.0 → 1.2.0

package/index.js

@@ -4,6 +4,7 @@
  * OpenHive MCP CLI
  *
  * Connects IDEs (Antigravity, Claude Desktop, Cursor, etc.) to your OpenHive instance.
+ * Supports single image posts and carousels (2-10 images).
  *
  * Environment variables:
  *   OPENHIVE_API_URL   - Your OpenHive API URL (e.g., https://your-server.com)
@@ -14,7 +15,7 @@
  *   "mcpServers": {
  *     "openhive": {
  *       "command": "npx",
- *       "args": ["-y", "openhive-mcp"],
+ *       "args": ["-y", "openhive-mcp-server"],
  *       "env": {
  *         "OPENHIVE_API_URL": "https://your-api-url",
  *         "OPENHIVE_API_TOKEN": "your-token"
@@ -48,23 +49,170 @@ async function apiRequest(path, options = {}) {
     },
   });
   const data = await res.json();
-  if (!res.ok) throw new Error(data.error || 'API request failed');
+  if (!res.ok) throw new Error(data.error || `API request failed: ${res.status}`);
   return data.data;
 }
 
-const server = new McpServer({ name: 'openhive', version: '1.0.0' });
+const server = new McpServer({ name: 'openhive', version: '1.2.0' });
 
 // ── Posts ──
 
-server.tool('create_post', 'Cria um novo post', {
-  caption: z.string().optional().describe('Legenda do post'),
-  imageUrl: z.string().optional().describe('URL da imagem'),
-  hashtags: z.array(z.string()).optional().describe('Lista de hashtags'),
-  scheduledAt: z.string().optional().describe('Data de agendamento ISO'),
-}, async (input) => {
-  const result = await apiRequest('/api/posts', { method: 'POST', body: JSON.stringify(input) });
-  return { content: [{ type: 'text', text: JSON.stringify(result, null, 2) }] };
-});
+server.tool(
+  'create_post',
+  'Cria um post para Instagram. Suporta imagem unica ou carrossel (2-10 imagens). Para carrossel, use image_prompts (gerar via IA) ou image_urls (URLs prontas)',
+  {
+    caption: z.string().optional().describe('Legenda do post'),
+    image_prompt: z.string().optional().describe('Prompt para gerar UMA imagem via IA'),
+    image_prompts: z.array(z.string()).min(2).max(10).optional().describe('Array de prompts para gerar carrossel (2-10 imagens via IA)'),
+    image_urls: z.array(z.string()).min(2).max(10).optional().describe('Array de URLs de imagens prontas para carrossel (2-10). Use com render_html_to_image'),
+    aspect_ratio: z.string().optional().describe('Formato: 1:1 (Feed), 4:5 (Retrato), 9:16 (Stories)'),
+    scheduled_at: z.string().optional().describe('Data/hora para agendar (ISO 8601)'),
+    hashtags: z.array(z.string()).optional().describe('Lista de hashtags'),
+    tone: z.string().optional().describe('Tom da legenda: educativo, inspirador, humor, noticia'),
+  },
+  async (input) => {
+    let imageUrl;
+    let images = [];
+    let caption = input.caption;
+    let hashtags = input.hashtags;
+    const aspectRatio = input.aspect_ratio || '1:1';
+
+    // Generate multiple images for carousel via IA
+    if (input.image_prompts && input.image_prompts.length >= 2) {
+      const results = await Promise.allSettled(
+        input.image_prompts.map((prompt) =>
+          apiRequest('/api/generate/image', {
+            method: 'POST',
+            body: JSON.stringify({ prompt, aspectRatio }),
+          })
+        )
+      );
+      images = results
+        .filter((r) => r.status === 'fulfilled')
+        .map((r, idx) => ({
+          imageUrl: r.value.imageUrl,
+          order: idx,
+          prompt: input.image_prompts[idx],
+          source: 'NANOBANA',
+        }));
+
+      const failed = results.filter((r) => r.status === 'rejected').length;
+      if (failed > 0) {
+        console.error(`[create_post] ${failed} image(s) failed to generate`);
+      }
+    }
+    // Use provided URLs directly for carousel
+    else if (input.image_urls && input.image_urls.length >= 2) {
+      images = input.image_urls.map((url, idx) => ({
+        imageUrl: url,
+        order: idx,
+        source: 'URL',
+      }));
+    }
+    // Single image generation
+    else if (input.image_prompt) {
+      const img = await apiRequest('/api/generate/image', {
+        method: 'POST',
+        body: JSON.stringify({ prompt: input.image_prompt, aspectRatio }),
+      });
+      imageUrl = img.imageUrl;
+    }
+
+    // Auto-generate caption if not provided
+    if (!caption) {
+      const topic = input.image_prompt || (input.image_prompts && input.image_prompts[0]) || 'post de tecnologia';
+      const result = await apiRequest('/api/generate/caption', {
+        method: 'POST',
+        body: JSON.stringify({ topic, tone: input.tone }),
+      });
+      caption = result.caption;
+      hashtags = hashtags || result.hashtags;
+    }
+
+    const isCarousel = images.length >= 2;
+
+    const postBody = {
+      caption,
+      hashtags,
+      source: 'MCP',
+      aspectRatio,
+      isCarousel,
+      ...(isCarousel ? { images } : { imageUrl }),
+      ...(input.scheduled_at ? { scheduledAt: input.scheduled_at } : {}),
+    };
+
+    const post = await apiRequest('/api/posts', {
+      method: 'POST',
+      body: JSON.stringify(postBody),
+    });
+
+    return {
+      content: [{
+        type: 'text',
+        text: JSON.stringify({
+          post_id: post.id,
+          caption: post.caption,
+          image_url: post.imageUrl,
+          is_carousel: post.isCarousel,
+          image_count: isCarousel ? images.length : (post.imageUrl ? 1 : 0),
+          images: post.images || [],
+          status: post.status,
+        }, null, 2),
+      }],
+    };
+  }
+);
+
+server.tool(
+  'add_image_to_post',
+  'Adiciona uma imagem a um post existente. Se o post ficar com 2+ imagens, vira carrossel automaticamente',
+  {
+    post_id: z.string().describe('ID do post'),
+    image_url: z.string().optional().describe('URL de imagem pronta (de render_html_to_image ou upload)'),
+    image_prompt: z.string().optional().describe('Prompt para gerar imagem via IA'),
+    aspect_ratio: z.string().optional().describe('Formato: 1:1, 4:5, 9:16 (usado se gerar via IA)'),
+  },
+  async (input) => {
+    let imageUrl = input.image_url;
+
+    // Generate image if prompt provided
+    if (!imageUrl && input.image_prompt) {
+      const img = await apiRequest('/api/generate/image', {
+        method: 'POST',
+        body: JSON.stringify({
+          prompt: input.image_prompt,
+          aspectRatio: input.aspect_ratio || '1:1',
+        }),
+      });
+      imageUrl = img.imageUrl;
+    }
+
+    if (!imageUrl) {
+      return {
+        content: [{
+          type: 'text',
+          text: JSON.stringify({ error: 'Provide image_url or image_prompt' }),
+        }],
+      };
+    }
+
+    const result = await apiRequest(`/api/posts/${input.post_id}/images`, {
+      method: 'POST',
+      body: JSON.stringify({
+        imageUrl,
+        source: input.image_prompt ? 'NANOBANA' : 'URL',
+        prompt: input.image_prompt || null,
+      }),
+    });
+
+    return {
+      content: [{
+        type: 'text',
+        text: JSON.stringify(result, null, 2),
+      }],
+    };
+  }
+);
 
 server.tool('list_posts', 'Lista posts com filtros', {
   status: z.string().optional().describe('Filtrar por status: DRAFT, SCHEDULED, PUBLISHED, FAILED'),
@@ -81,8 +229,13 @@ server.tool('list_posts', 'Lista posts com filtros', {
 
 server.tool('publish_now', 'Publica um post imediatamente no Instagram', {
   post_id: z.string().describe('ID do post'),
+  account_id: z.string().optional().describe('ID da conta Instagram (opcional, usa a padrao se nao informado)'),
 }, async (input) => {
-  const result = await apiRequest(`/api/posts/${input.post_id}/publish`, { method: 'POST' });
+  const body = input.account_id ? { accountId: input.account_id } : {};
+  const result = await apiRequest(`/api/posts/${input.post_id}/publish`, {
+    method: 'POST',
+    body: JSON.stringify(body),
+  });
   return { content: [{ type: 'text', text: JSON.stringify(result, null, 2) }] };
 });
 
@@ -96,8 +249,8 @@ server.tool('schedule_post', 'Agenda um post para publicacao', {
   return { content: [{ type: 'text', text: JSON.stringify(result, null, 2) }] };
 });
 
-server.tool('generate_image', 'Gera imagem com IA (Gemini)', {
-  prompt: z.string().describe('Descricao da imagem'),
+server.tool('generate_image', 'Gera uma imagem via IA (NanoBana)', {
+  prompt: z.string().describe('Descricao da imagem desejada'),
   aspectRatio: z.string().optional().describe('Formato: 1:1, 4:5, 9:16'),
 }, async (input) => {
   const result = await apiRequest('/api/generate/image', {
@@ -106,7 +259,7 @@ server.tool('generate_image', 'Gera imagem com IA (Gemini)', {
   return { content: [{ type: 'text', text: JSON.stringify(result, null, 2) }] };
 });
 
-server.tool('generate_caption', 'Gera legenda com IA', {
+server.tool('generate_caption', 'Gera legenda otimizada para Instagram', {
   topic: z.string().describe('Tema do post'),
   tone: z.string().optional().describe('Tom: educativo, inspirador, humor, noticia'),
 }, async (input) => {
@@ -116,16 +269,31 @@ server.tool('generate_caption', 'Gera legenda com IA', {
   return { content: [{ type: 'text', text: JSON.stringify(result, null, 2) }] };
 });
 
-server.tool('render_html_to_image', 'Renderiza HTML/CSS/Tailwind em imagem PNG', {
-  html: z.string().describe('Codigo HTML do post (suporta Tailwind CSS)'),
-  width: z.number().optional().describe('Largura em pixels (default: 1080)'),
-  height: z.number().optional().describe('Altura em pixels (default: 1080)'),
-}, async (input) => {
-  const result = await apiRequest('/api/generate/html', {
-    method: 'POST', body: JSON.stringify(input),
-  });
-  return { content: [{ type: 'text', text: JSON.stringify(result, null, 2) }] };
-});
+server.tool(
+  'render_html_to_image',
+  'Renderiza HTML/CSS/Tailwind em imagem PNG. Retorna image_url. Para carrossel: chame para cada slide e depois use create_post com image_urls contendo todas as URLs',
+  {
+    html: z.string().describe('Codigo HTML completo do slide (suporta Tailwind CSS via CDN)'),
+    width: z.number().optional().describe('Largura em pixels (default: 1080)'),
+    height: z.number().optional().describe('Altura em pixels (default: 1080). Use 1350 para 4:5, 1920 para 9:16'),
+  },
+  async (input) => {
+    const result = await apiRequest('/api/generate/html', {
+      method: 'POST', body: JSON.stringify(input),
+    });
+    return {
+      content: [{
+        type: 'text',
+        text: JSON.stringify({
+          image_url: result.imageUrl,
+          width: input.width || 1080,
+          height: input.height || 1080,
+          tip: 'Colete todas as image_urls dos slides e use create_post({ image_urls: [...], caption: "..." }) para criar o carrossel',
+        }, null, 2),
+      }],
+    };
+  }
+);
 
 server.tool('generate_template_image', 'Gera imagem usando template HTML pre-definido', {
   title: z.string().describe('Texto principal'),
@@ -143,25 +311,61 @@ server.tool('generate_template_image', 'Gera imagem usando template HTML pre-def
   return { content: [{ type: 'text', text: JSON.stringify(result, null, 2) }] };
 });
 
+server.tool('upload_image', 'Faz upload de uma imagem (base64) para o storage', {
+  image_base64: z.string().describe('Imagem em base64'),
+  filename: z.string().describe('Nome do arquivo (ex: foto.png)'),
+}, async (input) => {
+  const result = await apiRequest('/api/upload', {
+    method: 'POST',
+    body: JSON.stringify(input),
+  });
+  return { content: [{ type: 'text', text: JSON.stringify(result, null, 2) }] };
+});
+
+server.tool('get_analytics', 'Retorna metricas dos posts publicados', {
+  period: z.string().optional().describe('Periodo: 7d, 30d ou 90d'),
+}, async (input) => {
+  const params = new URLSearchParams();
+  if (input.period) params.set('period', input.period);
+  const result = await apiRequest(`/api/analytics?${params}`);
+  return { content: [{ type: 'text', text: JSON.stringify(result, null, 2) }] };
+});
+
 // ── Tasks ──
 
-server.tool('create_task', 'Cria uma tarefa', {
+server.tool('create_task', 'Cria uma tarefa de producao de conteudo', {
   title: z.string().describe('Titulo da tarefa'),
   description: z.string().optional().describe('Descricao'),
   platform: z.string().optional().describe('Plataforma: YOUTUBE, INSTAGRAM, TIKTOK, OTHER'),
   priority: z.string().optional().describe('Prioridade: LOW, MEDIUM, HIGH, URGENT'),
+  recordDate: z.string().optional().describe('Data de gravacao ISO'),
+  publishDate: z.string().optional().describe('Data de publicacao ISO'),
+  script: z.string().optional().describe('Roteiro'),
+  projectId: z.string().optional().describe('ID do projeto associado'),
+  isSponsored: z.boolean().optional().describe('Se e patrocinado'),
+  sponsorName: z.string().optional().describe('Nome do patrocinador'),
+  sponsorBriefing: z.string().optional().describe('Briefing do patrocinador'),
+  sponsorDeadline: z.string().optional().describe('Deadline do patrocinador ISO'),
 }, async (input) => {
   const result = await apiRequest('/api/tasks', { method: 'POST', body: JSON.stringify(input) });
   return { content: [{ type: 'text', text: JSON.stringify(result, null, 2) }] };
 });
 
-server.tool('list_tasks', 'Lista tarefas', {
+server.tool('list_tasks', 'Lista tarefas com filtros', {
   status: z.string().optional().describe('Status: PENDING, IN_PROGRESS, COMPLETED, CANCELLED'),
+  priority: z.string().optional().describe('Prioridade: LOW, MEDIUM, HIGH, URGENT'),
+  platform: z.string().optional().describe('Plataforma: YOUTUBE, INSTAGRAM, TIKTOK, OTHER'),
+  projectId: z.string().optional().describe('ID do projeto'),
   limit: z.string().optional().describe('Limite'),
+  page: z.string().optional().describe('Pagina'),
 }, async (input) => {
   const params = new URLSearchParams();
   if (input.status) params.set('status', input.status);
+  if (input.priority) params.set('priority', input.priority);
+  if (input.platform) params.set('platform', input.platform);
+  if (input.projectId) params.set('projectId', input.projectId);
   if (input.limit) params.set('limit', input.limit);
+  if (input.page) params.set('page', input.page);
   const result = await apiRequest(`/api/tasks?${params}`);
   return { content: [{ type: 'text', text: JSON.stringify(result, null, 2) }] };
 });
@@ -169,8 +373,18 @@ server.tool('list_tasks', 'Lista tarefas', {
 server.tool('update_task', 'Atualiza uma tarefa', {
   task_id: z.string().describe('ID da tarefa'),
   title: z.string().optional(),
-  status: z.string().optional(),
-  priority: z.string().optional(),
+  description: z.string().optional(),
+  status: z.string().optional().describe('PENDING, IN_PROGRESS, COMPLETED, CANCELLED'),
+  priority: z.string().optional().describe('LOW, MEDIUM, HIGH, URGENT'),
+  platform: z.string().optional(),
+  recordDate: z.string().optional(),
+  publishDate: z.string().optional(),
+  script: z.string().optional(),
+  projectId: z.string().optional(),
+  isSponsored: z.boolean().optional(),
+  sponsorName: z.string().optional(),
+  sponsorBriefing: z.string().optional(),
+  sponsorDeadline: z.string().optional(),
 }, async (input) => {
   const { task_id, ...body } = input;
   const result = await apiRequest(`/api/tasks/${task_id}`, { method: 'PUT', body: JSON.stringify(body) });
@@ -186,30 +400,384 @@ server.tool('delete_task', 'Remove uma tarefa', {
 
 // ── Projects ──
 
-server.tool('create_project', 'Cria um projeto', {
+server.tool('create_project', 'Cria um projeto com modulos opcionais', {
   title: z.string().describe('Titulo'),
   description: z.string().optional(),
+  modules: z.array(z.object({
+    title: z.string(),
+    content: z.string().optional(),
+  })).optional().describe('Lista de modulos iniciais'),
 }, async (input) => {
   const result = await apiRequest('/api/projects', { method: 'POST', body: JSON.stringify(input) });
   return { content: [{ type: 'text', text: JSON.stringify(result, null, 2) }] };
 });
 
 server.tool('list_projects', 'Lista projetos', {
+  status: z.string().optional().describe('PLANNING, IN_PROGRESS, COMPLETED, ARCHIVED'),
   limit: z.string().optional(),
 }, async (input) => {
   const params = new URLSearchParams();
+  if (input.status) params.set('status', input.status);
   if (input.limit) params.set('limit', input.limit);
   const result = await apiRequest(`/api/projects?${params}`);
   return { content: [{ type: 'text', text: JSON.stringify(result, null, 2) }] };
 });
 
-server.tool('get_project', 'Detalhes de um projeto', {
+server.tool('get_project', 'Detalhes de um projeto com modulos e tarefas', {
   project_id: z.string().describe('ID do projeto'),
 }, async (input) => {
   const result = await apiRequest(`/api/projects/${input.project_id}`);
   return { content: [{ type: 'text', text: JSON.stringify(result, null, 2) }] };
 });
 
+server.tool('update_project', 'Atualiza um projeto', {
+  project_id: z.string().describe('ID do projeto'),
+  title: z.string().optional(),
+  description: z.string().optional(),
+  status: z.string().optional().describe('PLANNING, IN_PROGRESS, COMPLETED, ARCHIVED'),
+}, async (input) => {
+  const { project_id, ...body } = input;
+  const result = await apiRequest(`/api/projects/${project_id}`, { method: 'PUT', body: JSON.stringify(body) });
+  return { content: [{ type: 'text', text: JSON.stringify(result, null, 2) }] };
+});
+
+server.tool('delete_project', 'Deleta um projeto e seus modulos', {
+  project_id: z.string().describe('ID do projeto'),
+}, async (input) => {
+  const result = await apiRequest(`/api/projects/${input.project_id}`, { method: 'DELETE' });
+  return { content: [{ type: 'text', text: JSON.stringify(result, null, 2) }] };
+});
+
+// ── Modules ──
+
+server.tool('add_module', 'Adiciona modulo a um projeto', {
+  project_id: z.string().describe('ID do projeto'),
+  title: z.string().describe('Titulo do modulo'),
+  content: z.string().optional().describe('Conteudo/descricao'),
+  order: z.number().optional().describe('Posicao na lista'),
+}, async (input) => {
+  const { project_id, ...body } = input;
+  const result = await apiRequest(`/api/projects/${project_id}/modules`, {
+    method: 'POST', body: JSON.stringify(body),
+  });
+  return { content: [{ type: 'text', text: JSON.stringify(result, null, 2) }] };
+});
+
+server.tool('update_module', 'Atualiza um modulo', {
+  project_id: z.string().describe('ID do projeto'),
+  module_id: z.string().describe('ID do modulo'),
+  title: z.string().optional(),
+  content: z.string().optional(),
+  isRecorded: z.boolean().optional().describe('Marcar como gravado'),
+  driveLink: z.string().optional().describe('Link do Google Drive'),
+}, async (input) => {
+  const { project_id, module_id, ...body } = input;
+  const result = await apiRequest(`/api/projects/${project_id}/modules/${module_id}`, {
+    method: 'PUT', body: JSON.stringify(body),
+  });
+  return { content: [{ type: 'text', text: JSON.stringify(result, null, 2) }] };
+});
+
+server.tool('delete_module', 'Remove modulo de um projeto', {
+  project_id: z.string().describe('ID do projeto'),
+  module_id: z.string().describe('ID do modulo'),
+}, async (input) => {
+  const result = await apiRequest(`/api/projects/${input.project_id}/modules/${input.module_id}`, {
+    method: 'DELETE',
+  });
+  return { content: [{ type: 'text', text: JSON.stringify(result, null, 2) }] };
+});
+
+// ── Video Clips ──
+
+server.tool('analyze_youtube_video', 'Analisa video do YouTube: baixa, transcreve e encontra melhores momentos', {
+  url: z.string().describe('URL do video do YouTube'),
+  whisper_model: z.string().optional().describe('Modelo Whisper: tiny, base, small, medium, large'),
+  max_moments: z.number().optional().describe('Maximo de momentos (default: 10)'),
+  language: z.string().optional().describe('Idioma: pt, en, es'),
+}, async (input) => {
+  const result = await apiRequest('/api/video-clips/analyze', {
+    method: 'POST', body: JSON.stringify(input),
+  });
+  return { content: [{ type: 'text', text: JSON.stringify(result, null, 2) }] };
+});
+
+server.tool('cut_youtube_clips', 'Corta clips de video ja analisado', {
+  video_clip_id: z.string().describe('ID do video clip'),
+  clips: z.array(z.object({
+    start: z.number().describe('Segundo inicial'),
+    end: z.number().describe('Segundo final'),
+    title: z.string().optional().describe('Titulo do clip'),
+  })).describe('Lista de clips para cortar'),
+  format: z.string().optional().describe('Formato: vertical, square, horizontal'),
+  burn_subs: z.boolean().optional().describe('Queimar legendas no video'),
+}, async (input) => {
+  const result = await apiRequest(`/api/video-clips/${input.video_clip_id}/cut`, {
+    method: 'POST', body: JSON.stringify({
+      clips: input.clips,
+      format: input.format,
+      burnSubs: input.burn_subs,
+    }),
+  });
+  return { content: [{ type: 'text', text: JSON.stringify(result, null, 2) }] };
+});
+
+server.tool('list_video_clips', 'Lista video clips com status', {
+  status: z.string().optional().describe('PENDING, ANALYZING, ANALYZED, CLIPPING, READY, FAILED'),
+  page: z.string().optional().describe('Pagina'),
+  limit: z.string().optional().describe('Itens por pagina'),
+}, async (input) => {
+  const params = new URLSearchParams();
+  if (input.status) params.set('status', input.status);
+  if (input.page) params.set('page', input.page);
+  if (input.limit) params.set('limit', input.limit);
+  const result = await apiRequest(`/api/video-clips?${params}`);
+  return { content: [{ type: 'text', text: JSON.stringify(result, null, 2) }] };
+});
+
+// ── Update Post & Mixed Carousel ──
+
+server.tool('update_post', 'Atualiza um post existente (legenda, hashtags, agendamento). Se o post estiver agendado e voce mudar a data, o agendamento e atualizado automaticamente', {
+  post_id: z.string().describe('ID do post'),
+  caption: z.string().optional().describe('Nova legenda'),
+  hashtags: z.array(z.string()).optional().describe('Novas hashtags'),
+  scheduled_at: z.string().optional().describe('Nova data/hora de agendamento (ISO 8601). Reagenda automaticamente se ja estiver agendado'),
+  status: z.enum(['DRAFT', 'SCHEDULED']).optional().describe('Novo status (DRAFT cancela agendamento)'),
+}, async (input) => {
+  const body = {};
+  if (input.caption !== undefined) body.caption = input.caption;
+  if (input.hashtags !== undefined) body.hashtags = input.hashtags;
+  if (input.scheduled_at !== undefined) body.scheduledAt = input.scheduled_at;
+  if (input.status !== undefined) body.status = input.status;
+  const result = await apiRequest(`/api/posts/${input.post_id}`, {
+    method: 'PUT', body: JSON.stringify(body),
+  });
+  return { content: [{ type: 'text', text: JSON.stringify(result, null, 2) }] };
+});
+
+server.tool(
+  'create_mixed_carousel',
+  'Cria carrossel misto: capa gerada por IA (Gemini) + slides informativos em HTML/Template. Aceita brand_id para aplicar logo, cores e tom de voz da marca automaticamente',
+  {
+    cover_prompt: z.string().describe('Prompt para gerar a imagem de capa via IA (primeiro slide)'),
+    slides: z.array(z.object({
+      title: z.string().describe('Texto principal do slide'),
+      subtitle: z.string().optional().describe('Subtitulo do slide'),
+      template: z.string().optional().describe('Template: bold-gradient, minimal-dark, neon-card, quote-elegant, stats-impact, split-color'),
+    })).min(1).max(9).describe('Lista de slides template (1-9, a capa IA conta como slide 1)'),
+    caption: z.string().optional().describe('Legenda do post (gerada automaticamente se nao informada)'),
+    hashtags: z.array(z.string()).optional().describe('Lista de hashtags'),
+    aspect_ratio: z.enum(['1:1', '4:5', '9:16']).optional().describe('Proporcao: 1:1 (Feed), 4:5 (Retrato), 9:16 (Stories)'),
+    tone: z.string().optional().describe('Tom da legenda: educativo, inspirador, humor, noticia'),
+    scheduled_at: z.string().optional().describe('Data/hora para agendar (ISO 8601)'),
+    brand_id: z.string().optional().describe('ID do brand para aplicar identidade visual (logo + cores + tom + hashtags). Use list_brands antes'),
+    apply_brand: z.boolean().optional().describe('Se true (padrao), aplica brand. Se false, ignora mesmo com brand_id'),
+  },
+  async (input) => {
+    const aspectRatio = input.aspect_ratio || '1:1';
+    const images = [];
+
+    // Resolve brand if provided
+    let brand = null;
+    if (input.brand_id && input.apply_brand !== false) {
+      try {
+        brand = await apiRequest(`/api/brands/${input.brand_id}`);
+      } catch (err) {
+        // ignore brand load errors
+      }
+    }
+
+    // Step 1: AI cover (with brand hints in prompt)
+    let coverPrompt = input.cover_prompt;
+    if (brand) {
+      const hints = [];
+      if (brand.primaryColor) hints.push(`paleta ${brand.primaryColor} e ${brand.secondaryColor || ''}`);
+      if (brand.voiceTone) hints.push(`estilo ${brand.voiceTone}`);
+      if (hints.length > 0) coverPrompt = `${input.cover_prompt}. Identidade visual: ${hints.join(', ')}`;
+    }
+    const cover = await apiRequest('/api/generate/image', {
+      method: 'POST', body: JSON.stringify({ prompt: coverPrompt, aspectRatio }),
+    });
+    images.push({ imageUrl: cover.imageUrl, order: 0, prompt: coverPrompt });
+
+    // Step 2: Template slides (with brand colors/logo if available)
+    const slideResults = await Promise.allSettled(
+      input.slides.map((slide) => {
+        const body = {
+          title: slide.title,
+          subtitle: slide.subtitle,
+          template: slide.template || 'bold-gradient',
+          aspectRatio,
+        };
+        if (input.brand_id) {
+          body.brandId = input.brand_id;
+          body.applyBrand = input.apply_brand !== false;
+        }
+        return apiRequest('/api/generate/template', {
+          method: 'POST', body: JSON.stringify(body),
+        });
+      })
+    );
+
+    for (let i = 0; i < slideResults.length; i++) {
+      const r = slideResults[i];
+      if (r.status === 'fulfilled') {
+        images.push({ imageUrl: r.value.imageUrl, order: images.length, prompt: input.slides[i].title });
+      }
+    }
+
+    if (images.length < 2) {
+      throw new Error(`Carrossel precisa de pelo menos 2 imagens. Apenas ${images.length} gerada(s) com sucesso.`);
+    }
+
+    // Step 3: Caption
+    let caption = input.caption;
+    let hashtags = input.hashtags;
+    if (!caption) {
+      const tone = input.tone || (brand && brand.voiceTone) || undefined;
+      const result = await apiRequest('/api/generate/caption', {
+        method: 'POST', body: JSON.stringify({ topic: input.cover_prompt, tone }),
+      });
+      caption = result.caption;
+      hashtags = hashtags || result.hashtags;
+    }
+
+    // Merge brand default hashtags
+    if (brand && brand.defaultHashtags && brand.defaultHashtags.length) {
+      const existing = new Set((hashtags || []).map((h) => h.toLowerCase()));
+      const merged = [...(hashtags || [])];
+      for (const tag of brand.defaultHashtags) {
+        if (!existing.has(tag.toLowerCase())) merged.push(tag);
+      }
+      hashtags = merged;
+    }
+
+    // Step 4: Create post
+    const post = await apiRequest('/api/posts', {
+      method: 'POST',
+      body: JSON.stringify({
+        caption, hashtags, source: 'MCP', aspectRatio,
+        isCarousel: true, images,
+        ...(input.scheduled_at ? { scheduledAt: input.scheduled_at } : {}),
+      }),
+    });
+
+    return {
+      content: [{
+        type: 'text',
+        text: JSON.stringify({
+          post_id: post.id,
+          caption: post.caption,
+          is_carousel: true,
+          cover_image: images[0].imageUrl,
+          template_slides: images.length - 1,
+          total_images: images.length,
+          brand_applied: brand ? { id: brand.id, name: brand.name } : null,
+          status: post.status,
+          scheduled_at: post.scheduledAt || null,
+        }, null, 2),
+      }],
+    };
+  }
+);
+
+// ── Brands ──
+
+server.tool('list_brands', 'Lista todos os brands cadastrados (identidade visual: logo, cores, produtos, tom de voz). Use ANTES de criar qualquer post visual para perguntar ao usuario qual brand aplicar', {}, async () => {
+  const result = await apiRequest('/api/brands');
+  return { content: [{ type: 'text', text: JSON.stringify(result, null, 2) }] };
+});
+
+server.tool('get_brand', 'Retorna detalhes completos de um brand especifico', {
+  brand_id: z.string().describe('ID do brand'),
+}, async (input) => {
+  const result = await apiRequest(`/api/brands/${input.brand_id}`);
+  return { content: [{ type: 'text', text: JSON.stringify(result, null, 2) }] };
+});
+
+server.tool('get_default_brand', 'Retorna o brand padrao do usuario (se houver). Util para aplicar automaticamente quando o usuario nao especifica', {}, async () => {
+  const result = await apiRequest('/api/brands/default');
+  return { content: [{ type: 'text', text: JSON.stringify(result, null, 2) }] };
+});
+
+server.tool('create_brand', 'Cria um novo brand com identidade visual', {
+  name: z.string().describe('Nome do brand'),
+  logo_url: z.string().optional().describe('URL do logo'),
+  primary_color: z.string().optional().describe('Cor primaria em hex (#RRGGBB)'),
+  secondary_color: z.string().optional().describe('Cor secundaria em hex (#RRGGBB)'),
+  accent_color: z.string().optional().describe('Cor de destaque em hex'),
+  font_family: z.string().optional().describe('Familia de fonte preferida'),
+  description: z.string().optional().describe('Descricao do brand'),
+  voice_tone: z.string().optional().describe('Tom de voz: profissional, descontraido, educativo'),
+  products: z.array(z.string()).optional().describe('Lista de produtos/servicos'),
+  default_hashtags: z.array(z.string()).optional().describe('Hashtags padrao a aplicar nos posts'),
+  is_default: z.boolean().optional().describe('Se este sera o brand padrao'),
+}, async (input) => {
+  const body = {
+    name: input.name,
+    logoUrl: input.logo_url,
+    primaryColor: input.primary_color,
+    secondaryColor: input.secondary_color,
+    accentColor: input.accent_color,
+    fontFamily: input.font_family,
+    description: input.description,
+    voiceTone: input.voice_tone,
+    products: input.products,
+    defaultHashtags: input.default_hashtags,
+    isDefault: input.is_default,
+  };
+  const result = await apiRequest('/api/brands', {
+    method: 'POST', body: JSON.stringify(body),
+  });
+  return { content: [{ type: 'text', text: JSON.stringify(result, null, 2) }] };
+});
+
+server.tool('update_brand', 'Atualiza um brand existente', {
+  brand_id: z.string().describe('ID do brand'),
+  name: z.string().optional(),
+  logo_url: z.string().optional(),
+  primary_color: z.string().optional(),
+  secondary_color: z.string().optional(),
+  accent_color: z.string().optional(),
+  font_family: z.string().optional(),
+  description: z.string().optional(),
+  voice_tone: z.string().optional(),
+  products: z.array(z.string()).optional(),
+  default_hashtags: z.array(z.string()).optional(),
+  is_default: z.boolean().optional(),
+}, async (input) => {
+  const body = {};
+  if (input.name !== undefined) body.name = input.name;
+  if (input.logo_url !== undefined) body.logoUrl = input.logo_url;
+  if (input.primary_color !== undefined) body.primaryColor = input.primary_color;
+  if (input.secondary_color !== undefined) body.secondaryColor = input.secondary_color;
+  if (input.accent_color !== undefined) body.accentColor = input.accent_color;
+  if (input.font_family !== undefined) body.fontFamily = input.font_family;
+  if (input.description !== undefined) body.description = input.description;
+  if (input.voice_tone !== undefined) body.voiceTone = input.voice_tone;
+  if (input.products !== undefined) body.products = input.products;
+  if (input.default_hashtags !== undefined) body.defaultHashtags = input.default_hashtags;
+  if (input.is_default !== undefined) body.isDefault = input.is_default;
+  const result = await apiRequest(`/api/brands/${input.brand_id}`, {
+    method: 'PUT', body: JSON.stringify(body),
+  });
+  return { content: [{ type: 'text', text: JSON.stringify(result, null, 2) }] };
+});
+
+server.tool('set_default_brand', 'Define um brand como padrao (desmarca os outros automaticamente)', {
+  brand_id: z.string().describe('ID do brand a tornar padrao'),
+}, async (input) => {
+  const result = await apiRequest(`/api/brands/${input.brand_id}/default`, { method: 'PUT' });
+  return { content: [{ type: 'text', text: JSON.stringify(result, null, 2) }] };
+});
+
+server.tool('delete_brand', 'Remove um brand', {
+  brand_id: z.string().describe('ID do brand a remover'),
+}, async (input) => {
+  const result = await apiRequest(`/api/brands/${input.brand_id}`, { method: 'DELETE' });
+  return { content: [{ type: 'text', text: JSON.stringify(result, null, 2) }] };
+});
+
 // ── Start ──
 
 async function main() {

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "openhive-mcp-server",
-  "version": "1.0.0",
-  "description": "OpenHive AI MCP Server - Connect Claude, Antigravity, Cursor and other IDEs to your OpenHive instance",
+  "version": "1.2.0",
+  "description": "OpenHive AI MCP Server - Connect Claude, Antigravity, Cursor and other IDEs to your OpenHive instance. 35 tools including Brands and Mixed Carousel.",
   "main": "index.js",
   "bin": {
     "openhive-mcp": "./index.js"