suparank 1.2.6 → 1.2.8

package/mcp-client/publishers/wordpress.js

@@ -0,0 +1,220 @@
+/**
+ * Suparank MCP - WordPress Publisher
+ *
+ * Publish content to WordPress using REST API or Suparank Connector plugin
+ */
+
+import { log, progress } from '../utils/logging.js'
+import { fetchWithRetry, fetchWithTimeout } from '../services/api.js'
+import { getCredentials } from '../services/credentials.js'
+import { sessionState } from '../services/session-state.js'
+import { markdownToHtml } from '../utils/formatting.js'
+
+/**
+ * Fetch available categories from WordPress
+ * @returns {Promise<Array|null>} Categories array or null
+ */
+export async function fetchWordPressCategories() {
+  const credentials = getCredentials()
+  const wpConfig = credentials?.wordpress
+
+  if (!wpConfig?.secret_key || !wpConfig?.site_url) {
+    return null
+  }
+
+  try {
+    log('Fetching WordPress categories...')
+
+    // Try new Suparank endpoint first, then fall back to legacy
+    const endpoints = [
+      { url: `${wpConfig.site_url}/wp-json/suparank/v1/categories`, header: 'X-Suparank-Key' },
+      { url: `${wpConfig.site_url}/wp-json/writer-mcp/v1/categories`, header: 'X-Writer-MCP-Key' }
+    ]
+
+    for (const endpoint of endpoints) {
+      try {
+        const response = await fetchWithTimeout(endpoint.url, {
+          method: 'GET',
+          headers: {
+            [endpoint.header]: wpConfig.secret_key
+          }
+        }, 10000) // 10s timeout
+
+        if (response.ok) {
+          const result = await response.json()
+          if (result.success && result.categories) {
+            log(`Found ${result.categories.length} WordPress categories`)
+            return result.categories
+          }
+        }
+      } catch (e) {
+        // Try next endpoint
+      }
+    }
+
+    log('Failed to fetch categories from any endpoint')
+    return null
+  } catch (error) {
+    log(`Error fetching categories: ${error.message}`)
+    return null
+  }
+}
+
+/**
+ * Publish content to WordPress
+ * @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.categories=[]] - Category names
+ * @param {string[]} [args.tags=[]] - Tag names
+ * @param {string} [args.featured_image_url] - Featured image URL
+ * @returns {Promise<object>} MCP response
+ */
+export async function executeWordPressPublish(args) {
+  const credentials = getCredentials()
+  const wpConfig = credentials.wordpress
+  const { title, content, status = 'draft', categories = [], tags = [], featured_image_url } = args
+
+  progress('Publish', `Publishing to WordPress: "${title}"`)
+  log(`Publishing to WordPress: ${title}`)
+
+  // Convert markdown to HTML for WordPress
+  const htmlContent = markdownToHtml(content)
+
+  // Method 1: Use Suparank Connector plugin (secret_key auth)
+  if (wpConfig.secret_key) {
+    return publishWithPlugin(wpConfig, {
+      title,
+      htmlContent,
+      status,
+      categories,
+      tags,
+      featured_image_url
+    })
+  }
+
+  // Method 2: Use standard REST API with application password
+  if (wpConfig.app_password && wpConfig.username) {
+    return publishWithRestApi(wpConfig, {
+      title,
+      htmlContent,
+      status,
+      categories,
+      tags
+    })
+  }
+
+  throw new Error('WordPress credentials not configured. Add either secret_key (with plugin) or username + app_password to ~/.suparank/credentials.json')
+}
+
+/**
+ * Publish using Suparank/Writer MCP Connector plugin
+ */
+async function publishWithPlugin(wpConfig, { title, htmlContent, status, categories, tags, featured_image_url }) {
+  log('Using Suparank/Writer MCP Connector plugin')
+
+  // Try new Suparank endpoint first, then fall back to legacy
+  const endpoints = [
+    { url: `${wpConfig.site_url}/wp-json/suparank/v1/publish`, header: 'X-Suparank-Key' },
+    { url: `${wpConfig.site_url}/wp-json/writer-mcp/v1/publish`, header: 'X-Writer-MCP-Key' }
+  ]
+
+  const postBody = JSON.stringify({
+    title,
+    content: htmlContent,
+    status,
+    categories,
+    tags,
+    featured_image_url,
+    excerpt: sessionState.metaDescription || ''
+  })
+
+  let lastError = null
+  for (const endpoint of endpoints) {
+    try {
+      const response = await fetchWithRetry(endpoint.url, {
+        method: 'POST',
+        headers: {
+          'Content-Type': 'application/json',
+          [endpoint.header]: wpConfig.secret_key
+        },
+        body: postBody
+      }, 2, 30000) // 2 retries, 30s timeout
+
+      if (response.ok) {
+        const result = await response.json()
+
+        if (result.success) {
+          return formatSuccessResponse(result.post, status)
+        }
+      }
+      lastError = await response.text()
+    } catch (e) {
+      lastError = e.message
+    }
+  }
+
+  throw new Error(`WordPress error: ${lastError}`)
+}
+
+/**
+ * Publish using standard WordPress REST API
+ */
+async function publishWithRestApi(wpConfig, { title, htmlContent, status, categories, tags }) {
+  log('Using WordPress REST API with application password')
+
+  const auth = Buffer.from(`${wpConfig.username}:${wpConfig.app_password}`).toString('base64')
+  const postData = {
+    title,
+    content: htmlContent,
+    status,
+    categories: [],
+    tags: []
+  }
+
+  const response = await fetch(`${wpConfig.site_url}/wp-json/wp/v2/posts`, {
+    method: 'POST',
+    headers: {
+      'Authorization': `Basic ${auth}`,
+      'Content-Type': 'application/json'
+    },
+    body: JSON.stringify(postData)
+  })
+
+  if (!response.ok) {
+    const error = await response.text()
+    throw new Error(`WordPress error: ${error}`)
+  }
+
+  const post = await response.json()
+
+  return {
+    content: [{
+      type: 'text',
+      text: `Post published to WordPress!\n\n**Title:** ${post.title.rendered}\n**Status:** ${post.status}\n**URL:** ${post.link}\n**ID:** ${post.id}\n\n${status === 'draft' ? 'The post is saved as a draft. Edit and publish from WordPress dashboard.' : 'The post is now live!'}`
+    }]
+  }
+}
+
+/**
+ * Format success response for plugin publishing
+ */
+function formatSuccessResponse(post, status) {
+  const categoriesInfo = post.categories?.length
+    ? `\n**Categories:** ${post.categories.join(', ')}`
+    : ''
+  const tagsInfo = post.tags?.length
+    ? `\n**Tags:** ${post.tags.join(', ')}`
+    : ''
+  const imageInfo = post.featured_image
+    ? `\n**Featured Image:** Uploaded`
+    : ''
+
+  return {
+    content: [{
+      type: 'text',
+      text: `Post published to WordPress!\n\n**Title:** ${post.title}\n**Status:** ${post.status}\n**URL:** ${post.url}\n**Edit:** ${post.edit_url}\n**ID:** ${post.id}${categoriesInfo}${tagsInfo}${imageInfo}\n\n${status === 'draft' ? 'The post is saved as a draft. Edit and publish from WordPress dashboard.' : 'The post is now live!'}`
+    }]
+  }
+}

package/mcp-client/server.js

@@ -0,0 +1,220 @@
+/**
+ * Suparank MCP - Server Entry Point
+ *
+ * MCP server setup with stdio transport.
+ * Handles tool listing and execution.
+ */
+
+import { Server } from '@modelcontextprotocol/sdk/server/index.js'
+import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js'
+import {
+  CallToolRequestSchema,
+  ListToolsRequestSchema,
+  InitializeRequestSchema
+} from '@modelcontextprotocol/sdk/types.js'
+
+import { log, progress } from './utils/logging.js'
+import { projectSlug, apiUrl } from './config.js'
+
+// Services
+import {
+  loadCredentials,
+  hasCredential,
+  getCredentials,
+  getExternalMCPs,
+  getCompositionHints
+} from './services/credentials.js'
+import { restoreSession } from './services/session-state.js'
+import { incrementStat } from './services/stats.js'
+import { fetchProjectConfig } from './services/project.js'
+
+// Tools
+import {
+  ORCHESTRATOR_TOOLS,
+  ACTION_TOOLS,
+  getAvailableTools
+} from './tools/index.js'
+
+// Handlers
+import {
+  callBackendTool,
+  executeActionTool,
+  executeOrchestratorTool
+} from './handlers/index.js'
+
+/**
+ * Main server entry point
+ */
+export async function main() {
+  log(`Starting MCP client for project: ${projectSlug}`)
+  log(`API URL: ${apiUrl}`)
+
+  // Load local credentials
+  const credentials = loadCredentials()
+  if (credentials) {
+    const configured = []
+    if (hasCredential('wordpress')) configured.push('wordpress')
+    if (hasCredential('ghost')) configured.push('ghost')
+    if (hasCredential('image')) {
+      const creds = getCredentials()
+      configured.push(`image:${creds.image_provider}`)
+    }
+    if (hasCredential('webhooks')) configured.push('webhooks')
+
+    const externalMcps = getExternalMCPs()
+    if (externalMcps.length > 0) {
+      configured.push(`mcps:${externalMcps.map(m => m.name).join(',')}`)
+    }
+
+    if (configured.length > 0) {
+      log(`Configured integrations: ${configured.join(', ')}`)
+    }
+  }
+
+  // Restore session state from previous run
+  if (restoreSession()) {
+    progress('Session', 'Restored previous workflow state')
+  }
+
+  // Fetch project configuration
+  progress('Init', 'Connecting to platform...')
+  let project
+  try {
+    project = await fetchProjectConfig()
+    progress('Init', `Connected to project: ${project.name}`)
+  } catch (error) {
+    log('Failed to load project config. Exiting.')
+    process.exit(1)
+  }
+
+  // Create MCP server
+  const server = new Server(
+    {
+      name: 'suparank',
+      version: '1.0.0'
+    },
+    {
+      capabilities: {
+        tools: {}
+      }
+    }
+  )
+
+  // Handle initialization
+  server.setRequestHandler(InitializeRequestSchema, async (request) => {
+    log('Received initialize request')
+    return {
+      protocolVersion: '2024-11-05',
+      capabilities: {
+        tools: {}
+      },
+      serverInfo: {
+        name: 'suparank',
+        version: '1.0.0'
+      }
+    }
+  })
+
+  // Handle tools list
+  server.setRequestHandler(ListToolsRequestSchema, async () => {
+    log('Received list tools request')
+    const tools = getAvailableTools()
+    log(`Returning ${tools.length} tools (${ACTION_TOOLS.length} action tools)`)
+    return { tools }
+  })
+
+  // Handle tool calls
+  server.setRequestHandler(CallToolRequestSchema, async (request) => {
+    const { name, arguments: args } = request.params
+    progress('Tool', `Executing ${name}`)
+    log(`Executing tool: ${name}`)
+
+    // Track tool call stats
+    incrementStat('tool_calls')
+
+    // Check if this is an orchestrator tool
+    const orchestratorTool = ORCHESTRATOR_TOOLS.find(t => t.name === name)
+
+    if (orchestratorTool) {
+      try {
+        const result = await executeOrchestratorTool(name, args || {}, project)
+        log(`Orchestrator tool ${name} completed successfully`)
+        return result
+      } catch (error) {
+        log(`Orchestrator tool ${name} failed:`, error.message)
+        return {
+          content: [{
+            type: 'text',
+            text: `Error executing ${name}: ${error.message}`
+          }]
+        }
+      }
+    }
+
+    // Check if this is an action tool
+    const actionTool = ACTION_TOOLS.find(t => t.name === name)
+
+    if (actionTool) {
+      // Check credentials
+      if (!hasCredential(actionTool.requiresCredential)) {
+        return {
+          content: [{
+            type: 'text',
+            text: `Error: ${name} requires ${actionTool.requiresCredential} credentials.\n\nTo enable this tool:\n1. Run: npx suparank setup\n2. Add your ${actionTool.requiresCredential} credentials to ~/.suparank/credentials.json\n3. Restart the MCP server\n\nSee dashboard Settings > Credentials for setup instructions.`
+          }]
+        }
+      }
+
+      // Execute action tool locally
+      try {
+        const result = await executeActionTool(name, args || {})
+        log(`Action tool ${name} completed successfully`)
+        return result
+      } catch (error) {
+        log(`Action tool ${name} failed:`, error.message)
+        return {
+          content: [{
+            type: 'text',
+            text: `Error executing ${name}: ${error.message}`
+          }]
+        }
+      }
+    }
+
+    // Regular tool - call backend
+    try {
+      // Add composition hints if configured
+      const hints = getCompositionHints(name)
+      const externalMcps = getExternalMCPs()
+
+      const result = await callBackendTool(name, args || {})
+
+      // Inject composition hints into response if available
+      if (hints && result.content && result.content[0]?.text) {
+        const mcpList = externalMcps.length > 0
+          ? `\n\n## External MCPs Available\n${externalMcps.map(m => `- **${m.name}**: ${m.available_tools.join(', ')}`).join('\n')}`
+          : ''
+
+        result.content[0].text = result.content[0].text +
+          `\n\n---\n## Integration Hints\n${hints}${mcpList}`
+      }
+
+      log(`Tool ${name} completed successfully`)
+      return result
+    } catch (error) {
+      log(`Tool ${name} failed:`, error.message)
+      throw error
+    }
+  })
+
+  // Error handler
+  server.onerror = (error) => {
+    log('Server error:', error)
+  }
+
+  // Connect to stdio transport
+  const transport = new StdioServerTransport()
+  await server.connect(transport)
+
+  log('MCP server ready and listening on stdio')
+}

package/mcp-client/services/credentials.js

@@ -125,3 +125,25 @@ export function getProviderConfig(provider) {
 export function clearCredentialsCache() {
   localCredentials = null
 }
+
+/**
+ * Get list of external MCPs configured
+ * @returns {Array} Array of external MCP configurations
+ */
+export function getExternalMCPs() {
+  const creds = getCredentials()
+  return creds?.external_mcps || []
+}
+
+/**
+ * Get composition hints for a specific tool
+ * @param {string} toolName - Tool name to get hints for
+ * @returns {string|null} Composition hints or null
+ */
+export function getCompositionHints(toolName) {
+  const creds = getCredentials()
+  if (!creds?.tool_instructions) return null
+
+  const instruction = creds.tool_instructions.find(t => t.tool_name === toolName)
+  return instruction?.composition_hints || null
+}

package/mcp-client/services/index.js

@@ -8,3 +8,4 @@ export * from './api.js'
 export * from './credentials.js'
 export * from './session-state.js'
 export * from './stats.js'
+export * from './project.js'

package/mcp-client/services/project.js

@@ -0,0 +1,40 @@
+/**
+ * Suparank MCP - Project Service
+ *
+ * Fetch and manage project configuration from the Suparank API
+ */
+
+import { log } from '../utils/logging.js'
+import { fetchWithRetry } from './api.js'
+import { apiUrl, apiKey, projectSlug } from '../config.js'
+
+/**
+ * Fetch project configuration from the Suparank API
+ * @returns {Promise<object>} Project object with config
+ */
+export async function fetchProjectConfig() {
+  try {
+    const response = await fetchWithRetry(`${apiUrl}/projects/${projectSlug}`, {
+      headers: {
+        'Authorization': `Bearer ${apiKey}`,
+        'Content-Type': 'application/json'
+      }
+    }, 3, 15000) // 3 retries, 15s timeout
+
+    if (!response.ok) {
+      const error = await response.text()
+
+      if (response.status === 401) {
+        throw new Error(`Invalid or expired API key. Please create a new one in the dashboard.`)
+      }
+
+      throw new Error(`Failed to fetch project: ${error}`)
+    }
+
+    const data = await response.json()
+    return data.project
+  } catch (error) {
+    log('Error fetching project config:', error.message)
+    throw error
+  }
+}