Upload 2 files

Dockerfile

@@ -0,0 +1,115 @@
+###############################################################################
+# Dockerfile pour Hugging Face Spaces - Microsoft Rewards Script
+#
+# Ce Dockerfile :
+#   1. Clone le repo GitHub et compile le projet TypeScript
+#   2. Installe Python + Gradio pour l'interface web (port 7860)
+#   3. Lance app.py qui gère les credentials via les HF Secrets
+#
+# Secrets a configurer dans HF Spaces :
+#   - MS_ACCOUNTS : JSON array, ex: [{"email":"ton@mail.com","password":"tonmdp"}]
+#     ou bien separement :
+#   - MS_EMAIL : ton email Microsoft
+#   - MS_PASSWORD : ton mot de passe Microsoft
+###############################################################################
+
+FROM node:22-slim
+
+# Meta pour Hugging Face Spaces
+LABEL maintainer="user"
+LABEL description="Microsoft Rewards Script - Hugging Face Space"
+
+# Variables d'environnement
+ENV DEBIAN_FRONTEND=noninteractive \
+    PLAYWRIGHT_BROWSERS_PATH=0 \
+    NODE_ENV=production \
+    TZ=Europe/Paris \
+    FORCE_HEADLESS=1 \
+    PYTHONUNBUFFERED=1
+
+# Installer les dependances systeme : Python3, pip, cron, Chromium deps, git
+RUN apt-get update && apt-get install -y --no-install-recommends \
+    python3 \
+    python3-pip \
+    python3-venv \
+    git \
+    cron \
+    gettext-base \
+    tzdata \
+    ca-certificates \
+    curl \
+    libglib2.0-0 \
+    libdbus-1-3 \
+    libexpat1 \
+    libfontconfig1 \
+    libgtk-3-0 \
+    libnspr4 \
+    libnss3 \
+    libasound2 \
+    libflac12 \
+    libatk1.0-0 \
+    libatspi2.0-0 \
+    libdrm2 \
+    libgbm1 \
+    libdav1d6 \
+    libx11-6 \
+    libx11-xcb1 \
+    libxcomposite1 \
+    libxcursor1 \
+    libxdamage1 \
+    libxext6 \
+    libxfixes3 \
+    libxi6 \
+    libxrandr2 \
+    libxrender1 \
+    libxss1 \
+    libxtst6 \
+    libdouble-conversion3 \
+    && rm -rf /var/lib/apt/lists/* /var/cache/apt/archives/*
+
+# Repertoire de travail pour le script Microsoft Rewards
+WORKDIR /usr/src/microsoft-rewards-script
+
+# Cloner le repo
+RUN git clone https://github.com/TheNetsky/Microsoft-Rewards-Script.git /usr/src/microsoft-rewards-script
+
+# Installer les dependances Node.js et compiler
+RUN npm ci --ignore-scripts \
+    && npm run build \
+    && rm -rf node_modules \
+    && npm ci --omit=dev --ignore-scripts \
+    && npm cache clean --force
+
+# Installer le navigateur Chromium pour Playwright
+RUN npx playwright install --with-deps --only-shell chromium \
+    && rm -rf /root/.cache /tmp/* /var/tmp/*
+
+# Config par defaut : headless = true pour Docker
+RUN sed -i 's/"headless": false/"headless": true/' /usr/src/microsoft-rewards-script/src/config.json || true
+
+# Repertoire pour les sessions persistantes
+RUN mkdir -p /usr/src/microsoft-rewards-script/dist/sessions
+
+# Repertoire de travail pour l'app Python
+WORKDIR /app
+
+# Installer les dependances Python (Gradio + APScheduler)
+RUN pip3 install --no-cache-dir --break-system-packages \
+    gradio \
+    apscheduler
+
+# Copier l'application Python
+COPY app.py /app/app.py
+
+# Exposer le port 7860 (requis par Hugging Face Spaces)
+EXPOSE 7860
+
+# Utilisateur non-root pour HF Spaces
+RUN useradd -m -u 1000 appuser \
+    && chown -R appuser:appuser /app \
+    && chown -R appuser:appuser /usr/src/microsoft-rewards-script
+
+USER appuser
+
+# Lancer l'app Gradio
+CMD ["python3", "/app/app.py"]

app (1).py

@@ -0,0 +1,460 @@
+"""
+app.py - Microsoft Rewards Script pour Hugging Face Spaces
+
+Interface Gradio qui :
+  - Lit les credentials depuis les HF Secrets (variables d'environnement)
+  - Genere le fichier accounts.json automatiquement
+  - Lance le script Microsoft Rewards a intervalle regulier
+  - Affiche les logs en temps reel
+  - Permet de declencher manuellement une execution
+
+=== CONFIGURATION DES SECRETS HF ===
+
+Dans Settings > Repository secrets de votre Space, ajoutez :
+
+Option 1 (compte unique) :
+  MS_EMAIL      = votre_email@outlook.com
+  MS_PASSWORD   = votre_mot_de_passe
+
+Option 2 (multi-comptes, prevaut sur Option 1) :
+  MS_ACCOUNTS   = [{"email":"mail1@outlook.com","password":"mdp1"},{"email":"mail2@outlook.com","password":"mdp2"}]
+
+Optionnel :
+  CRON_SCHEDULE = 0 7,16,20 * * *   (defaut: 3 fois par jour)
+  RUN_ON_START  = true               (defaut: true)
+"""
+
+import json
+import os
+import subprocess
+import threading
+import time
+import signal
+import sys
+from datetime import datetime
+from pathlib import Path
+
+import gradio as gr
+from apscheduler.schedulers.background import BackgroundScheduler
+
+# === Constantes ===
+SCRIPT_DIR = Path("/usr/src/microsoft-rewards-script")
+DIST_DIR = SCRIPT_DIR / "dist"
+ACCOUNTS_FILE = DIST_DIR / "accounts.json"
+CONFIG_FILE = DIST_DIR / "config.json"
+LOG_FILE = Path("/app/rewards_script.log")
+MAX_LOG_LINES = 500
+
+# === Etat global ===
+is_running = False
+run_process = None
+
+
+def log_message(msg: str):
+    """Ajoute un message horodate au log."""
+    timestamp = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
+    line = f"[{timestamp}] {msg}"
+    print(line, flush=True)
+    try:
+        with open(LOG_FILE, "a", encoding="utf-8") as f:
+            f.write(line + "\n")
+    except Exception:
+        pass
+
+
+def read_log() -> str:
+    """Lit les dernieres lignes du fichier de log."""
+    try:
+        if LOG_FILE.exists():
+            with open(LOG_FILE, "r", encoding="utf-8") as f:
+                lines = f.readlines()
+            return "".join(lines[-MAX_LOG_LINES:])
+        return "Aucun log disponible."
+    except Exception as e:
+        return f"Erreur lecture log: {e}"
+
+
+def generate_accounts_json() -> bool:
+    """
+    Genere le fichier accounts.json a partir des secrets HF.
+    Priorite : MS_ACCOUNTS > MS_EMAIL + MS_PASSWORD
+    """
+    ms_accounts = os.environ.get("MS_ACCOUNTS", "").strip()
+    ms_email = os.environ.get("MS_EMAIL", "").strip()
+    ms_password = os.environ.get("MS_PASSWORD", "").strip()
+
+    accounts = []
+
+    if ms_accounts:
+        try:
+            accounts = json.loads(ms_accounts)
+            if not isinstance(accounts, list):
+                log_message("ERREUR: MS_ACCOUNTS doit etre un tableau JSON.")
+                return False
+            # Valider chaque entree
+            for acc in accounts:
+                if not acc.get("email") or not acc.get("password"):
+                    log_message(f"ERREUR: Compte invalide dans MS_ACCOUNTS: {acc}")
+                    return False
+                # Ajouter proxy par defaut si absent
+                if "proxy" not in acc:
+                    acc["proxy"] = {
+                        "proxyAxios": True,
+                        "url": "",
+                        "port": 0,
+                        "username": "",
+                        "password": ""
+                    }
+            log_message(f"Accounts charges depuis MS_ACCOUNTS: {len(accounts)} compte(s)")
+        except json.JSONDecodeError as e:
+            log_message(f"ERREUR: MS_ACCOUNTS n'est pas un JSON valide: {e}")
+            return False
+
+    elif ms_email and ms_password:
+        accounts = [
+            {
+                "email": ms_email,
+                "password": ms_password,
+                "proxy": {
+                    "proxyAxios": True,
+                    "url": "",
+                    "port": 0,
+                    "username": "",
+                    "password": ""
+                }
+            }
+        ]
+        log_message(f"Account charge depuis MS_EMAIL/MS_PASSWORD: {ms_email}")
+
+    else:
+        log_message("ERREUR: Aucun credential trouve ! Configurez MS_ACCOUNTS ou MS_EMAIL+MS_PASSWORD dans les secrets HF.")
+        return False
+
+    # Ecrire le fichier accounts.json dans dist/
+    try:
+        with open(ACCOUNTS_FILE, "w", encoding="utf-8") as f:
+            json.dump(accounts, f, indent=4)
+        log_message(f"Fichier accounts.json genere: {ACCOUNTS_FILE}")
+        return True
+    except Exception as e:
+        log_message(f"ERREUR: Impossible d'ecrire accounts.json: {e}")
+        return False
+
+
+def ensure_config():
+    """S'assure que config.json existe avec headless=true."""
+    try:
+        if CONFIG_FILE.exists():
+            with open(CONFIG_FILE, "r", encoding="utf-8") as f:
+                config = json.load(f)
+            # Forcer headless en mode Docker
+            config["headless"] = True
+            with open(CONFIG_FILE, "w", encoding="utf-8") as f:
+                json.dump(config, f, indent=4)
+            log_message("Config mise a jour: headless=true")
+        else:
+            default_config = {
+                "baseURL": "https://rewards.bing.com",
+                "sessionPath": "sessions",
+                "headless": True,
+                "parallel": False,
+                "runOnZeroPoints": False,
+                "clusters": 1,
+                "saveFingerprint": {"mobile": False, "desktop": False},
+                "workers": {
+                    "doDailySet": True,
+                    "doMorePromotions": True,
+                    "doPunchCards": True,
+                    "doDesktopSearch": True,
+                    "doMobileSearch": True,
+                    "doDailyCheckIn": True,
+                    "doReadToEarn": True
+                },
+                "searchOnBingLocalQueries": False,
+                "globalTimeout": "30s",
+                "searchSettings": {
+                    "useGeoLocaleQueries": False,
+                    "scrollRandomResults": True,
+                    "clickRandomResults": True,
+                    "searchDelay": {"min": "3min", "max": "5min"},
+                    "retryMobileSearchAmount": 2
+                },
+                "logExcludeFunc": ["SEARCH-CLOSE-TABS"],
+                "webhookLogExcludeFunc": ["SEARCH-CLOSE-TABS"],
+                "proxy": {"proxyGoogleTrends": True, "proxyBingTerms": True},
+                "webhook": {"enabled": False, "url": ""},
+                "conclusionWebhook": {"enabled": False, "url": ""}
+            }
+            with open(CONFIG_FILE, "w", encoding="utf-8") as f:
+                json.dump(default_config, f, indent=4)
+            log_message("Config par defaut creee avec headless=true")
+    except Exception as e:
+        log_message(f"ERREUR config: {e}")
+
+
+def run_script():
+    """Lance le script Microsoft Rewards et capture la sortie."""
+    global is_running, run_process
+
+    if is_running:
+        log_message("Script deja en cours d'execution, skip...")
+        return
+
+    is_running = True
+    log_message("=== Demarrage du script Microsoft Rewards ===")
+
+    # Regenerer accounts.json avant chaque run (au cas ou les secrets changent)
+    if not generate_accounts_json():
+        log_message("Impossible de generer accounts.json, abandon.")
+        is_running = False
+        return
+
+    ensure_config()
+
+    try:
+        env = os.environ.copy()
+        env["PLAYWRIGHT_BROWSERS_PATH"] = "0"
+        env["FORCE_HEADLESS"] = "1"
+
+        run_process = subprocess.Popen(
+            ["node", "./dist/index.js"],
+            cwd=str(SCRIPT_DIR),
+            stdout=subprocess.PIPE,
+            stderr=subprocess.STDOUT,
+            text=True,
+            env=env
+        )
+
+        # Lire la sortie en temps reel
+        for line in run_process.stdout:
+            line = line.strip()
+            if line:
+                log_message(f"[SCRIPT] {line}")
+
+        run_process.wait()
+        exit_code = run_process.returncode
+
+        if exit_code == 0:
+            log_message("=== Script termine avec succes ===")
+        else:
+            log_message(f"=== Script termine avec erreur (code: {exit_code}) ===")
+
+    except Exception as e:
+        log_message(f"ERREUR durant l'execution: {e}")
+    finally:
+        is_running = False
+        run_process = None
+
+
+def run_script_threaded():
+    """Lance le script dans un thread separé."""
+    thread = threading.Thread(target=run_script, daemon=True)
+    thread.start()
+
+
+def manual_run():
+    """Declenche manuellement le script depuis l'interface."""
+    if is_running:
+        return "⚠️ Le script est deja en cours d'execution. Patientez..."
+    run_script_threaded()
+    return "✅ Script lance ! Consultez les logs ci-dessous."
+
+
+def get_status():
+    """Retourne le statut actuel."""
+    if is_running:
+        return "🟡 En cours d'execution..."
+    return "🟢 En attente (prochain run selon le planning)"
+
+
+def get_next_run():
+    """Retourne l'heure du prochain run planifie."""
+    if scheduler.running:
+        jobs = scheduler.get_jobs()
+        if jobs:
+            next_time = jobs[0].next_run_time
+            if next_time:
+                return f"Prochain run: {next_time.strftime('%Y-%m-%d %H:%M:%S')}"
+    return "Planification non active"
+
+
+def refresh_logs():
+    """Rafraichit l'affichage des logs."""
+    return read_log()
+
+
+def refresh_status():
+    """Rafraichit l'affichage du statut."""
+    status = get_status()
+    next_run = get_next_run()
+    accounts_info = "Non configure"
+    if ACCOUNTS_FILE.exists():
+        try:
+            with open(ACCOUNTS_FILE, "r") as f:
+                accs = json.load(f)
+            emails = [a.get("email", "?") for a in accs]
+            accounts_info = f"{len(accs)} compte(s): {', '.join(emails)}"
+        except Exception:
+            accounts_info = "Erreur de lecture"
+
+    return f"{status}\n{next_run}\nComptes: {accounts_info}"
+
+
+# === Parse le cron schedule ===
+def parse_cron_schedule():
+    """Parse la variable CRON_SCHEDULE en composants APScheduler."""
+    schedule = os.environ.get("CRON_SCHEDULE", "0 7,16,20 * * *").strip()
+    parts = schedule.split()
+    if len(parts) != 5:
+        log_message(f"CRON_SCHEDULE invalide '{schedule}', utilisation du defaut")
+        parts = ["0", "7,16,20", "*", "*", "*"]
+
+    return {
+        "hour": parts[1],
+        "minute": parts[0],
+        "day": parts[2],
+        "month": parts[3],
+        "day_of_week": parts[4]
+    }
+
+
+# === Scheduler ===
+scheduler = BackgroundScheduler()
+
+# === Interface Gradio ===
+def build_ui():
+    with gr.Blocks(
+        title="Microsoft Rewards Script",
+        theme=gr.themes.Soft(),
+        css="""
+        .status-box { font-size: 16px; padding: 15px; border-radius: 8px; }
+        .log-box { font-family: monospace; font-size: 12px; }
+        """
+    ) as demo:
+        gr.Markdown(
+            """
+            # 🎁 Microsoft Rewards Script
+            Automatisation de Microsoft Rewards via [TheNetsky/Microsoft-Rewards-Script](https://github.com/TheNetsky/Microsoft-Rewards-Script)
+
+            ---
+            """
+        )
+
+        with gr.Row():
+            with gr.Column(scale=1):
+                gr.Markdown("### 📊 Statut")
+                status_display = gr.Textbox(
+                    value="Demarrage...",
+                    label="Statut actuel",
+                    interactive=False,
+                    lines=3,
+                    elem_classes=["status-box"]
+                )
+                refresh_status_btn = gr.Button("🔄 Rafraichir le statut", variant="secondary")
+                refresh_status_btn.click(fn=refresh_status, outputs=status_display)
+
+            with gr.Column(scale=1):
+                gr.Markdown("### 🚀 Execution manuelle")
+                run_btn = gr.Button("▶️ Lancer le script maintenant", variant="primary", size="lg")
+                run_output = gr.Textbox(label="Resultat", interactive=False)
+                run_btn.click(fn=manual_run, outputs=run_output)
+
+        gr.Markdown("### 📜 Logs")
+        log_display = gr.Textbox(
+            value="Chargement des logs...",
+            label="Logs du script",
+            interactive=False,
+            lines=20,
+            max_lines=50,
+            elem_classes=["log-box"]
+        )
+
+        with gr.Row():
+            refresh_log_btn = gr.Button("🔄 Rafraichir les logs", variant="secondary")
+            clear_log_btn = gr.Button("🗑️ Vider les logs")
+
+        refresh_log_btn.click(fn=refresh_logs, outputs=log_display)
+        clear_log_btn.click(fn=lambda: (open(LOG_FILE, "w").close() if LOG_FILE.exists() else None, "Logs effaces.")[1], outputs=log_display)
+
+        # Auto-refresh des logs toutes les 10 secondes
+        timer = gr.Timer(value=10)
+        timer.tick(fn=refresh_logs, outputs=log_display)
+        timer.tick(fn=refresh_status, outputs=status_display)
+
+        gr.Markdown(
+            """
+            ---
+            ### 🔐 Configuration des Secrets (HF Spaces > Settings > Repository secrets)
+
+            | Secret | Description | Exemple |
+            |--------|-------------|---------|
+            | `MS_EMAIL` | Email du compte Microsoft | `vous@outlook.com` |
+            | `MS_PASSWORD` | Mot de passe du compte | `votre_mot_de_passe` |
+            | `MS_ACCOUNTS` | Multi-comptes (JSON) | `[{"email":"m1@outlook.com","password":"p1"}]` |
+            | `CRON_SCHEDULE` | Planning cron (defaut: `0 7,16,20 * * *`) | `0 8 * * *` |
+            | `RUN_ON_START` | Lancer au demarrage (defaut: `true`) | `true` |
+
+            > **Note** : Si `MS_ACCOUNTS` est defini, il prevaut sur `MS_EMAIL` + `MS_PASSWORD`.
+            """
+        )
+
+    return demo
+
+
+# === Point d'entree ===
+if __name__ == "__main__":
+    log_message("=" * 50)
+    log_message("Microsoft Rewards Script - Hugging Face Space")
+    log_message("=" * 50)
+
+    # Verifier les credentials au demarrage
+    has_accounts = os.environ.get("MS_ACCOUNTS", "").strip()
+    has_email = os.environ.get("MS_EMAIL", "").strip()
+    has_password = os.environ.get("MS_PASSWORD", "").strip()
+
+    if has_accounts:
+        log_message("Mode multi-comptes detecte (MS_ACCOUNTS)")
+    elif has_email and has_password:
+        log_message(f"Mode compte unique detecte (MS_EMAIL={has_email})")
+    else:
+        log_message("⚠️ ATTENTION: Aucun credential configure !")
+        log_message("Ajoutez MS_EMAIL + MS_PASSWORD ou MS_ACCOUNTS dans les secrets HF.")
+
+    # Generer accounts.json au demarrage
+    generate_accounts_json()
+    ensure_config()
+
+    # Configurer le scheduler
+    cron_params = parse_cron_schedule()
+    log_message(f"Planning cron: minute={cron_params['minute']} heure={cron_params['hour']} jour={cron_params['day']} mois={cron_params['month']} jour_semaine={cron_params['day_of_week']}")
+
+    scheduler.add_job(
+        run_script_threaded,
+        "cron",
+        minute=cron_params["minute"],
+        hour=cron_params["hour"],
+        day=cron_params["day"],
+        month=cron_params["month"],
+        day_of_week=cron_params["day_of_week"],
+        id="rewards_daily_run",
+        name="Microsoft Rewards Daily Run"
+    )
+    scheduler.start()
+    log_message("Scheduler demarre")
+
+    # Lancer au demarrage si RUN_ON_START=true
+    if os.environ.get("RUN_ON_START", "true").lower() == "true":
+        log_message("RUN_ON_START=true => Lancement initial dans 30 secondes...")
+        # Petit delai pour laisser Gradio demarrer
+        threading.Timer(30, run_script_threaded).start()
+    else:
+        log_message("RUN_ON_START=false => Pas de lancement initial")
+
+    # Lancer l'interface Gradio (bloquant)
+    demo = build_ui()
+    demo.launch(
+        server_name="0.0.0.0",
+        server_port=7860,
+        show_error=True,
+        show_api=False
+    )