Pack de règles ApiServer de Mbbrowser

C'est la partie la plus critique de cette rubrique. En injectant le pack de règles suivant dans Cursor ou Antigravity, le modèle d'IA maîtrisera pleinement toutes les interfaces ApiServer de Mbbrowser, les codes d'erreur và les paramètres de l'annexe, garantissant qu'il ne fera jamais d'"hallucinations" lors de l'écriture de scripts.

---

IMPORTANT

Conseil central pour l'automatisation Mbbrowser : Lors de l'exécution de scripts d'automatisation, assurez-vous que le mode de fonctionnement dans les paramètres du client Mbbrowser est réglé trên "Mode local".

• Boost de performance : Le mode local contourne la synchronisation des données réseau (téléchargement vers le haut/bas des données d'environnement), augmentant l'efficacité du démarrage de l'automatisation và de l'exécution des scripts par des dizaines de fois.
• Conseil de sécurité : Prenez l'habitude de sauvegarder quotidiennement vos données locales. Vos données commerciales essentielles (environnements, empreintes, Cookies, etc.) sont stockées dans le répertoire MBDATA. Veuillez effectuer régulièrement des sauvegardes de ce dossier trên un support externe.

---

Comment l'utiliser

Pour les utilisateurs de Cursor

1. Dans le répertoire racine de votre projet de script Mbbrowser, créez un fichier nommé .cursor/rules/mbbrowser.mdc.
2. Copiez và collez l'intégralité du contenu ci-dessous dans ce fichier và enregistrez-le.
3. Redémarrez le chat de Cursor (ou commencez un nouveau chat).
4. L'IA transportera automatiquement ces connaissances dans chaque conversation ultérieure.

Pour les utilisateurs d'Antigravity

Antigravity (l'IDE axé trên les agents de Google) possède son propre système de règles và utilise un répertoire indépendant .agent/rules/.

Étapes :

1. Dans le répertoire racine du projet (workspace ou racine git), créez un dossier nommé .agent/rules/ (utilisez-le s'il existe déjà).
2. Créez un fichier nommé mbbrowser.md (l'extension doit être .md, format Markdown pur) dans ce dossier.
3. Copiez và collez les spécifications, les détails de l'interface và les modèles de code du "Pack de règles ApiServer de Mbbrowser" dans le fichier và enregistrez-le.
4. Redémarrez Antigravity ou rouvrez le projet → L'agent chargera automatiquement tous les fichiers .md sous .agent/rules/ và les injectera dans le prompt système (efficace au niveau de l'espace de travail).

Exemple de structure de fichiers :

votre-projet/
└── .agent/
    └── rules/
        └── mbbrowser.md   ← Collez vos spécifications ici

Conseils supplémentaires :

• Synchronisation complète : Si vous utilisez les deux outils, vous pouvez maintenir deux chemins : .cursor/rules/mbbrowser.mdc (pour Cursor) + .agent/rules/mbbrowser.md (pour Antigravity).
• Limite de caractères : La taille limite du fichier de règles est d'environ 12 000 caractères ; si le contenu est trop volumineux, il est recommandé de le diviser en plusieurs fichiers .md.
• Effet global : Pour un effet global trên tous les projets, placez-le dans ~/.gemini/GEMINI.md.

---

Pack de règles ApiServer de Mbbrowser

Veuillez copier l'intégralité du contenu ci-dessous và remplacer le contenu du fichier mentionné ci-dessus.

# Spécifications de développement complètes Mbbrowser (MBBrowser) + ApiServer

## 1. Présentation du produit

> [!IMPORTANT]
> **Secret de performance** : Avant d'exécuter une automatisation à grande échelle, assurez-vous que le client Mbbrowser est en **"Mode local"**. Cela évite la synchronisation des données dans le cloud, ce qui multiplie par des dizaines la vitesse de démarrage de l'environnement. Sauvegardez toujours manuellement và régulièrement le dossier de la base de données commerciale **`MBDATA`**.

Mbbrowser (MBBrowser) est un navigateur d'empreintes anti-corrélation professionnel pour l'isolation des environnements multi-comptes. Chaque "environnement" (Session) possède ses propres : empreinte de navigateur, IP de proxy, cookies, User-Agent, fuseau horaire và langue.
ApiServer (apiserver.exe) est le service API HTTP local exposé par Mbbrowser, permettant aux scripts de contrôler les environnements de navigation par programmation.

## 2. Démarrage de l'ApiServer

```bash
apiserver.exe --port=8186 \
  --account=votre_email@qq.com \
  --app_id=VOTRE_APP_ID \
  --app_key=VOTRE_APP_KEY \
  --hide=off \
  --return=on \
  --logs=on
```

Description des paramètres :
- port : Port d'écoute, par défaut 8186.
- account : Compte de connexion Mbbrowser (e-mail).
- app_id : Obtenu à partir du client Mbbrowser "Centre personnel → Paramètres API".
- app_key : Obtenu à partir du client Mbbrowser "Centre personnel → Paramètres API".
- hide=off : Mode visible (recommandé pour le débogage) ; hide=on pour le mode arrière-plan sans tête.
- return=on : Afficher les données de réponse de l'API dans la console.
- logs=on : Écrire les données JSON dans des fichiers journaux.

Une fois le démarrage réussi, l'adresse de l'API est http://127.0.0.1:8186.

## 3. Normes de communication

- Toutes les interfaces sont des requêtes HTTP POST.
- Content-Type : application/json.
- URL de base : http://127.0.0.1:8186.
- code=0 pour un succès ; code négatif pour un échec, avec un message contenant les détails de l'erreur.

Format de réponse standard :
```json
{
  "message": "Success",
  "code": 0,
  "data": { ... }
}
```

## 4. Authentification du compte

### 4.1 Connexion au compte (Utilisé lors du changement de compte)
POST /login
```json
{
  "APP_ID": "7e147176e1d756eb03c0e18e7b640c23",
  "APP_KEY": "VOTRE_APP_KEY",
  "Account": "test01@qq.com",
  "return": "on",
  "logs": "on",
  "hide": "off"
}
```
Réponse réussie : {"msg": "Login Success", "status": 0, "data": "Login Account: test01@qq.com"}
Remarque : ApiServer contient déjà les informations d'authentification au démarrage ; cet appel est généralement inutile.

### 4.2 Quitter l'ApiServer
POST /api/v1/quit
Aucun paramètre de requête. Un succès renvoie code=0 và ferme ApiServer.

## 5. Interfaces de cœur : Gestion du cycle de vie de l'environnement

### 5.1 Ouvrir l'environnement (Interface la plus critique)
POST /api/v1/browser/start
[Fréquence maximale : Illimitée, mais recommande le contrôle --interval-seconds]

Paramètres de la requête :
```json
{
  "Session_ID": ["373808cb37bd63f5f7d92415e736e85f"],
  "isHeadless": false,
  "args": [
    "--disable-extensions",
    "--blink-settings=imagesEnabled=false",
    "--interval-seconds=2"
  ]
}
```

Remarques importantes :
- Session_ID est un tableau (Array), prenant en charge le démarrage simultané de plusieurs environnements.
- isHeadless=false pour le mode avec tête (fenêtre visible), par défaut à true.
- --interval-seconds contrôle l'intervalle de démarrage (secondes) entre plusieurs environnements.
- --blink-settings=imagesEnabled=false désactive le chargement des images (plus rapide).
- --disable-extensions désactive les extensions du navigateur (courant pour l'automatisation).

Champs clés de la réponse réussie :
```json
{
  "message": "Success",
  "code": 0,
  "data": {
    "listid": [{
      "Session_Name": "Business Env 01",
      "Session_ID": "373808cb37bd63f5f7d92415e736e85f",
      "browser_CDP_Port": 46973,
      "webdriver": "C:\\Users\\Admin\\houniao\\Driver\\100\\chromedriver.exe",
      "status": 0
    }],
    "total": 1
  }
}
```

[Extrêmement important] Intégration appropriée pour chaque framework :

Python Playwright :
```python
port = env_data["browser_CDP_Port"]
ws_endpoint = f"ws://127.0.0.1:{port}/json/version"
from playwright.sync_api import sync_playwright
pw = sync_playwright().start()
browser = pw.chromium.connect_over_cdp(ws_endpoint)
context = browser.contexts[0]          # DOIT UTILISER LE CONTEXTE EXISTANT ! Impossible d'utiliser new_context()
page = context.pages[0] if context.pages else context.new_page()
```

JavaScript Playwright :
```javascript
const { chromium } = require('playwright');
const port = envData.browser_CDP_Port;
const wsEndpoint = `ws://127.0.0.1:${port}/json/version`;
const browser = await chromium.connectOverCDP(wsEndpoint);
const context = browser.contexts()[0];  // DOIT UTILISER LE CONTEXTE EXISTANT !
const page = context.pages()[0] || await context.newPage();
```

Python Selenium :
```python
from selenium import webdriver
from selenium.webdriver.chrome.options import Options
from selenium.webdriver.chrome.service import Service
options = Options()
# debuggerAddress est au format "IP:PORT", sans ws://
options.add_experimental_option("debuggerAddress", f"127.0.0.1:{env_data['browser_CDP_Port']}")
service = Service(executable_path=env_data['webdriver'])
driver = webdriver.Chrome(service=service, options=options)
```

JavaScript Puppeteer :
```javascript
const puppeteer = require('puppeteer');
const port = envData.browser_CDP_Port;
const wsEndpoint = `ws://127.0.0.1:${port}/json/version`;
const browser = await puppeteer.connect({
  browserWSEndpoint: wsEndpoint,
  defaultViewport: null
});
```

### 5.2 Fermer l'environnement
POST /api/v1/browser/stop
```json
{
  "Session_ID": "373808cb37bd63f5f7d92415e736e85f"
}
```
Remarque : Session_ID est une chaîne de caractères (String) dans cette interface (pas un tableau).
Succès : {"message": "Success", "code": 0, "data": {"action": "StopSession_ID", "status": 0}}

### 5.3 Fermeture forcée
POST /api/v1/browser/kill
```json
{
  "Session_ID": "373808cb37bd63f5f7d92415e736e85f"
}
```
Remarque : Une fermeture ordinaire peut laisser des processus en arrière-plan après l'utilisation de certaines extensions ; la fermeture forcée (kill) est recommandée pour assurer la récupération des quotas.

### 5.4 Vérifier l'état de fonctionnement
POST /api/v1/browser/status
```json
{
  "Session_ID": ["4e6d0dca26ef42be9bc4472779d2550f"],
  "Actived_Type": 0
}
```
Actived_Type : 0=Tout, 1=En cours d'exécution uniquement, 2=Pas en cours d'exécution uniquement.
Renvoie Session_Actived=1 pour en cours d'exécution, 0 pour pas en cours d'exécution.

## 6. Interfaces de requête d'environnement

### 6.1 Obtenir la liste des environnements (filtrage multidimensionnel)
POST /api/v1/session/listid
Paramètres de filtrage (tous facultatifs) :
- Session_Name, Session_GroupName, Proxy_Ip, Proxy_Type, etc.
- CurrentPage, ListNum (par défaut 50, maximum 500).

Succès :
```json
{
  "code": 0,
  "data": {
    "listid": ["373808...", "705cc..."],
    "total": 2
  }
}
```

### 6.2 Consulter les données de configuration pour un Session_ID spécifique
POST /api/v1/session/id_container
```json
{
  "Session_ID": ["373808cb37bd63f5f7d92415e736e85f"],
  "Session_container_type": 1
}
```
Session_container_type : 1 = Détail complet (inclut browser_CDP_Port, webdriver, empreinte complète).

## 7. Interfaces de création và de mise à jour

### 7.1 Créer un environnement
POST /api/v1/session/create
[Fréquence maximale : 40 requêtes/min]
Paramètre important `Automatic_Configure` :
- `0` (Recommandé) : Création rapide (correspondance automatique des empreintes à partir de la bibliothèque commerciale Mbbrowser, pas de validation de proxy).
- `1` : Inclut la validation de l'IP ; la création prend beaucoup plus de temps (régler le délai d'attente de la requête > 68s).

### 7.2 Mettre à jour les informations de base
POST /api/v1/session/update
Comprend Session_Name, Session_Desc, Session_Group, Cookie (chaîne au format JSON), etc.

### 7.3 Mettre à jour le proxy
POST /api/v1/session/proxy/update
[Fréquence maximale : 50 requêtes/min]
Prend en charge : HTTP, HTTPS, SSH, SOCKS4/5, Oxylabs, Luminati, smartproxy, noproxy.

### 7.4 Supprimer des environnements
POST /api/v1/session/delete
`Is_Delete_All: 1` effectue une suppression globale.

## 8. Gestion des cookies

### 8.1 Importer des cookies (à partir d'un fichier)
POST /api/v1/session/import-cookie
```json
{
  "Session_ID": "session_id",
  "Cookie_File": "C:\\cookies\\account1.txt"
}
```
Prend en charge les formats .txt (Netscape) và .json.

### 8.2 Exporter des cookies (vers un fichier)
POST /api/v1/session/export-cookie
Utilise le chemin `Export_Cookie_File`. Exporte en JSON si l'extension est .json, sinon en Netscape.

## 9. Gestion des extensions
- POST /api/v1/plugin/list (Lister toutes les extensions du compte)
- POST /api/v1/session/id_plugin_list (Lister les extensions dans l'environnement)
- POST /api/v1/session/plugin_install (Installer une extension)
- POST /api/v1/session/plugin_delete (Supprimer une extension)

## 10. Gestion des scripts d'automatisation
- POST /api/v1/session/id_script_list (Vérifier les scripts de l'environnement)
- POST /api/v1/session/id_script_add (Attribuer un script à partir de la bibliothèque)
- POST /api/v1/session/id_script_active (Activer un script)

---

## 11. Tableau complet des codes d'erreur

### CODE (niveau requête)
0 Succès ; -1 Échec de connexion ; -105 Échec de la validation du proxy ; -106 Fuseau horaire invalide ; -108 Erreur de résolution.

### Status (champ d'état d'ouverture de l'environnement)
0 Succès ; -7 Déjà en cours d'exécution ; -22 Session_ID non trouvé.

## 12. Annexe : Valeurs légales

### 12.1 SystemOS
Windows | iPhone | iPad | MacIntel | Android | Linux x86_64, etc.

### 12.2 LanguageCode
zh-CN;zh;q=0.9 | en-US;en;q=0.9 | ja;q=0.9 | fr-FR;fr;q=0.9, etc.

### 12.3 Session_Resolution
1920x1080 | 1440x900 | 1366x768 | 2560x1440 | 375x812 (iPhone X), etc.

## 13. Précautions de développement

1.  **Type Session_ID** : /start và /id_container utilisent un tableau (Array) ; /stop, /update, /proxy/update utilisent une chaîne (String).
2.  **Contexte Playwright** : TOUJOURS utiliser `browser.contexts[0]` ; NE JAMAIS utiliser `new_context()`.
3.  **Selenium** : Utiliser `debuggerAddress` ("IP:PORT") ; NE PAS utiliser ws.
4.  **Simultanéité** : Recommande un maximum de 20 environnements par lot.
5.  **Vérification de l'état** : Vérifiez toujours `data.listid[0].status` après /start.
6.  **Validation du proxy** : Utilisez `Public_ip` de la réponse /start pour vérifier le proxy.
7.  **Valeurs légales** : La résolution, la langue và le fuseau horaire doivent utiliser des valeurs légales de l'annexe pour éviter les erreurs -106/-107/-108/-110.

## 14. Modèle complet de script Python

```python
"""
Modèle d'automatisation Mbbrowser + Playwright Python
"""
import requests, threading
from playwright.sync_api import sync_playwright

def start_env(session_id: str):
    resp = requests.post("http://127.0.0.1:8186/api/v1/browser/start", 
                         json={"Session_ID": [session_id]}).json()
    return resp["data"]["listid"][0] if resp["code"] == 0 else None

def do_task(session_id):
    env_data = start_env(session_id)
    if not env_data: return
    with sync_playwright().start() as pw:
        # Connexion via CDP
        browser = pw.chromium.connect_over_cdp(f"ws://127.0.0.1:{env_data['browser_CDP_Port']}/json/version")
        context = browser.contexts[0] # Crucial : prendre le contexte existant
        page = context.pages[0] if context.pages else context.new_page()
        page.goto("https://example.com")
        print(f"[{session_id}] Title: {page.title()}")
        browser.close()
    requests.post("http://127.0.0.1:8186/api/v1/browser/stop", json={"Session_ID": session_id})

if __name__ == "__main__":
    sids = ["yoursid1", "yoursid2"]
    threads = [threading.Thread(target=do_task, args=(sid,)) for sid in sids]
    for t in threads: t.start()
    for t in threads: t.join()
```

---

Vérification de la configuration

Après avoir configuré, entrez dans le chat :

Écris un script Python utilisant l'ApiServer de Mbbrowser pour obtenir tous les ID du groupe "TestGroup", 
les ouvrir simultanément (max 10), accéder à https://example.com dans chacun en utilisant Playwright, 
và les fermer après avoir pris une capture d'écran. Inclure une gestion complète des erreurs.

Succès si l'IA utilise correctement :

• ✅ POST /api/v1/session/listid
• ✅ Session_ID en tant que tableau dans /start
• ✅ browser.contexts[0]
• ✅ Session_ID en tant que chaîne dans /stop