Jeremylongshore Claude Code Plugins Plus Skills Fireflies Deploy Integration

Fireflies.ai Deploy Integration

Overview

Deploy Fireflies.ai integrations across platforms. Covers GraphQL client setup, webhook receiver deployment, and secret management for Vercel, Docker, and Google Cloud Run.

Prerequisites

• Fireflies.ai Business+ plan for API access
• FIREFLIES_API_KEY and FIREFLIES_WEBHOOK_SECRET ready
• Platform CLI installed (vercel, docker, or gcloud)

Instructions

Step 1: Shared GraphQL Client

// lib/fireflies.ts
const FIREFLIES_API = "https://api.fireflies.ai/graphql";

export async function firefliesQuery(query: string, variables?: any) {
  const res = await fetch(FIREFLIES_API, {
    method: "POST",
    headers: {
      "Content-Type": "application/json",
      Authorization: `Bearer ${process.env.FIREFLIES_API_KEY}`,
    },
    body: JSON.stringify({ query, variables }),
  });

  const json = await res.json();
  if (json.errors) throw new Error(json.errors[0].message);
  return json.data;
}

Step 2: Webhook Receiver (Next.js / Vercel)

// app/api/webhooks/fireflies/route.ts
import crypto from "crypto";

export async function POST(req: Request) {
  const rawBody = await req.text();
  const signature = req.headers.get("x-hub-signature") || "";

  // Verify HMAC-SHA256 signature
  const expected = crypto
    .createHmac("sha256", process.env.FIREFLIES_WEBHOOK_SECRET!)
    .update(rawBody)
    .digest("hex");

  if (!crypto.timingSafeEqual(Buffer.from(signature), Buffer.from(expected))) {
    return Response.json({ error: "Invalid signature" }, { status: 401 });
  }

  const event = JSON.parse(rawBody);

  if (event.eventType === "Transcription completed") {
    // Fetch transcript data
    const data = await firefliesQuery(`
      query($id: String!) {
        transcript(id: $id) {
          id title duration
          speakers { name }
          summary { overview action_items }
        }
      }
    `, { id: event.meetingId });

    // Process transcript (store, notify, create tasks)
    console.log(`Processed: ${data.transcript.title}`);
  }

  return Response.json({ received: true });
}

Step 3: Deploy to Vercel

set -euo pipefail
# Add secrets
vercel env add FIREFLIES_API_KEY production
vercel env add FIREFLIES_WEBHOOK_SECRET production

# Deploy
vercel --prod

# Register webhook URL in Fireflies dashboard:
# https://your-app.vercel.app/api/webhooks/fireflies

Step 4: Deploy with Docker

FROM node:20-slim
WORKDIR /app
COPY package*.json ./
RUN npm ci --only=production
COPY . .
RUN npm run build
EXPOSE 3000
CMD ["node", "dist/index.js"]

# docker-compose.yml
services:
  fireflies-app:
    build: .
    ports:
      - "3000:3000"
    environment:
      - FIREFLIES_API_KEY=${FIREFLIES_API_KEY}
      - FIREFLIES_WEBHOOK_SECRET=${FIREFLIES_WEBHOOK_SECRET}
    restart: unless-stopped

set -euo pipefail
docker compose up -d
# Verify
curl -f http://localhost:3000/api/health | jq .

Step 5: Deploy to Google Cloud Run

set -euo pipefail
# Build and push
gcloud builds submit --tag gcr.io/$PROJECT_ID/fireflies-app

# Deploy
gcloud run deploy fireflies-app \
  --image gcr.io/$PROJECT_ID/fireflies-app \
  --platform managed \
  --allow-unauthenticated \
  --set-env-vars "FIREFLIES_WEBHOOK_SECRET=${FIREFLIES_WEBHOOK_SECRET}" \
  --set-secrets "FIREFLIES_API_KEY=fireflies-api-key:latest"

# Get URL for webhook registration
gcloud run services describe fireflies-app --format='value(status.url)'

Step 6: Health Check Endpoint

// app/api/health/route.ts (or /health endpoint)
export async function GET() {
  try {
    const start = Date.now();
    const data = await firefliesQuery("{ user { email } }");
    return Response.json({
      status: "healthy",
      fireflies: {
        connected: true,
        user: data.user.email,
        latencyMs: Date.now() - start,
      },
    });
  } catch (err) {
    return Response.json({
      status: "degraded",
      fireflies: { connected: false, error: (err as Error).message },
    }, { status: 503 });
  }
}

Post-Deploy: Register Webhook

After deploying, register your webhook URL:

1. Go to app.fireflies.ai/settings > Developer settings
2. Enter your webhook URL (e.g., https://your-app.vercel.app/api/webhooks/fireflies)
3. Save the webhook secret

Or test via API:

set -euo pipefail
# Test API connectivity from deployed app
curl -f https://your-app.vercel.app/api/health | jq .

Error Handling

Output

• Deployed webhook receiver with HMAC signature verification
• GraphQL client configured with platform-specific secrets
• Health check endpoint monitoring Fireflies connectivity
• Platform-specific deployment verified

Resources

• Fireflies API Docs
• Fireflies Webhooks

Next Steps

For webhook event handling, see fireflies-webhooks-events.

Converted and distributed by TomeVault — claim your Tome and manage your conversions.