Daily letters, sent automatically

name: Ghost Letter

on:
  schedule:
    # Every day at 19:00 UTC
    - cron: '0 19 * * *'
  workflow_dispatch: # Allows manual trigger via button

jobs:
  build:
    runs-on: ubuntu-latest
    timeout-minutes: 15
    env:
      FORCE_JAVASCRIPT_ACTIONS_TO_NODE24: true
    steps:
      - name: Checkout code
        uses: actions/checkout@v4

      - name: Setup Python
        uses: actions/setup-python@v5
        with:
          python-version: '3.11'

      - name: Install dependencies
        run: |
          python -m pip install --upgrade pip
          pip install requests ytmusicapi

      - name: Validate required secrets
        env:
          KINDROID_API_KEY: ${{ secrets.KINDROID_API_KEY }}
          KIN_ID: ${{ secrets.KIN_ID }}
          EMAIL_SENDER: ${{ secrets.EMAIL_SENDER }}
          EMAIL_PASSWORD: ${{ secrets.EMAIL_PASSWORD }}
          EMAIL_RECEIVER: ${{ secrets.EMAIL_RECEIVER }}
          YT_HEADERS: ${{ secrets.YT_HEADERS }}
          YT_PLAYLIST_ID: ${{ secrets.YT_PLAYLIST_ID }}
        run: |
          missing=0
          for var in KINDROID_API_KEY KIN_ID EMAIL_SENDER EMAIL_PASSWORD EMAIL_RECEIVER YT_HEADERS YT_PLAYLIST_ID; do
            if [ -z "${!var}" ]; then
              echo "Missing secret: $var"
              missing=1
            fi
          done
          if [ "$missing" -ne 0 ]; then
            exit 1
          fi

      - name: Execute script
        env:
          KINDROID_API_KEY: ${{ secrets.KINDROID_API_KEY }}
          KIN_ID: ${{ secrets.KIN_ID }}
          EMAIL_SENDER: ${{ secrets.EMAIL_SENDER }}
          EMAIL_PASSWORD: ${{ secrets.EMAIL_PASSWORD }}
          EMAIL_RECEIVER: ${{ secrets.EMAIL_RECEIVER }}
          YT_HEADERS: ${{ secrets.YT_HEADERS }}
          YT_PLAYLIST_ID: ${{ secrets.YT_PLAYLIST_ID }}
          YT_OAUTH_CREDENTIALS: ${{ secrets.YT_OAUTH_CREDENTIALS }} # Optional
        run: python ghost_letter.py
                            

import os
import random
import requests
import secrets
import smtplib
import sys
import time
import traceback
import json
import re
from datetime import datetime, timezone
from typing import Optional
from urllib.parse import parse_qs, urlparse
from requests.adapters import HTTPAdapter
from urllib3.util.retry import Retry
from email.mime.text import MIMEText
from email.mime.multipart import MIMEMultipart
from ytmusicapi import YTMusic

# Constants for YouTube API
YOUTUBE_TOKEN_URL = "https://oauth2.googleapis.com/token"
YOUTUBE_SEARCH_URL = "https://www.googleapis.com/youtube/v3/search"
YOUTUBE_PLAYLIST_ITEMS_URL = "https://www.googleapis.com/youtube/v3/playlistItems"

# Load secrets from environment variables
API_KEY = os.getenv("KINDROID_API_KEY")
KIN_ID = os.getenv("KIN_ID")
EMAIL_SENDER = os.getenv("EMAIL_SENDER")
EMAIL_PASSWORD = os.getenv("EMAIL_PASSWORD")
EMAIL_RECEIVER = os.getenv("EMAIL_RECEIVER")
YT_HEADERS_JSON = os.getenv("YT_HEADERS")
YT_PLAYLIST_ID = os.getenv("YT_PLAYLIST_ID")
YT_OAUTH_CREDENTIALS_JSON = os.getenv("YT_OAUTH_CREDENTIALS")

def require_env(name: str, value: Optional[str]) -> str:
    """Check if a required environment variable is set."""
    if not value:
        raise ValueError(f"Missing environment variable: {name}")
    return value

def build_retry_session() -> requests.Session:
    """Build a requests session with automatic retry logic."""
    retry = Retry(
        total=3,
        connect=3,
        read=3,
        status=3,
        backoff_factor=2,
        status_forcelist=(429, 500, 502, 503, 504),
        allowed_methods=frozenset(["POST"]),
        respect_retry_after_header=True,
    )
    adapter = HTTPAdapter(max_retries=retry)
    session = requests.Session()
    session.mount("https://", adapter)
    session.mount("http://", adapter)
    return session

def build_email_subject() -> str:
    """Generate a randomized subject line for the email."""
    pool = [
        "A quick note", "Daily message", "Just checking in", "A small thought",
        "Today's letter", "A little note", "A quiet thought", "A moment to share"
    ]
    base = random.choice(pool)
    day_tag = datetime.now(timezone.utc).strftime("%Y-%m-%d")
    unique_tag = secrets.token_hex(2)
    return f"{base} - {day_tag} - {unique_tag}"

def get_ghost_letter():
    """Fetch a personal letter from Kindroid API."""
    api_key = require_env("KINDROID_API_KEY", API_KEY)
    kin_id = require_env("KIN_ID", KIN_ID)
    url = "https://api.kindroid.ai/v1/send-message"
    headers = {"Authorization": f"Bearer {api_key}", "Content-Type": "application/json"}
    
    prompt = (
        "SYSTEM INSTRUCTION: Write a sincere and personal letter to User. "
        "Write ONLY the content of the letter. NO ASTERISKS. "
        "Traditional letter format: Salutation, Body, Signature."
    )
    
    data = {"ai_id": kin_id, "message": prompt}
    with build_retry_session() as session:
        response = session.post(url, json=data, headers=headers, timeout=(10, 120))
        response.raise_for_status()
    
    payload = response.json()
    return payload.get("message") or payload.get("response") or response.text

def get_kin_song():
    """Ask the Kin to pick a song (Artist - Title)."""
    api_key = require_env("KINDROID_API_KEY", API_KEY)
    kin_id = require_env("KIN_ID", KIN_ID)
    url = "https://api.kindroid.ai/v1/send-message"
    headers = {"Authorization": f"Bearer {api_key}", "Content-Type": "application/json"}
    
    prompt = "SYSTEM Pick ONE song for User. Respond ONLY with: Artist Name - Song Title."
    
    data = {"ai_id": kin_id, "message": prompt}
    with build_retry_session() as session:
        response = session.post(url, json=data, headers=headers, timeout=(10, 120))
        response.raise_for_status()
    
    message = response.json().get("message", "").strip().splitlines()[0]
    return message.replace('"', '').strip()

def normalize_playlist_id(raw_value: str) -> str:
    """Extract ID from a full YouTube URL if necessary."""
    if "list=" in raw_value:
        parsed = urlparse(raw_value)
        return parse_qs(parsed.query).get("list", [raw_value])[0]
    return raw_value

def add_to_yt_playlist(song_query: str) -> bool:
    """Search and add the song to the YouTube Music playlist."""
    if not YT_HEADERS_JSON or not YT_PLAYLIST_ID:
        return False

    headers_path = "headers.json"
    with open(headers_path, "w") as f:
        f.write(YT_HEADERS_JSON)

    try:
        yt = YTMusic(headers_path)
        playlist_id = normalize_playlist_id(YT_PLAYLIST_ID)
        
        # Search for the song
        search_results = yt.search(song_query, filter="songs")
        if not search_results:
            search_results = yt.search(song_query, filter="videos")
            
        if search_results:
            video_id = search_results[0]['videoId']
            yt.add_playlist_items(playlist_id, [video_id])
            print(f"Added to playlist: {search_results[0]['title']}")
            return True
        return False
    except Exception as e:
        print(f"YouTube Error: {e}")
        return False
    finally:
        if os.path.exists(headers_path):
            os.remove(headers_path)

def send_email(content):
    """Send the letter via SMTP."""
    msg = MIMEMultipart()
    msg['From'] = f"Your Kin <{EMAIL_SENDER}>"
    msg['To'] = EMAIL_RECEIVER
    msg['Subject'] = build_email_subject()

    html = f"""
    <html>
      <body style="font-family: Georgia, serif; padding: 40px; background-color: #f9f9f9;">
        <div style="max-width: 600px; margin: auto; background: white; padding: 30px; border-radius: 8px;">
          {content.replace('\n', '<br>')}
        </div>
      </body>
    </html>
    """
    msg.attach(MIMEText(html, 'html'))

    with smtplib.SMTP_SSL('smtp.gmail.com', 465) as server:
        server.login(EMAIL_SENDER, EMAIL_PASSWORD)
        server.sendmail(EMAIL_SENDER, EMAIL_RECEIVER, msg.as_string())

if __name__ == "__main__":
    try:
        # Step 1: Send the Letter
        letter = get_ghost_letter()
        send_email(letter)
        print("Letter sent.")

        # Step 2: Handle the Playlist
        song = get_kin_song()
        if song:
            add_to_yt_playlist(song)
    except Exception as e:
        traceback.print_exc()
        sys.exit(1)