@totalaudiopromo/tap-mcp 0.1.0

package/README.md

@@ -0,0 +1,79 @@
+# @total-audio/tap-mcp
+
+MCP server for [Total Audio Promo](https://totalaudiopromo.com) -- the first music PR tool with programmatic access.
+
+Exposes 10 tools and 3 resources via the [Model Context Protocol](https://modelcontextprotocol.io), giving AI agents full access to the music PR campaign lifecycle.
+
+## Tools
+
+| Tool                   | Description                                                  |
+| ---------------------- | ------------------------------------------------------------ |
+| `tap_list_campaigns`   | List campaigns with optional status filter                   |
+| `tap_get_campaign`     | Get campaign details with contact counts and pitch stats     |
+| `tap_list_contacts`    | List contacts with filters (status, genre, BBC-only, search) |
+| `tap_search_contacts`  | Search contacts by name, outlet, genre, or BBC station       |
+| `tap_contact_insights` | Get enrichment and relationship insights for a contact       |
+| `tap_draft_pitch`      | Generate AI-drafted pitches (subject, body, variants)        |
+| `tap_log_outcome`      | Log campaign outcomes (replied, coverage, playlist, etc.)    |
+| `tap_get_action_queue` | Get today's prioritised action queue                         |
+
+## Resources
+
+| URI               | Description                  |
+| ----------------- | ---------------------------- |
+| `tap://campaigns` | Browse all campaigns as JSON |
+| `tap://contacts`  | Browse all contacts as JSON  |
+| `tap://artists`   | Browse all artists as JSON   |
+
+## Setup
+
+### Claude Code
+
+Add to `.claude/settings.json`:
+
+```json
+{
+  "mcpServers": {
+    "tap": {
+      "command": "npx",
+      "args": ["@total-audio/tap-mcp"],
+      "env": {
+        "TAP_SUPABASE_URL": "your-supabase-url",
+        "TAP_SUPABASE_KEY": "your-service-role-key"
+      }
+    }
+  }
+}
+```
+
+### From source
+
+```json
+{
+  "mcpServers": {
+    "tap": {
+      "command": "npx",
+      "args": ["tsx", "packages/tap-mcp/src/index.ts"],
+      "env": {
+        "TAP_SUPABASE_URL": "your-supabase-url",
+        "TAP_SUPABASE_KEY": "your-service-role-key"
+      }
+    }
+  }
+}
+```
+
+## Environment Variables
+
+| Variable           | Description               |
+| ------------------ | ------------------------- |
+| `TAP_SUPABASE_URL` | Supabase project URL      |
+| `TAP_SUPABASE_KEY` | Supabase service role key |
+
+## REST API
+
+TAP also has a REST API with 7 endpoints for contacts, enrichment, validation, and API key management. See the [developer docs](https://totalaudiopromo.com/developers) and [OpenAPI spec](https://totalaudiopromo.com/api/openapi.json).
+
+## Licence
+
+MIT

package/dist/index.d.ts

@@ -0,0 +1 @@
+#!/usr/bin/env node

package/dist/index.js

@@ -0,0 +1,894 @@
+#!/usr/bin/env node
+
+// src/index.ts
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+
+// src/tools/campaigns.ts
+import { z } from "zod";
+
+// src/auth.ts
+import { createClient } from "@supabase/supabase-js";
+var adminClient = null;
+function getSupabaseUrl() {
+  const url = process.env.TAP_SUPABASE_URL || process.env.NEXT_PUBLIC_SUPABASE_URL;
+  if (!url) throw new Error("TAP_SUPABASE_URL or NEXT_PUBLIC_SUPABASE_URL is required");
+  return url;
+}
+function getWorkspaceId() {
+  const wsId = process.env.TAP_WORKSPACE_ID;
+  if (!wsId) {
+    throw new Error(
+      "TAP_WORKSPACE_ID environment variable is required. Set it to the workspace ID this MCP server should operate within."
+    );
+  }
+  return wsId;
+}
+function getTapUrl() {
+  return process.env.TAP_URL || "https://totalaudiopromo.com";
+}
+function getAdminClient() {
+  if (adminClient) return adminClient;
+  const url = getSupabaseUrl();
+  const key = process.env.TAP_SUPABASE_KEY || process.env.SUPABASE_SERVICE_ROLE_KEY;
+  if (!key) throw new Error("TAP_SUPABASE_KEY or SUPABASE_SERVICE_ROLE_KEY is required");
+  adminClient = createClient(url, key, {
+    auth: { persistSession: false, autoRefreshToken: false }
+  });
+  return adminClient;
+}
+
+// src/tools/campaigns.ts
+function registerCampaignTools(server2) {
+  server2.tool(
+    "tap_list_campaigns",
+    "List campaigns in the workspace, optionally filtered by status",
+    {
+      status: z.enum(["draft", "active", "paused", "completed", "archived"]).optional(),
+      limit: z.number().optional().describe("Max results (default 50)")
+    },
+    async ({ status, limit }) => {
+      const supabase = getAdminClient();
+      const wsId = getWorkspaceId();
+      let query = supabase.from("tap_projects").select("id, name, artist_name, status, release_name, release_date, goal, created_at", {
+        count: "exact"
+      }).eq("workspace_id", wsId).order("created_at", { ascending: false }).limit(limit || 50);
+      if (status) query = query.eq("status", status);
+      const { data, count, error } = await query;
+      if (error) return { content: [{ type: "text", text: `Error: ${error.message}` }] };
+      return {
+        content: [
+          {
+            type: "text",
+            text: JSON.stringify({ campaigns: data || [], total: count || 0 }, null, 2)
+          }
+        ]
+      };
+    }
+  );
+  server2.tool(
+    "tap_get_campaign",
+    "Get campaign details including contacts, outcomes, and pitch stats",
+    {
+      campaign_id: z.string().describe("Campaign ID")
+    },
+    async ({ campaign_id }) => {
+      const supabase = getAdminClient();
+      const wsId = getWorkspaceId();
+      const { data: campaign, error } = await supabase.from("tap_projects").select("*").eq("id", campaign_id).eq("workspace_id", wsId).single();
+      if (error || !campaign) {
+        return {
+          content: [
+            { type: "text", text: `Campaign not found in workspace: ${campaign_id}` }
+          ]
+        };
+      }
+      const [contactsResult, outcomesResult, pitchesResult] = await Promise.all([
+        supabase.from("campaign_contacts").select("contact_id, pitch_status", { count: "exact" }).eq("project_id", campaign_id),
+        supabase.from("tap_contact_outcomes").select("outcome_type").eq("project_id", campaign_id).eq("workspace_id", wsId),
+        supabase.from("campaign_pitch_drafts").select("id", { count: "exact", head: true }).eq("campaign_id", campaign_id)
+      ]);
+      const contacts = contactsResult.data || [];
+      const outcomes = outcomesResult.data || [];
+      const pitched = contacts.filter(
+        (c) => ["sent", "opened", "replied"].includes(c.pitch_status)
+      ).length;
+      const replied = contacts.filter((c) => c.pitch_status === "replied").length;
+      return {
+        content: [
+          {
+            type: "text",
+            text: JSON.stringify(
+              {
+                ...campaign,
+                stats: {
+                  totalContacts: contactsResult.count || 0,
+                  pitched,
+                  replied,
+                  responseRate: contacts.length > 0 ? Math.round(replied / contacts.length * 100) : 0,
+                  outcomes: outcomes.length,
+                  pitchDrafts: pitchesResult.count || 0
+                }
+              },
+              null,
+              2
+            )
+          }
+        ]
+      };
+    }
+  );
+  server2.tool(
+    "tap_create_campaign",
+    "Create a new campaign in the workspace",
+    {
+      name: z.string().describe("Campaign name"),
+      artist_name: z.string().optional().describe("Artist name"),
+      release_name: z.string().optional().describe("Release name"),
+      release_date: z.string().optional().describe("Release date (YYYY-MM-DD)"),
+      goal: z.string().optional().describe("Campaign goal"),
+      channels: z.array(z.string()).optional().describe("Target channels (radio, press, playlist)")
+    },
+    async ({ name, artist_name, release_name, release_date, goal, channels }) => {
+      const supabase = getAdminClient();
+      const wsId = getWorkspaceId();
+      const { data, error } = await supabase.from("tap_projects").insert({
+        workspace_id: wsId,
+        name,
+        artist_name: artist_name || null,
+        release_name: release_name || null,
+        release_date: release_date || null,
+        goal: goal || null,
+        services: channels || null,
+        status: "draft"
+      }).select("*").single();
+      if (error) return { content: [{ type: "text", text: `Error: ${error.message}` }] };
+      return {
+        content: [
+          {
+            type: "text",
+            text: JSON.stringify(
+              { campaign: data, message: `Campaign "${name}" created as draft` },
+              null,
+              2
+            )
+          }
+        ]
+      };
+    }
+  );
+  server2.tool(
+    "tap_suggest_contacts",
+    "Get AI-scored contact suggestions for a campaign based on warmth, genre overlap, response rate, and past outcomes",
+    {
+      campaign_id: z.string().describe("Campaign ID"),
+      limit: z.number().optional().describe("Max suggestions (default 20)")
+    },
+    async ({ campaign_id, limit }) => {
+      const supabase = getAdminClient();
+      const wsId = getWorkspaceId();
+      const { data: campaign, error } = await supabase.from("tap_projects").select("workspace_id, services, artist_id").eq("id", campaign_id).eq("workspace_id", wsId).single();
+      if (error || !campaign) {
+        return {
+          content: [
+            { type: "text", text: `Campaign not found in workspace: ${campaign_id}` }
+          ]
+        };
+      }
+      const { data: existingLinks } = await supabase.from("campaign_contacts").select("contact_id").eq("project_id", campaign_id);
+      const excludeIds = new Set((existingLinks || []).map((l) => l.contact_id));
+      const { data: contacts } = await supabase.from("tap_contacts").select(
+        "id, name, email, outlet, platform_type, genres, bbc_station, enrichment_confidence"
+      ).eq("workspace_id", wsId).order("updated_at", { ascending: false }).limit(200);
+      if (!contacts || contacts.length === 0) {
+        return {
+          content: [{ type: "text", text: JSON.stringify({ suggestions: [], total: 0 }) }]
+        };
+      }
+      const contactIds = contacts.filter((c) => !excludeIds.has(c.id)).map((c) => c.id);
+      const { data: metricsRows } = await supabase.from("contact_relationship_metrics").select("contact_id, warmth_level, response_rate, avg_response_days").in("contact_id", contactIds);
+      const metricsMap = /* @__PURE__ */ new Map();
+      for (const m of metricsRows ?? []) {
+        metricsMap.set(m.contact_id, m);
+      }
+      const channelMap = {
+        radio: "radio",
+        press: "press",
+        playlists: "playlist"
+      };
+      const targetPlatforms = new Set(
+        (campaign.services || []).map((s) => channelMap[s]).filter(Boolean)
+      );
+      const scored = contacts.filter((c) => !excludeIds.has(c.id)).map((c) => {
+        let score = 0;
+        const reasons = [];
+        const metrics = metricsMap.get(c.id);
+        if (targetPlatforms.size > 0 && c.platform_type && targetPlatforms.has(c.platform_type)) {
+          score += 3;
+          reasons.push(`${c.platform_type} match`);
+        }
+        if (metrics?.warmth_level === "hot") {
+          score += 3;
+          reasons.push("hot");
+        } else if (metrics?.warmth_level === "warm") {
+          score += 2;
+          reasons.push("warm");
+        }
+        if (metrics?.response_rate != null && metrics.response_rate > 0.25) {
+          score += 2;
+          reasons.push("good response rate");
+        }
+        if (metrics?.avg_response_days != null && metrics.avg_response_days <= 7) {
+          score += 1;
+          reasons.push("fast responder");
+        }
+        return { ...c, score, reason: reasons.join(", ") || "workspace contact" };
+      }).filter((c) => c.score >= 2).sort((a, b) => b.score - a.score).slice(0, limit || 20);
+      return {
+        content: [
+          {
+            type: "text",
+            text: JSON.stringify({ suggestions: scored, total: scored.length }, null, 2)
+          }
+        ]
+      };
+    }
+  );
+  server2.tool(
+    "tap_add_contact_to_campaign",
+    "Add a contact to a campaign (creates a campaign_contacts link)",
+    {
+      campaign_id: z.string().describe("Campaign ID"),
+      contact_id: z.string().describe("Contact ID to add"),
+      notes: z.string().optional().describe("Notes about why this contact was added")
+    },
+    async ({ campaign_id, contact_id, notes }) => {
+      const supabase = getAdminClient();
+      const wsId = getWorkspaceId();
+      const { data: campaign, error: campError } = await supabase.from("tap_projects").select("id, name").eq("id", campaign_id).eq("workspace_id", wsId).maybeSingle();
+      if (campError || !campaign) {
+        return {
+          content: [
+            { type: "text", text: `Campaign not found in workspace: ${campaign_id}` }
+          ]
+        };
+      }
+      const { data: contact, error: contactError } = await supabase.from("tap_contacts").select("id, name, email").eq("id", contact_id).eq("workspace_id", wsId).maybeSingle();
+      if (contactError || !contact) {
+        return {
+          content: [
+            { type: "text", text: `Contact not found in workspace: ${contact_id}` }
+          ]
+        };
+      }
+      const { data: existing } = await supabase.from("campaign_contacts").select("id").eq("project_id", campaign_id).eq("contact_id", contact_id).maybeSingle();
+      if (existing) {
+        return {
+          content: [
+            {
+              type: "text",
+              text: `${contact.name} is already in campaign "${campaign.name}"`
+            }
+          ]
+        };
+      }
+      const { data, error } = await supabase.from("campaign_contacts").insert({
+        project_id: campaign_id,
+        contact_id,
+        pitch_status: "not_pitched",
+        notes: notes || null,
+        added_at: (/* @__PURE__ */ new Date()).toISOString()
+      }).select("id, project_id, contact_id, pitch_status, added_at").single();
+      if (error) return { content: [{ type: "text", text: `Error: ${error.message}` }] };
+      return {
+        content: [
+          {
+            type: "text",
+            text: JSON.stringify(
+              {
+                link: data,
+                message: `Added ${contact.name} (${contact.email}) to campaign "${campaign.name}"`
+              },
+              null,
+              2
+            )
+          }
+        ]
+      };
+    }
+  );
+  server2.tool(
+    "tap_campaign_memory",
+    "Get or set campaign learnings/memory",
+    {
+      campaign_id: z.string(),
+      action: z.enum(["get", "set"]).describe("Get or set campaign memory"),
+      what_worked: z.string().optional().describe("What worked well (for set action)"),
+      do_differently: z.string().optional().describe("What to do differently (for set action)"),
+      best_angle: z.string().optional().describe("Best pitch angle (for set action)")
+    },
+    async ({ campaign_id, action, what_worked, do_differently, best_angle }) => {
+      const supabase = getAdminClient();
+      const wsId = getWorkspaceId();
+      if (action === "get") {
+        const { data, error: error2 } = await supabase.from("tap_projects").select("memory_what_worked, memory_do_differently, memory_best_angle, memory_notes").eq("id", campaign_id).eq("workspace_id", wsId).single();
+        if (error2) return { content: [{ type: "text", text: `Error: ${error2.message}` }] };
+        return {
+          content: [
+            {
+              type: "text",
+              text: JSON.stringify(data, null, 2)
+            }
+          ]
+        };
+      }
+      const updates = {};
+      if (what_worked !== void 0) updates.memory_what_worked = what_worked;
+      if (do_differently !== void 0) updates.memory_do_differently = do_differently;
+      if (best_angle !== void 0) updates.memory_best_angle = best_angle;
+      const { error } = await supabase.from("tap_projects").update(updates).eq("id", campaign_id).eq("workspace_id", wsId);
+      if (error) return { content: [{ type: "text", text: `Error: ${error.message}` }] };
+      return {
+        content: [
+          {
+            type: "text",
+            text: "Campaign memory updated successfully"
+          }
+        ]
+      };
+    }
+  );
+}
+
+// src/tools/contacts.ts
+import { z as z2 } from "zod";
+function registerContactTools(server2) {
+  server2.tool(
+    "tap_list_contacts",
+    "List contacts in the workspace with optional filters",
+    {
+      status: z2.string().optional().describe("Pipeline status filter"),
+      genre: z2.string().optional().describe("Genre filter"),
+      bbc_only: z2.boolean().optional().describe("Only show BBC contacts"),
+      search: z2.string().optional().describe("Search name, email, outlet"),
+      limit: z2.number().optional().describe("Max results (default 50)"),
+      offset: z2.number().optional()
+    },
+    async ({ status, genre, bbc_only, search, limit, offset }) => {
+      const supabase = getAdminClient();
+      const wsId = getWorkspaceId();
+      let query = supabase.from("tap_contacts").select(
+        "id, name, email, outlet, role, genres, bbc_station, pipeline_status, enrichment_confidence, platform_type",
+        { count: "exact" }
+      ).eq("workspace_id", wsId).order("name", { ascending: true }).limit(limit || 50);
+      if (status) query = query.eq("pipeline_status", status);
+      if (genre) query = query.contains("genres", [genre]);
+      if (bbc_only) query = query.not("bbc_station", "is", null);
+      if (search) {
+        const q = search.replace(/'/g, "''");
+        query = query.or(
+          `name.ilike.%${q}%,email.ilike.%${q}%,outlet.ilike.%${q}%,bbc_station.ilike.%${q}%`
+        );
+      }
+      if (offset) query = query.range(offset, offset + (limit || 50) - 1);
+      const { data, count, error } = await query;
+      if (error) return { content: [{ type: "text", text: `Error: ${error.message}` }] };
+      return {
+        content: [
+          {
+            type: "text",
+            text: JSON.stringify({ contacts: data || [], total: count || 0 }, null, 2)
+          }
+        ]
+      };
+    }
+  );
+  server2.tool(
+    "tap_search_contacts",
+    "Search contacts by name, outlet, genre, or BBC station",
+    {
+      query: z2.string().describe("Search query"),
+      limit: z2.number().optional().describe("Max results (default 20)")
+    },
+    async ({ query, limit }) => {
+      const supabase = getAdminClient();
+      const wsId = getWorkspaceId();
+      const q = query.replace(/'/g, "''");
+      const { data, error } = await supabase.from("tap_contacts").select(
+        "id, name, email, outlet, role, genres, bbc_station, pipeline_status, enrichment_confidence"
+      ).eq("workspace_id", wsId).or(
+        `name.ilike.%${q}%,email.ilike.%${q}%,outlet.ilike.%${q}%,bbc_station.ilike.%${q}%,role.ilike.%${q}%`
+      ).order("name", { ascending: true }).limit(limit || 20);
+      if (error) return { content: [{ type: "text", text: `Error: ${error.message}` }] };
+      return {
+        content: [
+          {
+            type: "text",
+            text: JSON.stringify({ results: data || [], count: data?.length || 0 }, null, 2)
+          }
+        ]
+      };
+    }
+  );
+  server2.tool(
+    "tap_contact_insights",
+    "Get relationship insights for a contact (warmth, response rate, outcomes)",
+    {
+      contact_id: z2.string().describe("Contact ID")
+    },
+    async ({ contact_id }) => {
+      const supabase = getAdminClient();
+      const wsId = getWorkspaceId();
+      const { data: metrics } = await supabase.from("contact_relationship_metrics").select(
+        "warmth_level, warmth_score, response_rate, total_pitches, positive_outcomes, avg_response_days, last_contacted_at"
+      ).eq("contact_id", contact_id).maybeSingle();
+      const { data: outcomes } = await supabase.from("tap_contact_outcomes").select("outcome_type, channel, occurred_at, notes").eq("contact_id", contact_id).eq("workspace_id", wsId).order("occurred_at", { ascending: false }).limit(5);
+      const { data: contact } = await supabase.from("tap_contacts").select("name, email, outlet").eq("id", contact_id).eq("workspace_id", wsId).maybeSingle();
+      if (!contact) {
+        return {
+          content: [
+            { type: "text", text: `Contact not found in workspace: ${contact_id}` }
+          ]
+        };
+      }
+      return {
+        content: [
+          {
+            type: "text",
+            text: JSON.stringify(
+              {
+                contact: { name: contact.name, email: contact.email, outlet: contact.outlet },
+                metrics: metrics ? {
+                  warmth: metrics.warmth_level,
+                  warmthScore: metrics.warmth_score,
+                  responseRate: metrics.response_rate,
+                  totalPitches: metrics.total_pitches,
+                  positiveOutcomes: metrics.positive_outcomes,
+                  avgResponseDays: metrics.avg_response_days,
+                  lastContactedAt: metrics.last_contacted_at
+                } : null,
+                recentOutcomes: (outcomes ?? []).map((o) => ({
+                  type: o.outcome_type,
+                  channel: o.channel,
+                  date: o.occurred_at,
+                  notes: o.notes
+                }))
+              },
+              null,
+              2
+            )
+          }
+        ]
+      };
+    }
+  );
+  server2.tool(
+    "tap_create_contact",
+    "Create a new contact in the workspace",
+    {
+      name: z2.string().describe("Contact display name"),
+      email: z2.string().email().describe("Email address (must be unique in workspace)"),
+      outlet: z2.string().optional().describe("Station, publication, or company name"),
+      role: z2.string().optional().describe("Job title or role"),
+      genres: z2.array(z2.string()).optional().describe('Music genres (e.g. ["pop", "indie"])'),
+      platform_type: z2.enum(["radio", "press", "playlist", "tv", "online", "other"]).optional().describe("Contact platform type"),
+      bbc_station: z2.string().optional().describe("BBC station name if applicable"),
+      notes: z2.string().optional().describe("Free-text notes about this contact")
+    },
+    async ({ name, email, outlet, role, genres, platform_type, bbc_station, notes }) => {
+      const supabase = getAdminClient();
+      const wsId = getWorkspaceId();
+      const { data: existing } = await supabase.from("tap_contacts").select("id, name").eq("workspace_id", wsId).eq("email", email).maybeSingle();
+      if (existing) {
+        return {
+          content: [
+            {
+              type: "text",
+              text: `Contact with email ${email} already exists: ${existing.name} (${existing.id})`
+            }
+          ]
+        };
+      }
+      const { data, error } = await supabase.from("tap_contacts").insert({
+        workspace_id: wsId,
+        name,
+        email,
+        outlet: outlet || null,
+        role: role || null,
+        genres: genres || null,
+        platform_type: platform_type || null,
+        bbc_station: bbc_station || null,
+        notes: notes || null,
+        source: "mcp",
+        pipeline_status: "new",
+        enriched: false
+      }).select(
+        "id, name, email, outlet, role, genres, platform_type, bbc_station, pipeline_status"
+      ).single();
+      if (error) return { content: [{ type: "text", text: `Error: ${error.message}` }] };
+      return {
+        content: [
+          {
+            type: "text",
+            text: JSON.stringify({ contact: data, message: `Contact "${name}" created` }, null, 2)
+          }
+        ]
+      };
+    }
+  );
+  server2.tool(
+    "tap_enrich_contact",
+    "Trigger AI enrichment for a contact (returns enriched data)",
+    {
+      contact_id: z2.string().describe("Contact ID to enrich")
+    },
+    async ({ contact_id }) => {
+      const supabase = getAdminClient();
+      const wsId = getWorkspaceId();
+      const { data: contact, error: fetchError } = await supabase.from("tap_contacts").select("id, name, email, outlet").eq("id", contact_id).eq("workspace_id", wsId).single();
+      if (fetchError || !contact) {
+        return {
+          content: [
+            { type: "text", text: `Contact not found in workspace: ${contact_id}` }
+          ]
+        };
+      }
+      const { error: updateError } = await supabase.from("tap_contacts").update({ enrichment_source: "queued" }).eq("id", contact_id).eq("workspace_id", wsId);
+      if (updateError) {
+        return {
+          content: [
+            { type: "text", text: `Failed to queue enrichment: ${updateError.message}` }
+          ]
+        };
+      }
+      return {
+        content: [
+          {
+            type: "text",
+            text: JSON.stringify(
+              {
+                message: `Enrichment queued for ${contact.name}`,
+                contact: { id: contact.id, name: contact.name, email: contact.email }
+              },
+              null,
+              2
+            )
+          }
+        ]
+      };
+    }
+  );
+}
+
+// src/tools/pitches.ts
+import { z as z3 } from "zod";
+function textResponse(text) {
+  return { content: [{ type: "text", text }] };
+}
+function registerPitchTools(server2) {
+  server2.tool(
+    "tap_draft_pitch",
+    "Generate a complete AI-drafted pitch for a contact within a campaign. Returns subject, body, and variants ready to use.",
+    {
+      campaign_id: z3.string().describe("Campaign ID"),
+      contact_id: z3.string().describe("Contact ID"),
+      tone: z3.enum(["professional", "casual", "enthusiastic"]).optional().describe("Pitch tone (default: professional)"),
+      key_hook: z3.string().optional().describe("Key hook or angle for the pitch")
+    },
+    async ({ campaign_id, contact_id, tone, key_hook }) => {
+      const supabase = getAdminClient();
+      const wsId = getWorkspaceId();
+      const { data: campaign, error: campaignError } = await supabase.from("tap_projects").select("name, artist_name, release_name, release_date, goal, workspace_id").eq("id", campaign_id).eq("workspace_id", wsId).single();
+      if (campaignError || !campaign) {
+        return textResponse(`Campaign not found in workspace: ${campaign_id}`);
+      }
+      const { data: contact, error: contactError } = await supabase.from("tap_contacts").select(
+        "name, email, outlet, role, genres, bbc_station, platform_type, enrichment_confidence, submission_guidelines, pitch_tips, best_timing, geographic_scope"
+      ).eq("id", contact_id).eq("workspace_id", wsId).single();
+      if (contactError || !contact) {
+        return textResponse(`Contact not found in workspace: ${contact_id}`);
+      }
+      const baseUrl = getTapUrl();
+      const resolvedTone = tone || "professional";
+      const resolvedHook = key_hook || campaign.goal || `New release from ${campaign.artist_name}`;
+      const cronSecret = process.env.TAP_CRON_SECRET || process.env.CRON_SECRET;
+      if (!cronSecret) {
+        return textResponse(
+          "TAP_CRON_SECRET is not configured. Cannot generate pitch via service auth. Set TAP_CRON_SECRET in MCP environment."
+        );
+      }
+      const generateBody = {
+        artistName: campaign.artist_name,
+        releaseName: campaign.release_name,
+        releaseDate: campaign.release_date,
+        contactName: contact.name,
+        keyHook: resolvedHook,
+        workspaceId: wsId,
+        campaignId: campaign_id,
+        tone: resolvedTone,
+        contactOutlet: contact.outlet,
+        contactRole: contact.role,
+        contactGenres: Array.isArray(contact.genres) ? contact.genres : void 0,
+        contactBbcStation: contact.bbc_station,
+        contactPlatformType: contact.platform_type,
+        contactSubmissionGuidelines: contact.submission_guidelines,
+        contactPitchTips: Array.isArray(contact.pitch_tips) ? contact.pitch_tips : void 0,
+        contactBestTiming: contact.best_timing,
+        contactGeographicScope: contact.geographic_scope
+      };
+      let draft;
+      try {
+        const res = await fetch(`${baseUrl}/api/pitch/generate`, {
+          method: "POST",
+          headers: {
+            "Content-Type": "application/json",
+            Authorization: `Bearer ${cronSecret}`
+          },
+          body: JSON.stringify(generateBody)
+        });
+        if (!res.ok) {
+          const errText = await res.text();
+          return textResponse(`Pitch generation failed (${res.status}): ${errText}`);
+        }
+        const json = await res.json();
+        draft = json.data ?? json;
+      } catch (err) {
+        return textResponse(
+          `Pitch generation request failed: ${err instanceof Error ? err.message : String(err)}`
+        );
+      }
+      return textResponse(
+        JSON.stringify(
+          {
+            campaign: {
+              id: campaign_id,
+              name: campaign.name,
+              artist: campaign.artist_name,
+              release: campaign.release_name
+            },
+            contact: {
+              id: contact_id,
+              name: contact.name,
+              outlet: contact.outlet,
+              role: contact.role
+            },
+            draft
+          },
+          null,
+          2
+        )
+      );
+    }
+  );
+}
+
+// src/tools/outcomes.ts
+import { z as z4 } from "zod";
+function registerOutcomeTools(server2) {
+  server2.tool(
+    "tap_log_outcome",
+    "Log a campaign outcome for a contact",
+    {
+      campaign_id: z4.string().describe("Campaign ID"),
+      contact_id: z4.string().describe("Contact ID"),
+      outcome_type: z4.enum([
+        "no_response",
+        "opened",
+        "replied_positive",
+        "replied_negative",
+        "added_to_playlist",
+        "interview_booked",
+        "coverage",
+        "declined",
+        "other"
+      ]).describe("Outcome type"),
+      channel: z4.string().optional().describe("Channel (radio, press, playlist, social)"),
+      notes: z4.string().optional().describe("Additional notes")
+    },
+    async ({ campaign_id, contact_id, outcome_type, channel, notes }) => {
+      const supabase = getAdminClient();
+      const wsId = getWorkspaceId();
+      const { data: campaign, error: campaignError } = await supabase.from("tap_projects").select("id").eq("id", campaign_id).eq("workspace_id", wsId).single();
+      if (campaignError || !campaign) {
+        return {
+          content: [
+            { type: "text", text: `Campaign not found in workspace: ${campaign_id}` }
+          ]
+        };
+      }
+      const { data, error } = await supabase.from("tap_contact_outcomes").insert({
+        workspace_id: wsId,
+        project_id: campaign_id,
+        contact_id,
+        outcome_type,
+        channel: channel || null,
+        notes: notes || null,
+        occurred_at: (/* @__PURE__ */ new Date()).toISOString()
+      }).select("id").single();
+      if (error) return { content: [{ type: "text", text: `Error: ${error.message}` }] };
+      return {
+        content: [
+          {
+            type: "text",
+            text: JSON.stringify(
+              {
+                message: `Outcome "${outcome_type}" logged for campaign`,
+                outcomeId: data.id
+              },
+              null,
+              2
+            )
+          }
+        ]
+      };
+    }
+  );
+  server2.tool(
+    "tap_get_action_queue",
+    "Get today's prioritised action queue (follow-ups, stale contacts, pending pitches)",
+    {},
+    async () => {
+      const supabase = getAdminClient();
+      const wsId = getWorkspaceId();
+      const { data: campaigns, error: campaignsError } = await supabase.from("tap_projects").select("id, name, artist_name, status").eq("workspace_id", wsId).eq("status", "active");
+      if (campaignsError) {
+        return { content: [{ type: "text", text: `Error: ${campaignsError.message}` }] };
+      }
+      if (!campaigns || campaigns.length === 0) {
+        return {
+          content: [
+            {
+              type: "text",
+              text: JSON.stringify({ actions: [], message: "No active campaigns" }, null, 2)
+            }
+          ]
+        };
+      }
+      const campaignIds = campaigns.map((c) => c.id);
+      const threeDaysAgo = /* @__PURE__ */ new Date();
+      threeDaysAgo.setDate(threeDaysAgo.getDate() - 3);
+      const [followUpsResult, unenrichedResult] = await Promise.all([
+        supabase.from("campaign_contacts").select("contact_id, project_id, pitch_status, updated_at").in("project_id", campaignIds).eq("pitch_status", "sent").lt("updated_at", threeDaysAgo.toISOString()).limit(20),
+        supabase.from("tap_contacts").select("id", { count: "exact", head: true }).eq("workspace_id", wsId).is("enriched_at", null)
+      ]);
+      if (followUpsResult.error) {
+        return {
+          content: [
+            {
+              type: "text",
+              text: `Error fetching follow-ups: ${followUpsResult.error.message}`
+            }
+          ]
+        };
+      }
+      const pendingFollowUps = followUpsResult.data || [];
+      const unenrichedCount = unenrichedResult.count || 0;
+      const actions = [
+        ...pendingFollowUps.map((c) => ({
+          type: "follow_up",
+          priority: "high",
+          campaignId: c.project_id,
+          contactId: c.contact_id,
+          description: "Pitch sent > 3 days ago with no response"
+        })),
+        ...unenrichedCount > 0 ? [
+          {
+            type: "enrichment",
+            priority: "medium",
+            description: `${unenrichedCount} contacts need enrichment`
+          }
+        ] : []
+      ];
+      return {
+        content: [
+          {
+            type: "text",
+            text: JSON.stringify(
+              {
+                date: (/* @__PURE__ */ new Date()).toISOString().split("T")[0],
+                activeCampaigns: campaigns.length,
+                actions
+              },
+              null,
+              2
+            )
+          }
+        ]
+      };
+    }
+  );
+}
+
+// src/resources/index.ts
+function registerResources(server2) {
+  server2.resource("tap-campaigns", "tap://campaigns", async () => {
+    const supabase = getAdminClient();
+    const wsId = getWorkspaceId();
+    const { data, error } = await supabase.from("tap_projects").select("id, name, artist_name, status, release_name, created_at").eq("workspace_id", wsId).order("created_at", { ascending: false }).limit(100);
+    if (error) {
+      return {
+        contents: [
+          {
+            uri: "tap://campaigns",
+            mimeType: "application/json",
+            text: JSON.stringify({ error: error.message }, null, 2)
+          }
+        ]
+      };
+    }
+    return {
+      contents: [
+        {
+          uri: "tap://campaigns",
+          mimeType: "application/json",
+          text: JSON.stringify(data || [], null, 2)
+        }
+      ]
+    };
+  });
+  server2.resource("tap-contacts", "tap://contacts", async () => {
+    const supabase = getAdminClient();
+    const wsId = getWorkspaceId();
+    const { data, count, error } = await supabase.from("tap_contacts").select("id, name, email, outlet, role, pipeline_status, enrichment_confidence", {
+      count: "exact"
+    }).eq("workspace_id", wsId).order("name", { ascending: true }).limit(100);
+    if (error) {
+      return {
+        contents: [
+          {
+            uri: "tap://contacts",
+            mimeType: "application/json",
+            text: JSON.stringify({ error: error.message }, null, 2)
+          }
+        ]
+      };
+    }
+    return {
+      contents: [
+        {
+          uri: "tap://contacts",
+          mimeType: "application/json",
+          text: JSON.stringify({ contacts: data || [], total: count || 0 }, null, 2)
+        }
+      ]
+    };
+  });
+  server2.resource("tap-artists", "tap://artists", async () => {
+    const supabase = getAdminClient();
+    const wsId = getWorkspaceId();
+    const { data, error } = await supabase.from("tap_artists").select("id, name, spotify_id, genres, created_at").eq("workspace_id", wsId).order("name", { ascending: true }).limit(100);
+    if (error) {
+      return {
+        contents: [
+          {
+            uri: "tap://artists",
+            mimeType: "application/json",
+            text: JSON.stringify({ error: error.message }, null, 2)
+          }
+        ]
+      };
+    }
+    return {
+      contents: [
+        {
+          uri: "tap://artists",
+          mimeType: "application/json",
+          text: JSON.stringify(data || [], null, 2)
+        }
+      ]
+    };
+  });
+}
+
+// src/index.ts
+var server = new McpServer({
+  name: "tap",
+  version: "0.1.0"
+});
+registerCampaignTools(server);
+registerContactTools(server);
+registerPitchTools(server);
+registerOutcomeTools(server);
+registerResources(server);
+var transport = new StdioServerTransport();
+await server.connect(transport);

package/package.json

@@ -0,0 +1,52 @@
+{
+  "name": "@totalaudiopromo/tap-mcp",
+  "version": "0.1.0",
+  "description": "MCP server for Total Audio Promo — music PR campaign management via Model Context Protocol. 10 tools + 3 resources for contacts, campaigns, pitches, and outcomes.",
+  "type": "module",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "bin": {
+    "tap-mcp": "./dist/index.js"
+  },
+  "files": [
+    "dist",
+    "README.md"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/totalaudiopromo/total-audio-platform",
+    "directory": "packages/tap-mcp"
+  },
+  "homepage": "https://totalaudiopromo.com/developers",
+  "keywords": [
+    "mcp",
+    "model-context-protocol",
+    "music-pr",
+    "music-promotion",
+    "ai-agent",
+    "contacts",
+    "campaigns",
+    "enrichment",
+    "total-audio-promo"
+  ],
+  "license": "MIT",
+  "scripts": {
+    "build": "tsup src/index.ts --format esm --dts --clean",
+    "dev": "tsx src/index.ts",
+    "typecheck": "tsc --noEmit",
+    "prepublishOnly": "pnpm build"
+  },
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.28.0",
+    "@supabase/supabase-js": "^2.100.1",
+    "zod": "^3.24.2"
+  },
+  "devDependencies": {
+    "tsup": "^8.4.0",
+    "tsx": "^4.19.4",
+    "typescript": "^5.9.3"
+  }
+}