@intranefr/superbackend 1.5.0 → 1.5.2

package/src/controllers/blogAdmin.controller.js

@@ -0,0 +1,279 @@
+const BlogPost = require('../models/BlogPost');
+const {
+  extractExcerptFromMarkdown,
+  generateUniqueBlogSlug,
+  normalizeTags,
+  slugify,
+  parsePagination,
+} = require('../services/blog.service');
+
+function normalizeStringField(value) {
+  if (value === undefined) return undefined;
+  return String(value || '').trim();
+}
+
+exports.list = async (req, res) => {
+  try {
+    const { page, limit, skip } = parsePagination({
+      page: req.query.page,
+      limit: req.query.limit,
+      maxLimit: 200,
+      defaultLimit: 50,
+    });
+
+    const filter = {};
+
+    const status = String(req.query.status || '').trim();
+    if (status) filter.status = status;
+
+    const tag = String(req.query.tag || '').trim();
+    if (tag) filter.tags = tag;
+
+    const category = String(req.query.category || '').trim();
+    if (category) filter.category = category;
+
+    const q = String(req.query.q || '').trim();
+    if (q) {
+      const re = new RegExp(q.replace(/[.*+?^${}()|[\]\\]/g, '\\$&'), 'i');
+      filter.$or = [{ title: re }, { excerpt: re }, { slug: re }];
+    }
+
+    const statsBaseFilter = { ...filter };
+    delete statsBaseFilter.status;
+
+    const [items, total, statsTotal, statsDraft, statsScheduled, statsPublished, statsArchived] = await Promise.all([
+      BlogPost.find(filter)
+        .sort({ updatedAt: -1, createdAt: -1 })
+        .select('title slug status excerpt category tags authorName publishedAt scheduledAt updatedAt createdAt')
+        .skip(skip)
+        .limit(limit)
+        .lean(),
+      BlogPost.countDocuments(filter),
+      BlogPost.countDocuments(statsBaseFilter),
+      BlogPost.countDocuments({ ...statsBaseFilter, status: 'draft' }),
+      BlogPost.countDocuments({ ...statsBaseFilter, status: 'scheduled' }),
+      BlogPost.countDocuments({ ...statsBaseFilter, status: 'published' }),
+      BlogPost.countDocuments({ ...statsBaseFilter, status: 'archived' }),
+    ]);
+
+    res.json({
+      items,
+      pagination: { page, limit, total, pages: Math.ceil(total / limit) },
+      stats: {
+        total: statsTotal,
+        draft: statsDraft,
+        scheduled: statsScheduled,
+        published: statsPublished,
+        archived: statsArchived,
+      },
+    });
+  } catch (error) {
+    console.error('Error listing admin blog posts:', error);
+    res.status(500).json({ error: 'Failed to list blog posts' });
+  }
+};
+
+exports.suggestions = async (req, res) => {
+  try {
+    const [categories, authorNames, tagsAgg] = await Promise.all([
+      BlogPost.distinct('category', { category: { $ne: '' } }),
+      BlogPost.distinct('authorName', { authorName: { $ne: '' } }),
+      BlogPost.aggregate([
+        { $unwind: '$tags' },
+        { $match: { tags: { $ne: '' } } },
+        { $group: { _id: '$tags' } },
+        { $project: { _id: 0, tag: '$_id' } },
+      ]),
+    ]);
+
+    const tags = (tagsAgg || []).map((t) => String(t.tag || '')).filter(Boolean);
+
+    res.json({
+      categories: (categories || []).map((x) => String(x || '')).filter(Boolean).sort(),
+      tags: tags.sort(),
+      authorNames: (authorNames || []).map((x) => String(x || '')).filter(Boolean).sort(),
+    });
+  } catch (error) {
+    console.error('Error building blog suggestions:', error);
+    res.status(500).json({ error: 'Failed to load suggestions' });
+  }
+};
+
+exports.create = async (req, res) => {
+  try {
+    const payload = req.body || {};
+    const title = normalizeStringField(payload.title);
+    if (!title) return res.status(400).json({ error: 'title is required' });
+
+    const markdown = String(payload.markdown || '');
+    if (!markdown.trim()) return res.status(400).json({ error: 'markdown is required' });
+
+    const html = String(payload.html || payload.markdown || '');
+    const excerpt =
+      normalizeStringField(payload.excerpt) || extractExcerptFromMarkdown(markdown);
+
+    const desiredSlug = normalizeStringField(payload.slug);
+    const slug = desiredSlug ? slugify(desiredSlug) : await generateUniqueBlogSlug(title);
+
+    const post = await BlogPost.create({
+      title,
+      slug,
+      status: 'draft',
+      excerpt,
+      markdown,
+      html,
+      coverImageUrl: normalizeStringField(payload.coverImageUrl) || '',
+      category: normalizeStringField(payload.category) || '',
+      tags: normalizeTags(payload.tags),
+      authorName: normalizeStringField(payload.authorName) || '',
+      seoTitle: normalizeStringField(payload.seoTitle) || '',
+      seoDescription: normalizeStringField(payload.seoDescription) || '',
+      scheduledAt: null,
+      publishedAt: null,
+    });
+
+    res.status(201).json({ item: post.toObject() });
+  } catch (error) {
+    console.error('Error creating blog post:', error);
+    res.status(500).json({ error: 'Failed to create blog post' });
+  }
+};
+
+exports.get = async (req, res) => {
+  try {
+    const post = await BlogPost.findById(req.params.id).lean();
+    if (!post) return res.status(404).json({ error: 'Not found' });
+    res.json({ item: post });
+  } catch (error) {
+    console.error('Error getting blog post:', error);
+    res.status(500).json({ error: 'Failed to get blog post' });
+  }
+};
+
+exports.update = async (req, res) => {
+  try {
+    const post = await BlogPost.findById(req.params.id);
+    if (!post) return res.status(404).json({ error: 'Not found' });
+
+    const payload = req.body || {};
+
+    if (payload.title !== undefined) post.title = normalizeStringField(payload.title) || '';
+    if (!post.title) return res.status(400).json({ error: 'title is required' });
+
+    if (payload.slug !== undefined) {
+      const desired = slugify(payload.slug);
+      post.slug = desired || (await generateUniqueBlogSlug(post.title, { excludeId: post._id }));
+    }
+    if (!post.slug) {
+      post.slug = await generateUniqueBlogSlug(post.title, { excludeId: post._id });
+    }
+
+    if (payload.markdown !== undefined) post.markdown = String(payload.markdown || '');
+    if (payload.html !== undefined) post.html = String(payload.html || '');
+
+    if (payload.excerpt !== undefined) {
+      post.excerpt = normalizeStringField(payload.excerpt) || '';
+    }
+    if (!post.excerpt) {
+      post.excerpt = extractExcerptFromMarkdown(post.markdown);
+    }
+
+    if (payload.coverImageUrl !== undefined) post.coverImageUrl = normalizeStringField(payload.coverImageUrl) || '';
+    if (payload.category !== undefined) post.category = normalizeStringField(payload.category) || '';
+    if (payload.authorName !== undefined) post.authorName = normalizeStringField(payload.authorName) || '';
+    if (payload.seoTitle !== undefined) post.seoTitle = normalizeStringField(payload.seoTitle) || '';
+    if (payload.seoDescription !== undefined) post.seoDescription = normalizeStringField(payload.seoDescription) || '';
+    if (payload.tags !== undefined) post.tags = normalizeTags(payload.tags);
+
+    await post.save();
+
+    res.json({ item: post.toObject() });
+  } catch (error) {
+    console.error('Error updating blog post:', error);
+    res.status(500).json({ error: 'Failed to update blog post' });
+  }
+};
+
+exports.publish = async (req, res) => {
+  try {
+    const post = await BlogPost.findById(req.params.id);
+    if (!post) return res.status(404).json({ error: 'Not found' });
+
+    post.status = 'published';
+    post.scheduledAt = null;
+    if (!post.publishedAt) post.publishedAt = new Date();
+    await post.save();
+
+    res.json({ item: post.toObject() });
+  } catch (error) {
+    console.error('Error publishing blog post:', error);
+    res.status(500).json({ error: 'Failed to publish blog post' });
+  }
+};
+
+exports.unpublish = async (req, res) => {
+  try {
+    const post = await BlogPost.findById(req.params.id);
+    if (!post) return res.status(404).json({ error: 'Not found' });
+
+    post.status = 'draft';
+    post.scheduledAt = null;
+    await post.save();
+
+    res.json({ item: post.toObject() });
+  } catch (error) {
+    console.error('Error unpublishing blog post:', error);
+    res.status(500).json({ error: 'Failed to unpublish blog post' });
+  }
+};
+
+exports.schedule = async (req, res) => {
+  try {
+    const post = await BlogPost.findById(req.params.id);
+    if (!post) return res.status(404).json({ error: 'Not found' });
+
+    const scheduledAtRaw = req.body?.scheduledAt;
+    const scheduledAt = scheduledAtRaw ? new Date(scheduledAtRaw) : null;
+    if (!scheduledAt || Number.isNaN(scheduledAt.getTime())) {
+      return res.status(400).json({ error: 'scheduledAt is required and must be a valid date' });
+    }
+
+    post.status = 'scheduled';
+    post.scheduledAt = scheduledAt;
+    await post.save();
+
+    res.json({ item: post.toObject() });
+  } catch (error) {
+    console.error('Error scheduling blog post:', error);
+    res.status(500).json({ error: 'Failed to schedule blog post' });
+  }
+};
+
+exports.archive = async (req, res) => {
+  try {
+    const post = await BlogPost.findById(req.params.id);
+    if (!post) return res.status(404).json({ error: 'Not found' });
+
+    post.status = 'archived';
+    post.scheduledAt = null;
+    await post.save();
+
+    res.json({ item: post.toObject() });
+  } catch (error) {
+    console.error('Error archiving blog post:', error);
+    res.status(500).json({ error: 'Failed to archive blog post' });
+  }
+};
+
+exports.remove = async (req, res) => {
+  try {
+    const post = await BlogPost.findById(req.params.id);
+    if (!post) return res.status(404).json({ error: 'Not found' });
+
+    await BlogPost.deleteOne({ _id: post._id });
+    res.json({ deleted: true });
+  } catch (error) {
+    console.error('Error deleting blog post:', error);
+    res.status(500).json({ error: 'Failed to delete blog post' });
+  }
+};

package/src/controllers/blogAiAdmin.controller.js

@@ -0,0 +1,224 @@
+const llmService = require('../services/llm.service');
+
+function safeJsonExtract(raw) {
+  const text = String(raw || '').trim();
+  if (!text) return null;
+
+  let cleaned = text;
+  if (cleaned.startsWith('```')) {
+    cleaned = cleaned.replace(/^```[a-zA-Z]*\s*/m, '').replace(/```\s*$/m, '').trim();
+  }
+
+  const firstObj = cleaned.indexOf('{');
+  const lastObj = cleaned.lastIndexOf('}');
+  const firstArr = cleaned.indexOf('[');
+  const lastArr = cleaned.lastIndexOf(']');
+
+  let candidate = cleaned;
+  if (firstObj !== -1 && lastObj !== -1 && lastObj > firstObj) {
+    candidate = cleaned.slice(firstObj, lastObj + 1);
+  } else if (firstArr !== -1 && lastArr !== -1 && lastArr > firstArr) {
+    candidate = cleaned.slice(firstArr, lastArr + 1);
+  }
+
+  try {
+    return JSON.parse(candidate);
+  } catch {
+    return null;
+  }
+}
+
+exports.generateField = async (req, res) => {
+  try {
+    const { field, context, providerKey, model } = req.body || {};
+    const f = String(field || '').trim();
+    if (!f) return res.status(400).json({ error: 'field is required' });
+    if (!providerKey) return res.status(400).json({ error: 'providerKey is required' });
+
+    const ctx = context && typeof context === 'object' ? context : {};
+
+    const system =
+      'You are an expert blog editor. You write clear, concise, SEO-friendly copy. ' +
+      'Return ONLY the requested output with no extra commentary.';
+
+    const instructionsByField = {
+      title: 'Generate a compelling blog post title. Keep it SEO-friendly. Max 70 characters. Return only the title.',
+      excerpt: 'Generate a short excerpt (1-2 sentences). SEO-friendly, no markdown, no quotes. Return only the excerpt.',
+      category: 'Suggest a single category (2-4 words). Return only the category.',
+      tags: 'Generate 5-10 relevant tags. Return as a comma-separated list, lowercase where appropriate.',
+      seoTitle: 'Generate an SEO title. Max 60 characters. Return only the SEO title.',
+      seoDescription: 'Generate an SEO meta description. Max 155 characters. Return only the description.',
+    };
+
+    const instruction =
+      instructionsByField[f] || `Generate a value for field "${f}". Return only the value.`;
+
+    const result = await llmService.callAdhoc(
+      {
+        providerKey,
+        model,
+        promptKeyForAudit: `blog.ai.generate.${f}`,
+        messages: [
+          { role: 'system', content: system },
+          { role: 'user', content: instruction + '\n\nContext (JSON):\n' + JSON.stringify(ctx, null, 2) },
+        ],
+      },
+      { temperature: 0.6, max_tokens: 256 },
+    );
+
+    res.json({ value: String(result?.content || '').trim(), usage: result?.usage || null });
+  } catch (error) {
+    console.error('[blog-ai] generate-field error', error);
+    res.status(500).json({ error: error.message || 'Failed to generate field' });
+  }
+};
+
+exports.generateAll = async (req, res) => {
+  try {
+    const { context, providerKey, model } = req.body || {};
+    if (!providerKey) return res.status(400).json({ error: 'providerKey is required' });
+
+    const ctx = context && typeof context === 'object' ? context : {};
+
+    const system = 'Return ONLY a valid JSON object, no markdown fences.';
+
+    const user =
+      'Generate blog metadata fields based on the blog content and context.\n' +
+      'Return a JSON object with keys: title, excerpt, category, tags, seoTitle, seoDescription.\n' +
+      'tags must be an array of strings.\n\n' +
+      'Context (JSON):\n' +
+      JSON.stringify(ctx, null, 2);
+
+    const result = await llmService.callAdhoc(
+      {
+        providerKey,
+        model,
+        promptKeyForAudit: 'blog.ai.generate_all',
+        messages: [
+          { role: 'system', content: system },
+          { role: 'user', content: user },
+        ],
+      },
+      { temperature: 0.6, max_tokens: 600 },
+    );
+
+    const parsed = safeJsonExtract(result?.content) || null;
+    if (!parsed || typeof parsed !== 'object') {
+      return res.status(500).json({ error: 'AI returned invalid JSON', raw: String(result?.content || '') });
+    }
+
+    if (typeof parsed.tags === 'string') {
+      parsed.tags = parsed.tags
+        .split(',')
+        .map((t) => String(t || '').trim())
+        .filter(Boolean);
+    }
+    if (parsed.tags !== undefined && !Array.isArray(parsed.tags)) {
+      parsed.tags = [];
+    }
+
+    res.json({ values: parsed, usage: result?.usage || null });
+  } catch (error) {
+    console.error('[blog-ai] generate-all error', error);
+    res.status(500).json({ error: error.message || 'Failed to generate all' });
+  }
+};
+
+exports.formatMarkdown = async (req, res) => {
+  try {
+    const { text, context, providerKey, model } = req.body || {};
+    if (!providerKey) return res.status(400).json({ error: 'providerKey is required' });
+
+    const input = String(text || '');
+    if (!input.trim()) return res.status(400).json({ error: 'text is required' });
+
+    const ctx = context && typeof context === 'object' ? context : {};
+
+    const system = 'You are an expert blog editor. Output only markdown. Do not wrap in code fences.';
+
+    const user =
+      'Convert the following content into clean, well-structured markdown with headings, lists, and short paragraphs.\n' +
+      'Preserve meaning, improve readability.\n\n' +
+      'Context (JSON):\n' +
+      JSON.stringify(ctx, null, 2) +
+      '\n\nInput:\n' +
+      input;
+
+    const result = await llmService.callAdhoc(
+      {
+        providerKey,
+        model,
+        promptKeyForAudit: 'blog.ai.format_markdown',
+        messages: [
+          { role: 'system', content: system },
+          { role: 'user', content: user },
+        ],
+      },
+      { temperature: 0.4, max_tokens: 2000 },
+    );
+
+    res.json({ markdown: String(result?.content || ''), usage: result?.usage || null });
+  } catch (error) {
+    console.error('[blog-ai] format-markdown error', error);
+    res.status(500).json({ error: error.message || 'Failed to format markdown' });
+  }
+};
+
+exports.refineMarkdown = async (req, res) => {
+  try {
+    const { markdown, instruction, selectionStart, selectionEnd, context, providerKey, model } = req.body || {};
+    if (!providerKey) return res.status(400).json({ error: 'providerKey is required' });
+
+    const md = String(markdown || '');
+    if (!md.trim()) return res.status(400).json({ error: 'markdown is required' });
+
+    const instr = String(instruction || '').trim();
+    if (!instr) return res.status(400).json({ error: 'instruction is required' });
+
+    const ctx = context && typeof context === 'object' ? context : {};
+
+    const start = Number(selectionStart);
+    const end = Number(selectionEnd);
+    const hasSelection = Number.isFinite(start) && Number.isFinite(end) && end > start;
+    const selected = hasSelection ? md.slice(start, end) : '';
+
+    const system = 'You are an expert blog editor. Output only markdown. Do not wrap in code fences.';
+
+    const user = hasSelection
+      ? 'Refine ONLY the selected markdown according to the instruction. Return ONLY the replacement markdown for the selection.\n\n' +
+        'Instruction:\n' + instr +
+        '\n\nContext (JSON):\n' + JSON.stringify(ctx, null, 2) +
+        '\n\nSelected markdown:\n' + selected
+      : 'Refine the full markdown according to the instruction. Return ONLY the full updated markdown.\n\n' +
+        'Instruction:\n' + instr +
+        '\n\nContext (JSON):\n' + JSON.stringify(ctx, null, 2) +
+        '\n\nMarkdown:\n' + md;
+
+    const result = await llmService.callAdhoc(
+      {
+        providerKey,
+        model,
+        promptKeyForAudit: hasSelection ? 'blog.ai.refine.selection' : 'blog.ai.refine.full',
+        messages: [
+          { role: 'system', content: system },
+          { role: 'user', content: user },
+        ],
+      },
+      { temperature: 0.5, max_tokens: 2000 },
+    );
+
+    const replacement = String(result?.content || '');
+    const nextMarkdown = hasSelection ? md.slice(0, start) + replacement + md.slice(end) : replacement;
+
+    res.json({
+      markdown: nextMarkdown,
+      replaced: hasSelection,
+      selectionStart: hasSelection ? start : null,
+      selectionEnd: hasSelection ? start + replacement.length : null,
+      usage: result?.usage || null,
+    });
+  } catch (error) {
+    console.error('[blog-ai] refine-markdown error', error);
+    res.status(500).json({ error: error.message || 'Failed to refine markdown' });
+  }
+};

package/src/controllers/blogAutomationAdmin.controller.js

@@ -0,0 +1,141 @@
+const blogAutomationService = require('../services/blogAutomation.service');
+
+exports.getConfig = async (req, res) => {
+  res.status(400).json({
+    error: 'Deprecated endpoint. Use /api/admin/blog-automation/configs instead.',
+  });
+};
+
+exports.saveConfig = async (req, res) => {
+  res.status(400).json({
+    error: 'Deprecated endpoint. Use /api/admin/blog-automation/configs instead.',
+  });
+};
+
+exports.listConfigs = async (req, res) => {
+  try {
+    const configs = await blogAutomationService.getBlogAutomationConfigs();
+    res.json({ configs });
+  } catch (error) {
+    console.error('Error listing blog automation configs:', error);
+    res.status(500).json({ error: 'Failed to load configs' });
+  }
+};
+
+exports.previewPromptsByConfigId = async (req, res) => {
+  try {
+    const configId = String(req.params.id || '').trim();
+    if (!configId) return res.status(400).json({ error: 'configId is required' });
+    const prompts = await blogAutomationService.previewPromptsByConfigId(configId);
+    res.json({ prompts });
+  } catch (error) {
+    const status = Number(error?.statusCode || 500);
+    if (status !== 500) return res.status(status).json({ error: String(error?.message || 'Invalid request') });
+    console.error('Error previewing blog automation prompts:', error);
+    res.status(500).json({ error: 'Failed to preview prompts' });
+  }
+};
+
+exports.getConfigById = async (req, res) => {
+  try {
+    const cfg = await blogAutomationService.getBlogAutomationConfigById(req.params.id);
+    res.json({ config: cfg });
+  } catch (error) {
+    const status = Number(error?.statusCode || 500);
+    if (status !== 500) return res.status(status).json({ error: String(error?.message || 'Invalid request') });
+    console.error('Error getting blog automation config:', error);
+    res.status(500).json({ error: 'Failed to load config' });
+  }
+};
+
+exports.createConfig = async (req, res) => {
+  try {
+    const name = String(req.body?.name || '').trim();
+    const created = await blogAutomationService.createAutomationConfig({ name });
+    const blogCronsBootstrap = require('../services/blogCronsBootstrap.service');
+    await blogCronsBootstrap.bootstrap();
+    res.json({ config: created });
+  } catch (error) {
+    console.error('Error creating blog automation config:', error);
+    res.status(500).json({ error: 'Failed to create config' });
+  }
+};
+
+exports.updateConfigById = async (req, res) => {
+  try {
+    const config = req.body?.config;
+    if (!config || typeof config !== 'object') {
+      return res.status(400).json({ error: 'config object is required' });
+    }
+    const updated = await blogAutomationService.updateAutomationConfig(req.params.id, config);
+    const blogCronsBootstrap = require('../services/blogCronsBootstrap.service');
+    await blogCronsBootstrap.bootstrap();
+    res.json({ config: updated });
+  } catch (error) {
+    const status = Number(error?.statusCode || 500);
+    if (status !== 500) return res.status(status).json({ error: String(error?.message || 'Invalid request') });
+    console.error('Error updating blog automation config:', error);
+    res.status(500).json({ error: 'Failed to update config' });
+  }
+};
+
+exports.deleteConfigById = async (req, res) => {
+  try {
+    await blogAutomationService.deleteAutomationConfig(req.params.id);
+    const blogCronsBootstrap = require('../services/blogCronsBootstrap.service');
+    await blogCronsBootstrap.bootstrap();
+    res.json({ success: true });
+  } catch (error) {
+    const status = Number(error?.statusCode || 500);
+    if (status !== 500) return res.status(status).json({ error: String(error?.message || 'Invalid request') });
+    console.error('Error deleting blog automation config:', error);
+    res.status(500).json({ error: 'Failed to delete config' });
+  }
+};
+
+exports.getStyleGuide = async (req, res) => {
+  try {
+    const styleGuide = await blogAutomationService.getBlogAutomationStyleGuide();
+    res.json({ styleGuide });
+  } catch (error) {
+    console.error('Error getting blog automation style guide:', error);
+    res.status(500).json({ error: 'Failed to load style guide' });
+  }
+};
+
+exports.saveStyleGuide = async (req, res) => {
+  try {
+    const styleGuide = String(req.body?.styleGuide ?? '');
+    await blogAutomationService.updateStyleGuide(styleGuide);
+    res.json({ success: true });
+  } catch (error) {
+    console.error('Error saving blog automation style guide:', error);
+    res.status(500).json({ error: 'Failed to save style guide' });
+  }
+};
+
+exports.listRuns = async (req, res) => {
+  try {
+    const limit = Math.min(100, Math.max(1, Number(req.query.limit || 30) || 30));
+    const configId = String(req.query.configId || '').trim();
+    const runs = await blogAutomationService.listRuns({ limit, configId });
+    res.json({ runs });
+  } catch (error) {
+    console.error('Error listing blog automation runs:', error);
+    res.status(500).json({ error: 'Failed to load runs' });
+  }
+};
+
+exports.runNow = async (req, res) => {
+  try {
+    const configId = String(req.body?.configId || '').trim();
+    if (!configId) return res.status(400).json({ error: 'configId is required' });
+    const run = await blogAutomationService.runBlogAutomation({ trigger: 'manual', configId });
+    res.json({ run });
+  } catch (error) {
+    const status = Number(error?.statusCode || 500);
+    if (status !== 500) return res.status(status).json({ error: String(error?.message || 'Invalid request') });
+    console.error('Error starting blog automation run:', error);
+    res.status(500).json({ error: 'Failed to run automation' });
+  }
+};

package/src/controllers/blogInternal.controller.js

@@ -0,0 +1,26 @@
+const blogAutomationService = require('../services/blogAutomation.service');
+const blogPublishingService = require('../services/blogPublishing.service');
+
+exports.runAutomation = async (req, res) => {
+  try {
+    const trigger = req.body?.trigger === 'scheduled' ? 'scheduled' : 'manual';
+    const configId = String(req.body?.configId || '').trim();
+    if (!configId) return res.status(400).json({ error: 'configId is required' });
+    const run = await blogAutomationService.runBlogAutomation({ trigger, configId });
+    res.json({ run });
+  } catch (error) {
+    console.error('internal automation run error:', error);
+    res.status(500).json({ error: 'Failed to run automation' });
+  }
+};
+
+exports.publishScheduled = async (req, res) => {
+  try {
+    const limit = req.body?.limit;
+    const result = await blogPublishingService.publishScheduledDue({ limit });
+    res.json({ result });
+  } catch (error) {
+    console.error('internal publish scheduled error:', error);
+    res.status(500).json({ error: 'Failed to publish scheduled posts' });
+  }
+};