@omnicensus/mcp-server 0.3.2

package/README.md

@@ -0,0 +1,85 @@
+# Omnicensus MCP Server
+
+Score and analyze videos through any MCP-compatible AI agent — Claude Desktop, Cursor, Windsurf, Continue, Cline, and others.
+
+## What it does
+
+Exposes 27 tools to the agent. The core ones:
+
+| Tool | Use |
+|---|---|
+| `quick_score` | Score a video's hook in ~10s. No signup needed. Returns viral score + hook diagnostic. |
+| `analyze_video` | Submit for full analysis (drop-off moments, edit suggestions, best 30s/60s clips, audience reactions). |
+| `get_job_status` | Poll a submitted job. |
+| `get_capabilities` | List analysis modes, platforms, current API version. |
+| `get_agent_balance` | Check credit balance. |
+| `submit_retention_feedback` | Send real view/retention numbers to improve accuracy. |
+| `extract_clips` | Pull the best short clips from a video. |
+
+Plus ~20 more for thumbnails, FCPXML/CSV exports, hook variants, report chat, channel insights, competitor teardown, audience exploration, social scheduling/posting, brain-map sharing, credit purchase, and team/org billing. Call `get_capabilities` for the live catalog.
+
+## Install (Claude Desktop)
+
+```bash
+claude mcp add omnicensus npx -- -y @omnicensus/mcp-server
+```
+
+Then in `~/Library/Application Support/Claude/claude_desktop_config.json` add your API key:
+
+```json
+{
+  "mcpServers": {
+    "omnicensus": {
+      "command": "npx",
+      "args": ["-y", "@omnicensus/mcp-server"],
+      "env": { "OMNICENSUS_API_KEY": "sk_live_..." }
+    }
+  }
+}
+```
+
+## Install (Cursor / Windsurf / Continue)
+
+Add to your `~/.cursor/mcp.json` (Cursor) or equivalent:
+
+```json
+{
+  "mcpServers": {
+    "omnicensus": {
+      "command": "npx",
+      "args": ["-y", "@omnicensus/mcp-server"],
+      "env": { "OMNICENSUS_API_KEY": "sk_live_..." }
+    }
+  }
+}
+```
+
+## Get an API key
+
+1. Sign in at https://omnicensus.video
+2. Settings → Developers → Generate API key
+3. Copy the `sk_live_...` value into the env above
+
+## Example prompts (once installed)
+
+> "Score this video for me: https://example.com/myvideo.mp4"
+
+> "Analyze https://example.com/long-form.mp4 for TikTok — find me the best 30-second clip."
+
+> "What's my Omnicensus balance?"
+
+## Local development
+
+From the Omnicensus repo:
+
+```bash
+cd mcp-server
+npm install
+npm run dev   # runs from src/ via tsx
+```
+
+To point at a local backend, set `OMNICENSUS_API_BASE` to your emulator's functions URL.
+
+## License
+
+MIT

package/dist/index.js

@@ -0,0 +1,398 @@
+#!/usr/bin/env node
+/**
+ * Omnicensus MCP Server — full user-side coverage for AI agents.
+ *
+ * Auth: API key via env OMNICENSUS_API_KEY (get one at
+ *       https://omnicensus.video/settings?tab=developers).
+ *
+ * Install (Claude Desktop):
+ *   claude mcp add omnicensus npx -- -y @omnicensus/mcp-server
+ *
+ * Cursor / Windsurf: drop this in mcp.json:
+ *   { "omnicensus": { "command": "npx", "args": ["-y", "@omnicensus/mcp-server"],
+ *     "env": { "OMNICENSUS_API_KEY": "sk_live_..." } } }
+ */
+import { Server } from "@modelcontextprotocol/sdk/server/index.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { CallToolRequestSchema, ListToolsRequestSchema, ErrorCode, McpError, } from "@modelcontextprotocol/sdk/types.js";
+import { z } from "zod";
+const API_BASE = process.env.OMNICENSUS_API_BASE
+    ?? "https://us-central1-tribemind-ac19c.cloudfunctions.net";
+const API_KEY = process.env.OMNICENSUS_API_KEY ?? "";
+function authHeaders() {
+    if (!API_KEY)
+        return { "Content-Type": "application/json" };
+    return { "Content-Type": "application/json", "x-api-key": API_KEY };
+}
+// raw=true returns the response body as a string (for non-JSON endpoints like
+// exportJob, which returns an FCPXML document). All calls have a 60s timeout —
+// every endpoint returns quickly (jobs return a job_id you then poll), so a hang
+// means something is wrong and we surface a clear error instead of blocking.
+async function call(path, init = {}, raw = false) {
+    const ctrl = new AbortController();
+    const timer = setTimeout(() => ctrl.abort(), 60_000);
+    let res;
+    try {
+        res = await fetch(`${API_BASE}${path}`, {
+            ...init,
+            headers: { ...authHeaders(), ...(init.headers || {}) },
+            signal: ctrl.signal,
+        });
+    }
+    catch (e) {
+        clearTimeout(timer);
+        if (e?.name === "AbortError")
+            throw new McpError(ErrorCode.InternalError, "Omnicensus request timed out after 60s");
+        throw new McpError(ErrorCode.InternalError, `Omnicensus network error: ${e?.message ?? String(e)}`);
+    }
+    clearTimeout(timer);
+    const text = await res.text();
+    if (!res.ok) {
+        let msg = text.slice(0, 200);
+        try {
+            const j = JSON.parse(text);
+            msg = j?.error?.message ?? j?.error ?? msg;
+        }
+        catch { /* non-JSON error body */ }
+        throw new McpError(ErrorCode.InternalError, `Omnicensus ${res.status}: ${msg}`);
+    }
+    if (raw)
+        return text;
+    try {
+        return JSON.parse(text);
+    }
+    catch {
+        return { raw: text };
+    }
+}
+// ── Tool schemas ────────────────────────────────────────────────────────────
+const QuickScore = z.object({ video_url: z.string().url() });
+const AnalyzeVideo = z.object({
+    video_url: z.string().url(),
+    analysis_mode: z.enum(["fast", "deep", "turbo"]).default("fast"),
+    platform: z.enum(["youtube", "youtube_shorts", "tiktok", "instagram_reels"]).optional(),
+    duration_minutes: z.number().min(0.1).max(360).optional(),
+});
+const GetJobStatus = z.object({
+    job_id: z.string(),
+    output_format: z.enum(["agent", "default"]).default("agent"),
+});
+const ListRecentJobs = z.object({ limit: z.number().min(1).max(100).default(20) });
+const ShareReport = z.object({ job_id: z.string(), is_public: z.boolean().default(true) });
+const ExportJob = z.object({
+    job_id: z.string(),
+    format: z.enum(["fcpxml"]).default("fcpxml"),
+});
+const SubmitFeedback = z.object({
+    job_id: z.string(),
+    actual_views: z.number().int().min(0).optional(),
+    actual_retention_rate: z.number().min(0).max(1).optional(),
+    feedback_text: z.string().max(2000).optional(),
+});
+const BuyCredits = z.object({});
+const ManageBilling = z.object({});
+const GetCapabilities = z.object({});
+const GetAgentBalance = z.object({});
+const CreateSubAgentKey = z.object({
+    name: z.string().min(1).max(60),
+    spend_cap_credits: z.number().int().min(1).max(10000).default(100),
+});
+const SocialPlatform = z.enum(["youtube_shorts", "tiktok", "instagram_reels"]);
+const ExtractClips = z.object({
+    video_url: z.string().url(),
+    num_clips: z.number().int().min(1).max(5).default(5),
+    aspect_ratio: z.enum(["source", "9:16", "1:1", "16:9"]).default("source"),
+    caption_language: z.enum(["en", "es", "pt", "fr", "de", "hi", "zh", "ja", "ko", "ar"]).optional(),
+    include_broll: z.boolean().optional(),
+});
+const ScoreHookVariant = z.object({
+    job_id: z.string(),
+    hook_text: z.string().min(1).max(600),
+});
+const ChatWithReport = z.object({
+    job_id: z.string(),
+    messages: z.array(z.object({
+        role: z.enum(["user", "assistant"]),
+        content: z.string(),
+    })).min(1),
+    chat_id: z.string().optional(),
+    mode: z.enum(["report", "ideas"]).default("report"),
+});
+const ExploreAudience = z.object({
+    job_id: z.string(),
+    demographics: z.record(z.unknown()),
+});
+const PostClipToSocial = z.object({
+    job_id: z.string(),
+    platforms: z.array(SocialPlatform).min(1),
+    clip_index: z.number().int().min(0).optional(),
+    caption: z.string().optional(),
+    hashtags: z.array(z.string()).optional(),
+});
+const SchedulePost = z.object({
+    job_id: z.string(),
+    platforms: z.array(SocialPlatform).min(1),
+    scheduled_at: z.number().int(),
+    clip_type: z.string().default("full"),
+    caption: z.string().optional(),
+    hashtags: z.array(z.string()).max(30).optional(),
+});
+const CreateOrgJob = z.object({
+    org_id: z.string(),
+    client_id: z.string(),
+    video_url: z.string().url(),
+    analysis_mode: z.enum(["fast", "turbo", "deep"]).optional(),
+});
+const GetOrgRollup = z.object({ org_id: z.string() });
+const GenerateThumbnails = z.object({
+    job_id: z.string(),
+    platforms: z.array(z.enum(["youtube", "short", "square"])).optional(),
+    k: z.number().int().min(1).max(5).optional(),
+});
+const ChannelInsights = z.object({
+    limit: z.number().int().min(3).max(50).optional(),
+    org_id: z.string().optional(),
+    client_id: z.string().optional(),
+});
+const CompetitorTeardown = z.object({ competitor_job_id: z.string() });
+const ApplyEdits = z.object({ job_id: z.string() });
+const ShareBrainMap = z.object({ job_id: z.string() });
+const FundOrgPool = z.object({ org_id: z.string(), credits: z.number().int().min(5).max(5000) });
+const SetAccountProfile = z.object({ account_type: z.enum(['individual', 'business']), company_name: z.string().optional(), company_size: z.string().optional(), website: z.string().optional(), vat_id: z.string().optional(), use_case: z.string().optional(), country: z.string().optional() });
+// ── Server setup ────────────────────────────────────────────────────────────
+const server = new Server({ name: "omnicensus-mcp", version: "0.2.0" }, { capabilities: { tools: {} } });
+// One-sentence descriptions per tool — total tools/list ≈ 350 tokens.
+const TOOLS = [
+    { name: "quick_score", schema: QuickScore,
+        desc: "Score a video's hook in ~10s — no API key needed. Pass a public https video URL; returns {job_id, status}. Poll get_job_status until status='completed'." },
+    { name: "analyze_video", schema: AnalyzeVideo,
+        desc: "Full engagement analysis (drop-offs, edit suggestions, best 30s/60s clips, audience reactions). Modes: fast (60s) | deep (5m) | turbo (15s, 1.5× credits). Returns {job_id}." },
+    { name: "get_job_status", schema: GetJobStatus,
+        desc: "Poll a job. output_format='agent' returns minimal report (saves ~1850 tokens). When status='completed', read report.agent_instructions.{verdict,edits,clips}. brain_simulation_url (when present) links the predicted Cortex brain-reaction map (literature-grounded, not a brain scan)." },
+    { name: "list_recent_jobs", schema: ListRecentJobs,
+        desc: "List the API key owner's recent jobs (default 20). Returns job_id, status, viral_score, share_url, created_at for each." },
+    { name: "share_report", schema: ShareReport,
+        desc: "Toggle a job's public visibility. is_public=true returns {share_url, og_image_url} the agent can post on social or hand back to the user." },
+    { name: "export_job", schema: ExportJob,
+        desc: "Export a job's edit suggestions as an FCPXML timeline file (imports into Final Cut Pro, Premiere, and DaVinci Resolve). Returns the FCPXML document as text." },
+    { name: "submit_retention_feedback", schema: SubmitFeedback,
+        desc: "After the user publishes the video, report back actual views / retention so future predictions improve. Free, improves model accuracy." },
+    { name: "buy_credits", schema: BuyCredits,
+        desc: "Get a Stripe Checkout URL (accepts card / Stripe Link / USDC crypto) so the human can buy 10 credits for $20. Return the URL to the user — agents never see card data." },
+    { name: "manage_billing", schema: ManageBilling,
+        desc: "Open Stripe Customer Portal — user can manage subscription, payment methods, view invoices. Returns a URL; hand it to the user." },
+    { name: "create_sub_agent_key", schema: CreateSubAgentKey,
+        desc: "Mint a scoped child API key with a credit spend cap (default 100). Use this to delegate to worker agents without sharing your master key." },
+    { name: "get_capabilities", schema: GetCapabilities,
+        desc: "One-shot discovery — returns the full Omnicensus tool catalog, modes, platforms, rate limits, share URL template, error codes. ~430 tokens." },
+    { name: "get_agent_balance", schema: GetAgentBalance,
+        desc: "Returns the API key's remaining credit balance. Call before buy_credits if you need to warn the user." },
+    { name: "extract_clips", schema: ExtractClips,
+        desc: "Render 1-5 short vertical clips from a video (1 credit/clip). aspect_ratio: source|9:16|1:1|16:9. Optional caption_language (translates burned captions) and include_broll (Pexels/Pixabay overlays). Applies the API key owner's saved brand kit. Returns {job_id}; poll get_job_status until ready, then read clips[].url." },
+    { name: "score_hook_variant", schema: ScoreHookVariant,
+        desc: "Predict a candidate hook's viral score (0-100) before reshooting. Free. Returns {predicted_score, current_score, delta, verdict, reasoning} for the given job_id." },
+    { name: "chat_with_report", schema: ChatWithReport,
+        desc: "Ask follow-up questions about an analyzed job's report (1 credit/message, refunded on failure). Pass the full messages[] history; returns {message, chat_id}. mode: report|ideas." },
+    { name: "explore_audience", schema: ExploreAudience,
+        desc: "Re-run analysis against a synthetic audience (free, max 10/hour). Pass demographics (ageGroups, gender, subscribedStatus, countries). Returns {exploration_id, status}." },
+    { name: "post_clip_to_social", schema: PostClipToSocial,
+        desc: "Post a rendered clip to connected accounts (youtube_shorts|tiktok|instagram_reels). Free. Account must already be connected in Settings. Returns per-platform {results, clip_url}." },
+    { name: "schedule_post", schema: SchedulePost,
+        desc: "Queue a future post to connected accounts. Free at schedule time; a cron publishes it when due. scheduled_at is a future unix timestamp in MILLISECONDS. Returns {id, status}." },
+    { name: "create_org_job", schema: CreateOrgJob,
+        desc: "Agency/team: analyze a video billed to an ORG credit pool (not personal). Your API key's owner must be a member (owner/admin/editor) of org_id. Deducts from the pool with per-member/client caps. Returns {job_id, credits_charged}; poll get_job_status." },
+    { name: "get_org_rollup", schema: GetOrgRollup,
+        desc: "Agency/team roll-up for org_id (member-only): org totals (pooled_credits, members, clients, jobs, spend) + per-client {jobs_count, avg_score, trend, recent}." },
+    { name: "generate_thumbnails", schema: GenerateThumbnails,
+        desc: "Generate ranked, platform-sized thumbnail candidates for an analyzed job. CV-scored frames (face/sharpness/contrast/colour/title-space) cropped to youtube(1280x720)/short(1080x1920)/square(1080x1080). k=1-5 (default 3). Free. Returns {status, job_id}; poll get_job_status for thumbnails.candidates[]." },
+    { name: "channel_insights", schema: ChannelInsights,
+        desc: "Aggregate patterns across recent jobs (default 20, max 50): avg score + trend, hook trend, common drop points (% of video), best-performing length bucket, recurring weak craft dimension, top genres. Personal by default; pass org_id (+optional client_id) for an agency scope (member-only). Free. Honest enough=false under 3 videos. Returns {insights, scope}." },
+    { name: "competitor_teardown", schema: CompetitorTeardown,
+        desc: "Diff an analysed competitor video against YOUR channel averages (analyze_video the competitor's URL first, then pass its job_id). Returns {teardown:{headline,they_win[],you_win[],parity[],competitor_score,your_avg_score}} — what they do better, where you lead, and parity. Only compares dimensions both sides have. Free. Honest enough=false with no own history." },
+    { name: "apply_edits", schema: ApplyEdits,
+        desc: "Render a downloadable edited cut of an analysed job by removing its 'cut' edit_suggestions (dead zones / low-energy spans). Free. Returns {status, job_id}; poll get_job_status for edited_cut{url, original_duration, edited_duration, removed_seconds, cuts_applied[]}." },
+    { name: "share_brain_map", schema: ShareBrainMap,
+        desc: "Make a job's predicted brain-reaction map public on a token-gated /brain/{token} page (honest 'predicted, not a scan' label). Job must have a brain_simulation_url. Free. Returns {share_url, token}." },
+    { name: "set_account_profile", schema: SetAccountProfile,
+        desc: "Set the account type (individual or business/corporate) + profile. A 'business' account unlocks the org/team workflow (create_org_job, get_org_rollup, fund_org_pool). Returns {ok, account_profile}." },
+    { name: "fund_org_pool", schema: FundOrgPool,
+        desc: "Fund an agency org credit pool by CARD via Stripe (owner/admin of org_id only). credits 5-5000 at $2/credit. LIVE BILLING — returns {url} (a Stripe checkout link); the pool is credited after the human completes payment. First top-up saves the card so the pool can auto-recharge." },
+];
+server.setRequestHandler(ListToolsRequestSchema, async () => ({
+    tools: TOOLS.map(t => ({ name: t.name, description: t.desc, inputSchema: zToJsonSchema(t.schema) })),
+}));
+server.setRequestHandler(CallToolRequestSchema, async (req) => {
+    const name = req.params.name;
+    const args = req.params.arguments ?? {};
+    try {
+        switch (name) {
+            case "quick_score": {
+                const p = QuickScore.parse(args);
+                return toolResult(await call("/quickScore", { method: "POST", body: JSON.stringify({ video_url: p.video_url }) }));
+            }
+            case "analyze_video": {
+                const p = AnalyzeVideo.parse(args);
+                return toolResult(await call("/analyzeVideo", { method: "POST", body: JSON.stringify(p) }));
+            }
+            case "get_job_status": {
+                const p = GetJobStatus.parse(args);
+                return toolResult(await call(`/getJobStatus?job_id=${encodeURIComponent(p.job_id)}&output_format=${p.output_format}`));
+            }
+            case "list_recent_jobs": {
+                const p = ListRecentJobs.parse(args);
+                return toolResult(await call(`/listRecentJobs?limit=${p.limit}`));
+            }
+            case "share_report": {
+                const p = ShareReport.parse(args);
+                return toolResult(await call("/setJobVisibilityHttp", { method: "POST", body: JSON.stringify(p) }));
+            }
+            case "export_job": {
+                const p = ExportJob.parse(args);
+                // exportJob returns a raw FCPXML document, not JSON — return it as text.
+                const xml = await call(`/exportJob?job_id=${encodeURIComponent(p.job_id)}&format=${p.format}`, {}, true);
+                return { content: [{ type: "text", text: String(xml) }] };
+            }
+            case "submit_retention_feedback": {
+                const p = SubmitFeedback.parse(args);
+                return toolResult(await call("/ingestFeedback", { method: "POST", body: JSON.stringify(p) }));
+            }
+            case "buy_credits":
+                return toolResult(await call("/buyCreditsHttp", { method: "POST", body: "{}" }));
+            case "manage_billing":
+                return toolResult(await call("/manageBillingHttp", { method: "POST", body: "{}" }));
+            case "create_sub_agent_key": {
+                const p = CreateSubAgentKey.parse(args);
+                return toolResult(await call("/createSubAgentKey", { method: "POST", body: JSON.stringify(p) }));
+            }
+            case "get_capabilities":
+                return toolResult(await call("/getCapabilities"));
+            case "get_agent_balance":
+                return toolResult(await call("/getAgentBalance"));
+            case "extract_clips": {
+                const p = ExtractClips.parse(args);
+                return toolResult(await call("/extractClips", { method: "POST", body: JSON.stringify(p) }));
+            }
+            case "score_hook_variant": {
+                const p = ScoreHookVariant.parse(args);
+                return toolResult(await call("/scoreHookVariantHttp", { method: "POST", body: JSON.stringify(p) }));
+            }
+            case "chat_with_report": {
+                const p = ChatWithReport.parse(args);
+                return toolResult(await call("/chatWithReportHttp", { method: "POST", body: JSON.stringify(p) }));
+            }
+            case "explore_audience": {
+                const p = ExploreAudience.parse(args);
+                return toolResult(await call("/exploreAudienceHttp", { method: "POST", body: JSON.stringify(p) }));
+            }
+            case "post_clip_to_social": {
+                const p = PostClipToSocial.parse(args);
+                return toolResult(await call("/postClipToSocialHttp", { method: "POST", body: JSON.stringify(p) }));
+            }
+            case "schedule_post": {
+                const p = SchedulePost.parse(args);
+                return toolResult(await call("/schedulePostHttp", { method: "POST", body: JSON.stringify(p) }));
+            }
+            case "create_org_job": {
+                const p = CreateOrgJob.parse(args);
+                return toolResult(await call("/createOrgJobHttp", { method: "POST", body: JSON.stringify(p) }));
+            }
+            case "get_org_rollup": {
+                const p = GetOrgRollup.parse(args);
+                return toolResult(await call(`/getOrgRollupHttp?org_id=${encodeURIComponent(p.org_id)}`));
+            }
+            case "generate_thumbnails": {
+                const p = GenerateThumbnails.parse(args);
+                return toolResult(await call("/generateThumbnailsHttp", { method: "POST", body: JSON.stringify(p) }));
+            }
+            case "channel_insights": {
+                const p = ChannelInsights.parse(args);
+                const qs = new URLSearchParams();
+                if (p.limit)
+                    qs.set("limit", String(p.limit));
+                if (p.org_id)
+                    qs.set("org_id", p.org_id);
+                if (p.client_id)
+                    qs.set("client_id", p.client_id);
+                const suffix = qs.toString() ? `?${qs.toString()}` : "";
+                return toolResult(await call(`/getChannelInsightsHttp${suffix}`));
+            }
+            case "competitor_teardown": {
+                const p = CompetitorTeardown.parse(args);
+                return toolResult(await call(`/getCompetitorTeardownHttp?competitor_job_id=${encodeURIComponent(p.competitor_job_id)}`));
+            }
+            case "apply_edits": {
+                const p = ApplyEdits.parse(args);
+                return toolResult(await call("/applyEditsHttp", { method: "POST", body: JSON.stringify(p) }));
+            }
+            case "share_brain_map": {
+                const p = ShareBrainMap.parse(args);
+                return toolResult(await call("/shareBrainMapHttp", { method: "POST", body: JSON.stringify(p) }));
+            }
+            case "set_account_profile": {
+                const p = SetAccountProfile.parse(args);
+                return toolResult(await call("/setAccountProfileHttp", { method: "POST", body: JSON.stringify(p) }));
+            }
+            case "fund_org_pool": {
+                const p = FundOrgPool.parse(args);
+                return toolResult(await call("/createOrgPoolCheckoutHttp", { method: "POST", body: JSON.stringify(p) }));
+            }
+            default:
+                throw new McpError(ErrorCode.MethodNotFound, `Unknown tool: ${name}`);
+        }
+    }
+    catch (err) {
+        if (err instanceof z.ZodError) {
+            throw new McpError(ErrorCode.InvalidParams, `Invalid arguments: ${err.errors.map(e => `${e.path.join(".")}: ${e.message}`).join("; ")}`);
+        }
+        if (err instanceof McpError)
+            throw err;
+        throw new McpError(ErrorCode.InternalError, err instanceof Error ? err.message : String(err));
+    }
+});
+function toolResult(data) {
+    return { content: [{ type: "text", text: JSON.stringify(data, null, 2) }] };
+}
+// Minimal zod → JSON Schema (covers ZodObject, ZodString, ZodNumber, ZodBoolean,
+// ZodEnum, ZodArray, ZodRecord, ZodOptional, ZodDefault). Tight on purpose to
+// keep tools/list small.
+function zToJsonSchema(schema) {
+    const def = schema._def;
+    if (def.typeName === "ZodObject") {
+        const shape = def.shape();
+        const properties = {};
+        const required = [];
+        for (const [key, val] of Object.entries(shape)) {
+            const v = val;
+            properties[key] = zToJsonSchema(v);
+            if (!(v._def?.typeName === "ZodOptional" || v._def?.typeName === "ZodDefault")) {
+                required.push(key);
+            }
+        }
+        return { type: "object", properties, required };
+    }
+    if (def.typeName === "ZodOptional" || def.typeName === "ZodDefault")
+        return zToJsonSchema(def.innerType);
+    if (def.typeName === "ZodString")
+        return { type: "string" };
+    if (def.typeName === "ZodNumber")
+        return { type: "number" };
+    if (def.typeName === "ZodBoolean")
+        return { type: "boolean" };
+    if (def.typeName === "ZodEnum")
+        return { type: "string", enum: def.values };
+    if (def.typeName === "ZodArray")
+        return { type: "array", items: zToJsonSchema(def.type) };
+    if (def.typeName === "ZodRecord")
+        return { type: "object" };
+    return { type: "object" };
+}
+async function main() {
+    const transport = new StdioServerTransport();
+    await server.connect(transport);
+    process.stderr.write("[omnicensus-mcp] v0.2.0 connected via stdio\n");
+}
+main().catch((err) => {
+    process.stderr.write(`[omnicensus-mcp] fatal: ${err}\n`);
+    process.exit(1);
+});
+//# sourceMappingURL=index.js.map

package/package.json

@@ -0,0 +1,49 @@
+{
+  "name": "@omnicensus/mcp-server",
+  "version": "0.3.2",
+  "description": "MCP server for Omnicensus — let Claude, Cursor, Windsurf, and any MCP-compatible AI agent score, analyze, share, export, and bill on the Omnicensus video-engagement platform.",
+  "license": "MIT",
+  "homepage": "https://omnicensus.video",
+  "bin": {
+    "omnicensus-mcp": "dist/index.js"
+  },
+  "main": "dist/index.js",
+  "type": "module",
+  "files": [
+    "dist/index.js",
+    "README.md"
+  ],
+  "scripts": {
+    "build": "tsc",
+    "start": "node dist/index.js",
+    "dev": "tsx src/index.ts",
+    "test": "node test-smoke.mjs",
+    "prepublishOnly": "npm run build"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "engines": {
+    "node": ">=18"
+  },
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.0.0",
+    "zod": "^3.23.0"
+  },
+  "devDependencies": {
+    "@types/node": "^22.0.0",
+    "tsx": "^4.19.0",
+    "typescript": "^5.6.0"
+  },
+  "keywords": [
+    "mcp",
+    "modelcontextprotocol",
+    "claude",
+    "cursor",
+    "windsurf",
+    "video",
+    "engagement",
+    "ai-agent",
+    "omnicensus"
+  ]
+}