# 1. Go to https://www.dropbox.com/developers/apps
# 2. Click "Create app" -> "Scoped access" -> "Single folder" (recommended) or "Full Dropbox"
# 3. Name your app, e.g. "speak-transcriber"
# 4. Under "Permissions" tab: enable files.content.read (and files.content.write if writing back)
# 5. Under "Webhooks" tab: add your callback URL, e.g. https://your-app.example.com/dropbox/webhook
# 6. Dropbox sends a GET challenge first -- your handler must echo back the "challenge" query param
# 7. Store the app secret as DROPBOX_APP_SECRET and the access token as DROPBOX_TOKEN in your .env

import express from "express";
import fetch from "node-fetch";

const app = express();
app.use(express.json());

// Dropbox webhook verification challenge (GET)
app.get("/dropbox/webhook", (req, res) => {
  res.send(req.query.challenge);
});

// Dropbox webhook notification (POST) - thin payload, just account IDs
app.post("/dropbox/webhook", async (req, res) => {
  res.sendStatus(200); // Respond immediately

  const accounts = req.body?.list_folder?.accounts ?? [];
  for (const account of accounts) {
    await processDropboxAccount(account);
  }
});

async function processDropboxAccount(account) {
  // 1. List changed files using stored cursor (or "" for first run)
  const cursor = await getCursor(account); // implement storage lookup
  const listRes = await fetch(
    "https://api.dropboxapi.com/2/files/list_folder/continue",
    {
      method: "POST",
      headers: {
        Authorization: `Bearer ${process.env.DROPBOX_TOKEN}`,
        "Content-Type": "application/json",
      },
      body: JSON.stringify({ cursor }),
    }
  ).then(r => r.json());

  await storeCursor(account, listRes.cursor); // store new cursor

  const audioVideoExts = /\.(mp3|mp4|wav|m4a|mov|webm|aac|ogg|flac)$/i;
  for (const entry of listRes.entries ?? []) {
    if (entry[".tag"] !== "file" || !audioVideoExts.test(entry.name)) continue;

    // 2. Download file from Dropbox
    const fileBuffer = await fetch(
      "https://content.dropboxapi.com/2/files/download",
      {
        method: "POST",
        headers: {
          Authorization: `Bearer ${process.env.DROPBOX_TOKEN}`,
          "Dropbox-API-Arg": JSON.stringify({ path: entry.path_display }),
        },
      }
    ).then(r => r.buffer());

    // 3. Upload to Speak AI
    const form = new FormData();
    form.append("name", entry.name);
    form.append("tags", "dropbox");
    form.append("file", new Blob([fileBuffer]), entry.name);

    await fetch("https://api.speakai.co/v1/media/upload", {
      method: "POST",
      headers: { "x-speakai-key": process.env.SPEAK_API_KEY },
      body: form,
    });
  }
}

app.listen(3000);

import os, hmac, hashlib, requests
from fastapi import FastAPI, Request, Response

app = FastAPI()
AUDIO_VIDEO_EXTS = {".mp3", ".mp4", ".wav", ".m4a", ".mov", ".webm", ".aac", ".ogg", ".flac"}

# Dropbox webhook verification challenge (GET)
@app.get("/dropbox/webhook")
async def verify(request: Request):
    return Response(content=request.query_params["challenge"], media_type="text/plain")

# Dropbox webhook notification (POST)
@app.post("/dropbox/webhook")
async def webhook(request: Request):
    body = await request.json()
    accounts = body.get("list_folder", {}).get("accounts", [])
    for account in accounts:
        process_dropbox_account(account)
    return {"ok": True}

def process_dropbox_account(account: str):
    headers = {"Authorization": f"Bearer {os.environ['DROPBOX_TOKEN']}",
               "Content-Type": "application/json"}
    cursor = get_cursor(account)  # implement storage lookup

    list_res = requests.post(
        "https://api.dropboxapi.com/2/files/list_folder/continue",
        headers=headers, json={"cursor": cursor}, timeout=30
    ).json()
    store_cursor(account, list_res["cursor"])

    for entry in list_res.get("entries", []):
        if entry.get(".tag") != "file":
            continue
        ext = os.path.splitext(entry["name"])[1].lower()
        if ext not in AUDIO_VIDEO_EXTS:
            continue

        # Download from Dropbox
        file_bytes = requests.post(
            "https://content.dropboxapi.com/2/files/download",
            headers={
                "Authorization": f"Bearer {os.environ['DROPBOX_TOKEN']}",
                "Dropbox-API-Arg": f'{{"path": "{entry["path_display"]}"}}'
            },
            timeout=120
        ).content

        # Upload to Speak AI
        requests.post(
            "https://api.speakai.co/v1/media/upload",
            headers={"x-speakai-key": os.environ["SPEAK_API_KEY"]},
            files={"file": (entry["name"], file_bytes)},
            data={"name": entry["name"], "tags": "dropbox"},
            timeout=300,
        )

curl -X POST https://api.speakai.co/v1/webhook \
  -H "x-speakai-key: $SPEAK_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "callbackUrl": "https://your-app.example.com/speak/dropbox-writeback",
    "events": ["media.analyzed"],
    "description": "Write Speak transcript back to Dropbox"
  }'

// Speak posts: { eventType, state, mediaId } (verified 2026-05-07)
import express from "express";
const app = express();
app.use(express.json());

app.post("/speak/dropbox-writeback", async (req, res) => {
  const { eventType, state, mediaId } = req.body;
  if (eventType !== "media.analyzed" || state !== "processed") return res.sendStatus(204);
  res.sendStatus(202);

  // 1. Fetch transcript from Speak
  const transcript = await fetch(
    `https://api.speakai.co/v1/media/${mediaId}/transcript`,
    { headers: { "x-speakai-key": process.env.SPEAK_API_KEY } }
  ).then(r => r.json());

  // 2. Fetch insight for the summary
  const insight = await fetch(
    `https://api.speakai.co/v1/media/insight/${mediaId}`,
    { headers: { "x-speakai-key": process.env.SPEAK_API_KEY } }
  ).then(r => r.json());

  const media = insight.data;
  const transcriptText = (transcript.data?.paragraphs ?? [])
    .map(p => `[${p.speaker || "Speaker"}] ${p.text}`)
    .join("\n\n");

  const outputContent = [
    `# ${media.name}`,
    `Processed: ${new Date(media.updatedAt).toISOString()}`,
    "",
    "## Transcript",
    transcriptText,
  ].join("\n");

  // 3. Write back to Dropbox - same folder as original, with -transcript.txt suffix
  const originalPath = media.tags?.find(t => t.startsWith("dropbox-path:"))?.replace("dropbox-path:", "");
  const outputPath = originalPath
    ? originalPath.replace(/(\.[^.]+)$/, "-transcript.txt")
    : `/transcripts/${mediaId}-transcript.txt`;

  await fetch("https://content.dropboxapi.com/2/files/upload", {
    method: "POST",
    headers: {
      Authorization: `Bearer ${process.env.DROPBOX_TOKEN}`,
      "Content-Type": "application/octet-stream",
      "Dropbox-API-Arg": JSON.stringify({
        path: outputPath,
        mode: "overwrite",
        autorename: false,
      }),
    },
    body: outputContent,
  });
});

app.listen(3000);

import os, requests
from fastapi import FastAPI, Request

app = FastAPI()

@app.post("/speak/dropbox-writeback")
async def hook(req: Request):
    body = await req.json()
    if body.get("eventType") != "media.analyzed" or body.get("state") != "processed":
        return {"ok": True}
    media_id = body["mediaId"]

    # 1. Fetch transcript from Speak
    transcript = requests.get(
        f"https://api.speakai.co/v1/media/{media_id}/transcript",
        headers={"x-speakai-key": os.environ["SPEAK_API_KEY"]},
        timeout=30,
    ).json()

    # 2. Fetch insight for summary
    insight = requests.get(
        f"https://api.speakai.co/v1/media/insight/{media_id}",
        headers={"x-speakai-key": os.environ["SPEAK_API_KEY"]},
        timeout=30,
    ).json()["data"]

    paragraphs = transcript.get("data", {}).get("paragraphs", [])
    transcript_text = "\n\n".join(
        f"[{p.get('speaker', 'Speaker')}] {p['text']}" for p in paragraphs
    )

    output_content = "\n".join([
        f"# {insight['name']}",
        f"Processed: {insight.get('updatedAt', '')}",
        "",
        "## Transcript",
        transcript_text,
    ])

    # 3. Write back to Dropbox
    tags = insight.get("tags") or []
    original_path = next((t.replace("dropbox-path:", "") for t in tags if t.startswith("dropbox-path:")), None)
    if original_path:
        import re
        output_path = re.sub(r"(\.[^.]+)$", "-transcript.txt", original_path)
    else:
        output_path = f"/transcripts/{media_id}-transcript.txt"

    requests.post(
        "https://content.dropboxapi.com/2/files/upload",
        headers={
            "Authorization": f"Bearer {os.environ['DROPBOX_TOKEN']}",
            "Content-Type": "application/octet-stream",
            "Dropbox-API-Arg": f'{{"path": "{output_path}", "mode": "overwrite", "autorename": false}}',
        },
        data=output_content.encode("utf-8"),
        timeout=30,
    )
    return {"ok": True}

// Speak webhook body shape (verified 2026-05-07): { eventType, state, mediaId }
import express from "express";
const app = express();
app.use(express.json());

app.post("/speak/dropbox-to-crm", async (req, res) => {
  const { eventType, state, mediaId } = req.body;
  if (eventType !== "media.analyzed" || state !== "processed") return res.sendStatus(204);
  res.sendStatus(202);

  // 1. Fetch full insight
  const { data } = await fetch(
    `https://api.speakai.co/v1/media/insight/${mediaId}`,
    { headers: { "x-speakai-key": process.env.SPEAK_API_KEY } }
  ).then(r => r.json());

  // Skip files not tagged as Dropbox-sourced (optional filter)
  if (!data.tags?.includes("dropbox")) return;

  // 2. Push to HubSpot Meetings (or Salesforce Tasks, or Zoho Calls)
  const start = new Date(data.createdAt);
  const end = new Date(start.getTime() + (data.duration?.inSecond || 0) * 1000);

  await fetch("https://api.hubapi.com/crm/v3/objects/meetings", {
    method: "POST",
    headers: {
      Authorization: `Bearer ${process.env.HUBSPOT_TOKEN}`,
      "Content-Type": "application/json",
    },
    body: JSON.stringify({
      properties: {
        hs_timestamp: start.toISOString(),
        hs_meeting_title: data.name,
        hs_meeting_body: `Dropbox file transcript. Open in Speak: https://app.speakai.co/media/${mediaId}`,
        hs_meeting_external_url: `https://app.speakai.co/media/${mediaId}`,
        hs_meeting_start_time: start.toISOString(),
        hs_meeting_end_time: end.toISOString(),
        hs_meeting_outcome: "COMPLETED",
      },
    }),
  });
});

app.listen(3000);

# Claude Desktop / Claude Code (auto-detects your installation)
npx @speakai/mcp-server init

# Paste your Speak API key when prompted. Setup takes about 2 minutes.

# Claude.ai (web) and ChatGPT MCP connector
# Settings > Integrations > Add MCP Server
# Remote URL:    https://api.speakai.co/v1/mcp
# Auth header:   x-speakai-key: YOUR_SPEAK_API_KEY

# Verify the connection responds:
curl -s https://api.speakai.co/v1/mcp \
  -H "x-speakai-key: $SPEAK_API_KEY" \
  -H "Accept: application/json"