git clone https://github.com/rbrown101010/codex-marketing-skills.git
cd codex-marketing-skills

# For Codex
mkdir -p "$HOME/.codex/skills"
cp -R skills/youtube-researcher "$HOME/.codex/skills/"

# For Claude Code (adjust path as needed)
cp -R skills/youtube-researcher "$HOME/.claude/skills/"

# YouTube Researcher
export SUPADATA_API_KEY="your_key_here"
export SERPAPI_KEY="your_key_here"

# Buffer Publisher
export BUFFER_API_KEY="your_key_here"

# Gen Media
export FAL_KEY="your_key_here"

import os
import requests

SUPADATA_API_KEY = os.getenv("SUPADATA_API_KEY")
SERPAPI_KEY = os.getenv("SERPAPI_KEY")

def search_youtube_channel(channel_id, query):
    """Search a specific YouTube channel for videos matching query."""
    url = f"https://serpapi.com/search"
    params = {
        "engine": "youtube",
        "search_query": f"{query} site:youtube.com/c/{channel_id}",
        "api_key": SERPAPI_KEY
    }
    response = requests.get(url, params=params)
    return response.json()

def get_transcript(video_id):
    """Fetch transcript for a YouTube video."""
    url = f"https://api.supadata.ai/v1/youtube/transcript/{video_id}"
    headers = {"Authorization": f"Bearer {SUPADATA_API_KEY}"}
    response = requests.get(url, headers=headers)
    return response.json()

# Example: analyze a creator's hook style
results = search_youtube_channel("veritasium", "physics")
for video in results.get("video_results", [])[:3]:
    transcript = get_transcript(video["id"])
    first_30_sec = [t for t in transcript if t["start"] < 30]
    print(f"Hook for {video['title']}:")
    print(" ".join([t["text"] for t in first_30_sec]))

# Search highlights
readwise search "marketing frameworks"

# Export highlights from a specific book
readwise export --book "Building a Second Brain" --format markdown

# List recent Reader saves
readwise reader list --limit 20

import subprocess
import json

def search_readwise(query):
    """Search Readwise highlights."""
    result = subprocess.run(
        ["readwise", "search", query, "--format", "json"],
        capture_output=True,
        text=True
    )
    return json.loads(result.stdout)

# Example: find all highlights about "storytelling"
highlights = search_readwise("storytelling")
for h in highlights[:5]:
    print(f"{h['text']} — {h['title']}")

# Generate diagram from JSON definition
excalidraw-cli create diagram.json --output funnel.excalidraw

# Export to PNG
excalidraw-cli export funnel.excalidraw --format png --output funnel.png

import json
import subprocess

def create_excalidraw_diagram(elements, output_path):
    """Create an Excalidraw diagram from element definitions."""
    diagram_def = {
        "type": "excalidraw",
        "version": 2,
        "source": "https://excalidraw.com",
        "elements": elements
    }
    
    with open("temp_diagram.json", "w") as f:
        json.dump(diagram_def, f)
    
    subprocess.run([
        "excalidraw-cli", "create", "temp_diagram.json",
        "--output", output_path
    ])

# Example: create a simple funnel
elements = [
    {"type": "rectangle", "x": 100, "y": 50, "width": 200, "height": 60, "text": "Awareness"},
    {"type": "rectangle", "x": 100, "y": 150, "width": 180, "height": 60, "text": "Interest"},
    {"type": "rectangle", "x": 100, "y": 250, "width": 160, "height": 60, "text": "Purchase"}
]
create_excalidraw_diagram(elements, "marketing_funnel.excalidraw")

import requests

MCP_SERVER = "http://localhost:8080"

def create_paper_card(board_id, title, content):
    """Create a new card on a Paper board."""
    response = requests.post(
        f"{MCP_SERVER}/boards/{board_id}/cards",
        json={"title": title, "content": content}
    )
    return response.json()

def get_board_cards(board_id):
    """Retrieve all cards from a board."""
    response = requests.get(f"{MCP_SERVER}/boards/{board_id}/cards")
    return response.json()

# Example: create a campaign planning board
board_id = "campaign-q4-2026"
create_paper_card(board_id, "Audience", "Target: SaaS founders, 30-45, technical background")
create_paper_card(board_id, "Channels", "LinkedIn, YouTube, email newsletter")

# Render a Remotion composition
npx remotion render src/index.ts LaunchVideo output.mp4

# Preview in browser
npx remotion preview src/index.ts

// src/LaunchVideo.jsx
import { useCurrentFrame, useVideoConfig, interpolate } from 'remotion';

export const LaunchVideo = () => {
  const frame = useCurrentFrame();
  const { fps } = useVideoConfig();
  
  const opacity = interpolate(frame, [0, 30], [0, 1], { extrapolateRight: 'clamp' });
  
  return (
    <div style={{ flex: 1, justifyContent: 'center', alignItems: 'center', opacity }}>
      <h1 style={{ fontSize: 100 }}>New Product Launch</h1>
    </div>
  );
};

// plugin-workflows/hyperframes-gsap/animate.js
import gsap from 'gsap';

export function animateCTA(element) {
  gsap.timeline()
    .from(element, { scale: 0.8, opacity: 0, duration: 0.5 })
    .to(element, { scale: 1.05, duration: 0.3, yoyo: true, repeat: 1 });
}

# List available models
genmedia list

# Generate an image
genmedia run fal-ai/flux/schnell --prompt "product shot of a coffee mug on a desk" --output mug.png

# Generate a video
genmedia run fal-ai/ltx-video --prompt "camera pan over a modern office" --duration 5 --output office.mp4

import os
import subprocess

FAL_KEY = os.getenv("FAL_KEY")

def generate_image(prompt, model="fal-ai/flux/schnell", output="output.png"):
    """Generate an image using fal.ai models."""
    subprocess.run([
        "genmedia", "run", model,
        "--prompt", prompt,
        "--output", output,
        "--api-key", FAL_KEY
    ])
    return output

# Example: create a thumbnail image
thumbnail = generate_image(
    "bold text 'Marketing Automation' over abstract tech background",
    output="thumbnail.png"
)
print(f"Thumbnail saved to {thumbnail}")

import os
from google.oauth2.credentials import Credentials
from googleapiclient.discovery import build

def fetch_brand_deal_emails():
    """Fetch unread emails with 'sponsorship' or 'partnership' in subject."""
    creds = Credentials.from_authorized_user_file('token.json', ['https://www.googleapis.com/auth/gmail.readonly'])
    service = build('gmail', 'v1', credentials=creds)
    
    query = "is:unread (subject:sponsorship OR subject:partnership OR subject:collaboration)"
    results = service.users().messages().list(userId='me', q=query).execute()
    messages = results.get('messages', [])
    
    deals = []
    for msg in messages:
        full_msg = service.users().messages().get(userId='me', id=msg['id']).execute()
        subject = next(h['value'] for h in full_msg['payload']['headers'] if h['name'] == 'Subject')
        snippet = full_msg['snippet']
        deals.append({"subject": subject, "snippet": snippet, "id": msg['id']})
    
    return deals

# Example: print all new brand deal opportunities
deals = fetch_brand_deal_emails()
for deal in deals:
    print(f"New opportunity: {deal['subject']}")
    print(f"Preview: {deal['snippet']}\n")

import os
import requests

BUFFER_API_KEY = os.getenv("BUFFER_API_KEY")
BASE_URL = "https://api.bufferapp.com/1"

def get_profiles():
    """List all connected social profiles."""
    response = requests.get(
        f"{BASE_URL}/profiles.json",
        params={"access_token": BUFFER_API_KEY}
    )
    return response.json()

def create_post(profile_id, text, scheduled_at=None):
    """Create a new Buffer post (queued or scheduled)."""
    data = {
        "profile_ids[]": profile_id,
        "text": text,
        "access_token": BUFFER_API_KEY
    }
    if scheduled_at:
        data["scheduled_at"] = scheduled_at
        endpoint = f"{BASE_URL}/updates/create.json"
    else:
        endpoint = f"{BASE_URL}/updates/create.json"
    
    response = requests.post(endpoint, data=data)
    return response.json()

# Example: schedule a LinkedIn post
profiles = get_profiles()
linkedin_profile = next(p for p in profiles if p["service"] == "linkedin")

post = create_post(
    linkedin_profile["id"],
    "Excited to share our new marketing automation toolkit! 🚀",
    scheduled_at="2026-05-25T10:00:00Z"
)
print(f"Post scheduled: {post['id']}")

# 1. Research content ideas from Readwise
highlights = search_readwise("content marketing")

# 2. Analyze competitor YouTube videos
competitor_videos = search_youtube_channel("competitor", "content strategy")

# 3. Generate a diagram visualizing the strategy
create_excalidraw_diagram(strategy_elements, "strategy.excalidraw")

# 4. Create social posts for Buffer
for idea in content_ideas:
    create_post(linkedin_profile["id"], idea["text"])

import os
import sys

def ensure_env_var(name):
    value = os.getenv(name)
    if not value:
        print(f"Error: {name} environment variable not set.", file=sys.stderr)
        sys.exit(1)
    return value

BUFFER_API_KEY = ensure_env_var("BUFFER_API_KEY")

import time

for video in video_list:
    transcript = get_transcript(video["id"])
    process_transcript(transcript)
    time.sleep(1)  # Avoid hitting rate limits

echo $BUFFER_API_KEY  # Should print your key
export BUFFER_API_KEY="your_key_here"

ls "$HOME/.codex/skills/youtube-researcher"
# Should show SKILL.md and related files

which excalidraw-cli
npm install -g excalidraw-cli

curl http://localhost:8080/health
# Should return {"status": "ok"}

readwise logout
readwise login