Clean commit: remove virtualenv and large files

.gitignore

@@ -0,0 +1,30 @@
+__pycache__/
+*.pyc
+.env
+generated_images/
+.vscode/
+dist/
+build/
+.DS_Store
+venv/
+env/
+ .venv/
+.venv
+*.egg-info/
+# Ignore environment and secrets
+.env
+.env.bak
+
+# Python cache
+__pycache__/
+*.py[cod]
+
+# Generated images
+generated_images/
+
+# VS Code
+.vscode/
+
+# OS files
+Thumbs.db
+.DS_Store

HF_AUTH.md

@@ -0,0 +1,58 @@
+# Hugging Face Space authentication (quick guide)
+
+This repo can be pushed to a Hugging Face Space. Below are minimal steps to authenticate and configure your local folder so `git push` to the Space works.
+
+1) Install the CLI (in your venv)
+
+```powershell
+pip install --upgrade huggingface_hub
+# optional CLI helper
+pip install --upgrade huggingface-hub[cli]
+```
+
+2) Login interactively (recommended)
+
+```powershell
+huggingface-cli login
+# then paste your HF token when prompted
+```
+
+3) Or set token in `.env` (non-interactive)
+
+Add one of these lines to your `.env` (already used by helper scripts):
+
+```
+HF_TOKEN=hf_xxx...
+HUGGINGFACEHUB_API_TOKEN=hf_xxx...
+```
+
+4) Use the helper script to configure git remote (optional)
+
+Run in repo root (will print suggested remote and can add it):
+
+```powershell
+python hf_auth_setup.py
+```
+
+Or manually add remote (replace `<token>`, `<username>`, `<repo>`):
+
+```powershell
+git remote remove origin --no-optional || true
+git remote add origin https://<token>@huggingface.co/spaces/<username>/<repo>.git
+git push -u origin main
+```
+
+Note: embedding the token in the remote URL is convenient but the token will be visible in your local git config. Use `huggingface-cli login` or a credential helper for more secure usage.
+
+5) Space runtime Secrets
+
+In the Hugging Face Space UI set the following Secrets (Settings → Secrets):
+- `FB_PAGE_ACCESS_TOKEN`
+- `FB_PAGE_ID`
+- `REPLICATE_API_TOKEN`
+- `OPENAI_API_KEY` (if used)
+- `RUN_DAILY_REPLICATE` (set to `true` to enable scheduled runs)
+
+6) Troubleshooting
+- If `git push` fails with 403, verify the token scope and that the token is valid.
+- You can create a new token at: https://huggingface.co/settings/tokens (grant `read` and `write` as needed for repo creation/push).

README.md

@@ -0,0 +1,104 @@
+---
+title: Wisdom Poster
+emoji: "🪷"
+colorFrom: "indigo"
+colorTo: "teal"
+sdk: gradio
+sdk_version: "3.50.0"
+app_file: app.py
+pinned: false
+---
+
+# Wisdom Poster — Hugging Face Space
+
+This Space generates short wisdom text and a matching image, then posts the result to a Facebook Page. The app supports both OpenAI and Replicate image generation; it will try providers in the order configured by the `PROVIDER_ORDER` environment variable (default: `openai,replicate`).
+
+Quick setup (local)
+
+1. Install dependencies:
+
+```bash
+python -m pip install -r requirements.txt
+```
+
+2. Create a local `.env` (do NOT commit it). Example keys used by the app:
+
+- `FB_PAGE_ID` — the numeric Page ID
+- `FB_PAGE_ACCESS_TOKEN` — a Page access token with `pages_manage_posts` / publish permissions
+- `OPENAI_API_KEY` — (optional) OpenAI API key if using OpenAI image generation
+- `REPLICATE_API_TOKEN` — (optional) Replicate API key if using Replicate
+- `REPLICATE_MODEL` — (optional) default replicate model ref (owner/name:version), e.g. `google/nano-banana`
+- `PROVIDER_ORDER` — (optional) e.g. `replicate,openai` or `openai,replicate` (default `openai,replicate`)
+- `RUN_DAILY_REPLICATE` — (optional) `true` to enable scheduled daily runs inside `app.py`
+- `DAILY_INTERVAL_HOURS` — (optional) schedule interval in hours (default `24`)
+- `DAILY_PROMPT` — (optional) override prompt for scheduled runs
+
+Deploying to Hugging Face Spaces
+
+1. In your Space settings, set the following Secrets (Settings → Secrets):
+
+- `FB_PAGE_ACCESS_TOKEN`
+- `FB_PAGE_ID`
+- `REPLICATE_API_TOKEN` (if you plan to use Replicate)
+- `OPENAI_API_KEY` (if you plan to use OpenAI)
+- `PROVIDER_ORDER` (optional)
+- `RUN_DAILY_REPLICATE` (set to `true` to enable daily runs)
+
+2. Ensure `app.py` and `requirements.txt` are present at the repository root. The Space entrypoint is `app.py` (specified in the metadata above).
+
+Notes and recommendations
+
+- The app spawns a daemon background thread for scheduled runs when `RUN_DAILY_REPLICATE` is enabled. This works while the Space process is active but can be interrupted during redeploys — for guaranteed scheduling, use an external scheduler.
+- Keep your Space private if you do not want the public to access the UI or to expose functionality.
+- Monitor usage and API costs for OpenAI/Replicate.
+
+Troubleshooting
+
+- If the Space fails to start, check the `requirements.txt` includes all needed packages and that Secrets are set.
+- Use the Space logs (Settings → Logs) to inspect runtime errors.
+
+Minimal files to leave in the Space repo
+
+- `app.py` (entrypoint)
+- `requirements.txt`
+- `generate_image.py`, `generate_wisdom.py`, `post_to_facebook.py`
+- `.gitignore` (ignore `.env`, generated images)
+
+If you want, I can also add a short *Deploy checklist* file with exact steps and screenshot guidance for adding Secrets in the HF UI.
+# Post to Facebook Page
+
+This repository includes a small Python script to post a message to a Facebook Page using a Page Access Token stored in a `.env` file.
+
+Setup
+
+1. Install dependencies:
+
+```bash
+python -m pip install -r requirements.txt
+```
+
+2. Populate your `.env` (do not commit secrets). Example keys used by the script:
+
+- `FB_PAGE_ID` — the numeric Page ID
+- `FB_PAGE_ACCESS_TOKEN` — a Page access token with `pages_manage_posts` or appropriate publish permissions
+- `MESSAGE` — optional default message
+- `LINK` — optional link to attach
+
+Usage
+
+Run directly with a message:
+
+```bash
+python post_to_facebook.py --message "Hello from script"
+```
+
+Or rely on `MESSAGE` in `.env`:
+
+```bash
+python post_to_facebook.py
+```
+
+Notes
+
+- The script posts to the Graph API endpoint `/{page-id}/feed`.
+- If you need long-lived tokens or other flows, exchange tokens using Facebook's API before placing them in `.env`.

app.py

@@ -0,0 +1,162 @@
+import os
+import logging
+from dotenv import load_dotenv
+import gradio as gr
+import threading
+import requests
+from dotenv import load_dotenv
+
+load_dotenv()
+logging.basicConfig(level=logging.INFO, format="%(asctime)s %(levelname)s %(message)s")
+logger = logging.getLogger(__name__)
+
+from generate_wisdom import generate_wisdom
+from post_to_facebook import post_to_facebook
+from generate_image import generate_image, generate_and_post
+from generate_image import generate_and_post
+
+
+def generate_and_optionally_post(topic: str, do_post: bool):
+    try:
+        logger.info("Generating wisdom for topic: %s", topic)
+        wisdom = generate_wisdom(topic)
+    except Exception as e:
+        logger.exception("Failed to generate wisdom: %s", e)
+        return "Error generating wisdom: " + str(e), ""
+
+    if do_post:
+        page_id = os.getenv("FB_PAGE_ID")
+        token = os.getenv("FB_PAGE_ACCESS_TOKEN")
+        if not page_id or not token:
+            logger.error("Missing Facebook credentials in environment")
+            return wisdom, "Missing FB_PAGE_ID or FB_PAGE_ACCESS_TOKEN in environment"
+        try:
+            logger.info("Posting wisdom to Facebook page %s", page_id)
+            res = post_to_facebook(page_id, token, wisdom)
+            status = f"Posted to Facebook: {res.get('id') if isinstance(res, dict) else res}"
+        except Exception as e:
+            logger.exception("Failed to post to Facebook: %s", e)
+            status = "Failed to post to Facebook: " + str(e)
+    else:
+        status = "Not posted (preview only)"
+
+    return wisdom, status
+
+
+with gr.Blocks() as demo:
+    gr.Markdown("# Buddhism Wisdom Generator & Facebook Poster")
+    with gr.Row():
+        topic = gr.Textbox(label="Topic (optional)", placeholder="e.g. mindfulness, compassion")
+        do_post = gr.Checkbox(label="Post to Facebook", value=False)
+    with gr.Row():
+        image_prompt = gr.Textbox(label="Image prompt (optional)", placeholder="Prompt for image generation")
+        image_post = gr.Checkbox(label="Post image to Facebook", value=False)
+        force_replicate = gr.Checkbox(label="Force Replicate", value=False)
+    use_wisdom_for_image = gr.Checkbox(label="Use generated wisdom as image prompt", value=True)
+    generate_btn = gr.Button("Generate & Post")
+    output_text = gr.Textbox(label="Generated Wisdom", lines=3)
+    status = gr.Textbox(label="Status", lines=2)
+
+    img_btn = gr.Button("Generate Image & Post")
+    img_output = gr.Image(label="Generated Image")
+    img_status = gr.Textbox(label="Image Status", lines=2)
+
+    generate_btn.click(fn=generate_and_optionally_post, inputs=[topic, do_post], outputs=[output_text, status])
+    def _gen_img(prompt, do_post, use_wisdom, force_replicate):
+        if not prompt and not use_wisdom:
+            return None, "No image prompt provided and not using wisdom"
+        try:
+            provider_order = None
+            if force_replicate:
+                provider_order = "replicate,openai"
+            res = generate_and_post(prompt, caption=None, post=do_post, use_wisdom_as_prompt=use_wisdom, provider_order=provider_order)
+            img_path = res.get("image_path")
+            wisdom = res.get("wisdom")
+            fb = res.get("facebook")
+            status_text = "Saved: " + img_path
+            if wisdom:
+                status_text += " | Wisdom used: " + (wisdom if len(wisdom) < 120 else wisdom[:117] + "...")
+            if fb:
+                status_text += " | Posted: " + str(fb)
+            return img_path, status_text
+        except Exception as e:
+            return None, "Error: " + str(e)
+
+    img_btn.click(fn=_gen_img, inputs=[image_prompt, image_post, use_wisdom_for_image, force_replicate], outputs=[img_output, img_status])
+
+if __name__ == "__main__":
+    # Before launching, optionally start the daily Replicate job if enabled
+    def validate_tokens() -> bool:
+        """Validate that required tokens are present and usable."""
+        load_dotenv()
+        fb_token = os.getenv("FB_PAGE_ACCESS_TOKEN")
+        fb_page = os.getenv("FB_PAGE_ID")
+        rep_token = os.getenv("REPLICATE_API_TOKEN")
+        ok = True
+        if not fb_token or not fb_page:
+            logger.error("Facebook token or page id missing")
+            ok = False
+        else:
+            try:
+                r = requests.get(f"https://graph.facebook.com/me?access_token={fb_token}", timeout=10)
+                if r.status_code != 200:
+                    logger.warning("Facebook token validation returned %s: %s", r.status_code, r.text)
+                    ok = False
+            except Exception:
+                logger.exception("Facebook token validation failed")
+                ok = False
+
+        if not rep_token:
+            logger.error("Replicate token missing")
+            ok = False
+        else:
+            try:
+                r2 = requests.get("https://api.replicate.com/v1/models", headers={"Authorization": f"Token {rep_token}"}, timeout=10)
+                if r2.status_code not in (200, 401):
+                    # 401 means token invalid - still a valid response shape
+                    logger.warning("Replicate models check returned %s", r2.status_code)
+                # treat 200 as ok
+                if r2.status_code == 200:
+                    pass
+            except Exception:
+                logger.exception("Replicate token validation failed")
+                ok = False
+
+        return ok
+
+    run_daily = os.getenv("RUN_DAILY_REPLICATE", "false").lower() in ("1", "true", "yes")
+    if run_daily:
+        logger.info("RUN_DAILY_REPLICATE enabled — validating tokens before starting background job")
+        if validate_tokens():
+            def _bg():
+                interval_hours = int(os.getenv("DAILY_INTERVAL_HOURS", "24"))
+                while True:
+                    try:
+                        logger.info("Starting scheduled daily generate_and_post run")
+                        # reuse existing generate_and_post helper: generate image (using provider order) and post
+                        prompt = os.getenv("DAILY_PROMPT")
+                        if not prompt:
+                            prompt = '''Create a photorealistic, serene Buddhist scene at sunrise. A calm Buddha statue in side profile, seated in meditation on a stone platform. Soft golden morning light with gentle rim lighting. Misty mountains and ancient Buddhist temple stupas fading into the background, creating depth and a peaceful spiritual atmosphere. Subtle haze, warm earth tones, cinematic lighting, natural stone textures, shallow depth of field. A tranquil lotus flower near still reflective water in the foreground.
+
+Generate a short, original Buddhist-style quote about mindfulness, impermanence, inner peace, or awareness. The quote must be calm, timeless, and simple (no modern language, no slang). Keep it under 18 words.
+
+Overlay the generated quote text in the center of the image using an elegant serif or handwritten-style font. The text should be softly glowing, perfectly legible, minimal, and harmonious with the scene. Avoid bold, modern, or decorative typography.
+
+Ultra-realistic photography style, fine-art cinematic composition, calming mood, high detail, balanced contrast, 4K quality.'''
+                        try:
+                            res = generate_and_post(prompt, caption=None, post=True, use_wisdom_as_prompt=True, caption_template=None, use_wisdom_as_caption=True)
+                            logger.info("Scheduled run result: %s", res)
+                        except Exception:
+                            logger.exception("Scheduled run failed")
+                    except Exception:
+                        logger.exception("Scheduled background loop crashed")
+                    logger.info("Sleeping for %s hours before next scheduled run", interval_hours)
+                    time.sleep(interval_hours * 3600)
+
+            t = threading.Thread(target=_bg, daemon=True)
+            t.start()
+            logger.info("Started background daily generate_and_post thread")
+        else:
+            logger.error("Token validation failed — daily job will not start")
+
+    demo.launch()

check_hf.py

@@ -0,0 +1,26 @@
+from huggingface_hub import whoami, repo_info
+from dotenv import load_dotenv
+import os, json, traceback
+
+load_dotenv()
+TOKEN = os.getenv('HF')
+print('HF token present:', bool(TOKEN))
+if not TOKEN:
+    print('No HF token found in environment.')
+    raise SystemExit(1)
+
+try:
+    info = whoami(token=TOKEN)
+    print('whoami:')
+    print(json.dumps(info, indent=2))
+except Exception:
+    print('whoami error:')
+    traceback.print_exc()
+
+try:
+    ri = repo_info('gowshiselva/whispermonk', repo_type='space', token=TOKEN)
+    print('repo_info:')
+    print(json.dumps(ri.to_dict(), indent=2))
+except Exception:
+    print('repo_info error:')
+    traceback.print_exc()

create_space_and_push.py

@@ -0,0 +1,17 @@
+import os
+import sys
+import subprocess
+from dotenv import load_dotenv
+
+load_dotenv()
+HF_TOKEN = os.getenv("HF") or os.getenv("HUGGINGFACE_TOKEN") or os.getenv("HUGGINGFACE_HUB_TOKEN")
+if not HF_TOKEN:
+    print("ERROR: No HF token found in environment (.env). Set HF=<your token>")
+    sys.exit(1)
+
+"""
+ARCHIVED: create_space_and_push.py
+
+This helper was useful during initial development but is not required inside
+the Space repository. Kept here as an archive placeholder.
+"""

deploy_hf_space.py

@@ -0,0 +1,104 @@
+import os
+import subprocess
+import sys
+import time
+from pathlib import Path
+
+try:
+    from dotenv import load_dotenv
+except Exception:
+    load_dotenv = None
+
+try:
+    from huggingface_hub import HfApi
+except Exception:
+    HfApi = None
+
+ROOT = Path.cwd()
+
+def load_token():
+    if load_dotenv:
+        dotenv_path = ROOT / '.env'
+        if dotenv_path.exists():
+            load_dotenv(dotenv_path)
+    for name in ('HF_TOKEN', 'HUGGINGFACEHUB_API_TOKEN', 'HUGGINGFACE_HUB_TOKEN', 'HUGGINGFACE_TOKEN', 'HF'):
+        val = os.getenv(name)
+        if val:
+            return val
+    return None
+
+def run(cmd, check=True):
+    print('>', ' '.join(cmd))
+    res = subprocess.run(cmd, cwd=ROOT, stdout=subprocess.PIPE, stderr=subprocess.STDOUT, text=True)
+    print(res.stdout)
+    if check and res.returncode != 0:
+        raise SystemExit(res.returncode)
+    return res
+
+def ensure_git_init():
+    if not (ROOT / '.git').exists():
+        run(['git', 'init'])
+    # set main branch
+    run(['git', 'branch', '-M', 'main'], check=False)
+    # Only add/commit if there are changes
+    status = subprocess.run(['git', 'status', '--porcelain'], cwd=ROOT, stdout=subprocess.PIPE, stderr=subprocess.DEVNULL, text=True)
+    if status.stdout.strip():
+        # perform add/commit without capturing stdout to avoid blocking on large outputs/hooks
+        print('> git add .')
+        subprocess.run(['git', 'add', '.'], cwd=ROOT)
+        print('> git commit -m "Initial commit for HF Space"')
+        subprocess.run(['git', 'commit', '-m', 'Initial commit for HF Space'], cwd=ROOT)
+
+def create_space_and_push(token, repo_name=None, private=False):
+    if HfApi is None:
+        print('huggingface_hub not installed. Please run: python -m pip install huggingface_hub')
+        raise SystemExit(1)
+
+    api = HfApi()
+    who = api.whoami(token=token)
+    username = who.get('name') or who.get('user', {}).get('name')
+    if not username:
+        print('Unable to determine HF username via token.')
+        raise SystemExit(1)
+
+    if repo_name is None:
+        repo_name = ROOT.name
+
+    repo_id = f"{username}/{repo_name}"
+    print('Creating or ensuring Space:', repo_id)
+    try:
+        api.create_repo(repo_id=repo_id, repo_type='space', token=token, private=private, space_sdk='gradio')
+        print('Repository created or already exists.')
+    except Exception as e:
+        print('create_repo warning:', e)
+
+    # Use huggingface_hub.Repository helper to push with token
+    try:
+        from huggingface_hub import Repository
+        repo_local_dir = str(ROOT)
+        print('Using huggingface_hub.Repository to push files (handles auth).')
+        repo = Repository(local_dir=repo_local_dir, clone_from=repo_id, use_auth_token=token)
+        repo.push_to_hub(commit_message='Initial commit for HF Space')
+    except Exception as e:
+        print('Repository push via huggingface_hub failed:', e)
+        print('Falling back to adding token-embedded remote and git push (may fail if token invalid).')
+        remote = f"https://{token}@huggingface.co/spaces/{repo_id}.git"
+        # remove existing origin if points elsewhere
+        run(['git', 'remote', 'remove', 'origin'], check=False)
+        run(['git', 'remote', 'add', 'origin', remote])
+        run(['git', 'push', '-u', 'origin', 'main'], check=False)
+
+def main():
+    token = load_token()
+    if not token:
+        print('No HF token found in environment or .env. Set HF_TOKEN or HUGGINGFACEHUB_API_TOKEN in .env or env.')
+        sys.exit(2)
+
+    ensure_git_init()
+    create_space_and_push(token, repo_name=None, private=False)
+    print('\nDeploy complete. Visit your Space URL:')
+    time.sleep(0.5)
+    print('https://huggingface.co/spaces/{owner}/{repo}'.format(owner=HfApi().whoami(token=token).get('name'), repo=ROOT.name))
+
+if __name__ == '__main__':
+    main()

exchange_tokens.py

@@ -0,0 +1,166 @@
+import os
+import sys
+import requests
+from dotenv import load_dotenv
+
+
+def exchange_short_lived_token(app_id: str, app_secret: str, short_token: str) -> str:
+    url = "https://graph.facebook.com/v15.0/oauth/access_token"
+    params = {
+        "grant_type": "fb_exchange_token",
+        "client_id": app_id,
+        "client_secret": app_secret,
+        "fb_exchange_token": short_token,
+    }
+    r = requests.get(url, params=params)
+    r.raise_for_status()
+    data = r.json()
+    return data.get("access_token")
+
+
+def debug_token(app_id: str, app_secret: str, token: str) -> dict:
+    # uses the app access token (app_id|app_secret)
+    app_access = f"{app_id}|{app_secret}"
+    url = "https://graph.facebook.com/debug_token"
+    params = {"input_token": token, "access_token": app_access}
+    r = requests.get(url, params=params)
+    r.raise_for_status()
+    return r.json()
+
+
+def get_page_access_token(long_lived_user_token: str, page_id: str | None = None, page_name: str | None = None):
+    url = "https://graph.facebook.com/v15.0/me/accounts"
+    params = {"access_token": long_lived_user_token}
+    r = requests.get(url, params=params)
+    r.raise_for_status()
+    data = r.json().get("data", [])
+    for page in data:
+        if page_id and str(page.get("id")) == str(page_id):
+            return page.get("access_token"), page
+        if page_name and page.get("name") and page_name.lower() in page.get("name").lower():
+            return page.get("access_token"), page
+    return None, None
+
+
+def write_env_token(env_path: str, token: str):
+    # simple replacement or append
+    if not os.path.exists(env_path):
+        with open(env_path, "w", encoding="utf-8") as f:
+            f.write(f"FB_PAGE_ACCESS_TOKEN={token}\n")
+        return
+
+    with open(env_path, "r", encoding="utf-8") as f:
+        lines = f.readlines()
+
+    key = "FB_PAGE_ACCESS_TOKEN"
+    found = False
+    for i, ln in enumerate(lines):
+        if ln.strip().startswith(key + "="):
+            lines[i] = f"{key}={token}\n"
+            found = True
+            break
+
+    if not found:
+        # append
+        if not lines or not lines[-1].endswith("\n"):
+            lines.append("\n")
+        lines.append(f"{key}={token}\n")
+
+    # write backup then replace
+    bak = env_path + ".bak"
+    try:
+        if os.path.exists(env_path):
+            os.replace(env_path, bak)
+        with open(env_path, "w", encoding="utf-8") as f:
+            f.writelines(lines)
+    except Exception as e:
+        # attempt to restore
+        if os.path.exists(bak):
+            os.replace(bak, env_path)
+        raise e
+
+
+def main():
+    env_path = os.path.join(os.getcwd(), ".env")
+    # ensure we explicitly load the project's .env file
+    load_dotenv(env_path)
+
+    app_id = os.getenv("FB_APP_ID")
+    app_secret = os.getenv("FB_APP_SECRET")
+    page_id = os.getenv("FB_PAGE_ID")
+    page_name = os.getenv("FB_PAGE_NAME") or "whisper monk"
+    # accept a few possible env var names (typos included)
+    short_token = (
+        os.getenv("FB_USER_SHORT_TOKEN")
+        or os.getenv("FB_USER_TOKEN")
+        or os.getenv("FB_USER_TOEK")
+        or os.getenv("FB_USER_TOEKN")
+    )
+
+    if not app_id or not app_secret:
+        print("ERROR: FB_APP_ID and FB_APP_SECRET must be set in .env")
+        sys.exit(1)
+
+    if not short_token:
+        print("ERROR: No user token found in .env (FB_USER_SHORT_TOKEN or FB_USER_TOKEN).")
+        sys.exit(1)
+
+    # First, inspect the token. If it's already a Page token, accept it directly.
+    try:
+        dbg = debug_token(app_id, app_secret, short_token)
+    except requests.HTTPError as e:
+        print("Token debug failed — attempting direct page lookup with provided token...")
+        try:
+            page_token, page_info = get_page_access_token(short_token, page_id=page_id, page_name=page_name)
+        except requests.HTTPError as e2:
+            print("Direct page lookup failed:", e2.response.text if e2.response is not None else str(e2))
+            sys.exit(1)
+        if page_token:
+            print("Found page using the provided token:", page_info.get("name"))
+            write_env_token(env_path, page_token)
+            print(f"Wrote FB_PAGE_ACCESS_TOKEN to {env_path}")
+            return
+        print("No page found via direct lookup; giving up.")
+        sys.exit(1)
+
+    data = dbg.get("data", {})
+    token_type = data.get("type")
+    if token_type and token_type.upper() == "PAGE":
+        print("Token is already a Page token — writing directly to .env")
+        write_env_token(env_path, short_token)
+        print(f"Wrote FB_PAGE_ACCESS_TOKEN to {env_path}")
+        return
+
+    print("Exchanging short-lived user token for long-lived token...")
+    try:
+        long_lived = exchange_short_lived_token(app_id, app_secret, short_token)
+    except requests.HTTPError as e:
+        print("Token exchange failed:", e.response.text if e.response is not None else str(e))
+        sys.exit(1)
+
+    if not long_lived:
+        print("Failed to obtain long-lived user token")
+        sys.exit(1)
+
+    print("Long-lived user token obtained.")
+    print("Retrieving managed pages for the user...")
+    try:
+        page_token, page_info = get_page_access_token(long_lived, page_id=page_id, page_name=page_name)
+    except requests.HTTPError as e:
+        print("Failed to list pages:", e.response.text if e.response is not None else str(e))
+        sys.exit(1)
+
+    if not page_token:
+        print("No matching page found for", page_id or page_name)
+        sys.exit(1)
+
+    print("Found page:", page_info.get("name"), "(id:", page_info.get("id"), ")")
+    print("Page access token retrieved.")
+
+    # write into .env
+    write_env_token(env_path, page_token)
+    print(f"Wrote FB_PAGE_ACCESS_TOKEN to {env_path} (previous saved as {env_path}.bak)")
+
+
+if __name__ == "__main__":
+    main()

generate_image.py

@@ -0,0 +1,504 @@
+import os
+import time
+import base64
+import logging
+from dotenv import load_dotenv
+from generate_wisdom import generate_wisdom
+
+try:
+    from openai import OpenAI
+    openai_client = OpenAI()
+    openai_legacy = None
+except Exception:
+    try:
+        import openai as openai_legacy
+        openai_client = None
+    except Exception:
+        openai_client = None
+        openai_legacy = None
+
+import requests
+
+logging.basicConfig(level=logging.INFO, format="%(asctime)s %(levelname)s %(message)s")
+logger = logging.getLogger(__name__)
+
+
+def generate_image_hf(prompt: str, model: str = "stabilityai/stable-diffusion-2", size: str = "1024x1024", steps: int = 20, guidance: float = 7.5) -> bytes:
+    """Generate image bytes using Hugging Face Inference API as a fallback.
+
+    Tries the requested `model` first; if it's not available via the Inference API
+    (HTTP 410/404) the function will try a small list of common SD models.
+    """
+    load_dotenv()
+    hf_token = os.getenv("HF")
+    if not hf_token:
+        logger.error("HF token missing in environment (HF)")
+        raise RuntimeError("HF token missing in environment (HF)")
+
+    try:
+        width, height = (int(x) for x in size.split("x"))
+    except Exception:
+        width, height = 1024, 1024
+
+    candidate_models = [model, "runwayml/stable-diffusion-v1-5", "prompthero/openjourney"]
+    last_exc = None
+    for m in candidate_models:
+        url = f"https://api-inference.huggingface.co/models/{m}"
+        headers = {"Authorization": f"Bearer {hf_token}", "Accept": "application/json"}
+        payload = {
+            "inputs": prompt,
+            "parameters": {
+                "width": width,
+                "height": height,
+                "num_inference_steps": steps,
+                "guidance_scale": guidance,
+            },
+            "options": {"wait_for_model": True},
+        }
+
+        logger.info("Trying HF model %s (size=%sx%s, steps=%s)", m, width, height, steps)
+        try:
+            resp = requests.post(url, headers=headers, json=payload, timeout=120)
+            resp.raise_for_status()
+        except requests.HTTPError as e:
+            status = getattr(e.response, "status_code", None)
+            logger.warning("HF model %s returned HTTP %s", m, status)
+            last_exc = e
+            # try next candidate if model not hosted on inference API (410/Gone or 404)
+            if status in (404, 410):
+                # attempt Space /api/predict for public Spaces (owner/model -> /spaces/owner/model)
+                try:
+                    owner, repo = m.split("/", 1)
+                    space_url = f"https://huggingface.co/spaces/{owner}/{repo}/api/predict"
+                    logger.info("Trying Space API %s", space_url)
+                    sp_headers = {"Authorization": f"Bearer {hf_token}"} if hf_token else {}
+                    sp_payload = {"data": [prompt]}
+                    sp_resp = requests.post(space_url, headers=sp_headers, json=sp_payload, timeout=180)
+                    sp_resp.raise_for_status()
+                    js = sp_resp.json()
+                    # many Spaces return {'data': [...]} where the first item is base64 or url
+                    if isinstance(js, dict) and "data" in js:
+                        first = js["data"][0]
+                        if isinstance(first, str):
+                            # try base64 decode
+                            import re
+
+                            mobj = re.search(r"([A-Za-z0-9+/=]{200,})", first)
+                            if mobj:
+                                return base64.b64decode(mobj.group(1))
+                            # if it's a direct URL, try fetching bytes
+                            if first.startswith("http"):
+                                r2 = requests.get(first, timeout=60)
+                                r2.raise_for_status()
+                                return r2.content
+                    # if we reach here, the Space didn't return usable image; continue to next model
+                except Exception:
+                    logger.warning("Space API attempt for %s failed", m)
+                continue
+            raise
+
+        content_type = resp.headers.get("content-type", "")
+        if content_type.startswith("application/json"):
+            js = resp.json()
+            # Try common response shapes for base64-encoded image
+            b64 = None
+            if isinstance(js, dict):
+                for key in ("image", "generated_image", "data", "images"):
+                    if key in js:
+                        val = js[key]
+                        if isinstance(val, str):
+                            b64 = val
+                            break
+                        if isinstance(val, list) and val:
+                            first = val[0]
+                            if isinstance(first, dict) and "image_base64" in first:
+                                b64 = first["image_base64"]
+                                break
+                            if isinstance(first, str):
+                                b64 = first
+                                break
+            if not b64:
+                import re
+
+                txt = str(js)
+                mobj = re.search(r"([A-Za-z0-9+/=]{200,})", txt)
+                if mobj:
+                    b64 = mobj.group(1)
+            if not b64:
+                raise RuntimeError("No base64 image found in HF JSON response")
+            return base64.b64decode(b64)
+
+        # otherwise assume binary image content
+        return resp.content
+
+    # If loop exhausted, raise last exception
+    if last_exc:
+        raise last_exc
+    raise RuntimeError("Hugging Face image generation failed for all candidates")
+
+
+def generate_image_replicate(prompt: str, model: str | None = None, image_inputs: list | None = None, aspect_ratio: str = "match_input_image", output_format: str = "jpg") -> bytes:
+    """Generate image bytes using Replicate as a final fallback.
+
+    Requires `REPLICATE_API_TOKEN` in the environment.
+    """
+    load_dotenv()
+    token = os.getenv("REPLICATE_API_TOKEN")
+    if not token:
+        logger.error("REPLICATE_API_TOKEN missing in environment")
+        raise RuntimeError("REPLICATE_API_TOKEN missing in environment")
+
+    try:
+        import replicate
+    except Exception:
+        logger.exception("Replicate client not installed")
+        raise
+
+    # Build list of replicate model candidates: primary then alternates
+    if model is None:
+        primary = os.getenv("REPLICATE_MODEL")
+    else:
+        primary = model
+    alternates = os.getenv("REPLICATE_MODEL_ALTERNATES", "")
+    candidates = []
+    if primary:
+        candidates.append(primary)
+    if alternates:
+        for part in alternates.split(","):
+            part = part.strip()
+            if part and part not in candidates:
+                candidates.append(part)
+
+    if not candidates:
+        logger.error("No Replicate model configured (set REPLICATE_MODEL or REPLICATE_MODEL_ALTERNATES)")
+        raise RuntimeError("No Replicate model configured")
+
+    input_payload = {
+        "prompt": prompt,
+        "image_input": image_inputs or [],
+        "aspect_ratio": aspect_ratio,
+        "output_format": output_format,
+    }
+
+    last_exc = None
+    for cand in candidates:
+        logger.info("Calling Replicate candidate model %s", cand)
+        try:
+            output = replicate.run(cand, input=input_payload)
+            # if succeed, proceed to handle output
+            break
+        except Exception as e:
+            logger.warning("Replicate model %s failed: %s", cand, e)
+            last_exc = e
+            output = None
+            continue
+    if output is None:
+        logger.error("All Replicate candidates failed")
+        raise last_exc or RuntimeError("Replicate generation failed for all candidates")
+
+    # Replicate often returns a URL or a list of URLs
+    logger.info("Replicate output type: %s", type(output))
+    # handle common output shapes
+    if isinstance(output, str) and output.startswith("http"):
+        r = requests.get(output, timeout=120)
+        r.raise_for_status()
+        return r.content
+    if isinstance(output, list) and output:
+        first = output[0]
+        if isinstance(first, str) and first.startswith("http"):
+            r = requests.get(first, timeout=120)
+            r.raise_for_status()
+            return r.content
+        if isinstance(first, bytes):
+            return first
+    if isinstance(output, bytes):
+        return output
+    if isinstance(output, dict):
+        # try common fields
+        if "url" in output and isinstance(output["url"], str):
+            r = requests.get(output["url"], timeout=120)
+            r.raise_for_status()
+            return r.content
+        if "image" in output and isinstance(output["image"], str):
+            try:
+                return base64.b64decode(output["image"])
+            except Exception:
+                pass
+
+    raise RuntimeError("Unknown Replicate output format")
+
+
+def generate_image_replicate_poll(prompt: str, model: str | None = None, image_inputs: list | None = None, aspect_ratio: str = "match_input_image", output_format: str = "jpg", check_interval: int = 8, timeout: int = 600) -> bytes:
+    """Create a Replicate prediction and poll every `check_interval` seconds until finished.
+
+    Saves logs and returns raw image bytes when available. Requires `REPLICATE_API_TOKEN` and
+    `REPLICATE_MODEL` (or pass `model` param) to be set.
+    """
+    load_dotenv()
+    token = os.getenv("REPLICATE_API_TOKEN")
+    if not token:
+        logger.error("REPLICATE_API_TOKEN missing in environment")
+        raise RuntimeError("REPLICATE_API_TOKEN missing in environment")
+
+    # Build candidate list (primary then alternates)
+    if model is None:
+        primary = os.getenv("REPLICATE_MODEL")
+    else:
+        primary = model
+    alternates = os.getenv("REPLICATE_MODEL_ALTERNATES", "")
+    candidates = []
+    if primary:
+        candidates.append(primary)
+    if alternates:
+        for part in alternates.split(","):
+            part = part.strip()
+            if part and part not in candidates:
+                candidates.append(part)
+
+    if not candidates:
+        logger.error("No Replicate model configured (set REPLICATE_MODEL or REPLICATE_MODEL_ALTERNATES)")
+        raise RuntimeError("No Replicate model configured (REPLICATE_MODEL missing)")
+
+    url = "https://api.replicate.com/v1/predictions"
+    headers = {
+        "Authorization": f"Token {token}",
+        "Content-Type": "application/json",
+        "Accept": "application/json",
+    }
+
+    payload = {
+        "version": model,
+        "input": {
+            "prompt": prompt,
+            "image_input": image_inputs or [],
+            "aspect_ratio": aspect_ratio,
+            "output_format": output_format,
+        },
+    }
+
+    last_exc = None
+    for cand in candidates:
+        logger.info("Creating Replicate prediction for model %s", cand)
+        payload["version"] = cand
+        try:
+            resp = requests.post(url, headers=headers, json=payload, timeout=30)
+            resp.raise_for_status()
+        except Exception as e:
+            logger.warning("Replicate create failed for %s: %s", cand, e)
+            last_exc = e
+            continue
+        pred = resp.json()
+        pred_id = pred.get("id")
+        if not pred_id:
+            logger.warning("Replicate create returned no id for %s", cand)
+            last_exc = RuntimeError("Replicate did not return a prediction id")
+            continue
+
+        logger.info("Replicate prediction created: %s (model=%s)", pred_id, cand)
+        started = time.time()
+        status = pred.get("status")
+        while status in ("starting", "processing", "queued"):
+            if time.time() - started > timeout:
+                last_exc = RuntimeError("Replicate prediction timed out")
+                break
+            logger.info("Prediction %s status=%s — sleeping %ss", pred_id, status, check_interval)
+            time.sleep(check_interval)
+            r2 = requests.get(f"{url}/{pred_id}", headers=headers, timeout=30)
+            r2.raise_for_status()
+            pred = r2.json()
+            status = pred.get("status")
+
+        if status != "succeeded":
+            detail = pred.get("error") or pred.get("output")
+            logger.warning("Prediction %s failed with status=%s: %s", pred_id, status, detail)
+            last_exc = RuntimeError(f"Replicate prediction failed: {detail}")
+            continue
+
+        logger.info("Prediction %s succeeded (model=%s)", pred_id, cand)
+        output = pred.get("output")
+    # output is commonly a list of urls
+    if isinstance(output, list) and output:
+        first = output[0]
+        if isinstance(first, str) and first.startswith("http"):
+            logger.info("Downloading output from %s", first)
+            r3 = requests.get(first, timeout=120)
+            r3.raise_for_status()
+            return r3.content
+        if isinstance(first, bytes):
+            return first
+
+    if isinstance(output, str) and output.startswith("http"):
+        r3 = requests.get(output, timeout=120)
+        r3.raise_for_status()
+        return r3.content
+
+    # fallback: try to inspect nested structures
+    if isinstance(output, dict):
+        for k in ("image", "url", "output"):
+            v = output.get(k)
+            if isinstance(v, str) and v.startswith("http"):
+                r3 = requests.get(v, timeout=120)
+                r3.raise_for_status()
+                return r3.content
+
+    raise RuntimeError("Unknown Replicate prediction output format")
+
+
+def generate_image(prompt: str, size: str = "1024x1024", provider_order: str | None = None) -> str:
+    """Generate an image from `prompt`. Returns local path to saved image (PNG).
+
+    Behavior: tries providers in the order specified by the `PROVIDER_ORDER`
+    environment variable (comma-separated). Supported providers: `openai`,
+    `huggingface` (or `hf`), and `replicate`. If a provider fails, the code
+    moves to the next provider. Default: `openai,replicate`.
+    """
+    load_dotenv()
+    logger.info("Generating image for prompt: %s", prompt)
+
+    def generate_image_openai(local_prompt: str, local_size: str) -> bytes:
+        api_key = os.getenv("OPENAI_API_KEY")
+        if not api_key:
+            logger.error("OPENAI_API_KEY not set")
+            raise RuntimeError("OPENAI_API_KEY not set")
+        if openai_client is not None:
+            resp = openai_client.images.generate(model="gpt-image-1", prompt=local_prompt, size=local_size)
+            b64 = resp.data[0].b64_json
+            return base64.b64decode(b64)
+        elif openai_legacy is not None:
+            openai_legacy.api_key = api_key
+            resp = openai_legacy.Image.create(prompt=local_prompt, size=local_size, n=1)
+            b64 = resp["data"][0]["b64_json"]
+            return base64.b64decode(b64)
+        else:
+            raise RuntimeError("No OpenAI client available")
+
+    # Provider order from env, default to openai then replicate
+    if provider_order is None:
+        provider_order = os.getenv("PROVIDER_ORDER", "openai,replicate")
+    providers = [p.strip().lower() for p in provider_order.split(",") if p.strip()]
+    if not providers:
+        providers = ["openai", "replicate"]
+
+    img_bytes = None
+    last_exc = None
+    for provider in providers:
+        try:
+            logger.info("Trying provider: %s", provider)
+            if provider in ("openai", "oa"):
+                img_bytes = generate_image_openai(prompt, size)
+            elif provider in ("huggingface", "hf"):
+                img_bytes = generate_image_hf(prompt, size=size)
+            elif provider == "replicate":
+                # use polling replicate fallback (checks every 8s)
+                img_bytes = generate_image_replicate_poll(prompt, check_interval=8)
+            else:
+                logger.warning("Unknown provider '%s' — skipping", provider)
+                continue
+            # if generation succeeded, break loop
+            if img_bytes:
+                logger.info("Provider %s succeeded", provider)
+                break
+        except Exception as e:
+            logger.exception("Provider %s failed: %s", provider, e)
+            last_exc = e
+            continue
+
+    if not img_bytes:
+        logger.error("All providers failed")
+        if last_exc:
+            raise SystemExit(1) from last_exc
+        raise SystemExit(1)
+    out_dir = os.path.join(os.getcwd(), "generated_images")
+    os.makedirs(out_dir, exist_ok=True)
+    ts = int(time.time())
+    filename = f"image_{ts}.png"
+    path = os.path.join(out_dir, filename)
+    with open(path, "wb") as f:
+        f.write(img_bytes)
+
+    logger.info("Saved generated image to %s", path)
+    return path
+
+
+def post_image_to_facebook(page_id: str, access_token: str, image_path: str, caption: str | None = None) -> dict:
+    url = f"https://graph.facebook.com/{page_id}/photos"
+    data = {"access_token": access_token}
+    if caption:
+        data["caption"] = caption
+    logger.info("Uploading image %s to Facebook page %s", image_path, page_id)
+    with open(image_path, "rb") as imgf:
+        files = {"source": imgf}
+        resp = requests.post(url, files=files, data=data)
+    try:
+        resp.raise_for_status()
+    except requests.HTTPError:
+        logger.error("Facebook upload error: %s", resp.text)
+        raise
+    logger.info("Upload successful: %s", resp.json())
+    return resp.json()
+
+
+def generate_and_post(prompt: str, caption: str | None = None, post: bool = False, use_wisdom_as_prompt: bool = False, caption_template: str | None = None, use_wisdom_as_caption: bool = False, provider_order: str | None = None) -> dict:
+    # If requested, generate a short wisdom text and use it (or append) as the image prompt
+    image_prompt = prompt
+    wisdom_text = None
+    if use_wisdom_as_prompt:
+        try:
+            wisdom_text = generate_wisdom(prompt)
+            # If no explicit prompt provided, use the wisdom as the image prompt
+            if not image_prompt:
+                image_prompt = wisdom_text
+            else:
+                # combine both: image prompt + the wisdom quote to guide imagery
+                image_prompt = f"{image_prompt}. Quote: {wisdom_text}"
+        except Exception as e:
+            logger.exception("Failed to generate wisdom for image prompt: %s", e)
+            # proceed using the original prompt
+
+    img_path = generate_image(image_prompt, provider_order=provider_order)
+    result = {"image_path": img_path}
+    if wisdom_text:
+        result["wisdom"] = wisdom_text
+    if post:
+        load_dotenv()
+        page_id = os.getenv("FB_PAGE_ID")
+        token = os.getenv("FB_PAGE_ACCESS_TOKEN")
+        if not page_id or not token:
+            logger.error("Missing FB_PAGE_ID or FB_PAGE_ACCESS_TOKEN in environment")
+            raise SystemExit(1)
+
+        # build final caption: explicit caption wins; then caption_template; then wisdom if requested
+        final_caption = caption
+        if not final_caption and caption_template:
+            try:
+                final_caption = caption_template.format(prompt=prompt or "", wisdom=wisdom_text or "")
+            except Exception:
+                logger.exception("Failed to format caption_template")
+                final_caption = caption_template
+        if not final_caption and use_wisdom_as_caption and wisdom_text:
+            final_caption = wisdom_text
+
+        res = post_image_to_facebook(page_id, token, img_path, final_caption)
+        result["facebook"] = res
+    return result
+
+
+if __name__ == "__main__":
+    import argparse
+
+    parser = argparse.ArgumentParser(description="Generate an image via OpenAI and optionally post to Facebook")
+    parser.add_argument("-p", "--prompt", required=True, help="Prompt for image generation")
+    parser.add_argument("--caption", help="Caption to use when posting to Facebook")
+    parser.add_argument("--caption-template", help="Caption template, supports {prompt} and {wisdom}")
+    parser.add_argument("--use-wisdom-as-caption", action="store_true", help="Use generated wisdom as caption if available")
+    parser.add_argument("--post", action="store_true", help="Post image to Facebook after generation")
+    args = parser.parse_args()
+
+    res = generate_and_post(
+        args.prompt,
+        caption=args.caption,
+        post=args.post,
+        caption_template=args.caption_template,
+        use_wisdom_as_caption=args.use_wisdom_as_caption,
+    )
+    print(res)

generate_wisdom.py

@@ -0,0 +1,107 @@
+import os
+import logging
+import argparse
+from dotenv import load_dotenv
+
+try:
+    # new OpenAI v1 client
+    from openai import OpenAI
+    openai_client = OpenAI()
+    openai_legacy = None
+except Exception:
+    try:
+        import openai as openai_legacy
+        openai_client = None
+    except Exception:
+        openai_client = None
+        openai_legacy = None
+
+logging.basicConfig(level=logging.INFO, format="%(asctime)s %(levelname)s %(message)s")
+logger = logging.getLogger(__name__)
+
+
+def generate_wisdom(prompt: str | None = None, max_tokens: int = 120) -> str:
+    load_dotenv()
+    api_key = os.getenv("OPENAI_API_KEY")
+    if not api_key:
+        logger.error("OPENAI_API_KEY not found in environment")
+        raise SystemExit(1)
+
+    base_prompt = (
+        "You are a concise Buddhist teacher. Provide a short (1-3 sentence) piece of wisdom"
+        " suitable for a social media post. Keep it insightful, non-denominational, and respectful."
+    )
+    if prompt:
+        user_prompt = f"{base_prompt}\nTopic: {prompt}\n"
+    else:
+        user_prompt = base_prompt
+
+    logger.info("Requesting wisdom from OpenAI (max_tokens=%s)", max_tokens)
+
+    if openai_client is not None:
+        # new OpenAI v1 client
+        resp = openai_client.chat.completions.create(
+            model="gpt-3.5-turbo",
+            messages=[
+                {"role": "system", "content": "You generate short Buddhist wisdom quotes."},
+                {"role": "user", "content": user_prompt},
+            ],
+            max_tokens=max_tokens,
+            temperature=0.8,
+        )
+        # response shape: resp.choices[0].message.content
+        try:
+            text = resp.choices[0].message.content.strip()
+        except Exception:
+            # fallback to dict access
+            text = resp["choices"][0]["message"]["content"].strip()
+    elif openai_legacy is not None:
+        openai_legacy.api_key = api_key
+        resp = openai_legacy.ChatCompletion.create(
+            model="gpt-3.5-turbo",
+            messages=[
+                {"role": "system", "content": "You generate short Buddhist wisdom quotes."},
+                {"role": "user", "content": user_prompt},
+            ],
+            max_tokens=max_tokens,
+            temperature=0.8,
+        )
+        text = resp["choices"][0]["message"]["content"].strip()
+    else:
+        logger.error("No usable OpenAI client available (install openai package)")
+        raise SystemExit(1)
+    logger.info("Received wisdom: %s", text)
+    return text
+
+
+def main():
+    parser = argparse.ArgumentParser(description="Generate short Buddhism wisdom via OpenAI")
+    parser.add_argument("-p", "--prompt", help="Optional topic prompt")
+    parser.add_argument("--post", action="store_true", help="Post generated wisdom to Facebook using FB_PAGE_ACCESS_TOKEN in .env")
+    parser.add_argument("--dry-run", action="store_true", help="Print but do not post")
+    args = parser.parse_args()
+
+    wisdom = generate_wisdom(args.prompt)
+    print("Generated wisdom:\n", wisdom)
+
+    if args.post:
+        if args.dry_run:
+            logger.info("Dry run enabled — not posting to Facebook")
+            return
+        from post_to_facebook import post_to_facebook
+        from dotenv import load_dotenv
+
+        load_dotenv()
+        page_id = os.getenv("FB_PAGE_ID")
+        token = os.getenv("FB_PAGE_ACCESS_TOKEN")
+        if not page_id or not token:
+            logger.error("FB_PAGE_ID or FB_PAGE_ACCESS_TOKEN missing in environment")
+            raise SystemExit(1)
+        logger.info("Posting wisdom to Facebook page %s", page_id)
+        res = post_to_facebook(page_id, token, wisdom)
+        logger.info("Facebook response: %s", res)
+        print("Posted. Response:", res)
+
+
+if __name__ == "__main__":
+    main()

hf_auth_setup.py

@@ -0,0 +1,73 @@
+"""hf_auth_setup.py
+
+Helper to show / set the Hugging Face spaces git remote from an HF token.
+
+Usage: `python hf_auth_setup.py` — it will try to read token from `.env` and print the suggested remote URL.
+If you confirm, it can add the remote for you.
+"""
+import os
+import subprocess
+from pathlib import Path
+
+try:
+    from dotenv import load_dotenv
+except Exception:
+    load_dotenv = None
+
+ROOT = Path.cwd()
+
+def load_token():
+    if load_dotenv:
+        p = ROOT / '.env'
+        if p.exists():
+            load_dotenv(p)
+    for key in ('HF_TOKEN', 'HUGGINGFACEHUB_API_TOKEN', 'HUGGINGFACE_TOKEN', 'HUGGINGFACE_HUB_TOKEN', 'HF'):
+        v = os.getenv(key)
+        if v:
+            return v
+    return None
+
+def run(cmd):
+    print('>', ' '.join(cmd))
+    return subprocess.run(cmd, cwd=ROOT)
+
+def main():
+    token = load_token()
+    if not token:
+        print('No HF token found in .env or env. Run `huggingface-cli login` or set HF_TOKEN in .env')
+        return
+
+    repo = ROOT.name
+    username = None
+    # Try to discover username via huggingface_hub if available
+    try:
+        from huggingface_hub import HfApi
+        api = HfApi()
+        info = api.whoami(token=token)
+        username = info.get('name') or (info.get('user') or {}).get('name')
+    except Exception:
+        pass
+
+    if not username:
+        username = input('Hugging Face username (not found automatically): ').strip()
+        if not username:
+            print('Username required to compose remote. Exiting.')
+            return
+
+    remote = f"https://{token}@huggingface.co/spaces/{username}/{repo}.git"
+    print('\nSuggested remote URL:')
+    print(remote)
+    print('\nYou can add this remote (token will be stored in git config).')
+    ans = input('Add remote and push now? [y/N]: ').strip().lower()
+    if ans != 'y':
+        print('Done — you can add the remote manually if desired.')
+        return
+
+    # remove origin if exists
+    run(['git', 'remote', 'remove', 'origin'])
+    run(['git', 'remote', 'add', 'origin', remote])
+    run(['git', 'push', '-u', 'origin', 'main'])
+    print('Pushed to remote. Visit https://huggingface.co/spaces/{}/{}'.format(username, repo))
+
+if __name__ == '__main__':
+    main()

post_to_facebook.py

@@ -0,0 +1,72 @@
+import os
+import argparse
+import logging
+import requests
+from dotenv import load_dotenv
+
+logging.basicConfig(level=logging.INFO, format="%(asctime)s %(levelname)s %(message)s")
+logger = logging.getLogger(__name__)
+
+
+def post_to_facebook(page_id: str, access_token: str, message: str, link: str | None = None):
+    url = f"https://graph.facebook.com/{page_id}/feed"
+    payload = {"message": message, "access_token": access_token}
+    if link:
+        payload["link"] = link
+    logger.info("Posting to Facebook page %s", page_id)
+    resp = requests.post(url, data=payload)
+    try:
+        resp.raise_for_status()
+    except requests.HTTPError:
+        logger.error("Facebook API error: %s", resp.text)
+        raise
+    data = resp.json()
+    logger.info("Post successful: %s", data)
+    return data
+
+
+def main():
+    load_dotenv()
+    parser = argparse.ArgumentParser(description="Post a message to a Facebook Page using Page Access Token from .env")
+    parser.add_argument("-m", "--message", help="Message text to post (or set MESSAGE in .env)")
+    parser.add_argument("-l", "--link", help="Optional link to include")
+    parser.add_argument("--use-app-access", action="store_true", help="Attempt to post using the app access token (APP_ID|APP_SECRET)")
+    args = parser.parse_args()
+
+    # Prefer explicit env names already present in the repo
+    page_id = os.getenv("FB_PAGE_ID") or os.getenv("PAGE_ID")
+    access_token = os.getenv("FB_PAGE_ACCESS_TOKEN") or os.getenv("PAGE_ACCESS_TOKEN")
+    message = args.message or os.getenv("MESSAGE")
+    link = args.link or os.getenv("LINK")
+    use_app_access = args.use_app_access
+
+    # build app access token if requested
+    if use_app_access:
+        app_id = os.getenv("FB_APP_ID")
+        app_secret = os.getenv("FB_APP_SECRET")
+        if not app_id or not app_secret:
+            print("ERROR: FB_APP_ID and FB_APP_SECRET required to build app access token")
+            raise SystemExit(1)
+        access_token = f"{app_id}|{app_secret}"
+
+    if not page_id or not access_token:
+        logger.error("Missing FB_PAGE_ID or FB_PAGE_ACCESS_TOKEN in environment (.env)")
+        raise SystemExit(1)
+
+    if not message:
+        logger.error("No message provided (use --message or set MESSAGE in .env)")
+        raise SystemExit(1)
+
+    try:
+        result = post_to_facebook(page_id, access_token, message, link)
+    except requests.HTTPError as e:
+        details = e.response.text if e.response is not None else str(e)
+        logger.error("Facebook API request failed: %s", details)
+        raise SystemExit(1)
+
+    logger.info("Posted to Facebook page successfully: %s", result)
+    print("Posted to Facebook page successfully:", result)
+
+
+if __name__ == "__main__":
+    main()

push_to_space.py

@@ -0,0 +1,22 @@
+import os
+import subprocess
+import sys
+from dotenv import load_dotenv
+
+load_dotenv()
+HF = os.getenv('HF')
+"""
+ARCHIVED: push_to_space.py
+
+Not required in the deployed Space. Kept as an archive placeholder.
+"""
+subprocess.run(['git','remote','add','origin', remote_with_token], check=True)
+subprocess.run(['git','branch','-M','main'], check=False)
+print('Pushing to remote...')
+res = subprocess.run(['git','push','-u','origin','main'], check=False)
+if res.returncode != 0:
+    print('git push failed with code', res.returncode)
+    sys.exit(res.returncode)
+# replace remote with tokenless url
+subprocess.run(['git','remote','set-url','origin', remote_no_token], check=True)
+print('Push complete')

push_upload_to_space.py

@@ -0,0 +1,28 @@
+"""
+ARCHIVED: push_upload_to_space.py
+
+This helper has been archived and removed from active use inside the
+Space repository. If you need to programmatically upload, restore from
+your development copy or use the `huggingface_hub` CLI.
+"""
+import os
+from dotenv import load_dotenv
+from huggingface_hub import upload_folder
+
+load_dotenv()
+HF = os.getenv('HF')
+if not HF:
+    print('ERROR: HF token not found in .env as HF')
+    raise SystemExit(1)
+
+repo_id = 'gowshiselva/whispermonk'
+print('Uploading folder to', repo_id)
+upload_folder(
+    folder_path='.',
+    path_in_repo='.',
+    repo_id=repo_id,
+    repo_type='space',
+    token=HF,
+    ignore_patterns=['.git/*','generated_images/*','*.env','*.env.bak']
+)
+print('Upload complete')

replicate_daily_job.py

@@ -0,0 +1,9 @@
+"""
+ARCHIVED: replicate_daily_job.py
+
+This file was replaced with an archival placeholder. The scheduled daily job
+is now implemented inside `app.py` for Hugging Face Space deployment.
+
+If you need to restore or run the original standalone script, check
+your repository history or re-create the script from backups.
+"""

requirements.txt

@@ -0,0 +1,6 @@
+python-dotenv>=1.0.0
+requests>=2.0.0
+openai>=0.27.0
+gradio>=3.50.0
+replicate>=0.10.0
+huggingface-hub>=0.18.0

run_generate_and_post.py

@@ -0,0 +1,7 @@
+"""
+ARCHIVED: run_generate_and_post.py
+
+This helper runner was replaced with an archival placeholder. The Gradio
+app (`app.py`) now contains an optional scheduled daily job and can be used
+to run generation+post using the configured provider order.
+"""