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

Không như Graph API chỉ hoạt động với Fanpage,Unlike the Graph API, which is limited to Pages, fbchat-v2 tích hợp sâu qua tài khoản cá nhân.integrates directly with personal accounts.

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

Mã nguồn được phân chia thành 3 lớp rõ ràng để dễ bảo trì.The codebase 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.3.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.3.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 bots, and other async frameworks already own an event loop. Inside a framework coroutine, use 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")from fbchat_v2._core._storage import EnvSessionStorage

storage = EnvSessionStorage("FBCHAT_COOKIES")
cookie = storage.load()
if not cookie:
    raise RuntimeError("Missing FBCHAT_COOKIES variable")

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átDo not use the client after leaving the async with khối.block.
• 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,
    "Hello",
    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,
    "Group notification",
    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,
    "Private notification",
    threadID=["10001", "10002"],
    typeChat="user",
    client=client,
)

result = await SendAPI().send(
    data_fb,
    "Nội dung trả lời",
    threadID="100012345678",
    typeChat="user",
    replyMessage=True,
    messageID="mid.$original",
    client=client,
)result = await SendAPI().send(
    data_fb,
    "Reply content",
    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õ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 a slow consumer. Do 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 applications because it is only a snapshot of the latest 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 the matching binary from GitHub Releases, place it in build/, or provide an 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. binary_path= truyền vào constructor.passed to the constructor.
2. Biến môi trường FBCHAT_E2EE_BIN.The FBCHAT_E2EE_BIN environment variable.
3. Đường dẫn mặc định trong build/.The default path under 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 compatibility sender for blocking integrations. New asyncio applications should reuse the listener and call the async methods 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 commandThe command 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.retains its legacy spelling for compatibility. Call sites must use this exact value; any other value returns 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 sangDo not run CPU-bound or blocking I/O work directly in a handler. Move blocking work to asyncio.to_thread(), process pool hoặc hàng đợi worker phù hợp., a process pool, or an appropriate 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")

Chặng 1 · v2.1.4 → v2.2.0: chuyển đổi asyncStage 1 · v2.1.4 → v2.2.0: async migration

Đây là chặng có thay đổi không tương thích ngược. Cần cập nhật call site, vòng đời listener, transport HTTP và đường import khi chuyển sang package.This stage contains backward-incompatible changes. Update call sites, listener lifecycle, HTTP transport, and import paths when moving to the package.

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()

Checklist chuyển API v2.1 → v2.2v2.1 → v2.2 API Checklist

1. Cố định phiên bản fbchat-v2==2.2.0 trong môi trường staging khi chuyển đổi call site.Pin fbchat-v2==2.2.0 in staging while migrating call sites.
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ọiCall asyncio.run(main()) tại điểm vào CLI duy nhất.only at the 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ờ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 trongAdd resource cleanup in a finally và kiểm thử cancellation.block 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.

Chặng 2 · v2.2.x → v2.3.0: siết vận hànhStage 2 · v2.2.x → v2.3.0: operational hardening

v2.3.0 không chủ động loại bỏ API Python công khai nào của dòng v2.2.x. Phần cần sửa nằm ở cách ứng dụng quản lý lỗi, client HTTP, listener E2EE và binary bridge; bỏ qua các ranh giới này thì code vẫn chạy được cho tới lúc production nổi drama.v2.3.0 does not intentionally remove any public Python API from the v2.2.x line. Applications must instead update how they manage errors, HTTP clients, E2EE listeners, and bridge binaries; ignoring those boundaries can produce failures that only surface in production.

1. Cố định source hoặc package ở 2.3.0 trong staging và xác minh version runtime trước khi rollout.Pin the source or package to 2.3.0 in staging and verify the runtime version before rollout.
2. Tiếp tục await mọi API async; code đồng bộ chỉ dùng wrapper *_blocking tương ứng.Continue to await every async API; synchronous code must use the matching *_blocking wrapper.
3. Với mutation archive, move-to-trash và unfriend, kiểm tra cả payload {"error": 1, ...}; HTTP 200 không đồng nghĩa thao tác thành công.For archive, move-to-trash, and unfriend mutations, also check for a {"error": 1, ...} payload; HTTP 200 does not mean the operation succeeded.
4. Ứng dụng tự tạo httpx.AsyncClient thì cũng phải đóng client trong lifecycle shutdown.An application that creates its own httpx.AsyncClient must also close it during shutdown.
5. Listener E2EE là single-use: sau khi dừng, tạo instance mới để reconnect và chờ require_e2ee=True trước khi gửi.An E2EE listener is single-use: after stopping it, create a new instance to reconnect and wait for require_e2ee=True before sending.
6. Giữ log_message_content và debug_errors ở false trừ khi đang debug trong môi trường cô lập không chứa dữ liệu thật.Keep log_message_content and debug_errors set to false unless debugging in an isolated environment without real data.
7. Windows ARM64 chưa có binary dựng sẵn; tự build bằng Go version trong bridge-e2ee/go.mod và xác minh SHA-256 trước khi chạy.Windows ARM64 has no prebuilt binary; build it with the Go version from bridge-e2ee/go.mod and verify its SHA-256 before use.

{
  "log_message_content": false,
  "debug_errors": false
}

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)],
    }

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

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

python scripts/release_artifacts.py validate \
  --release-tag v2.3.0

python scripts/release_artifacts.py verify \
  --release-tag v2.3.0 \
  --binaries-dir all-binaries \
  --dist-dir dist \
  --manifest all-binaries/SHA256SUMS

python scripts/verify_distribution.py \
  dist/fbchat_v2-2.3.0-py3-none-any.whl

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ử chạy trên Python 3.10, 3.11, 3.12, 3.13 và 3.14 đúng với ma trận CI của v2.3.The test suite runs on Python 3.10, 3.11, 3.12, 3.13, and 3.14, matching the v2.3 CI matrix.
• Workflow tạo đúng năm bridge binary cho Windows amd64, Linux và macOS amd64/arm64; Windows ARM64 phải tự build.The workflow produces exactly five bridge binaries for Windows amd64 plus Linux and macOS amd64/arm64; Windows ARM64 must be built manually.
• Đối chiếu SHA256SUMS, checksum nhúng trong package và provenance trước khi dùng artifact.Verify SHA256SUMS, checksums embedded in the package, and provenance before using an artifact.
• 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): document v2.3 operations.Commit using conventional format with scope, e.g. docs(website): document v2.3 operations.

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.