suparank 1.2.5 → 1.2.7

package/mcp-client/index.js

@@ -0,0 +1,33 @@
+#!/usr/bin/env node
+
+/**
+ * Suparank MCP - Main Entry Point
+ *
+ * Modular MCP server for AI-powered SEO content creation
+ *
+ * Usage:
+ *   npx suparank
+ *   node mcp-client/index.js <project-slug> <api-key>
+ *
+ * Credentials:
+ *   Local credentials are loaded from ~/.suparank/credentials.json
+ *   These enable additional tools: image generation, CMS publishing, webhooks
+ */
+
+import { main } from './server.js'
+import { log } from './utils/logging.js'
+
+// Re-export modules for external use
+export * from './config.js'
+export * from './utils/index.js'
+export * from './services/index.js'
+export * from './tools/index.js'
+export * from './handlers/index.js'
+export * from './publishers/index.js'
+export * from './workflow/index.js'
+
+// Run server
+main().catch((error) => {
+  log('Fatal error:', error)
+  process.exit(1)
+})

package/mcp-client/publishers/ghost.js

@@ -0,0 +1,105 @@
+/**
+ * Suparank MCP - Ghost Publisher
+ *
+ * Publish content to Ghost CMS using Admin API
+ */
+
+import { log, progress } from '../utils/logging.js'
+import { fetchWithRetry } from '../services/api.js'
+import { getCredentials } from '../services/credentials.js'
+import { markdownToHtml } from '../utils/formatting.js'
+
+/**
+ * Create JWT for Ghost Admin API
+ * @param {string} id - API key ID
+ * @param {string} secret - API key secret
+ * @returns {Promise<string>} JWT token
+ */
+async function createGhostJWT(id, secret) {
+  // Simple JWT creation for Ghost
+  const header = Buffer.from(JSON.stringify({ alg: 'HS256', typ: 'JWT', kid: id })).toString('base64url')
+  const now = Math.floor(Date.now() / 1000)
+  const payload = Buffer.from(JSON.stringify({
+    iat: now,
+    exp: now + 300, // 5 minutes
+    aud: '/admin/'
+  })).toString('base64url')
+
+  // Create signature using crypto
+  const crypto = await import('crypto')
+  const key = Buffer.from(secret, 'hex')
+  const signature = crypto.createHmac('sha256', key)
+    .update(`${header}.${payload}`)
+    .digest('base64url')
+
+  return `${header}.${payload}.${signature}`
+}
+
+/**
+ * Publish content to Ghost CMS
+ * @param {object} args - Publish arguments
+ * @param {string} args.title - Post title
+ * @param {string} args.content - Post content (markdown)
+ * @param {string} [args.status='draft'] - Publication status
+ * @param {string[]} [args.tags=[]] - Tag names
+ * @param {string} [args.featured_image_url] - Featured image URL
+ * @returns {Promise<object>} MCP response
+ */
+export async function executeGhostPublish(args) {
+  const credentials = getCredentials()
+  const { api_url, admin_api_key } = credentials.ghost
+  const { title, content, status = 'draft', tags = [], featured_image_url } = args
+
+  progress('Publish', `Publishing to Ghost: "${title}"`)
+  log(`Publishing to Ghost: ${title}`)
+
+  // Create JWT for Ghost Admin API
+  const [id, secret] = admin_api_key.split(':')
+  const token = await createGhostJWT(id, secret)
+
+  // Convert markdown to HTML for proper element separation
+  const htmlContent = markdownToHtml(content)
+
+  // Use HTML card for proper rendering (each element separate)
+  const mobiledoc = JSON.stringify({
+    version: '0.3.1',
+    atoms: [],
+    cards: [['html', { html: htmlContent }]],
+    markups: [],
+    sections: [[10, 0]]
+  })
+
+  const postData = {
+    posts: [{
+      title,
+      mobiledoc,
+      status,
+      tags: tags.map(name => ({ name })),
+      feature_image: featured_image_url
+    }]
+  }
+
+  const response = await fetchWithRetry(`${api_url}/ghost/api/admin/posts/`, {
+    method: 'POST',
+    headers: {
+      'Authorization': `Ghost ${token}`,
+      'Content-Type': 'application/json'
+    },
+    body: JSON.stringify(postData)
+  }, 2, 30000) // 2 retries, 30s timeout
+
+  if (!response.ok) {
+    const error = await response.text()
+    throw new Error(`Ghost error: ${error}`)
+  }
+
+  const result = await response.json()
+  const post = result.posts[0]
+
+  return {
+    content: [{
+      type: 'text',
+      text: `Post published to Ghost!\n\n**Title:** ${post.title}\n**Status:** ${post.status}\n**URL:** ${post.url}\n**ID:** ${post.id}\n\n${status === 'draft' ? 'The post is saved as a draft. Edit and publish from Ghost dashboard.' : 'The post is now live!'}`
+    }]
+  }
+}

package/mcp-client/publishers/image.js

@@ -0,0 +1,306 @@
+/**
+ * Suparank MCP - Image Publisher
+ *
+ * AI image generation using fal.ai, Gemini, or Wiro
+ */
+
+import { log, progress } from '../utils/logging.js'
+import { fetchWithRetry } from '../services/api.js'
+import { getCredentials } from '../services/credentials.js'
+import { sessionState, saveSession } from '../services/session-state.js'
+import { incrementStat } from '../services/stats.js'
+import { API_ENDPOINTS } from '../config.js'
+
+/**
+ * Generate an AI image using the configured provider
+ * @param {object} args - Image generation arguments
+ * @param {string} args.prompt - Image prompt
+ * @param {string} [args.style] - Style guidance
+ * @param {string} [args.aspect_ratio='16:9'] - Aspect ratio
+ * @returns {Promise<object>} MCP response with image URL
+ */
+export async function executeImageGeneration(args) {
+  const credentials = getCredentials()
+  const provider = credentials.image_provider
+  const config = credentials[provider]
+
+  if (!config?.api_key) {
+    throw new Error(`${provider} API key not configured`)
+  }
+
+  progress('Image', `Generating with ${provider}...`)
+
+  const { prompt, style, aspect_ratio = '16:9' } = args
+  const fullPrompt = style ? `${prompt}, ${style}` : prompt
+
+  log(`Generating image with ${provider}: ${fullPrompt.substring(0, 50)}...`)
+
+  switch (provider) {
+    case 'fal':
+      return generateWithFal(config, fullPrompt, aspect_ratio)
+
+    case 'gemini':
+      return generateWithGemini(config, fullPrompt, aspect_ratio)
+
+    case 'wiro':
+      return generateWithWiro(config, fullPrompt, aspect_ratio)
+
+    default:
+      throw new Error(`Unknown image provider: ${provider}`)
+  }
+}
+
+/**
+ * Generate image with fal.ai
+ */
+async function generateWithFal(config, fullPrompt, aspect_ratio) {
+  const response = await fetchWithRetry(API_ENDPOINTS.fal, {
+    method: 'POST',
+    headers: {
+      'Authorization': `Key ${config.api_key}`,
+      'Content-Type': 'application/json'
+    },
+    body: JSON.stringify({
+      prompt: fullPrompt,
+      aspect_ratio: aspect_ratio,
+      output_format: 'png',
+      resolution: '1K',
+      num_images: 1
+    })
+  }, 2, 60000) // 2 retries, 60s timeout for image generation
+
+  if (!response.ok) {
+    const error = await response.text()
+    throw new Error(`fal.ai error: ${error}`)
+  }
+
+  const result = await response.json()
+  const imageUrl = result.images?.[0]?.url
+
+  // Store in session for orchestrated workflows
+  storeImageInSession(imageUrl)
+
+  // Track stats
+  incrementStat('images_generated')
+
+  const imageNumber = 1 + sessionState.inlineImages.length
+  const totalImages = sessionState.currentWorkflow?.settings?.total_images || 1
+  const imageType = imageNumber === 1 ? 'Cover Image' : `Inline Image ${imageNumber - 1}`
+
+  return {
+    content: [{
+      type: 'text',
+      text: `# ✅ ${imageType} Generated (${imageNumber}/${totalImages})
+
+**URL:** ${imageUrl}
+
+**Prompt:** ${fullPrompt}
+**Provider:** fal.ai (nano-banana-pro)
+**Aspect Ratio:** ${aspect_ratio}
+
+${imageNumber < totalImages ? `\n**Next:** Generate ${totalImages - imageNumber} more image(s).` : '\n**All images generated!** Proceed to publish.'}`
+    }]
+  }
+}
+
+/**
+ * Generate image with Google Gemini
+ */
+async function generateWithGemini(config, fullPrompt, aspect_ratio) {
+  const model = config.model || 'gemini-3-pro-image-preview'
+  const response = await fetch(
+    `${API_ENDPOINTS.gemini}/${model}:generateContent`,
+    {
+      method: 'POST',
+      headers: {
+        'Content-Type': 'application/json',
+        'x-goog-api-key': config.api_key
+      },
+      body: JSON.stringify({
+        contents: [{
+          parts: [{ text: fullPrompt }]
+        }],
+        generationConfig: {
+          responseModalities: ['IMAGE'],
+          imageConfig: {
+            aspectRatio: aspect_ratio,
+            imageSize: '1K'
+          }
+        }
+      })
+    }
+  )
+
+  if (!response.ok) {
+    const error = await response.text()
+    throw new Error(`Gemini error: ${error}`)
+  }
+
+  const result = await response.json()
+  const imagePart = result.candidates?.[0]?.content?.parts?.find(p => p.inlineData)
+  const imageData = imagePart?.inlineData?.data
+  const mimeType = imagePart?.inlineData?.mimeType || 'image/png'
+
+  if (!imageData) {
+    throw new Error('No image data in Gemini response')
+  }
+
+  // Return base64 data URI
+  const dataUri = `data:${mimeType};base64,${imageData}`
+
+  // Track stats
+  incrementStat('images_generated')
+
+  return {
+    content: [{
+      type: 'text',
+      text: `Image generated successfully!\n\n**Format:** Base64 Data URI\n**Prompt:** ${fullPrompt}\n**Provider:** Google Gemini (${model})\n**Aspect Ratio:** ${aspect_ratio}\n\n**Data URI:** ${dataUri.substring(0, 100)}...\n\n[Full base64 data: ${imageData.length} chars]`
+    }]
+  }
+}
+
+/**
+ * Generate image with Wiro
+ */
+async function generateWithWiro(config, fullPrompt, aspect_ratio) {
+  const crypto = await import('crypto')
+  const apiKey = config.api_key
+  const apiSecret = config.api_secret
+
+  if (!apiSecret) {
+    throw new Error('Wiro API secret not configured. Add api_secret to wiro config in ~/.suparank/credentials.json')
+  }
+
+  // Generate nonce and signature
+  const nonce = Math.floor(Date.now() / 1000).toString()
+  const signatureData = `${apiSecret}${nonce}`
+  const signature = crypto.createHmac('sha256', apiKey)
+    .update(signatureData)
+    .digest('hex')
+
+  const model = config.model || 'google/nano-banana-pro'
+
+  // Submit task
+  log(`Submitting wiro.ai task for model: ${model}`)
+  const submitResponse = await fetch(`${API_ENDPOINTS.wiro}/Run/${model}`, {
+    method: 'POST',
+    headers: {
+      'Content-Type': 'application/json',
+      'x-api-key': apiKey,
+      'x-nonce': nonce,
+      'x-signature': signature
+    },
+    body: JSON.stringify({
+      prompt: fullPrompt,
+      aspectRatio: aspect_ratio,
+      resolution: '1K',
+      safetySetting: 'BLOCK_ONLY_HIGH'
+    })
+  })
+
+  if (!submitResponse.ok) {
+    const error = await submitResponse.text()
+    throw new Error(`wiro.ai submit error: ${error}`)
+  }
+
+  const submitResult = await submitResponse.json()
+  if (!submitResult.result || !submitResult.taskid) {
+    throw new Error(`wiro.ai task submission failed: ${JSON.stringify(submitResult.errors)}`)
+  }
+
+  const taskId = submitResult.taskid
+  log(`wiro.ai task submitted: ${taskId}`)
+
+  // Poll for completion
+  const maxAttempts = 60 // 60 seconds max
+  const pollInterval = 2000 // 2 seconds
+
+  for (let attempt = 0; attempt < maxAttempts; attempt++) {
+    await new Promise(resolve => setTimeout(resolve, pollInterval))
+
+    // Generate new signature for poll request
+    const pollNonce = Math.floor(Date.now() / 1000).toString()
+    const pollSignatureData = `${apiSecret}${pollNonce}`
+    const pollSignature = crypto.createHmac('sha256', apiKey)
+      .update(pollSignatureData)
+      .digest('hex')
+
+    const pollResponse = await fetch(API_ENDPOINTS.wiroTaskDetail, {
+      method: 'POST',
+      headers: {
+        'Content-Type': 'application/json',
+        'x-api-key': apiKey,
+        'x-nonce': pollNonce,
+        'x-signature': pollSignature
+      },
+      body: JSON.stringify({ taskid: taskId })
+    })
+
+    if (!pollResponse.ok) {
+      log(`wiro.ai poll error: ${await pollResponse.text()}`)
+      continue
+    }
+
+    const pollResult = await pollResponse.json()
+    const task = pollResult.tasklist?.[0]
+
+    if (!task) continue
+
+    const status = task.status
+    log(`wiro.ai task status: ${status}`)
+
+    // Check for completion
+    if (status === 'task_postprocess_end') {
+      const imageUrl = task.outputs?.[0]?.url
+      if (!imageUrl) {
+        throw new Error('wiro.ai task completed but no output URL')
+      }
+
+      // Store in session for orchestrated workflows
+      storeImageInSession(imageUrl)
+
+      // Track stats
+      incrementStat('images_generated')
+
+      const imageNumber = 1 + sessionState.inlineImages.length
+      const totalImages = sessionState.currentWorkflow?.settings?.total_images || 1
+      const imageType = imageNumber === 1 ? 'Cover Image' : `Inline Image ${imageNumber - 1}`
+
+      return {
+        content: [{
+          type: 'text',
+          text: `# ✅ ${imageType} Generated (${imageNumber}/${totalImages})
+
+**URL:** ${imageUrl}
+
+**Prompt:** ${fullPrompt}
+**Provider:** wiro.ai (${model})
+**Aspect Ratio:** ${aspect_ratio}
+**Processing Time:** ${task.elapsedseconds}s
+
+${imageNumber < totalImages ? `\n**Next:** Generate ${totalImages - imageNumber} more image(s).` : '\n**All images generated!** Proceed to publish.'}`
+        }]
+      }
+    }
+
+    // Check for failure
+    if (status === 'task_cancel') {
+      throw new Error('wiro.ai task was cancelled')
+    }
+  }
+
+  throw new Error('wiro.ai task timed out after 60 seconds')
+}
+
+/**
+ * Store generated image URL in session
+ * First image is cover, subsequent are inline
+ */
+function storeImageInSession(imageUrl) {
+  if (!sessionState.imageUrl) {
+    sessionState.imageUrl = imageUrl
+  } else {
+    sessionState.inlineImages.push(imageUrl)
+  }
+  saveSession()
+}

package/mcp-client/publishers/index.js

@@ -0,0 +1,20 @@
+/**
+ * Suparank MCP - Publishers Module
+ *
+ * Re-exports all publisher functions
+ */
+
+// Image generation
+export { executeImageGeneration } from './image.js'
+
+// WordPress publishing
+export {
+  executeWordPressPublish,
+  fetchWordPressCategories
+} from './wordpress.js'
+
+// Ghost publishing
+export { executeGhostPublish } from './ghost.js'
+
+// Webhook sending
+export { executeSendWebhook } from './webhook.js'

package/mcp-client/publishers/webhook.js

@@ -0,0 +1,76 @@
+/**
+ * Suparank MCP - Webhook Publisher
+ *
+ * Send data to configured webhooks (Make.com, n8n, Zapier, Slack)
+ */
+
+import { log } from '../utils/logging.js'
+import { getCredentials } from '../services/credentials.js'
+import { projectSlug } from '../config.js'
+
+/**
+ * Send data to a webhook
+ * @param {object} args - Webhook arguments
+ * @param {string} [args.webhook_type='default'] - Webhook type
+ * @param {object} [args.payload={}] - Data payload
+ * @param {string} [args.message] - Message text (for Slack)
+ * @returns {Promise<object>} MCP response
+ */
+export async function executeSendWebhook(args) {
+  const credentials = getCredentials()
+  const { webhook_type = 'default', payload = {}, message } = args
+  const webhooks = credentials.webhooks
+
+  // Get webhook URL
+  const urlMap = {
+    default: webhooks.default_url,
+    make: webhooks.make_url,
+    n8n: webhooks.n8n_url,
+    zapier: webhooks.zapier_url,
+    slack: webhooks.slack_url
+  }
+
+  const url = urlMap[webhook_type]
+  if (!url) {
+    throw new Error(`No ${webhook_type} webhook URL configured`)
+  }
+
+  log(`Sending webhook to ${webhook_type}: ${url}`)
+
+  // Format payload based on type
+  let body
+  const headers = { 'Content-Type': 'application/json' }
+
+  if (webhook_type === 'slack') {
+    body = JSON.stringify({
+      text: message || 'Message from Writer MCP',
+      ...payload
+    })
+  } else {
+    body = JSON.stringify({
+      source: 'suparank',
+      timestamp: new Date().toISOString(),
+      project: projectSlug,
+      data: payload,
+      message
+    })
+  }
+
+  const response = await fetch(url, {
+    method: 'POST',
+    headers,
+    body
+  })
+
+  if (!response.ok) {
+    const error = await response.text()
+    throw new Error(`Webhook error (${response.status}): ${error}`)
+  }
+
+  return {
+    content: [{
+      type: 'text',
+      text: `Webhook sent successfully!\n\n**Type:** ${webhook_type}\n**URL:** ${url.substring(0, 50)}...\n**Status:** ${response.status}\n\nThe data has been sent to your ${webhook_type} webhook.`
+    }]
+  }
+}