suparank 1.2.5 → 1.2.7

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
+  }
+}

package/mcp-client/services/session-state.js

@@ -0,0 +1,201 @@
+/**
+ * Suparank MCP - Session State Service
+ *
+ * Session state management with persistence and mutex protection
+ */
+
+import * as fs from 'fs'
+import {
+  getSessionFilePath,
+  ensureSuparankDir,
+  atomicWriteSync
+} from '../utils/paths.js'
+import { log, progress } from '../utils/logging.js'
+import { SESSION_EXPIRY_MS } from '../config.js'
+
+// Session state object
+export const sessionState = {
+  currentWorkflow: null,
+  stepResults: {},
+  articles: [],
+  article: null,
+  title: null,
+  imageUrl: null,
+  inlineImages: [],
+  keywords: null,
+  metadata: null,
+  metaTitle: null,
+  metaDescription: null,
+  contentFolder: null
+}
+
+// Session mutex for concurrent access protection
+let sessionLock = false
+const sessionLockQueue = []
+
+/**
+ * Acquire session lock for safe concurrent access
+ * @returns {Promise<void>}
+ */
+export async function acquireSessionLock() {
+  if (!sessionLock) {
+    sessionLock = true
+    return
+  }
+  return new Promise(resolve => {
+    sessionLockQueue.push(resolve)
+  })
+}
+
+/**
+ * Release session lock
+ */
+export function releaseSessionLock() {
+  if (sessionLockQueue.length > 0) {
+    const next = sessionLockQueue.shift()
+    next()
+  } else {
+    sessionLock = false
+  }
+}
+
+/**
+ * Generate a unique article ID
+ * @returns {string} Unique ID
+ */
+export function generateArticleId() {
+  return `article-${Date.now()}-${Math.random().toString(36).substring(2, 8)}`
+}
+
+/**
+ * Check if session has expired
+ * @param {string} savedAt - ISO timestamp when session was saved
+ * @returns {boolean} Whether session has expired
+ */
+export function isSessionExpired(savedAt) {
+  if (!savedAt) return true
+  const savedTime = new Date(savedAt).getTime()
+  const now = Date.now()
+  return (now - savedTime) > SESSION_EXPIRY_MS
+}
+
+/**
+ * Save session state to file
+ * Uses atomic write to prevent corruption
+ */
+export function saveSession() {
+  try {
+    ensureSuparankDir()
+    const sessionFile = getSessionFilePath()
+
+    const toSave = {
+      currentWorkflow: sessionState.currentWorkflow,
+      stepResults: sessionState.stepResults,
+      articles: sessionState.articles,
+      article: sessionState.article,
+      title: sessionState.title,
+      imageUrl: sessionState.imageUrl,
+      inlineImages: sessionState.inlineImages,
+      keywords: sessionState.keywords,
+      metadata: sessionState.metadata,
+      metaTitle: sessionState.metaTitle,
+      metaDescription: sessionState.metaDescription,
+      contentFolder: sessionState.contentFolder,
+      savedAt: new Date().toISOString()
+    }
+
+    atomicWriteSync(sessionFile, JSON.stringify(toSave, null, 2))
+    progress('Session', `Saved to ${sessionFile} (${sessionState.articles.length} articles)`)
+  } catch (error) {
+    log(`Warning: Failed to save session: ${error.message}`)
+    progress('Session', `FAILED to save: ${error.message}`)
+  }
+}
+
+/**
+ * Safe session save with mutex
+ * @returns {Promise<void>}
+ */
+export async function saveSessionSafe() {
+  await acquireSessionLock()
+  try {
+    saveSession()
+  } finally {
+    releaseSessionLock()
+  }
+}
+
+/**
+ * Load session state from file
+ * @returns {boolean} Whether session was restored
+ */
+export function restoreSession() {
+  const sessionFile = getSessionFilePath()
+
+  try {
+    if (fs.existsSync(sessionFile)) {
+      const content = fs.readFileSync(sessionFile, 'utf-8')
+      const saved = JSON.parse(content)
+
+      // Check if session is expired (24 hour max)
+      if (isSessionExpired(saved.savedAt)) {
+        log('Session expired, starting fresh')
+        return false
+      }
+
+      // Restore state
+      sessionState.currentWorkflow = saved.currentWorkflow || null
+      sessionState.stepResults = saved.stepResults || {}
+      sessionState.articles = saved.articles || []
+      sessionState.article = saved.article || null
+      sessionState.title = saved.title || null
+      sessionState.imageUrl = saved.imageUrl || null
+      sessionState.inlineImages = saved.inlineImages || []
+      sessionState.keywords = saved.keywords || null
+      sessionState.metadata = saved.metadata || null
+      sessionState.metaTitle = saved.metaTitle || null
+      sessionState.metaDescription = saved.metaDescription || null
+      sessionState.contentFolder = saved.contentFolder || null
+
+      log(`Session restored: ${sessionState.articles.length} articles, workflow: ${sessionState.currentWorkflow?.workflow_id || 'none'}`)
+      return true
+    }
+  } catch (error) {
+    log(`Warning: Could not restore session: ${error.message}`)
+  }
+
+  return false
+}
+
+/**
+ * Reset session state to initial values
+ */
+export function resetSession() {
+  sessionState.currentWorkflow = null
+  sessionState.stepResults = {}
+  sessionState.articles = []
+  sessionState.article = null
+  sessionState.title = null
+  sessionState.imageUrl = null
+  sessionState.inlineImages = []
+  sessionState.keywords = null
+  sessionState.metadata = null
+  sessionState.metaTitle = null
+  sessionState.metaDescription = null
+  sessionState.contentFolder = null
+}
+
+/**
+ * Clear session file from disk
+ */
+export function clearSessionFile() {
+  const sessionFile = getSessionFilePath()
+  try {
+    if (fs.existsSync(sessionFile)) {
+      fs.unlinkSync(sessionFile)
+      log('Session file cleared')
+    }
+  } catch (error) {
+    log(`Warning: Could not clear session file: ${error.message}`)
+  }
+}

package/mcp-client/services/stats.js

@@ -0,0 +1,50 @@
+/**
+ * Suparank MCP - Stats Service
+ *
+ * Usage statistics tracking
+ */
+
+import * as fs from 'fs'
+import { getStatsFilePath, ensureSuparankDir } from '../utils/paths.js'
+import { log } from '../utils/logging.js'
+import { DEFAULT_STATS } from '../config.js'
+
+/**
+ * Load usage stats from file
+ * @returns {object} Stats object
+ */
+export function loadStats() {
+  try {
+    const file = getStatsFilePath()
+    if (fs.existsSync(file)) {
+      return JSON.parse(fs.readFileSync(file, 'utf-8'))
+    }
+  } catch (e) {
+    log(`Warning: Could not load stats: ${e.message}`)
+  }
+  return { ...DEFAULT_STATS }
+}
+
+/**
+ * Save usage stats to file
+ * @param {object} stats - Stats object to save
+ */
+export function saveStats(stats) {
+  try {
+    ensureSuparankDir()
+    fs.writeFileSync(getStatsFilePath(), JSON.stringify(stats, null, 2))
+  } catch (e) {
+    log(`Error saving stats: ${e.message}`)
+  }
+}
+
+/**
+ * Increment a stat counter
+ * @param {string} key - Stat key to increment
+ * @param {number} amount - Amount to add (default: 1)
+ */
+export function incrementStat(key, amount = 1) {
+  const stats = loadStats()
+  stats[key] = (stats[key] || 0) + amount
+  saveStats(stats)
+}