@crowdlisten/harness 1.0.0

package/dist/transport/http.d.ts

@@ -0,0 +1,15 @@
+#!/usr/bin/env node
+/**
+ * Streamable HTTP Transport for CrowdListen Harness
+ *
+ * Exposes the full MCP tool surface over HTTP. Stateless mode —
+ * each request extracts auth from Authorization header.
+ *
+ * Endpoints:
+ *   POST   /mcp          — MCP tool calls (StreamableHTTPServerTransport)
+ *   GET    /mcp          — SSE connection for streaming
+ *   DELETE /mcp          — Session cleanup
+ *   GET    /health       — Health check
+ *   GET    /openapi.json — Auto-generated OpenAPI spec
+ */
+export declare function startHttpTransport(port?: number): Promise<void>;

package/dist/transport/http.js

@@ -0,0 +1,154 @@
+#!/usr/bin/env node
+/**
+ * Streamable HTTP Transport for CrowdListen Harness
+ *
+ * Exposes the full MCP tool surface over HTTP. Stateless mode —
+ * each request extracts auth from Authorization header.
+ *
+ * Endpoints:
+ *   POST   /mcp          — MCP tool calls (StreamableHTTPServerTransport)
+ *   GET    /mcp          — SSE connection for streaming
+ *   DELETE /mcp          — Session cleanup
+ *   GET    /health       — Health check
+ *   GET    /openapi.json — Auto-generated OpenAPI spec
+ */
+import * as http from "http";
+import * as crypto from "crypto";
+import { createClient } from "@supabase/supabase-js";
+import { StreamableHTTPServerTransport } from "@modelcontextprotocol/sdk/server/streamableHttp.js";
+import { createMcpServer, SERVER_VERSION } from "../server-factory.js";
+import { generateOpenApiSpec } from "../openapi.js";
+import { TOOLS } from "../tools.js";
+const CROWDLISTEN_SUPABASE_URL = process.env.CROWDLISTEN_URL || "https://fnvlxtzonwybshtvrzit.supabase.co";
+const CROWDLISTEN_ANON_KEY = process.env.CROWDLISTEN_ANON_KEY ||
+    "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJpc3MiOiJzdXBhYmFzZSIsInJlZiI6ImZudmx4dHpvbnd5YnNodHZyeml0Iiwicm9sZSI6ImFub24iLCJpYXQiOjE3NTY4NjExMjksImV4cCI6MjA3MjQzNzEyOX0.KAoEVMAVxqANcHBrjT5Et_9xiMZGP7LzdVSoSDLxpaA";
+// ─── Auth Extraction ───────────────────────────────────────────────────────
+async function authenticateRequest(req
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+) {
+    const authHeader = req.headers.authorization;
+    if (!authHeader || !authHeader.startsWith("Bearer ")) {
+        throw new Error("Authorization header required: Bearer <token>");
+    }
+    const token = authHeader.slice(7);
+    const supabase = createClient(CROWDLISTEN_SUPABASE_URL, CROWDLISTEN_ANON_KEY, {
+        auth: { autoRefreshToken: false, persistSession: false },
+    });
+    // Try as JWT first
+    const { data, error } = await supabase.auth.getUser(token);
+    if (!error && data.user) {
+        // Set session so RLS works — refresh_token must be non-empty
+        // for Supabase to properly set the auth context
+        await supabase.auth.setSession({
+            access_token: token,
+            refresh_token: token, // reuse access_token; won't refresh but RLS works
+        });
+        return { supabase, userId: data.user.id };
+    }
+    // Could be an API key — look up in api_keys table
+    const anonSb = createClient(CROWDLISTEN_SUPABASE_URL, CROWDLISTEN_ANON_KEY);
+    const { data: keyRow } = await anonSb
+        .from("api_keys")
+        .select("user_id")
+        .eq("key_hash", hashApiKey(token))
+        .eq("revoked", false)
+        .single();
+    if (keyRow) {
+        return { supabase: anonSb, userId: keyRow.user_id };
+    }
+    throw new Error("Invalid token or API key");
+}
+function hashApiKey(key) {
+    return crypto.createHash("sha256").update(key).digest("hex");
+}
+// ─── CORS Headers ──────────────────────────────────────────────────────────
+function setCorsHeaders(res) {
+    res.setHeader("Access-Control-Allow-Origin", "*");
+    res.setHeader("Access-Control-Allow-Methods", "GET, POST, DELETE, OPTIONS");
+    res.setHeader("Access-Control-Allow-Headers", "Content-Type, Authorization, Accept");
+    res.setHeader("Access-Control-Max-Age", "86400");
+}
+// ─── HTTP Server ───────────────────────────────────────────────────────────
+export async function startHttpTransport(port = 3848) {
+    // Cache the OpenAPI spec
+    let cachedSpec = null;
+    const httpServer = http.createServer(async (req, res) => {
+        setCorsHeaders(res);
+        // Handle CORS preflight
+        if (req.method === "OPTIONS") {
+            res.writeHead(204);
+            res.end();
+            return;
+        }
+        const url = new URL(req.url || "/", `http://localhost:${port}`);
+        // ── Health Check ─────────────────────────────────────────
+        if (url.pathname === "/health" && req.method === "GET") {
+            res.writeHead(200, { "Content-Type": "application/json" });
+            res.end(JSON.stringify({
+                status: "ok",
+                version: SERVER_VERSION,
+                tools: TOOLS.length,
+                transport: "streamable-http",
+            }));
+            return;
+        }
+        // ── OpenAPI Spec ─────────────────────────────────────────
+        if (url.pathname === "/openapi.json" && req.method === "GET") {
+            if (!cachedSpec) {
+                cachedSpec = JSON.stringify(generateOpenApiSpec(), null, 2);
+            }
+            res.writeHead(200, { "Content-Type": "application/json" });
+            res.end(cachedSpec);
+            return;
+        }
+        // ── MCP Endpoints ────────────────────────────────────────
+        if (url.pathname === "/mcp") {
+            try {
+                const { supabase, userId } = await authenticateRequest(req);
+                const server = createMcpServer({ supabase, userId });
+                const transport = new StreamableHTTPServerTransport({
+                    sessionIdGenerator: undefined, // Stateless mode
+                });
+                await server.connect(transport);
+                await transport.handleRequest(req, res);
+                // Clean up after request completes
+                await server.close();
+            }
+            catch (err) {
+                const message = err instanceof Error ? err.message : String(err);
+                const status = message.includes("Authorization") ? 401 : 500;
+                res.writeHead(status, { "Content-Type": "application/json" });
+                res.end(JSON.stringify({ error: message }));
+            }
+            return;
+        }
+        // ── 404 ──────────────────────────────────────────────────
+        res.writeHead(404, { "Content-Type": "application/json" });
+        res.end(JSON.stringify({
+            error: "Not found",
+            endpoints: ["/mcp", "/health", "/openapi.json"],
+        }));
+    });
+    httpServer.listen(port, () => {
+        console.error(`
+CrowdListen Harness HTTP server running
+
+  MCP:     http://localhost:${port}/mcp
+  Health:  http://localhost:${port}/health
+  OpenAPI: http://localhost:${port}/openapi.json
+
+  Tools: ${TOOLS.length} across planning, analysis, content, generation, LLM, and agent network
+
+  Connect from any MCP client:
+    { "url": "http://localhost:${port}/mcp" }
+`);
+    });
+    // Graceful shutdown
+    process.on("SIGINT", () => {
+        console.error("\nShutting down...");
+        httpServer.close(() => process.exit(0));
+    });
+    process.on("SIGTERM", () => {
+        httpServer.close(() => process.exit(0));
+    });
+}

package/package.json

@@ -0,0 +1,76 @@
+{
+  "name": "@crowdlisten/harness",
+  "version": "1.0.0",
+  "description": "Crowd context for AI agents — analyzed crowd intelligence from social platforms, with planning, skill packs, and semantic recall",
+  "type": "module",
+  "bin": {
+    "crowdlisten-harness": "dist/index.js",
+    "crowdlisten-serve": "dist/transport/http.js",
+    "crowdlisten": "dist/insights/cli.js"
+  },
+  "scripts": {
+    "build": "tsc",
+    "build:web": "cd src/context/web && npx vite build --outDir ../../../web-dist",
+    "build:catalog": "node scripts/build-catalog.js",
+    "build:all": "npm run build:catalog && npm run build && npm run build:web",
+    "dev": "tsx src/index.ts",
+    "start": "node dist/index.js",
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "test:coverage": "vitest run --coverage",
+    "test:e2e": "vitest run --config vitest.e2e.config.ts"
+  },
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.12.1",
+    "@supabase/supabase-js": "^2.49.4",
+    "@the-convocation/twitter-scraper": "^0.22.1",
+    "axios": "^1.13.1",
+    "commander": "^14.0.3",
+    "dotenv": "^17.3.1",
+    "jszip": "^3.10.1",
+    "node-fetch": "^3.3.2",
+    "pdf-parse": "^1.1.1"
+  },
+  "devDependencies": {
+    "tsx": "^4.19.0",
+    "typescript": "^5.7.0",
+    "@types/node": "^22.0.0",
+    "playwright": "^1.58.2",
+    "vitest": "^3.0.0",
+    "@vitest/coverage-v8": "^3.0.0",
+    "react": "^19.0.0",
+    "react-dom": "^19.0.0",
+    "@types/react": "^19.0.0",
+    "@types/react-dom": "^19.0.0",
+    "vite": "^6.0.0",
+    "@vitejs/plugin-react": "^4.3.0",
+    "tailwindcss": "^4.0.0",
+    "@tailwindcss/vite": "^4.0.0"
+  },
+  "files": [
+    "dist",
+    "web-dist",
+    "skills",
+    "README.md",
+    "AGENTS.md",
+    "LICENSE"
+  ],
+  "keywords": [
+    "mcp",
+    "planning",
+    "delegation",
+    "coding-agent",
+    "crowdlisten",
+    "knowledge-base",
+    "context-extraction",
+    "social-media",
+    "crowd-intelligence",
+    "skill-packs"
+  ],
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/Crowdlisten/crowdlisten_harness.git"
+  },
+  "homepage": "https://crowdlisten.com"
+}

package/skills/catalog.json

@@ -0,0 +1,272 @@
+[
+  {
+    "id": "competitive-analysis",
+    "name": "crowdlisten:competitive-analysis",
+    "description": "Competitive intelligence through audience perception analysis. Use when comparing brands, products, or competitors in social conversations. Requires CROWDLISTEN_API_KEY.",
+    "keywords": [
+      "competitive",
+      "intelligence",
+      "audience",
+      "perception",
+      "analysis",
+      "comparing",
+      "brands",
+      "products",
+      "competitors",
+      "social",
+      "conversations",
+      "crowdlisten",
+      "positioning",
+      "strategy",
+      "market",
+      "entry",
+      "landscape",
+      "assessment",
+      "tracking",
+      "competitor",
+      "changes",
+      "time",
+      "identifying",
+      "underserved",
+      "segments",
+      "feature",
+      "identification",
+      "preparing",
+      "fundraising",
+      "board",
+      "meetings",
+      "strategic",
+      "reviews"
+    ]
+  },
+  {
+    "id": "content-creator",
+    "name": "crowdlisten:content-creator",
+    "description": "Generate SEO-optimized marketing content with brand voice analysis. Blog posts, social media, email campaigns. Use when creating any branded content.",
+    "keywords": [
+      "generate",
+      "seo-optimized",
+      "marketing",
+      "content",
+      "brand",
+      "voice",
+      "analysis",
+      "blog",
+      "posts",
+      "social",
+      "media",
+      "email",
+      "campaigns",
+      "creating",
+      "branded",
+      "creator"
+    ]
+  },
+  {
+    "id": "content-strategy",
+    "name": "crowdlisten:content-strategy",
+    "description": "Data-driven content strategy grounded in audience demand. Topic demand analysis, content gaps, platform optimization, voice matching, campaign tracking. Requires CROWDLISTEN_API_KEY.",
+    "keywords": [
+      "data-driven",
+      "content",
+      "strategy",
+      "grounded",
+      "audience",
+      "demand",
+      "topic",
+      "analysis",
+      "gaps",
+      "platform",
+      "optimization",
+      "voice",
+      "matching",
+      "campaign",
+      "tracking",
+      "crowdlisten",
+      "calendar",
+      "planning",
+      "audience-validated",
+      "topics",
+      "finding",
+      "competitors",
+      "haven",
+      "covered",
+      "optimizing",
+      "format",
+      "timing",
+      "adapting",
+      "brand",
+      "match",
+      "communication",
+      "style",
+      "measuring",
+      "resonance",
+      "adjusting",
+      "product",
+      "launches",
+      "performance",
+      "monitoring",
+      "real-time",
+      "sentiment",
+      "during",
+      "launch",
+      "windows",
+      "crisis",
+      "early",
+      "warning",
+      "message",
+      "scoring"
+    ]
+  },
+  {
+    "id": "data-storytelling",
+    "name": "crowdlisten:data-storytelling",
+    "description": "Transform data and analysis into compelling narratives. Problem-Solution, Trend, Comparison, Hero's Journey frameworks. Use when presenting insights to stakeholders.",
+    "keywords": [
+      "transform",
+      "data",
+      "analysis",
+      "compelling",
+      "narratives",
+      "problem-solution",
+      "trend",
+      "comparison",
+      "hero",
+      "journey",
+      "frameworks",
+      "presenting",
+      "insights",
+      "stakeholders",
+      "storytelling"
+    ]
+  },
+  {
+    "id": "heuristic-evaluation",
+    "name": "crowdlisten:heuristic-evaluation",
+    "description": "Customer feedback analysis from social conversations. Journey friction detection, pain point mapping, persona generation, churn risk signals. Requires CROWDLISTEN_API_KEY.",
+    "keywords": [
+      "customer",
+      "feedback",
+      "analysis",
+      "social",
+      "conversations",
+      "journey",
+      "friction",
+      "detection",
+      "pain",
+      "point",
+      "mapping",
+      "persona",
+      "generation",
+      "churn",
+      "risk",
+      "signals",
+      "crowdlisten",
+      "experience",
+      "improvement",
+      "optimization",
+      "clustering",
+      "usability",
+      "signal",
+      "organic",
+      "discussions",
+      "support",
+      "strategy",
+      "ticket",
+      "deflection",
+      "health",
+      "monitoring",
+      "prevention",
+      "identifying",
+      "profiling",
+      "target",
+      "audience",
+      "segments",
+      "heuristic",
+      "evaluation"
+    ]
+  },
+  {
+    "id": "market-research-reports",
+    "name": "crowdlisten:market-research",
+    "description": "Generate comprehensive market research reports with Porter's Five Forces, PESTLE, SWOT, TAM/SAM/SOM, BCG Matrix. Use for market analysis, competitive landscape, industry trends.",
+    "keywords": [
+      "generate",
+      "comprehensive",
+      "market",
+      "research",
+      "reports",
+      "porter",
+      "five",
+      "forces",
+      "pestle",
+      "swot",
+      "matrix",
+      "analysis",
+      "competitive",
+      "landscape",
+      "industry",
+      "trends"
+    ]
+  },
+  {
+    "id": "user-stories",
+    "name": "crowdlisten:user-stories",
+    "description": "Turn social listening data into product decisions. JTBD extraction, feature demand scoring, persona generation, user story generation from real audience data. Requires CROWDLISTEN_API_KEY.",
+    "keywords": [
+      "turn",
+      "social",
+      "listening",
+      "data",
+      "product",
+      "decisions",
+      "jtbd",
+      "extraction",
+      "feature",
+      "demand",
+      "scoring",
+      "persona",
+      "generation",
+      "user",
+      "story",
+      "real",
+      "audience",
+      "crowdlisten",
+      "planning",
+      "roadmap",
+      "prioritization",
+      "discussions",
+      "request",
+      "analysis",
+      "early-stage",
+      "idea",
+      "validation",
+      "against",
+      "stories"
+    ]
+  },
+  {
+    "id": "ux-researcher",
+    "name": "crowdlisten:ux-research",
+    "description": "UX research synthesis — user personas, journey maps, heuristic evaluation (Nielsen's 10), design recommendations. Use when analyzing user behavior or designing experiences.",
+    "keywords": [
+      "research",
+      "synthesis",
+      "user",
+      "personas",
+      "journey",
+      "maps",
+      "heuristic",
+      "evaluation",
+      "nielsen",
+      "design",
+      "recommendations",
+      "analyzing",
+      "behavior",
+      "designing",
+      "experiences",
+      "researcher",
+      "designer"
+    ]
+  }
+]