import json
import os
import shutil
import sys
import argparse
import zipfile
import subprocess
# ==============================================================================
# 1. Messenger input CSV: Comes from a transformed exported CSV ("messenger_damien.csv").
# Because standard Facebook exports exclude absolute timestamps in older epochs, dates
# are parsed sequentially starting on Saturday, April 11, 2026. The JS layout engine
# steps dates forward day-by-day as the relative weekday names change.
# 2. Instagram input dir: Parsed directly from a raw Instagram JSON export. Timestamps
# are evaluated natively in milliseconds.
# 3. Direct quote replies: Compact network responses containing explicit message IDs
# are extracted from a browser network HAR capture using a targeted jq filter
# ("instagram_messagelist_reqs.json"). The JS compiler intersects these IDs with
# standard timestamps to draw linked quote cards in the message timeline.
# 4. Auditability: Raw source files are hosted unmodified in "static/inputs/" for user
# validation. Visually redacted images are blurred out natively using CSS filters
# rather than by modifying any of the input files.
# ==============================================================================
STATIC_PHOTOS_DIR = "static/photos"
STATIC_VIDEOS_DIR = "static/videos"
def process_and_copy_media(raw_path):
if not raw_path: return ""
raw_path = raw_path.strip()
filename = os.path.basename(raw_path)
if "your_instagram_activity" in raw_path:
sub_dir = "photos" if "photos" in raw_path else "videos"
dest_dir = STATIC_PHOTOS_DIR if sub_dir == "photos" else STATIC_VIDEOS_DIR
os.makedirs(dest_dir, exist_ok=True)
dest_path = os.path.join(dest_dir, filename)
if os.path.exists(raw_path):
try:
shutil.copy2(raw_path, dest_path)
except Exception:
pass
return f"static/{sub_dir}/{filename}"
return raw_path
def copy_referenced_media(json_path):
if not os.path.exists(json_path): return
with open(json_path, 'r', encoding='utf-8') as f:
data = json.load(f)
for msg in data.get('messages', []):
for key in ['photos', 'videos', 'audio_files']:
if key in msg and msg[key]:
uri = msg[key][0].get('uri', '')
if uri:
process_and_copy_media(uri)
def merge_instagram_archive(zip_path):
local_instagram_dir = "your_instagram_activity/messages/inbox/damien_542879920433437"
local_json_path = os.path.join(local_instagram_dir, "message_1.json")
existing_messages = []
participants = []
title = "Damien"
thread_path = "messages/inbox/damien_542879920433437"
if os.path.exists(local_json_path):
try:
with open(local_json_path, "r", encoding="utf-8") as f:
old_data = json.load(f)
existing_messages = old_data.get("messages", [])
participants = old_data.get("participants", [])
title = old_data.get("title", title)
thread_path = old_data.get("thread_path", thread_path)
except Exception as e:
sys.stderr.write(f"Warning: Failed to load existing local messages: {e}\n")
if not os.path.exists(zip_path):
sys.stderr.write(f"Error: Zip file {zip_path} not found.\n")
return
sys.stderr.write(f"Processing archive: {zip_path}\n")
new_messages = []
with zipfile.ZipFile(zip_path, 'r') as z:
for name in z.namelist():
if "messages/inbox/damien_542879920433437" in name and name.endswith(".json") and "message_" in name:
try:
with z.open(name) as f:
zip_data = json.loads(f.read().decode('utf-8'))
new_messages.extend(zip_data.get("messages", []))
if not participants:
participants = zip_data.get("participants", [])
except Exception as e:
sys.stderr.write(f"Error reading JSON {name} from ZIP: {e}\n")
is_media = False
for m_dir in ["/photos/", "/videos/", "/audio/", "/files/"]:
if "messages/inbox/damien_542879920433437" in name and m_dir in name:
is_media = True
break
if is_media and not name.endswith('/'):
suffix_index = name.find("messages/inbox/damien_542879920433437")
relative_path = name[suffix_index:]
dest_media_path = os.path.join("your_instagram_activity", relative_path)
os.makedirs(os.path.dirname(dest_media_path), exist_ok=True)
try:
with z.open(name) as src, open(dest_media_path, "wb") as dest:
shutil.copyfileobj(src, dest)
except Exception as e:
sys.stderr.write(f"Error extracting media {name}: {e}\n")
seen_keys = set()
merged_messages = []
def get_msg_key(m):
content = m.get("content", "")
media_key = ""
for k in ["photos", "videos", "audio_files", "files"]:
if k in m and m[k]:
media_key += str(m[k][0].get("uri", ""))
return (m.get("timestamp_ms"), m.get("sender_name"), content, media_key)
for m in existing_messages:
key = get_msg_key(m)
if key not in seen_keys:
seen_keys.add(key)
merged_messages.append(m)
added_count = 0
for m in new_messages:
key = get_msg_key(m)
if key not in seen_keys:
seen_keys.add(key)
merged_messages.append(m)
added_count += 1
sys.stderr.write(f"Merged {len(existing_messages)} existing with {len(new_messages)} new messages. Added {added_count} new entries.\n")
merged_messages.sort(key=lambda x: x.get("timestamp_ms", 0), reverse=True)
os.makedirs(local_instagram_dir, exist_ok=True)
output_data = {
"participants": participants,
"messages": merged_messages,
"title": title,
"is_still_participant": True,
"thread_path": thread_path,
"magic_words": []
}
with open(local_json_path, "w", encoding="utf-8") as f:
json.dump(output_data, f, indent=2, ensure_ascii=False)
def build_dist_directory():
"""Isolates compiled deployment assets, excluding large non-essential raw workspace files."""
sys.stderr.write("Building clean 'dist' folder for deployment...\n")
dist_dir = "dist"
if os.path.exists(dist_dir):
shutil.rmtree(dist_dir)
os.makedirs(dist_dir, exist_ok=True)
# Copy compiled index.html
if os.path.exists("index.html"):
shutil.copy2("index.html", os.path.join(dist_dir, "index.html"))
# Copy static assets folder recursively while filtering out items > 25MB
if os.path.exists("static"):
for root, dirs, files in os.walk("static"):
rel_path = os.path.relpath(root, "static")
dest_root = os.path.join(dist_dir, "static", rel_path) if rel_path != "." else os.path.join(dist_dir, "static")
os.makedirs(dest_root, exist_ok=True)
for f in files:
src_file = os.path.join(root, f)
dest_file = os.path.join(dest_root, f)
# Exclude files exceeding Cloudflare's 25MB file limits
file_size = os.path.getsize(src_file)
if file_size > 25 * 1024 * 1024:
sys.stderr.write(f"Skipping {src_file} (exceeds 25MB limit: {file_size / (1024*1024):.1f} MB)\n")
continue
shutil.copy2(src_file, dest_file)
def deploy_test_version():
if os.path.exists("instagram.zip"):
sys.stderr.write("Uploading instagram.zip to R2 bucket 'cdn'...\n")
try:
subprocess.run(
["npx", "wrangler", "r2", "object", "put", "cdn/instagram.zip", "--file", "instagram.zip", "--remote"],
check=True
)
sys.stderr.write("R2 Upload finished successfully.\n")
except Exception as e:
sys.stderr.write(f"Failed to upload asset to R2: {e}\n")
else:
sys.stderr.write("instagram.zip not found, skipping R2 upload step.\n")
# Isolate static files in /dist folder
build_dist_directory()
sys.stderr.write("Registering new version on Cloudflare (Preview / Test environment)...\n")
try:
# Deploy with '--assets dist' to isolate compiled assets, passing compatibility date
subprocess.run(
["npx", "wrangler", "versions", "upload", "--assets", "dist", "--name", "r-v-damien", "--compatibility-date", "2026-07-09"],
check=True
)
sys.stderr.write("Version successfully registered. Check output or dashboard for preview URL.\n")
except Exception as e:
sys.stderr.write(f"Upload command failed: {e}\n")
def promote_latest_version():
sys.stderr.write("Promoting the latest test version to production...\n")
try:
result = subprocess.run(
["npx", "wrangler", "versions", "list", "--name", "r-v-damien", "--json"],
capture_output=True, text=True, check=True
)
list_data = json.loads(result.stdout)
if not list_data:
sys.stderr.write("Error: No versions found to promote.\n")
sys.exit(1)
latest_version = max(list_data, key=lambda x: x.get('number', 0))
latest_id = latest_version.get('id')
latest_num = latest_version.get('number')
if not latest_id:
sys.stderr.write("Error: Could not determine latest version ID.\n")
sys.exit(1)
sys.stderr.write(f"Latest version found: #{latest_num} ({latest_id})\n")
sys.stderr.write(f"Promoting version {latest_id} to 100% traffic...\n")
subprocess.run(
["npx", "wrangler", "versions", "deploy", f"{latest_id}@100%", "--name", "r-v-damien", "--yes"],
check=True
)
sys.stderr.write("Successfully promoted version to production.\n")
except Exception as e:
sys.stderr.write(f"Failed to promote version: {e}\n")
sys.exit(1)
# Process arguments
parser = argparse.ArgumentParser(description="Compile logs and deployment workflows.")
parser.add_argument('--instagram', help='Path to new Instagram ZIP archive to append.')
parser.add_argument('--skip-deploy', action='store_true', help='Skip R2 upload and preview deployment.')
parser.add_argument('--promote', action='store_true', help='Promote the latest preview version directly to production (exits immediately).')
args, unknown = parser.parse_known_args()
if args.promote:
promote_latest_version()
sys.exit(0)
if args.instagram:
merge_instagram_archive(args.instagram)
os.makedirs("static/inputs", exist_ok=True)
raw_messenger_path = "messenger_damien.csv"
raw_instagram_json = "your_instagram_activity/messages/inbox/damien_542879920433437/message_1.json"
raw_reqs_json = "instagram_messagelist_reqs.json"
shutil.copy2(__file__, "static/inputs/program.py")
if os.path.exists(raw_messenger_path):
shutil.copy2(raw_messenger_path, "static/inputs/messenger.csv")
# Create instagram.zip from the current state of your_instagram_activity
instagram_folder = "your_instagram_activity/messages/inbox/damien_542879920433437"
if os.path.exists(instagram_folder):
shutil.make_archive("instagram", 'zip', instagram_folder)
copy_referenced_media(raw_instagram_json)
if os.path.exists(raw_instagram_json):
shutil.copy2(raw_instagram_json, "static/inputs/message_1.json")
if os.path.exists(raw_reqs_json):
shutil.copy2(raw_reqs_json, "static/inputs/instagram_messagelist_reqs.json")
css_content = ""
if os.path.exists("style.css"):
with open("style.css", "r", encoding="utf-8") as f:
css_content = f.read()
HTML_TEMPLATE = """
R v Damien McMullen
"""
final_html = (
HTML_TEMPLATE
.replace("{{CSS_CONTENT}}", css_content)
)
with open("index.html", "w", encoding="utf-8") as f:
f.write(final_html)
if not args.skip_deploy:
deploy_test_version()