Một thư viện chat
cho Facebook, hiện đại hơn. A chat library
for Facebook, reimagined.

Vì sao chọn fbchat-v2Why choose fbchat-v2

Why fbchat-v2

Không như Graph API chỉ hoạt động với Fanpage,Unlike Graph API which only works with Fanpages, fbchat-v2 tích hợp sâu qua tài khoản cá nhân.integrates deeply through personal accounts.

Unlike the Graph API limited to fanpages, fbchat-v2 integrates deeply via user accounts.

Kiến trúc ba tầngThree-Layer Architecture

Three-Layer Architecture

Mã nguồn được phân chia thành 3 lớp rõ ràng để dễ bảo trì.The source code is divided into 3 clear layers for easy maintenance.

The project is split into three clear layers for maintainability.

python -m venv .venv

# Windows PowerShell
.venv\Scripts\Activate.ps1

# Linux / macOS
source .venv/bin/activate

python -m pip install --upgrade pip
python -m pip install "fbchat-v2==2.2.0"

from fbchat_v2._core._session import dataGetHome
from fbchat_v2._messaging._send import api as SendAPI

git clone --recurse-submodules https://github.com/m008v/fbchat-v2.git
cd fbchat-v2
python -m venv .venv
python -m pip install -e .

# Windows PowerShell
$env:PYTHONPATH = "src"
python src/main.py

# Linux / macOS
export PYTHONPATH=src
python src/main.py

from _core._session import dataGetHome
from _messaging._send import api as SendAPI

Yêu cầu hệ thốngSystem Requirements

Kiểm tra khả năng importCheck Import Capability

import asyncio

from fbchat_v2._core._session import dataGetHome
from fbchat_v2._messaging._send import api as SendAPI


async def main() -> None:
    assert callable(dataGetHome)
    assert callable(SendAPI().send)
    print("fbchat-v2 2.2.0 import OK")


asyncio.run(main())

data_fb = dataGetHome(cookie)
result = SendAPI().send(data_fb, "hello", user_id)
listener.connect_mqtt()

data_fb = await dataGetHome(cookie)
result = await SendAPI().send(data_fb, "hello", user_id)
task = asyncio.create_task(listener.connect_mqtt())

Điểm vào của ứng dụng CLICLI Application Entry Point

import asyncio


async def main() -> None:
    # Entire async workflow goes here.
    ...


if __name__ == "__main__":
    asyncio.run(main())

Khi ứng dụng đã có event loopWhen App Already Has an Event Loop

FastAPI, Jupyter, Discord bot hoặc framework async đã sở hữu event loop. Trong coroutine của framework, gọi await trực tiếp. Không lồng asyncio.run().FastAPI, Jupyter, Discord bot or async frameworks already have an event loop. Inside the framework's coroutine, call await directly. Do not nest asyncio.run().

Chạy đồng thời có kiểm soátControlled Concurrency

import asyncio
import httpx

from fbchat_v2._features._facebook import _notification, _search


async with httpx.AsyncClient(timeout=30) as client:
    async with asyncio.TaskGroup() as group:
        notification_task = group.create_task(
            _notification.func(data_fb, client=client)
        )
        search_task = group.create_task(
            _search.func(data_fb, "m008v", client=client)
        )

    notifications = notification_task.result()
    users = search_task.result()

Python 3.10 chưa hỗ trợ TaskGroup; hãy sử dụng asyncio.gather(). Luôn thiết lập timeout tại ranh giới tác vụ và không bỏ qua CancelledError.Python 3.10 does not support TaskGroup; use asyncio.gather(). Always configure timeouts at task boundaries and do not ignore CancelledError.

import asyncio

from fbchat_v2._core._session import dataGetHome


async def main() -> None:
    cookie = "c_user=...; xs=...; fr=...; datr=...;"
    data_fb = await dataGetHome(cookie)
    if data_fb is None:
        raise RuntimeError("Cookie expired or Facebook changed homepage token.")

    required = {
        "FacebookID",
        "fb_dtsg",
        "jazoest",
        "sessionID",
        "clientRevision",
        "cookieFacebook",
    }
    missing = [key for key in required if not data_fb.get(key)]
    if missing:
        raise RuntimeError(f"dataFB missing field: {', '.join(missing)}")


asyncio.run(main())

Hợp đồng dataFBdataFB Contract

Lưu trữ phiên cục bộLocal session storage

from pathlib import Path
from fbchat_v2._core._storage import FileSessionStorage

storage = FileSessionStorage(Path(".secrets/facebook-session.json"))
storage.save(cookie)
cookie = storage.load()
storage.clear()

from fbchat_v2._core._storage import EnvSessionStorage

storage = EnvSessionStorage("FBCHAT_COOKIES")
cookie = storage.load()
if not cookie:
    raise RuntimeError("Thiếu biến FBCHAT_COOKIES")

import asyncio
import httpx

from fbchat_v2._features._facebook import _notification, _search


timeout = httpx.Timeout(30.0, connect=10.0)
limits = httpx.Limits(max_connections=20, max_keepalive_connections=10)

async with httpx.AsyncClient(
    timeout=timeout,
    limits=limits,
    follow_redirects=True,
) as client:
    notifications, users = await asyncio.gather(
        _notification.func(data_fb, client=client),
        _search.func(data_fb, "Minh", client=client),
    )

Timeout tại ranh giới tác vụTimeout at Task Boundaries

try:
    result = await asyncio.wait_for(
        _search.func(data_fb, "query", client=client),
        timeout=20,
    )
except asyncio.TimeoutError:
    result = {"error": 1, "messages": "Search timed out."}

• Không chia sẻ một client giữa nhiều event loop ở các thread khác nhau.Do not share one client across multiple event loops in different threads.
• Không sử dụng client sau khi thoát .Do not use client after exiting .Không sử dụng client sau khi thoátDo not use client after exiting async with.
• Không tắt xác minh TLS để chữa lỗi chứng chỉ. Sửa CA/proxy của môi trường.Do not disable TLS verification to fix certificate errors. Fix the environment's CA/proxy.
• Không thử lại vô hạn đối với các request làm thay đổi trạng thái, chẳng hạn đăng bài hoặc gửi tin nhắn.Do not retry indefinitely for state-changing requests, such as posting or sending messages.

await SendAPI().send(
    dataFB,
    contentSend,
    threadID,
    typeAttachment=None,
    attachmentID=None,
    typeChat=None,
    replyMessage=None,
    messageID=None,
    client=None,
)

result = await SendAPI().send(
    data_fb,
    "Xin chào",
    threadID="100012345678",
    typeChat="user",
    client=client,
)

result = await SendAPI().send(
    data_fb,
    "Thông báo nhóm",
    threadID="987654321",
    typeChat=None,
    client=client,
)

result = await SendAPI().send(
    data_fb,
    "Thông báo riêng",
    threadID=["10001", "10002"],
    typeChat="user",
    client=client,
)

result = await SendAPI().send(
    data_fb,
    "Nội dung returns lời",
    threadID="100012345678",
    typeChat="user",
    replyMessage=True,
    messageID="mid.$original",
    client=client,
)

Xử lý kết quả trả vềHandling Responses

if not isinstance(result, dict):
    raise TypeError("Send API did not return dict.")
if result.get("error"):
    payload = result.get("payload") or {}
    raise RuntimeError(
        payload.get("error-description") or "Facebook rejected message sending."
    )

message_id = (result.get("payload") or {}).get("messageID")

from fbchat_v2._messaging import _attachments
from fbchat_v2._messaging._send import api as SendAPI


uploaded = await _attachments.func(
    "photo.jpg",
    data_fb,
    client=client,
    include_error=True,
)
if not uploaded or not uploaded.get("attachmentID"):
    raise RuntimeError(f"Upload failed: {uploaded}")

result = await SendAPI().send(
    data_fb,
    "Attached image",
    threadID="100012345678",
    typeChat="user",
    typeAttachment=uploaded["typeAttachment"],
    attachmentID=uploaded["attachmentID"],
    client=client,
)

Cấu trúc kết quả thành côngSuccess Result Structure

{
    "attachmentID": "123...",
    "attachmentUrl": "https://...",
    "videoDuration": None,
    "attachmentType": "image/jpeg",
    "typeAttachment": "image",
}

Tải lên nhiều tệpUploading Multiple Files

Parser hiện trả về phần tử metadata đầu tiên và không cung cấp danh sách tương ứng với toàn bộ đường dẫn. Quy trình đáng tin cậy là tải từng tệp, kiểm tra từng kết quả rồi truyền danh sách ID:The parser currently returns the first metadata element and does not provide a list corresponding to the entire path. A reliable process is to upload each file, check each result, and then pass the ID list:

attachment_ids = []
for path in ["a.jpg", "b.jpg"]:
    item = await _attachments.func(path, data_fb, client=client, include_error=True)
    if not item or not item.get("attachmentID"):
        raise RuntimeError(f"Could not upload {path}: {item}")
    attachment_ids.append(item["attachmentID"])

await SendAPI().send(
    data_fb,
    "Album",
    threadID=user_id,
    typeChat="user",
    typeAttachment="image",
    attachmentID=attachment_ids,
    client=client,
)

import asyncio

from fbchat_v2._messaging._listening import listeningEvent


listener = listeningEvent(data_fb, message_queue_maxsize=1000)
listener_task = asyncio.create_task(
    listener.connect_mqtt(),
    name="fbchat-mqtt-listener",
)

try:
    while True:
        if listener_task.done():
            listener_task.result()

        event = await listener.get_message(timeout=30)
        if event is None:
            continue
        print(event["body"], event["messageID"])
finally:
    await listener.disconnect()
    await listener_task

Cấu trúc sự kiện đã chuẩn hóaStandardized Event Structure

{
    "body": "ping",
    "timestamp": 1710000000000,
    "userID": "1000...",
    "messageID": "mid.$...",
    "replyToID": "thread-id",
    "type": "thread",
    "attachments": {"id": 0, "url": None},
    "mentions": [],
}

Hàng đợi có giới hạn và loại bỏ sự kiện cũ nhất khi đầy. Theo dõi để phát hiện consumer xử lý chậm. Không nên thăm dò trong ứng dụng mới vì đây chỉ là ảnh chụp trạng thái cuối cùng.Bounded queue that drops the oldest events when full. Monitor to detect slow consumers. Do not poll in new applications as this is only a snapshot of the final state.Hàng đợi có giới hạn và loại bỏ sự kiện cũ nhất khi đầy. Theo dõiThe queue is bounded and drops the oldest event when full. Monitor listener.droppedMessages để phát hiện consumer xử lý chậm. Không nên thăm dòto detect slow-processing consumers. You should not poll bodyResults trong ứng dụng mới vì đây chỉ là ảnh chụp trạng thái cuối cùng.in new apps because this is only a snapshot of the final state.

Phương thức 1 - sử dụng binary phát hành sẵnMethod 1 - Using Pre-built Binaries

Tải tệp phù hợp từ GitHub Releases, đặt vào thư mục build/ hoặc khai báo đường dẫn tuyệt đối:Download suitable files from GitHub Releases, put them in build/ directory or declare absolute path:

# Windows PowerShell
$env:FBCHAT_E2EE_BIN = "C:\path\to\fbchat-bridge-e2ee-windows-amd64.exe"

# Linux / macOS
chmod +x ./fbchat-bridge-e2ee-linux-amd64
export FBCHAT_E2EE_BIN=/absolute/path/fbchat-bridge-e2ee-linux-amd64

Phương thức 2 - biên dịch từ mã nguồnMethod 2 - Compile from Source

git submodule update --init --recursive bridge-e2ee/meta
Set-Location bridge-e2ee
go mod download
New-Item -ItemType Directory -Force ..\build | Out-Null
go build -ldflags="-s -w" -o ..\build\fbchat-bridge-e2ee.exe .
Set-Location ..
.\build\fbchat-bridge-e2ee.exe --help

git submodule update --init --recursive bridge-e2ee/meta
cd bridge-e2ee
go mod download
mkdir -p ../build
go build -ldflags="-s -w" -o ../build/fbchat-bridge-e2ee .
cd ..
./build/fbchat-bridge-e2ee --help

Thứ tự xác định binaryBinary resolution order

1. truyền vào constructor.pass to constructor.binary_path=
2. Biến môi trường FBCHAT_E2EE_BIN.Environment variable FBCHAT_E2EE_BIN.
3. Đường dẫn mặc định trong build/.Default path in build/.
4. Tự động tải tệp GitHub Release phù hợp nếu đường dẫn mặc định chưa tồn tại.Automatically download the suitable GitHub Release file if the default path does not exist.

import asyncio
import contextlib

from fbchat_v2._messaging._listening_e2ee import listeningE2EEEvent


async def run_e2ee(data_fb: dict) -> None:
    listener = listeningE2EEEvent(
        data_fb,
        log_level="none",
        e2ee_memory_only=True,
        enable_e2ee=True,
    )
    loop = asyncio.get_running_loop()
    events: asyncio.Queue[dict] = asyncio.Queue(maxsize=1000)

    def enqueue(event: dict) -> None:
        if events.full():
            with contextlib.suppress(asyncio.QueueEmpty):
                events.get_nowait()
        events.put_nowait(event)

    listener.on_message(
        lambda event: loop.call_soon_threadsafe(enqueue, event)
    )
    task = asyncio.create_task(
        listener.connect_mqtt(),
        name="fbchat-e2ee-listener",
    )

    try:
        ready = await asyncio.to_thread(
            listener.wait_until_connected,
            90,
            require_e2ee=True,
        )
        if not ready:
            raise TimeoutError("E2EE handshake has not completed.")

        while True:
            if task.done():
                task.result()
            event = await events.get()
            if event.get("type") not in {"e2eeMessage", "message"}:
                continue
            await handle_message(listener, event)
    finally:
        listener.stop()
        try:
            await asyncio.wait_for(task, timeout=5)
        except asyncio.TimeoutError:
            task.cancel()
            with contextlib.suppress(asyncio.CancelledError):
                await task

Các loại sự kiện quan trọngImportant Event Types

Cấu trúc e2eeMessagee2eeMessage Structure

{
    "type": "e2eeMessage",
    "data": {
        "id": "message-id",
        "text": "ping",
        "timestampMs": 1710000000000,
        "senderId": "1000...",
        "threadId": "...",
        "chatJid": "1000...@msgr",
        "senderJid": "1000...@msgr",
        "attachments": [],
        "mentions": [],
    },
}

Gửi và trả lời tin nhắn E2EESending & Replying E2EE Messages

data = event["data"]

result = await listener.send_e2ee_message(
    data["chatJid"],
    "pong",
    reply_to_id=data["id"],
    reply_to_sender_jid=data["senderJid"],
)

from fbchat_v2._messaging._bridge_actions import BridgeActions

if listener._bridge is None:
    raise RuntimeError("Bridge is not ready.")

actions = BridgeActions(listener._bridge)

Gửi ảnh E2EE mà không chặn event loopSend E2EE Images Without Blocking Event Loop

from pathlib import Path
import asyncio

image_bytes = await asyncio.to_thread(Path("photo.jpg").read_bytes)
result = await actions.send_e2ee_image(
    chat_jid,
    image_bytes,
    mime_type="image/jpeg",
    caption="Test image",
)

Quản lý và dọn trạng thái typingManage & Cleanup Typing State

await actions.send_e2ee_typing(chat_jid, True)
try:
    response = await build_response(message)
    await listener.send_e2ee_message(chat_jid, response)
finally:
    await actions.send_e2ee_typing(chat_jid, False)

_send_e2ee.api là sender tương thích dành cho tích hợp blocking. Ứng dụng asyncio mới nên tái sử dụng listener và gọi các method async nêu trên._send_e2ee.api is a compatible sender designed for blocking integration. New asyncio applications should reuse the listener and call the async methods mentioned above.

Quy trình sử dụng HTTP client dùng chungWorkflow Using Shared HTTP Client

import httpx

from fbchat_v2._features._facebook import (
    _get_user_info,
    _notification,
    _search,
)


async with httpx.AsyncClient(timeout=30) as client:
    search = await _search.func(data_fb, "m008v", client=client)
    profile = await _get_user_info.func(
        data_fb,
        "100012345678",
        client=client,
    )
    notifications = await _notification.func(data_fb, client=client)
    latest = notifications.get("NotificationResults", [])[:5]

from fbchat_v2._features._thread import (
    _addAdmin,
    _all_thread_data,
    _changeEmoji,
    _changeNameThread,
    _changeNickname,
)


threads = await _all_thread_data.func(data_fb, client=client)
if threads.get("error") or not threads.get("dataGet"):
    raise RuntimeError(f"Could not fetch thread: {threads}")

info = await _all_thread_data.features(
    threads["dataGet"],
    "thread-id",
    "threadInfomation",
)

await _changeNameThread.func(data_fb, "thread-id", "New name", client=client)
await _changeEmoji.func(data_fb, "thread-id", "🔥", client=client)
await _changeNickname.func(
    data_fb, "thread-id", "user-id", "Nickname", client=client
)
await _addAdmin.func(
    data_fb, "thread-id", "user-id", statusChoice=True, client=client
)

Tên command giữ nguyên cách viết legacy để bảo đảm tương thích. Call site phải sử dụng chính xác giá trị này; một giá trị khác sẽ trả về kết quả lỗi.The command name retains its legacy spelling to ensure compatibility. The call site must use this exact value; any other value will return an error.Tên commandCommand name threadInfomation giữ nguyên cách viết legacy để bảo đảm tương thích. Call site phải sử dụng chính xác giá trị này; một giá trị khác sẽ trả về kết quả lỗi.keeps legacy casing to ensure compatibility. Call sites must use exactly this value; any other value will return an error.

Cấu hình cục bộLocal configuration

{
  "botName": "fbchat-v2 demo bot",
  "prefix": "/",
  "cookies": "c_user=...; xs=...; fr=...; datr=...;",
  "admins": ["100012345678"],
  "version": "0.0.1"
}

Lệnh có sẵnAvailable Commands

Thêm lệnh mớiAdding New Commands

# In __init__
self._handlers["hello"] = self._cmd_hello


async def _cmd_hello(self, message: dict, argument: str) -> None:
    sender_id = str(message.get("userID") or "")
    if self.admins and sender_id not in self.admins:
        await self._reply(message, "You do not have permission to use this command.")
        return

    name = argument.strip() or "you"
    await self._reply(message, f"Hello {name}!")

Không thực thi tác vụ CPU-bound hoặc I/O blocking trực tiếp trong handler. Hãy chuyển tác vụ blocking sang , process pool hoặc hàng đợi worker phù hợp.Do not execute CPU-bound or I/O blocking tasks directly in the handler. Move blocking tasks to , process pool, or appropriate worker queues.Không thực thi tác vụ CPU-bound hoặc I/O blocking trực tiếp trong handler. Hãy chuyển tác vụ blocking sangDo not execute CPU-bound or I/O blocking tasks directly in the handler. Move blocking tasks to asyncio.to_thread(), process pool hoặc hàng đợi worker phù hợp., process pool or a suitable worker queue.

CoreCore

Messaging

Reaction, chỉnh sửa và thu hồiReaction, Edit & Unsend

from fbchat_v2._messaging import _editMessage, _reactions, _unsend

edited = await _editMessage.func(
    data_fb,
    "mid.$message",
    "New content",
)
reacted = await _reactions.func(
    data_fb,
    "ADD_REACTION",
    "mid.$message",
    "🔥",
    client=client,
)
removed = await _unsend.func(
    "mid.$message",
    data_fb,
    client=client,
)

Theme và Messenger NotesTheme & Messenger Notes

from fbchat_v2._messaging import _changeTheme, _createNotes

themes = await _changeTheme.listThemes(data_fb)
theme = await _changeTheme.findTheme(data_fb, "Love")
if theme.get("error"):
    raise RuntimeError(theme)
changed = await _changeTheme.changeTheme(
    data_fb,
    threadID="thread-id",
    themeName="Love",
)

current = await _createNotes.checkNote(data_fb)
created = await _createNotes.createNote(
    data_fb,
    text="Running async",
    privacy="FRIENDS",
)
deleted = await _createNotes.deleteNote(data_fb, noteID="note-id")

data_fb = dataGetHome(cookie)

data_fb = await dataGetHome(cookie)

result = _search.func(data_fb, "Minh")

result = await _search.func(data_fb, "Minh")

result = sender.send(data_fb, "hi", uid)

result = await sender.send(data_fb, "hi", uid)

threading.Thread(target=listener.connect_mqtt)

task = asyncio.create_task(listener.connect_mqtt())

func_async(...)
func_sync(...)

await func(...)

requests.Session()

httpx.AsyncClient()

Danh sách kiểm tra nâng cấpMigration Checklist

1. Nâng cấp package và cố định phiên bản fbchat-v2==2.2.0 trong môi trường staging.Upgrade package and pin version fbchat-v2==2.2.0 in staging environment.
2. Cập nhật mọi lời gọi API mạng để sử dụng await.Update all network API calls to use await.
3. Đổi import func_async/func_sync về func.Change import func_async/func_sync to func.
4. Chỉ gọi tại điểm vào CLI duy nhất.Only call at the single CLI entry point.Chỉ gọiOnly call asyncio.run(main()) tại điểm vào CLI duy nhất.at a single CLI entry point.
5. Tạo một httpx.AsyncClient theo lifecycle ứng dụng.Create a httpx.AsyncClient bound to app lifecycle.
6. Chuyển listener nền từ thread target sang asyncio task được quản lý.Move background listener from thread target to managed asyncio task.
7. Đối với E2EE, chờ trước khi gửi tin nhắn.For E2EE, wait for before sending messages.Đối với E2EE, chờFor E2EE, wait for require_e2ee=True trước khi gửi tin nhắn.before sending messages.
8. Bổ sung quy trình dọn tài nguyên trong và kiểm thử cancellation.Add resource cleanup in and test cancellation.Bổ sung quy trình dọn tài nguyên trongAdd a resource cleanup process in finally và kiểm thử cancellation.and test cancellation.
9. Kiểm tra dict kết quả thay vì giả định HTTP 200 luôn biểu thị thành công.Check result dict instead of assuming HTTP 200 means success.
10. Chạy toàn bộ bộ kiểm thử và smoke test bằng cookie thử nghiệm riêng trước khi triển khai với tài khoản production.Run full test suite and smoke test with separate test cookies before deploying with production accounts.

Không ghi dataFB vào nhật kýDo Not Log dataFB

def safe_session_status(data_fb: dict) -> dict:
    required = (
        "FacebookID",
        "fb_dtsg",
        "jazoest",
        "sessionID",
        "clientRevision",
        "cookieFacebook",
    )
    return {
        "facebook_id_present": bool(data_fb.get("FacebookID")),
        "missing_fields": [key for key in required if not data_fb.get(key)],
    }

pytest tests/ -v --tb=short
python -m compileall -q src tests
ruff check src tests
ruff format --check src tests
git diff --check

cd bridge-e2ee
go test ./...
go vet ./...
go build ./...

# Example upload asset after workflow builds
gh release upload v2.2.0 \
  fbchat-bridge-e2ee-windows-amd64.exe \
  fbchat-bridge-e2ee-linux-amd64 \
  fbchat-bridge-e2ee-linux-arm64 \
  fbchat-bridge-e2ee-darwin-amd64 \
  fbchat-bridge-e2ee-darwin-arm64 \
  --clobber

# Example upload asset after workflow builds
gh release upload v2.2.0 \
  fbchat-bridge-e2ee-windows-amd64.exe \
  fbchat-bridge-e2ee-linux-amd64 \
  fbchat-bridge-e2ee-linux-arm64 \
  fbchat-bridge-e2ee-darwin-amd64 \
  fbchat-bridge-e2ee-darwin-arm64 \
  --clobber

Danh sách kiểm tra phát hànhRelease Checklist

• Phiên bản trong package, tag, changelog và ghi chú phát hành phải khớp nhau.Versions in package, tag, changelog, and release notes must match.
• Bộ kiểm thử được chạy trên Python 3.10, 3.11, 3.12 hoặc ma trận phiên bản mà dự án công bố hỗ trợ.The test suite runs on Python 3.10, 3.11, 3.12, or the version matrix officially supported by the project.
• Bridge được biên dịch đầy đủ cho Windows, Linux và macOS với kiến trúc amd64 hoặc arm64 tương ứng.Bridge is fully compiled for Windows, Linux, and macOS with respective amd64 or arm64 architectures.
• Không đưa thông tin bí mật, cấu hình cục bộ, cơ sở dữ liệu, báo cáo nội bộ hoặc binary ngoài phạm vi vào staging area.Do not include secrets, local configs, databases, internal reports, or out-of-scope binaries in the staging area.
• Kiểm tra UTF-8 không hợp lệ, U+FFFD, NUL và dấu hiệu mojibake thực tế trước khi commit.Check for invalid UTF-8, U+FFFD, NUL, and actual mojibake signs before committing.
• Commit dùng conventional format có scope, ví dụ docs(website): expand async v2.2 documentation.Commit using conventional format with scope, e.g. docs(website): expand async v2.2 documentation.

Chúng tôi cam kết tạo ra một môi trường thân thiện, an toàn và hòa nhập cho tất cả mọi người. Mọi hành vi quấy rối hoặc không tôn trọng sẽ không được dung thứ. Mọi thành viên đóng góp đều phải sử dụng ngôn từ lịch sự và tôn trọng. We are committed to providing a friendly, safe and welcoming environment for all. Harassment or disrespect of any kind will not be tolerated. All contributors must use polite and respectful language.