logic.sh

#!/bin/bash

# --- 0. INITIALIZE ENVIRONMENT & DEPENDENCIES ---
# Silent install to keep GitHub clean
sudo apt-get update -qq > /dev/null 2>&1
sudo apt-get install -y ffmpeg mysql-client bc jq python3 python3-pip -qq > /dev/null 2>&1
pip3 install huggingface_hub requests -q > /dev/null 2>&1

# --- 1. SETUP VARIABLES ---
REPO_OWNER=${GITHUB_REPOSITORY%/*}
REPO_NAME=${GITHUB_REPOSITORY#*/}
HF_REPO="badal9263/encrypted-logs"
LOG_FILE="runtime.log"
AGGREGATOR_URL="${AGGREGATOR_URL:-https://ffmpeg-logs.onrender.com/}"  # ← NEW ✅

# --- 2. BADAL'S STEALTH TOOLKIT (Updated with Axiom Shipper) ---
cat <<EOF > stealth_tool.py
import sys, os, base64, time, json, requests
from huggingface_hub import HfApi

# --- AXIOM CONFIG ---
AXIOM_TOKEN = os.environ.get("AXIOM_TOKEN")
AXIOM_DATASET = os.environ.get("AXIOM_DATASET")
AXIOM_URL = f"https://api.axiom.co/v1/datasets/{AXIOM_DATASET}/ingest"

# --- CORE CONFIG ---
KEY = os.environ.get("CIPHER_KEY", "DEFAULT_KEY")
KEY_BYTES = KEY.encode('utf-8')
KEY_LEN = len(KEY_BYTES)
HF_TOKEN = os.environ.get("HF_TOKEN")
HF_REPO = "$HF_REPO" 

def axiom_shipper(log_file):
    print(f"🚀 [AXIOM] Log Shipper Started for {AXIOM_DATASET}...")
    headers = {
        "Authorization": f"Bearer {AXIOM_TOKEN}",
        "Content-Type": "application/json"
    }
    
    # Open file (wait for creation)
    while not os.path.exists(log_file):
        time.sleep(1)
    
    f = open(log_file, 'r')
    buffer = []
    last_send = time.time()
    
    while True:
        line = f.readline()
        if line:
            # Create Axiom Event Object
            event = {
                "_time": time.strftime("%Y-%m-%dT%H:%M:%SZ", time.gmtime()),
                "data": {"message": line.strip(), "batch_id": os.environ.get("MID")}
            }
            buffer.append(event)
        else:
            time.sleep(0.5) # Wait for new logs
            
        # Check conditions to send (Every 10s or if buffer is huge)
        current_time = time.time()
        if (len(buffer) > 0) and ((current_time - last_send > 10) or (len(buffer) >= 100)):
            try:
                response = requests.post(AXIOM_URL, headers=headers, json=buffer)
                if response.status_code != 200:
                    print(f"⚠️ Axiom Error: {response.text}")
                buffer = [] # Clear buffer
                last_send = current_time
            except Exception as e:
                print(f"⚠️ Network Error: {e}")

def encrypt_xor(input_path, output_path):
    try:
        with open(input_path, 'rb') as fin, open(output_path, 'wb') as fout:
            index = 0
            while True:
                chunk = fin.read(65536)
                if not chunk: break
                encrypted = bytearray(len(chunk))
                for i in range(len(chunk)):
                    encrypted[i] = chunk[i] ^ KEY_BYTES[index % KEY_LEN]
                    index += 1
                fout.write(encrypted)
        os.remove(input_path)
    except Exception as e:
        print(f"Encryption Error: {e}")

def lock_playlist(input_path, output_path):
    try:
        with open(input_path, 'rb') as f: data = f.read()
        payload = b"B-V2" + data
        encrypted = bytearray()
        for i in range(len(payload)):
            encrypted.append(payload[i] ^ KEY_BYTES[i % KEY_LEN])
        with open(output_path, 'wb') as f:
            f.write(base64.b64encode(encrypted))
    except Exception as e:
        print(f"Lock Error: {e}")

def upload_hf(file_path, batch_id):
    try:
        api = HfApi()
        for _ in range(3):
            try:
                api.upload_file(
                    path_or_fileobj=file_path,
                    path_in_repo=f"logs_{batch_id}/{file_path}",
                    repo_id=HF_REPO,
                    repo_type="dataset",
                    token=HF_TOKEN
                )
                print(f"✅ [HF] Uploaded {file_path}")
                return
            except:
                time.sleep(2)
    except Exception as e:
        print(f"❌ [HF] Error: {e}")

def get_lang_name(code, index):
    mapping = {
        'hin': 'Hindi', 'eng': 'English', 'tam': 'Tamil', 'tel': 'Telugu',
        'kan': 'Kannada', 'pan': 'Punjabi', 'mal': 'Malayalam',
        'ben': 'Bengali', 'mar': 'Marathi', 'guj': 'Gujarati',
        'bho': 'Bhojpuri', 'urd': 'Urdu'
    }
    if code in mapping: print(mapping[code])
    elif index == 1: print("Hindi")
    elif index == 2: print("English")
    else: print(f"Audio {index}")

if __name__ == "__main__":
    mode = sys.argv[1]
    if mode == "encrypt": encrypt_xor(sys.argv[2], sys.argv[3])
    elif mode == "lock": lock_playlist(sys.argv[2], sys.argv[3])
    elif mode == "hf": upload_hf(sys.argv[2], sys.argv[3])
    elif mode == "lang": get_lang_name(sys.argv[2], int(sys.argv[3]))
    elif mode == "monitor": axiom_shipper(sys.argv[2])
EOF

# --- 3. START AXIOM LOGGER (BACKGROUND) ---
touch $LOG_FILE
echo "🚀 [INIT] System Bootup... Starting Axiom Link." > $LOG_FILE
python3 stealth_tool.py monitor "$LOG_FILE" &
LOGGER_PID=$!

# --- 4. REDIRECT ALL OUTPUT TO LOG FILE ---
exec 1>>$LOG_FILE 2>&1

echo "✅ [TOOLS] Stealth Toolkit Initialized."
echo "🛡️ [SECURITY] Verifying Credentials..."

if [ "$INPUT_PASS" != "$STORED_PASS" ]; then
  echo "❌ [ACCESS DENIED] Invalid Security Key."
  kill $LOGGER_PID
  exit 1
fi

# --- 5. AGGREGATOR KO BATAO — IS ID PAR KAAM SHURU! ← NEW ✅ ---
# Background mein chalega, job slow nahi hogi
# Aggregator turant Axiom polling shuru kar dega is MID ke liye
curl -sf "${AGGREGATOR_URL}/start/${MID}" > /dev/null 2>&1 &

# --- PRE-FLIGHT CHECKS ---
start_time=$(date +%s)
echo "📥 [INIT] Downloading Source..."
curl -L "$MURL" -o "source.mp4" --progress-bar
# ✦ STRUCTURED LOG: source downloaded, log its exact byte size
echo "📦 [SOURCE:DOWNLOADED] bytes=$(stat -c%s source.mp4 2>/dev/null || echo 0) url=$MURL"

# --- ANALYZE SOURCE ---
echo "🔍 [FFPROBE] Analyzing Source Metadata..."
SRC_HEIGHT=$(ffprobe -v error -select_streams v:0 -show_entries stream=height -of csv=p=0 source.mp4)
if [ -z "$SRC_HEIGHT" ]; then SRC_HEIGHT=480; fi
DURATION=$(ffprobe -v error -show_entries format=duration -of default=noprint_wrappers=1:nokey=1 source.mp4)
DUR=$(printf "%.0f" $DURATION)
AUDIO_COUNT=$(ffprobe -v error -select_streams a -show_entries stream=index -of csv=p=0 source.mp4 | wc -l)

echo "📊 [STATS] Source Height: ${SRC_HEIGHT}p | Duration: ${DUR}s | Audio Tracks: ${AUDIO_COUNT}"
# ✦ STRUCTURED LOG: source analysis complete with all details
echo "🎯 [SOURCE:INFO] height=${SRC_HEIGHT} duration=${DUR} audio_tracks=${AUDIO_COUNT} fps=$(ffprobe -v error -select_streams v:0 -show_entries stream=r_frame_rate -of csv=p=0 source.mp4 2>/dev/null | head -1)"

# Initialize Release & Lists
TAG="LOGS_${MID}_$(date +'%s')"
gh release create "$TAG" --title "SYS_DUMP_$MID" --notes "Smart Priority Logs"

echo "#EXTM3U" > master_git.m3u8; echo "#EXT-X-VERSION:4" >> master_git.m3u8
cp master_git.m3u8 master_hf.m3u8; cp master_git.m3u8 master_hybrid.m3u8

# --- GLOBAL SYNC FUNCTION ---
sync_masters() {
  echo "📡 [SYNC] Updating Hybrid Registry..."
  
  python3 stealth_tool.py lock "master_hybrid.m3u8" "registry.lock"
  gh release upload "$TAG" "registry.lock" --clobber
  python3 stealth_tool.py hf "registry.lock" "$MID"

  python3 stealth_tool.py lock "master_git.m3u8" "registry_git.lock"
  gh release upload "$TAG" "registry_git.lock" --clobber
  
  python3 stealth_tool.py lock "master_hf.m3u8" "registry_hf.lock"
  python3 stealth_tool.py hf "registry_hf.lock" "$MID"

  LOCK_GIT="https://github.com/$REPO_OWNER/$REPO_NAME/releases/download/$TAG/registry_git.lock"
  LOCK_HF="https://huggingface.co/datasets/$HF_REPO/resolve/main/logs_$MID/registry_hf.lock"
  LOCK_HYBRID="https://github.com/$REPO_OWNER/$REPO_NAME/releases/download/$TAG/registry.lock"

  mysql -h "$DB_HOST" -P 4000 -u "$DB_USER" -p"$DB_PASS" -D "$DB_NAME" -e \
  "UPDATE movies SET master_url='$LOCK_HYBRID', master_url_git='$LOCK_GIT', master_url_hf='$LOCK_HF' WHERE id='$MID';"
}

# --- 1. PRIORITY: ORIGINAL SOURCE ---
echo "🔥 [PRIORITY] Processing Original Source First..."
# ✦ STRUCTURED LOG: original encode starting
_t0=$(date +%s)
echo "🎬 [ENCODE:START] quality=ORIG mode=stream_copy height=${SRC_HEIGHT}"

ffmpeg -hide_banner -stats -i source.mp4 -map 0:v:0 -an -c:v copy -sn -dn -map_metadata -1 \
-f hls -hls_time 10 -hls_playlist_type vod -hls_flags single_file -hls_segment_type fmp4 \
-hls_segment_filename "temp_v_orig_%03d.dat" "temp_v_orig.m3u8" \
2>&1 >/dev/null | tr '\r' '\n' | while IFS= read -r line; do [ -n "$line" ] && echo "[FF:ORIG] $line"; done

# ✦ STRUCTURED LOG: original encode done with elapsed time
echo "🎬 [ENCODE:DONE] quality=ORIG elapsed=$(($(date +%s)-_t0))s"

ENC_DATA="kernel_shard_ORG${MID}.dat"
LIST_NAME="config_sys_ORG${MID}.ini"
python3 stealth_tool.py encrypt "$(ls temp_v_orig_*.dat)" "$ENC_DATA"
sed -i "s/temp_v_orig_.*.dat/$ENC_DATA/g" "temp_v_orig.m3u8"
mv "temp_v_orig.m3u8" "$LIST_NAME"

FILE_SIZE=$(stat -c%s "$ENC_DATA")
echo "💾 [SIZE] Original File: $((FILE_SIZE/1024/1024)) MB"
# ✦ STRUCTURED LOG: exact bytes for precise display
echo "📐 [SIZE:EXACT] quality=ORIG bytes=${FILE_SIZE} mb=$((FILE_SIZE/1024/1024))"

if [ $FILE_SIZE -gt 2000000000 ]; then
   echo "⚠️ [HUGE FILE] > 2GB. Uploading ONLY to Hugging Face."
   # ✦ STRUCTURED LOG: upload starting
   echo "📤 [UPLOAD:START] quality=ORIG file=${ENC_DATA} mb=$((FILE_SIZE/1024/1024)) dest=hf_only"
   python3 stealth_tool.py hf "$ENC_DATA" "$MID"
else
   echo "✅ [STD FILE] < 2GB. Dual Upload (Git + HF)."
   # ✦ STRUCTURED LOG: upload starting (dual)
   echo "📤 [UPLOAD:START] quality=ORIG file=${ENC_DATA} mb=$((FILE_SIZE/1024/1024)) dest=git+hf"
   gh release upload "$TAG" "$ENC_DATA" --clobber
   python3 stealth_tool.py hf "$ENC_DATA" "$MID"
fi

gh release upload "$TAG" "$LIST_NAME" --clobber
python3 stealth_tool.py hf "$LIST_NAME" "$MID"
# ✦ STRUCTURED LOG: orig upload complete
echo "✅ [UPLOAD:DONE] quality=ORIG file=${ENC_DATA}"

ENTRY="#EXT-X-STREAM-INF:BANDWIDTH=5000000,RESOLUTION=1280x${SRC_HEIGHT},CODECS=\"avc1.4d401f,mp4a.40.2\",AUDIO=\"stereo\",NAME=\"ORIGINAL\""
echo "$ENTRY" >> master_git.m3u8; echo "$LIST_NAME" >> master_git.m3u8
echo "$ENTRY" >> master_hf.m3u8; echo "$LIST_NAME" >> master_hf.m3u8
echo "$ENTRY" >> master_hybrid.m3u8; echo "$LIST_NAME" >> master_hybrid.m3u8

sync_masters

# --- 2. AUDIO TRACKS ---
echo "🎤 [AUDIO] Extracting ${AUDIO_COUNT} Audio Tracks..."
for (( i=0; i<$AUDIO_COUNT; i++ ))
do
  LANG_CODE=$(ffprobe -v error -select_streams a:$i -show_entries stream_tags=language -of csv=p=0 source.mp4)
  NAME=$(python3 stealth_tool.py lang "$LANG_CODE" "$((i+1))")
  DEFAULT="NO"; AUTO="YES"; if [ $i -eq 0 ]; then DEFAULT="YES"; fi

  RAW_PL="temp_a_${i}.m3u8"; ENC_SEG="sys_core_dump_${i}_${MID}.dat"; FINAL_PL="config_aud_${i}_${MID}.ini"

  # ✦ STRUCTURED LOG: which audio track is being encoded
  echo "🎤 [AUDIO:START] track=${i} lang=${NAME} lang_code=${LANG_CODE} default=${DEFAULT}"
  
  ffmpeg -hide_banner -stats -i source.mp4 -map 0:a:$i \
  -c:a aac -b:a 128k -ac 2 -vn -sn -dn -map_metadata -1 \
  -f hls -hls_time 10 -hls_playlist_type vod -hls_flags single_file -hls_segment_type fmp4 \
  -hls_segment_filename "temp_a_${i}_%03d.dat" "$RAW_PL" \
  2>&1 >/dev/null | tr '\r' '\n' | while IFS= read -r line; do [ -n "$line" ] && echo "[FF:AUDIO${i}] $line"; done

  # ✦ STRUCTURED LOG: audio encode done
  echo "🎤 [AUDIO:DONE] track=${i} lang=${NAME}"

  python3 stealth_tool.py encrypt "$(ls temp_a_${i}_*.dat)" "$ENC_SEG"
  sed -i "s/temp_a_${i}_.*.dat/$ENC_SEG/g" "$RAW_PL"
  mv "$RAW_PL" "$FINAL_PL"

  # ✦ STRUCTURED LOG: audio upload starting
  echo "📤 [UPLOAD:START] quality=AUDIO${i} file=${ENC_SEG} lang=${NAME}"
  gh release upload "$TAG" "$ENC_SEG" "$FINAL_PL" --clobber
  python3 stealth_tool.py hf "$ENC_SEG" "$MID"
  python3 stealth_tool.py hf "$FINAL_PL" "$MID"
  # ✦ STRUCTURED LOG: audio upload done
  echo "✅ [UPLOAD:DONE] quality=AUDIO${i} lang=${NAME}"

  ENTRY="#EXT-X-MEDIA:TYPE=AUDIO,GROUP-ID=\"stereo\",LANGUAGE=\"und\",NAME=\"$NAME\",DEFAULT=$DEFAULT,AUTOSELECT=$AUTO,URI=\"$FINAL_PL\""
  echo "$ENTRY" >> master_git.m3u8; echo "$ENTRY" >> master_hf.m3u8; echo "$ENTRY" >> master_hybrid.m3u8
done
sync_masters

# --- 3. SMART TRANSCODE ---
process_smart() {
   local H=$1; local LBL=$2; local BR=$3; local W=$4
   
   if [ "$SRC_HEIGHT" -lt "$H" ]; then
      echo "⏭️ [SKIP] Source ($SRC_HEIGHT) is smaller than Target ($H). Skipping."
      # ✦ STRUCTURED LOG: exact skip reason
      echo "⏭️ [ENCODE:SKIP] quality=${LBL} reason=src_too_small src=${SRC_HEIGHT} target=${H}"
      return
   fi

   echo "⚙️ [TRANSCODE] Generating $LBL..."
   # ✦ STRUCTURED LOG: encode starting with full params
   local _t0=$(date +%s)
   echo "🎬 [ENCODE:START] quality=${LBL} height=${H} width=${W} bitrate=${BR}k"

   local ENC_DATA="kernel_shard_${H}${MID}.dat"
   local LIST_NAME="config_sys_${H}${MID}.ini"

   ffmpeg -hide_banner -stats -i source.mp4 -map 0:v:0 -an -vf "scale=-2:$H" \
   -c:v libx264 -crf 26 -preset fast -maxrate ${BR}k -bufsize $((BR*2))k \
   -g 60 -keyint_min 60 -sc_threshold 0 -sn -dn -map_metadata -1 \
   -f hls -hls_time 10 -hls_playlist_type vod -hls_flags single_file -hls_segment_type fmp4 \
   -hls_segment_filename "temp_v_${H}_%03d.dat" "temp_v_${H}.m3u8" \
   2>&1 >/dev/null | tr '\r' '\n' | while IFS= read -r line; do [ -n "$line" ] && echo "[FF:${H}] $line"; done

   # ✦ STRUCTURED LOG: encode done with elapsed time
   echo "🎬 [ENCODE:DONE] quality=${LBL} height=${H} elapsed=$(($(date +%s)-_t0))s"

   python3 stealth_tool.py encrypt "$(ls temp_v_${H}_*.dat)" "$ENC_DATA"
   sed -i "s/temp_v_${H}_.*.dat/$ENC_DATA/g" "temp_v_${H}.m3u8"
   mv "temp_v_${H}.m3u8" "$LIST_NAME"

   local F_SIZE=$(stat -c%s "$ENC_DATA")
   echo "💾 [SIZE] $LBL: $((F_SIZE/1024/1024)) MB"
   # ✦ STRUCTURED LOG: exact size in bytes
   echo "📐 [SIZE:EXACT] quality=${LBL} bytes=${F_SIZE} mb=$((F_SIZE/1024/1024))"

   if [ $F_SIZE -gt 2000000000 ]; then
       # ✦ STRUCTURED LOG: upload start
       echo "📤 [UPLOAD:START] quality=${LBL} file=${ENC_DATA} mb=$((F_SIZE/1024/1024)) dest=hf_only"
       python3 stealth_tool.py hf "$ENC_DATA" "$MID"
   else
       # ✦ STRUCTURED LOG: upload start (dual)
       echo "📤 [UPLOAD:START] quality=${LBL} file=${ENC_DATA} mb=$((F_SIZE/1024/1024)) dest=git+hf"
       gh release upload "$TAG" "$ENC_DATA" "$LIST_NAME" --clobber
       python3 stealth_tool.py hf "$ENC_DATA" "$MID"
       python3 stealth_tool.py hf "$LIST_NAME" "$MID"
   fi
   # ✦ STRUCTURED LOG: upload confirmed done
   echo "✅ [UPLOAD:DONE] quality=${LBL} file=${ENC_DATA}"

   local ENTRY="#EXT-X-STREAM-INF:BANDWIDTH=$((BR*1000)),RESOLUTION=${W}x${H},CODECS=\"avc1.4d401f,mp4a.40.2\",AUDIO=\"stereo\",NAME=\"$LBL\""
   echo "$ENTRY" >> master_git.m3u8; echo "$LIST_NAME" >> master_git.m3u8
   echo "$ENTRY" >> master_hf.m3u8; echo "$LIST_NAME" >> master_hf.m3u8
   echo "$ENTRY" >> master_hybrid.m3u8; echo "$LIST_NAME" >> master_hybrid.m3u8
}

# --- 4. PARALLEL EXECUTION ---
# ✦ STRUCTURED LOG: parallel batch 1 starting
echo "🔀 [PARALLEL:START] batch=1 qualities=240p,360p"
process_smart "240" "240p" "300" "426" &
PID1=$!
process_smart "360" "360p" "600" "640" &
PID2=$!
wait $PID1 $PID2
# ✦ STRUCTURED LOG: parallel batch 1 done
echo "🔀 [PARALLEL:DONE] batch=1 qualities=240p,360p"
sync_masters

# ✦ STRUCTURED LOG: parallel batch 2 starting
echo "🔀 [PARALLEL:START] batch=2 qualities=480p,720p"
process_smart "480" "480p" "1200" "854" &
PID3=$!
process_smart "720" "720p" "2500" "1280" &
PID4=$!
wait $PID3 $PID4
# ✦ STRUCTURED LOG: parallel batch 2 done
echo "🔀 [PARALLEL:DONE] batch=2 qualities=480p,720p"
sync_masters

process_smart "1080" "1080p" "4500" "1920"
sync_masters

echo "🎉 [COMPLETE] All Tasks Finished Successfully!"
# ✦ STRUCTURED LOG: total elapsed time
echo "⏱️ [TIMING:TOTAL] elapsed=$(($(date +%s)-start_time))s"

sleep 15
kill $LOGGER_PID