@socialneuron/mcp-server 1.5.2 → 1.6.0

package/README.md

@@ -1,13 +1,26 @@
 # @socialneuron/mcp-server
 
-> 52 MCP tools for AI-powered social media management. Create content, schedule posts, track analytics, and optimize performance — all from Claude Code or any MCP client.
+> 52 tools for AI-powered social media management. MCP, REST API, CLI — create content, schedule posts, track analytics, and optimize performance.
 
 [![npm version](https://img.shields.io/npm/v/@socialneuron/mcp-server)](https://www.npmjs.com/package/@socialneuron/mcp-server)
 [![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
 
+## Integration Methods
+
+| Method | Best For | Docs |
+|--------|----------|------|
+| **MCP** | AI agents (Claude, Cursor, VS Code) | [Setup](#quick-start) |
+| **REST API** | Any HTTP client, webhooks, Zapier | [Guide](docs/rest-api.md) |
+| **CLI** | Terminal, CI/CD pipelines | [Guide](docs/cli-guide.md) |
+| **SDK** | TypeScript/Node.js apps | Coming Q2 2026 |
+
+All methods share the same 52 tools, auth, scopes, and credit system. [Compare methods](docs/integration-methods.md).
+
 ## Quick Start
 
-### 1. Authenticate
+### MCP (AI Agents)
+
+#### 1. Authenticate
 
 ```bash
 npx -y @socialneuron/mcp-server login --device
@@ -15,7 +28,7 @@ npx -y @socialneuron/mcp-server login --device
 
 This opens your browser to authorize access. Requires a paid Social Neuron plan (Starter or above). See [pricing](https://socialneuron.com/pricing).
 
-### 2. Add to Claude Code
+#### 2. Add to Claude Code
 
 ```bash
 claude mcp add socialneuron -- npx -y @socialneuron/mcp-server
@@ -76,10 +89,42 @@ Add to `.cursor/mcp.json` in your workspace:
 ```
 </details>
 
-### 3. Start using
+#### 3. Start using
 
 Ask Claude: "What content should I post this week?" or "Schedule my latest video to YouTube and TikTok"
 
+### REST API (Any Language)
+
+```bash
+# Check credits
+curl -H "Authorization: Bearer snk_live_..." \
+  https://mcp.socialneuron.com/v1/credits
+
+# Generate content
+curl -X POST -H "Authorization: Bearer snk_live_..." \
+  -H "Content-Type: application/json" \
+  -d '{"topic": "AI trends", "platforms": ["linkedin"]}' \
+  https://mcp.socialneuron.com/v1/content/generate
+
+# Execute any tool via proxy
+curl -X POST -H "Authorization: Bearer snk_live_..." \
+  -H "Content-Type: application/json" \
+  -d '{"response_format": "json"}' \
+  https://mcp.socialneuron.com/v1/tools/get_brand_profile
+```
+
+See [REST API docs](docs/rest-api.md) | [OpenAPI spec](https://mcp.socialneuron.com/v1/openapi.json) | [Examples](examples/rest/)
+
+### CLI (Terminal & CI/CD)
+
+```bash
+npx @socialneuron/mcp-server sn system credits --json
+npx @socialneuron/mcp-server sn analytics loop --json
+npx @socialneuron/mcp-server sn discovery tools --module content
+```
+
+See [CLI guide](docs/cli-guide.md) | [Examples](examples/cli/)
+
 ## What You Can Do
 
 Ask Claude things like:
@@ -94,7 +139,7 @@ Ask Claude things like:
 
 ## Tool Categories (52 tools)
 
-These tools are available to AI agents (Claude, Cursor, etc.) via the MCP protocol.
+All tools are accessible via MCP, REST API (`POST /v1/tools/{name}`), and CLI.
 
 ### Content Lifecycle
 
@@ -273,23 +318,27 @@ No personal content, API keys, or request payloads are ever collected. Your user
 
 ## Examples
 
-See the [examples repo](https://github.com/socialneuron/examples) for prompt-driven workflow templates:
+See the [`examples/`](examples/) directory:
 
-- Weekly content batch planning
-- Cross-platform content repurposing
+- [REST API examples](examples/rest/) — curl scripts for every endpoint
+- [CLI examples](examples/cli/) — automation workflows
+- [MCP prompts](examples/mcp/claude-prompts.md) — natural language examples
+- [External examples repo](https://github.com/socialneuron/examples) — prompt-driven workflow templates
 - Performance review and optimization loops
 - Brand-aligned content generation
 - Comment engagement automation
 
 ## Links
 
-- [Social Neuron](https://socialneuron.com)
-- [For Developers](https://socialneuron.com/for-developers)
+- [For Developers](https://socialneuron.com/for-developers) — Integration methods, tools, pricing
+- [REST API Docs](docs/rest-api.md) — Endpoint reference
+- [CLI Guide](docs/cli-guide.md) — Terminal commands
+- [Integration Methods](docs/integration-methods.md) — Compare MCP vs REST vs CLI
+- [OpenAPI Spec](https://mcp.socialneuron.com/v1/openapi.json) — Machine-readable API spec
+- [Developer Settings](https://socialneuron.com/settings/developer) — Generate API keys
 - [Documentation](https://socialneuron.com/docs)
-- [Examples](https://github.com/socialneuron/examples)
-- [Agent Protocol](https://socialneuron.com/system-prompt.txt)
-- [Developer Settings](https://socialneuron.com/settings/developer)
 - [Pricing](https://socialneuron.com/pricing)
+- [Agent Protocol](https://socialneuron.com/system-prompt.txt)
 
 ## License
 

package/dist/http.js

@@ -1368,7 +1368,7 @@ function sanitizeDbError(error) {
 init_request_context();
 
 // src/lib/version.ts
-var MCP_VERSION = "1.5.2";
+var MCP_VERSION = "1.6.0";
 
 // src/tools/content.ts
 var MAX_CREDITS_PER_RUN = Math.max(
@@ -9462,6 +9462,986 @@ async function verifyApiKey(apiKey, supabaseUrl, supabaseAnonKey) {
 
 // src/http.ts
 init_posthog();
+
+// src/api/tool-executor.ts
+var toolHandlers = /* @__PURE__ */ new Map();
+function captureToolHandlers(server) {
+  const original = server.tool.bind(server);
+  server.tool = function capturedTool(...args) {
+    const name = args[0];
+    const handlerIndex = args.findIndex(
+      (a, i) => i > 0 && typeof a === "function"
+    );
+    if (handlerIndex !== -1) {
+      toolHandlers.set(name, args[handlerIndex]);
+    }
+    return original(...args);
+  };
+}
+async function executeToolDirect(name, args) {
+  const meta = {
+    tool: name,
+    version: MCP_VERSION,
+    timestamp: (/* @__PURE__ */ new Date()).toISOString()
+  };
+  const handler = toolHandlers.get(name);
+  if (!handler) {
+    return {
+      data: null,
+      error: `Tool '${name}' not found. Use GET /v1/tools to list available tools.`,
+      isError: true,
+      _meta: meta
+    };
+  }
+  try {
+    const result = await handler(args);
+    const textContent = result.content.filter((c) => c.type === "text").map((c) => c.text).join("\n");
+    if (result.isError) {
+      return { data: null, error: textContent, isError: true, _meta: meta };
+    }
+    let data;
+    try {
+      data = JSON.parse(textContent);
+    } catch {
+      data = { text: textContent };
+    }
+    return { data, error: null, isError: false, _meta: meta };
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    return { data: null, error: message, isError: true, _meta: meta };
+  }
+}
+function hasRegisteredTool(name) {
+  return toolHandlers.has(name);
+}
+function getRegisteredToolCount() {
+  return toolHandlers.size;
+}
+function checkToolScope(toolName, userScopes) {
+  const requiredScope = TOOL_SCOPES[toolName];
+  if (!requiredScope) {
+    return { allowed: false, requiredScope: null };
+  }
+  return { allowed: hasScope(userScopes, requiredScope), requiredScope };
+}
+function getToolCatalogForApi() {
+  return TOOL_CATALOG.filter((tool) => toolHandlers.has(tool.name)).map(
+    (tool) => ({
+      ...tool,
+      endpoint: `/v1/tools/${tool.name}`,
+      method: "POST"
+    })
+  );
+}
+
+// src/api/router.ts
+import { Router } from "express";
+init_request_context();
+
+// src/api/openapi.ts
+function generateOpenApiSpec() {
+  const modules = [...new Set(TOOL_CATALOG.map((t) => t.module))];
+  const toolPaths = {};
+  for (const tool of TOOL_CATALOG) {
+    toolPaths[`/v1/tools/${tool.name}`] = {
+      post: {
+        operationId: tool.name,
+        summary: tool.description,
+        tags: [tool.module],
+        "x-required-scope": tool.scope,
+        security: [{ bearerAuth: [] }],
+        requestBody: {
+          required: false,
+          content: {
+            "application/json": {
+              schema: {
+                type: "object",
+                description: `Input parameters for ${tool.name}. Pass tool-specific arguments as JSON.`
+              }
+            }
+          }
+        },
+        responses: {
+          "200": { $ref: "#/components/responses/ToolSuccess" },
+          "400": { $ref: "#/components/responses/ToolError" },
+          "401": { $ref: "#/components/responses/Unauthorized" },
+          "403": { $ref: "#/components/responses/InsufficientScope" },
+          "404": { $ref: "#/components/responses/NotFound" },
+          "429": { $ref: "#/components/responses/RateLimited" }
+        }
+      }
+    };
+  }
+  return {
+    openapi: "3.1.0",
+    info: {
+      title: "Social Neuron API",
+      version: MCP_VERSION,
+      description: "AI content creation platform \u2014 generate, schedule, and analyze social media content across platforms. 52 tools accessible via REST API, MCP, CLI, or SDK. Same auth, scopes, and credit system across all methods.",
+      contact: {
+        name: "Social Neuron",
+        email: "socialneuronteam@gmail.com",
+        url: "https://socialneuron.com/for-developers"
+      },
+      license: { name: "MIT", url: "https://opensource.org/licenses/MIT" },
+      termsOfService: "https://socialneuron.com/terms"
+    },
+    servers: [
+      {
+        url: "https://mcp.socialneuron.com",
+        description: "Production"
+      }
+    ],
+    tags: [
+      {
+        name: "tools",
+        description: "Tool discovery and universal tool proxy"
+      },
+      {
+        name: "credits",
+        description: "Credit balance and budget tracking"
+      },
+      {
+        name: "brand",
+        description: "Brand profile management"
+      },
+      {
+        name: "analytics",
+        description: "Performance analytics and insights"
+      },
+      {
+        name: "content",
+        description: "Content generation (text, image, video)"
+      },
+      {
+        name: "distribution",
+        description: "Post scheduling and publishing"
+      },
+      {
+        name: "posts",
+        description: "Post listing and status"
+      },
+      ...modules.map((m) => ({
+        name: m,
+        description: `${m} tools (via tool proxy)`
+      }))
+    ],
+    paths: {
+      "/v1/": {
+        get: {
+          operationId: "getApiInfo",
+          summary: "API info and discovery",
+          tags: ["tools"],
+          security: [{ bearerAuth: [] }],
+          responses: {
+            "200": {
+              description: "API metadata",
+              content: {
+                "application/json": {
+                  schema: { type: "object" }
+                }
+              }
+            }
+          }
+        }
+      },
+      "/v1/tools": {
+        get: {
+          operationId: "listTools",
+          summary: "List available tools with optional filtering",
+          tags: ["tools"],
+          security: [{ bearerAuth: [] }],
+          parameters: [
+            {
+              name: "module",
+              in: "query",
+              schema: { type: "string" },
+              description: "Filter by module name"
+            },
+            {
+              name: "scope",
+              in: "query",
+              schema: { type: "string" },
+              description: "Filter by required scope"
+            },
+            {
+              name: "q",
+              in: "query",
+              schema: { type: "string" },
+              description: "Search tools by keyword"
+            }
+          ],
+          responses: {
+            "200": {
+              description: "Tool catalog",
+              content: {
+                "application/json": {
+                  schema: {
+                    type: "object",
+                    properties: {
+                      data: {
+                        type: "object",
+                        properties: {
+                          tools: {
+                            type: "array",
+                            items: { $ref: "#/components/schemas/ToolEntry" }
+                          },
+                          total: { type: "integer" },
+                          modules: {
+                            type: "array",
+                            items: { type: "string" }
+                          }
+                        }
+                      },
+                      _meta: { $ref: "#/components/schemas/Meta" }
+                    }
+                  }
+                }
+              }
+            }
+          }
+        }
+      },
+      "/v1/credits": {
+        get: {
+          operationId: "getCreditBalance",
+          summary: "Get credit balance, plan, and monthly usage",
+          tags: ["credits"],
+          "x-tool-name": "get_credit_balance",
+          "x-required-scope": "mcp:read",
+          security: [{ bearerAuth: [] }],
+          responses: {
+            "200": { $ref: "#/components/responses/ToolSuccess" },
+            "401": { $ref: "#/components/responses/Unauthorized" }
+          }
+        }
+      },
+      "/v1/credits/budget": {
+        get: {
+          operationId: "getBudgetStatus",
+          summary: "Get per-session budget and spending status",
+          tags: ["credits"],
+          "x-tool-name": "get_budget_status",
+          "x-required-scope": "mcp:read",
+          security: [{ bearerAuth: [] }],
+          responses: {
+            "200": { $ref: "#/components/responses/ToolSuccess" },
+            "401": { $ref: "#/components/responses/Unauthorized" }
+          }
+        }
+      },
+      "/v1/brand": {
+        get: {
+          operationId: "getBrandProfile",
+          summary: "Get current brand profile",
+          tags: ["brand"],
+          "x-tool-name": "get_brand_profile",
+          "x-required-scope": "mcp:read",
+          security: [{ bearerAuth: [] }],
+          responses: {
+            "200": { $ref: "#/components/responses/ToolSuccess" },
+            "401": { $ref: "#/components/responses/Unauthorized" }
+          }
+        }
+      },
+      "/v1/analytics": {
+        get: {
+          operationId: "fetchAnalytics",
+          summary: "Fetch post performance analytics",
+          tags: ["analytics"],
+          "x-tool-name": "fetch_analytics",
+          "x-required-scope": "mcp:read",
+          security: [{ bearerAuth: [] }],
+          responses: {
+            "200": { $ref: "#/components/responses/ToolSuccess" },
+            "401": { $ref: "#/components/responses/Unauthorized" }
+          }
+        }
+      },
+      "/v1/analytics/insights": {
+        get: {
+          operationId: "getPerformanceInsights",
+          summary: "Get AI-generated performance insights",
+          tags: ["analytics"],
+          "x-tool-name": "get_performance_insights",
+          "x-required-scope": "mcp:read",
+          security: [{ bearerAuth: [] }],
+          responses: {
+            "200": { $ref: "#/components/responses/ToolSuccess" },
+            "401": { $ref: "#/components/responses/Unauthorized" }
+          }
+        }
+      },
+      "/v1/analytics/best-times": {
+        get: {
+          operationId: "getBestPostingTimes",
+          summary: "Get recommended posting times based on audience data",
+          tags: ["analytics"],
+          "x-tool-name": "get_best_posting_times",
+          "x-required-scope": "mcp:read",
+          security: [{ bearerAuth: [] }],
+          responses: {
+            "200": { $ref: "#/components/responses/ToolSuccess" },
+            "401": { $ref: "#/components/responses/Unauthorized" }
+          }
+        }
+      },
+      "/v1/posts": {
+        get: {
+          operationId: "listRecentPosts",
+          summary: "List recently published or scheduled posts",
+          tags: ["posts"],
+          "x-tool-name": "list_recent_posts",
+          "x-required-scope": "mcp:read",
+          security: [{ bearerAuth: [] }],
+          parameters: [
+            {
+              name: "limit",
+              in: "query",
+              schema: { type: "integer", default: 20 },
+              description: "Max number of posts to return"
+            }
+          ],
+          responses: {
+            "200": { $ref: "#/components/responses/ToolSuccess" },
+            "401": { $ref: "#/components/responses/Unauthorized" }
+          }
+        }
+      },
+      "/v1/accounts": {
+        get: {
+          operationId: "listConnectedAccounts",
+          summary: "List connected social media accounts",
+          tags: ["posts"],
+          "x-tool-name": "list_connected_accounts",
+          "x-required-scope": "mcp:read",
+          security: [{ bearerAuth: [] }],
+          responses: {
+            "200": { $ref: "#/components/responses/ToolSuccess" },
+            "401": { $ref: "#/components/responses/Unauthorized" }
+          }
+        }
+      },
+      "/v1/content/generate": {
+        post: {
+          operationId: "generateContent",
+          summary: "Generate social media content with AI",
+          tags: ["content"],
+          "x-tool-name": "generate_content",
+          "x-required-scope": "mcp:write",
+          security: [{ bearerAuth: [] }],
+          requestBody: {
+            required: true,
+            content: {
+              "application/json": {
+                schema: {
+                  type: "object",
+                  properties: {
+                    topic: {
+                      type: "string",
+                      description: "Content topic or prompt"
+                    },
+                    platforms: {
+                      type: "array",
+                      items: { type: "string" },
+                      description: "Target platforms"
+                    },
+                    tone: { type: "string", description: "Content tone" },
+                    content_type: {
+                      type: "string",
+                      description: "Type of content to generate"
+                    }
+                  }
+                }
+              }
+            }
+          },
+          responses: {
+            "200": { $ref: "#/components/responses/ToolSuccess" },
+            "401": { $ref: "#/components/responses/Unauthorized" },
+            "403": { $ref: "#/components/responses/InsufficientScope" }
+          }
+        }
+      },
+      "/v1/content/adapt": {
+        post: {
+          operationId: "adaptContent",
+          summary: "Adapt existing content for different platforms",
+          tags: ["content"],
+          "x-tool-name": "adapt_content",
+          "x-required-scope": "mcp:write",
+          security: [{ bearerAuth: [] }],
+          requestBody: {
+            required: true,
+            content: {
+              "application/json": {
+                schema: {
+                  type: "object",
+                  properties: {
+                    content: {
+                      type: "string",
+                      description: "Content to adapt"
+                    },
+                    target_platforms: {
+                      type: "array",
+                      items: { type: "string" },
+                      description: "Target platforms for adaptation"
+                    }
+                  }
+                }
+              }
+            }
+          },
+          responses: {
+            "200": { $ref: "#/components/responses/ToolSuccess" },
+            "401": { $ref: "#/components/responses/Unauthorized" },
+            "403": { $ref: "#/components/responses/InsufficientScope" }
+          }
+        }
+      },
+      "/v1/content/video": {
+        post: {
+          operationId: "generateVideo",
+          summary: "Generate video content using AI models",
+          tags: ["content"],
+          "x-tool-name": "generate_video",
+          "x-required-scope": "mcp:write",
+          security: [{ bearerAuth: [] }],
+          requestBody: {
+            required: true,
+            content: {
+              "application/json": {
+                schema: {
+                  type: "object",
+                  properties: {
+                    prompt: { type: "string" },
+                    aspect_ratio: { type: "string" },
+                    duration: { type: "integer" }
+                  }
+                }
+              }
+            }
+          },
+          responses: {
+            "200": { $ref: "#/components/responses/ToolSuccess" },
+            "401": { $ref: "#/components/responses/Unauthorized" },
+            "403": { $ref: "#/components/responses/InsufficientScope" }
+          }
+        }
+      },
+      "/v1/content/image": {
+        post: {
+          operationId: "generateImage",
+          summary: "Generate images using AI models",
+          tags: ["content"],
+          "x-tool-name": "generate_image",
+          "x-required-scope": "mcp:write",
+          security: [{ bearerAuth: [] }],
+          requestBody: {
+            required: true,
+            content: {
+              "application/json": {
+                schema: {
+                  type: "object",
+                  properties: {
+                    prompt: { type: "string" },
+                    aspect_ratio: { type: "string" },
+                    style: { type: "string" }
+                  }
+                }
+              }
+            }
+          },
+          responses: {
+            "200": { $ref: "#/components/responses/ToolSuccess" },
+            "401": { $ref: "#/components/responses/Unauthorized" },
+            "403": { $ref: "#/components/responses/InsufficientScope" }
+          }
+        }
+      },
+      "/v1/content/status/{jobId}": {
+        get: {
+          operationId: "checkJobStatus",
+          summary: "Check status of async content generation job",
+          tags: ["content"],
+          "x-tool-name": "check_status",
+          "x-required-scope": "mcp:read",
+          security: [{ bearerAuth: [] }],
+          parameters: [
+            {
+              name: "jobId",
+              in: "path",
+              required: true,
+              schema: { type: "string" },
+              description: "Job ID to check"
+            }
+          ],
+          responses: {
+            "200": { $ref: "#/components/responses/ToolSuccess" },
+            "401": { $ref: "#/components/responses/Unauthorized" },
+            "404": { $ref: "#/components/responses/NotFound" }
+          }
+        }
+      },
+      "/v1/distribution/schedule": {
+        post: {
+          operationId: "schedulePost",
+          summary: "Schedule or publish content to social platforms",
+          tags: ["distribution"],
+          "x-tool-name": "schedule_post",
+          "x-required-scope": "mcp:distribute",
+          security: [{ bearerAuth: [] }],
+          requestBody: {
+            required: true,
+            content: {
+              "application/json": {
+                schema: {
+                  type: "object",
+                  properties: {
+                    media_url: {
+                      type: "string",
+                      description: "URL of media to post"
+                    },
+                    caption: {
+                      type: "string",
+                      description: "Post caption text"
+                    },
+                    platforms: {
+                      type: "array",
+                      items: { type: "string" },
+                      description: "Target platforms"
+                    },
+                    schedule_at: {
+                      type: "string",
+                      format: "date-time",
+                      description: "ISO 8601 schedule time (omit for immediate)"
+                    }
+                  }
+                }
+              }
+            }
+          },
+          responses: {
+            "200": { $ref: "#/components/responses/ToolSuccess" },
+            "401": { $ref: "#/components/responses/Unauthorized" },
+            "403": { $ref: "#/components/responses/InsufficientScope" }
+          }
+        }
+      },
+      "/v1/loop": {
+        get: {
+          operationId: "getLoopSummary",
+          summary: "Get growth loop summary and optimization recommendations",
+          tags: ["analytics"],
+          "x-tool-name": "get_loop_summary",
+          "x-required-scope": "mcp:read",
+          security: [{ bearerAuth: [] }],
+          responses: {
+            "200": { $ref: "#/components/responses/ToolSuccess" },
+            "401": { $ref: "#/components/responses/Unauthorized" }
+          }
+        }
+      },
+      // Spread all tool proxy paths
+      ...toolPaths
+    },
+    components: {
+      securitySchemes: {
+        bearerAuth: {
+          type: "http",
+          scheme: "bearer",
+          description: "API key from Settings > Developer. Format: snk_live_..."
+        }
+      },
+      schemas: {
+        Meta: {
+          type: "object",
+          properties: {
+            tool: { type: "string" },
+            version: { type: "string" },
+            timestamp: { type: "string", format: "date-time" }
+          }
+        },
+        ToolEntry: {
+          type: "object",
+          properties: {
+            name: { type: "string" },
+            description: { type: "string" },
+            module: { type: "string" },
+            scope: { type: "string" },
+            endpoint: { type: "string" },
+            method: { type: "string" }
+          }
+        },
+        ApiError: {
+          type: "object",
+          properties: {
+            error: {
+              type: "object",
+              properties: {
+                code: { type: "string" },
+                message: { type: "string" },
+                status: { type: "integer" }
+              },
+              required: ["code", "message", "status"]
+            }
+          }
+        }
+      },
+      responses: {
+        ToolSuccess: {
+          description: "Successful tool execution",
+          content: {
+            "application/json": {
+              schema: {
+                type: "object",
+                properties: {
+                  data: { type: "object" },
+                  _meta: { $ref: "#/components/schemas/Meta" }
+                }
+              }
+            }
+          }
+        },
+        ToolError: {
+          description: "Tool execution error",
+          content: {
+            "application/json": {
+              schema: { $ref: "#/components/schemas/ApiError" }
+            }
+          }
+        },
+        Unauthorized: {
+          description: "Missing or invalid Bearer token",
+          content: {
+            "application/json": {
+              schema: { $ref: "#/components/schemas/ApiError" }
+            }
+          }
+        },
+        InsufficientScope: {
+          description: "API key lacks required scope",
+          content: {
+            "application/json": {
+              schema: { $ref: "#/components/schemas/ApiError" }
+            }
+          }
+        },
+        NotFound: {
+          description: "Tool or resource not found",
+          content: {
+            "application/json": {
+              schema: { $ref: "#/components/schemas/ApiError" }
+            }
+          }
+        },
+        RateLimited: {
+          description: "Rate limit exceeded",
+          headers: {
+            "Retry-After": {
+              schema: { type: "integer" },
+              description: "Seconds to wait before retrying"
+            }
+          },
+          content: {
+            "application/json": {
+              schema: { $ref: "#/components/schemas/ApiError" }
+            }
+          }
+        }
+      }
+    },
+    security: [{ bearerAuth: [] }]
+  };
+}
+
+// src/api/router.ts
+function createRestApiRouter(options) {
+  const router = Router();
+  const tokenVerifier2 = createTokenVerifier({
+    supabaseUrl: options.supabaseUrl,
+    supabaseAnonKey: options.supabaseAnonKey
+  });
+  async function authenticate(req, res, next) {
+    const authHeader = req.headers.authorization;
+    if (!authHeader?.startsWith("Bearer ")) {
+      res.status(401).json({
+        error: {
+          code: "unauthorized",
+          message: "Bearer token required. Get your API key at https://socialneuron.com/settings/developer",
+          status: 401
+        }
+      });
+      return;
+    }
+    const token = authHeader.slice(7);
+    try {
+      const authInfo = await tokenVerifier2.verifyAccessToken(token);
+      req.auth = {
+        userId: authInfo.extra?.userId ?? authInfo.clientId,
+        scopes: authInfo.scopes,
+        clientId: authInfo.clientId,
+        token: authInfo.token
+      };
+      next();
+    } catch (err) {
+      const message = err instanceof Error ? err.message : "Token verification failed";
+      res.status(401).json({
+        error: { code: "invalid_token", message, status: 401 }
+      });
+    }
+  }
+  function rateLimit(req, res, next) {
+    const rl = checkRateLimit("read", req.auth.userId);
+    if (!rl.allowed) {
+      res.setHeader("Retry-After", String(rl.retryAfter));
+      res.status(429).json({
+        error: {
+          code: "rate_limited",
+          message: "Too many requests. Please slow down.",
+          retry_after: rl.retryAfter,
+          status: 429
+        }
+      });
+      return;
+    }
+    next();
+  }
+  router.get("/openapi.json", (_req, res) => {
+    res.setHeader("Cache-Control", "public, max-age=3600");
+    res.json(generateOpenApiSpec());
+  });
+  router.get("/", (_req, res) => {
+    res.json({
+      name: "Social Neuron API",
+      version: MCP_VERSION,
+      description: "AI content creation platform \u2014 REST API",
+      tools: getRegisteredToolCount(),
+      documentation: "https://socialneuron.com/docs/rest-api",
+      endpoints: {
+        tools: "/v1/tools",
+        tool_proxy: "/v1/tools/:name",
+        credits: "/v1/credits",
+        brand: "/v1/brand",
+        analytics: "/v1/analytics",
+        posts: "/v1/posts",
+        accounts: "/v1/accounts",
+        content_generate: "/v1/content/generate",
+        distribution_schedule: "/v1/distribution/schedule",
+        openapi: "/v1/openapi.json"
+      },
+      auth: {
+        type: "Bearer token",
+        header: "Authorization: Bearer <your-api-key>",
+        get_key: "https://socialneuron.com/settings/developer"
+      }
+    });
+  });
+  router.use(
+    authenticate
+  );
+  router.use(
+    rateLimit
+  );
+  async function executeInContext(req, res, toolName, args) {
+    const scopeCheck = checkToolScope(toolName, req.auth.scopes);
+    if (!scopeCheck.allowed) {
+      res.status(403).json({
+        error: {
+          code: "insufficient_scope",
+          message: scopeCheck.requiredScope ? `Tool '${toolName}' requires scope '${scopeCheck.requiredScope}'. Regenerate your API key with the required scope at https://socialneuron.com/settings/developer` : `Tool '${toolName}' has no scope defined. Contact support.`,
+          required_scope: scopeCheck.requiredScope,
+          status: 403
+        }
+      });
+      return;
+    }
+    const rateLimitCategory = scopeCheck.requiredScope === "mcp:distribute" ? "posting" : scopeCheck.requiredScope === "mcp:write" ? "generation" : "read";
+    const toolRl = checkRateLimit(rateLimitCategory, req.auth.userId);
+    if (!toolRl.allowed) {
+      res.setHeader("Retry-After", String(toolRl.retryAfter));
+      res.status(429).json({
+        error: {
+          code: "rate_limited",
+          message: `Rate limit exceeded for ${rateLimitCategory} operations. Wait ${toolRl.retryAfter}s.`,
+          retry_after: toolRl.retryAfter,
+          status: 429
+        }
+      });
+      return;
+    }
+    const result = await requestContext.run(
+      {
+        userId: req.auth.userId,
+        scopes: req.auth.scopes,
+        creditsUsed: 0,
+        assetsGenerated: 0
+      },
+      () => executeToolDirect(toolName, args)
+    );
+    if (result.isError) {
+      const status = result.error?.includes("not found") ? 404 : result.error?.includes("rate limit") || result.error?.includes("Rate limit") ? 429 : result.error?.includes("Permission denied") ? 403 : 400;
+      res.status(status).json({
+        error: { code: "tool_error", message: result.error, status },
+        _meta: result._meta
+      });
+      return;
+    }
+    res.json({ data: result.data, _meta: result._meta });
+  }
+  router.get("/tools", (req, res) => {
+    const tools = getToolCatalogForApi();
+    const module = req.query.module;
+    const scope = req.query.scope;
+    const search = req.query.q;
+    let filtered = tools;
+    if (module) filtered = filtered.filter((t) => t.module === module);
+    if (scope) filtered = filtered.filter((t) => t.scope === scope);
+    if (search) {
+      const q = search.toLowerCase();
+      filtered = filtered.filter(
+        (t) => t.name.toLowerCase().includes(q) || t.description.toLowerCase().includes(q)
+      );
+    }
+    res.json({
+      data: {
+        tools: filtered,
+        total: filtered.length,
+        modules: [...new Set(TOOL_CATALOG.map((t) => t.module))]
+      },
+      _meta: { version: MCP_VERSION, timestamp: (/* @__PURE__ */ new Date()).toISOString() }
+    });
+  });
+  router.post(
+    "/tools/:name",
+    async (req, res) => {
+      const toolName = req.params.name;
+      if (!hasRegisteredTool(toolName)) {
+        res.status(404).json({
+          error: {
+            code: "tool_not_found",
+            message: `Tool '${toolName}' not found. Use GET /v1/tools to list available tools.`,
+            available_tools: TOOL_CATALOG.length,
+            status: 404
+          }
+        });
+        return;
+      }
+      await executeInContext(req, res, toolName, req.body || {});
+    }
+  );
+  router.get("/credits", async (req, res) => {
+    await executeInContext(req, res, "get_credit_balance", {
+      response_format: "json"
+    });
+  });
+  router.get(
+    "/credits/budget",
+    async (req, res) => {
+      await executeInContext(req, res, "get_budget_status", {
+        response_format: "json"
+      });
+    }
+  );
+  router.get("/brand", async (req, res) => {
+    await executeInContext(req, res, "get_brand_profile", {
+      response_format: "json"
+    });
+  });
+  router.get("/analytics", async (req, res) => {
+    const {
+      days,
+      platform: platform2,
+      limit: qLimit
+    } = req.query;
+    await executeInContext(req, res, "fetch_analytics", {
+      response_format: "json",
+      ...days && { days: Number(days) },
+      ...platform2 && { platform: platform2 },
+      ...qLimit && { limit: Number(qLimit) }
+    });
+  });
+  router.get(
+    "/analytics/insights",
+    async (req, res) => {
+      await executeInContext(req, res, "get_performance_insights", {
+        response_format: "json"
+      });
+    }
+  );
+  router.get(
+    "/analytics/best-times",
+    async (req, res) => {
+      await executeInContext(req, res, "get_best_posting_times", {
+        response_format: "json"
+      });
+    }
+  );
+  router.get("/posts", async (req, res) => {
+    await executeInContext(req, res, "list_recent_posts", {
+      response_format: "json",
+      limit: req.query.limit ? Number(req.query.limit) : void 0
+    });
+  });
+  router.get("/accounts", async (req, res) => {
+    await executeInContext(req, res, "list_connected_accounts", {
+      response_format: "json"
+    });
+  });
+  router.post(
+    "/content/generate",
+    async (req, res) => {
+      await executeInContext(req, res, "generate_content", {
+        response_format: "json",
+        ...req.body
+      });
+    }
+  );
+  router.post(
+    "/content/adapt",
+    async (req, res) => {
+      await executeInContext(req, res, "adapt_content", {
+        response_format: "json",
+        ...req.body
+      });
+    }
+  );
+  router.post(
+    "/content/video",
+    async (req, res) => {
+      await executeInContext(req, res, "generate_video", req.body || {});
+    }
+  );
+  router.post(
+    "/content/image",
+    async (req, res) => {
+      await executeInContext(req, res, "generate_image", req.body || {});
+    }
+  );
+  router.get(
+    "/content/status/:jobId",
+    async (req, res) => {
+      await executeInContext(req, res, "check_status", {
+        job_id: req.params.jobId,
+        response_format: "json"
+      });
+    }
+  );
+  router.post(
+    "/distribution/schedule",
+    async (req, res) => {
+      await executeInContext(req, res, "schedule_post", req.body || {});
+    }
+  );
+  router.get("/loop", async (req, res) => {
+    await executeInContext(req, res, "get_loop_summary", {
+      response_format: "json"
+    });
+  });
+  return router;
+}
+
+// src/http.ts
 var PORT = parseInt(process.env.PORT ?? "8080", 10);
 var SUPABASE_URL2 = process.env.SUPABASE_URL ?? "";
 var SUPABASE_ANON_KEY = process.env.SUPABASE_ANON_KEY ?? "";
@@ -9809,12 +10789,25 @@ app.delete(
     res.status(200).json({ status: "session_closed" });
   }
 );
+var restCaptureServer = new McpServer({
+  name: "socialneuron-rest",
+  version: MCP_VERSION
+});
+captureToolHandlers(restCaptureServer);
+registerAllTools(restCaptureServer, { skipScreenshots: true });
+var restRouter = createRestApiRouter({
+  supabaseUrl: SUPABASE_URL2,
+  supabaseAnonKey: SUPABASE_ANON_KEY
+});
+app.use("/v1", restRouter);
+console.log("[MCP HTTP] REST API mounted at /v1");
 var httpServer = app.listen(PORT, "0.0.0.0", () => {
   console.log(
     `[MCP HTTP] Social Neuron MCP Server listening on 0.0.0.0:${PORT}`
   );
   console.log(`[MCP HTTP] Health: http://localhost:${PORT}/health`);
   console.log(`[MCP HTTP] MCP endpoint: ${MCP_SERVER_URL}`);
+  console.log(`[MCP HTTP] REST API: http://localhost:${PORT}/v1`);
   console.log(`[MCP HTTP] Environment: ${NODE_ENV}`);
 });
 async function shutdown(signal) {

package/dist/index.js

@@ -14,7 +14,7 @@ var MCP_VERSION;
 var init_version = __esm({
   "src/lib/version.ts"() {
     "use strict";
-    MCP_VERSION = "1.5.2";
+    MCP_VERSION = "1.6.0";
   }
 });
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@socialneuron/mcp-server",
-  "version": "1.5.2",
+  "version": "1.6.0",
   "description": "MCP server for Social Neuron - AI content creation platform",
   "type": "module",
   "main": "dist/index.js",
@@ -22,6 +22,7 @@
     "type": "git",
     "url": "git+https://github.com/socialneuron/mcp-server.git"
   },
+  "source": "./src/index.ts",
   "exports": {
     ".": "./dist/index.js",
     "./http": "./dist/http.js"
@@ -43,6 +44,7 @@
     "tiktok",
     "instagram"
   ],
+  "mcpName": "com.socialneuron/mcp-server",
   "publishConfig": {
     "access": "public"
   },