From de4f3aeb74aae12742c1415f539276af1b45db5b Mon Sep 17 00:00:00 2001 From: Rixuan Shao <2023311022@bipt.edu.cn> Date: Sun, 17 May 2026 18:28:25 +0800 Subject: [PATCH] Import sanitized project structure and GitHub docs --- .gitignore | 14 + .../.github/workflows/schedule.yml | 41 + DouYinSparkFlow/.gitignore | 8 + DouYinSparkFlow/Dockerfile.server | 54 + DouYinSparkFlow/LICENSE | 21 + DouYinSparkFlow/README.md | 18 + DouYinSparkFlow/config.json | 40 + DouYinSparkFlow/core/__init__.py | 0 DouYinSparkFlow/core/browser.py | 63 + DouYinSparkFlow/core/friends.py | 134 ++ DouYinSparkFlow/core/login.py | 83 + DouYinSparkFlow/core/msg_builder.py | 129 ++ DouYinSparkFlow/core/protocol_dispatch.py | 279 +++ DouYinSparkFlow/core/protocol_sender.mjs | 728 +++++++ DouYinSparkFlow/core/tasks.py | 556 ++++++ DouYinSparkFlow/docker-compose.example.yml | 56 + DouYinSparkFlow/docs/images/image.png | Bin 0 -> 19699 bytes .../images/屏幕截图 2026-02-14 223607.png | Bin 0 -> 17981 bytes .../images/屏幕截图 2026-02-14 224614.png | Bin 0 -> 123891 bytes .../images/屏幕截图 2026-02-14 224915.png | Bin 0 -> 78819 bytes .../images/屏幕截图 2026-02-14 224951.png | Bin 0 -> 147828 bytes DouYinSparkFlow/login_desktop_server.py | 175 ++ DouYinSparkFlow/main.py | 64 + DouYinSparkFlow/relogin_worker.py | 261 +++ DouYinSparkFlow/requirements-web.txt | 5 + DouYinSparkFlow/requirements.txt | 22 + .../scripts/start_login_desktop.sh | 31 + DouYinSparkFlow/usersData.example.json | 1 + DouYinSparkFlow/utils/__init__.py | 0 .../utils/chinese_new_year_2026_mare.py | 933 +++++++++ DouYinSparkFlow/utils/config.py | 260 +++ DouYinSparkFlow/utils/github_action_config.py | 49 + DouYinSparkFlow/utils/hitokoto.py | 48 + DouYinSparkFlow/utils/logger.py | 54 + .../annotated_types-0.7.0-py3-none-any.whl | Bin 0 -> 13643 bytes .../webdeps/anyio-4.13.0-py3-none-any.whl | Bin 0 -> 114353 bytes .../webdeps/click-8.3.1-py3-none-any.whl | Bin 0 -> 108274 bytes .../colorama-0.4.6-py2.py3-none-any.whl | Bin 0 -> 25335 bytes .../webdeps/fastapi-0.115.6-py3-none-any.whl | Bin 0 -> 94843 bytes .../webdeps/h11-0.16.0-py3-none-any.whl | Bin 0 -> 37515 bytes .../vendor/webdeps/idna-3.11-py3-none-any.whl | Bin 0 -> 71008 bytes .../itsdangerous-2.2.0-py3-none-any.whl | Bin 0 -> 16234 bytes .../webdeps/jinja2-3.1.6-py3-none-any.whl | Bin 0 -> 134899 bytes ...inux_2_17_x86_64.manylinux_2_28_x86_64.whl | Bin 0 -> 20681 bytes .../webdeps/pydantic-2.12.5-py3-none-any.whl | Bin 0 -> 32768 bytes DouYinSparkFlow/webui/__init__.py | 1 + DouYinSparkFlow/webui/app.py | 646 ++++++ DouYinSparkFlow/webui/auth.py | 73 + DouYinSparkFlow/webui/login_sessions.py | 1275 ++++++++++++ DouYinSparkFlow/webui/ops.py | 407 ++++ DouYinSparkFlow/webui/static/.gitkeep | 1 + .../webui/static/multiPagePlugins.zip | Bin 0 -> 74886 bytes .../webui/static/multiPagePlugins/README.md | 446 +++++ .../static/multiPagePlugins/background.js | 1767 +++++++++++++++++ .../content/cloudflare-temp-email.js | 531 +++++ .../multiPagePlugins/content/duck-mail.js | 74 + .../multiPagePlugins/content/inbucket-mail.js | 258 +++ .../multiPagePlugins/content/mail-163.js | 296 +++ .../multiPagePlugins/content/qq-mail.js | 147 ++ .../multiPagePlugins/content/relay-firefox.js | 265 +++ .../multiPagePlugins/content/signup-page.js | 569 ++++++ .../static/multiPagePlugins/content/utils.js | 337 ++++ .../multiPagePlugins/content/vps-panel.js | 183 ++ .../static/multiPagePlugins/data/names.js | 38 + .../static/multiPagePlugins/icons/icon128.png | Bin 0 -> 2800 bytes .../static/multiPagePlugins/icons/icon16.png | Bin 0 -> 327 bytes .../static/multiPagePlugins/icons/icon48.png | Bin 0 -> 1062 bytes .../static/multiPagePlugins/manifest.json | 78 + .../shared/cloudflare-temp-email.js | 389 ++++ .../multiPagePlugins/shared/email-provider.js | 99 + .../multiPagePlugins/shared/oauth-flow.js | 85 + .../static/multiPagePlugins/shared/qq-mail.js | 67 + .../multiPagePlugins/sidepanel/sidepanel.css | 669 +++++++ .../multiPagePlugins/sidepanel/sidepanel.html | 179 ++ .../multiPagePlugins/sidepanel/sidepanel.js | 636 ++++++ .../tests/cloudflare-temp-email.test.js | 221 +++ .../tests/email-provider.test.js | 106 + .../tests/oauth-consent.test.js | 102 + .../multiPagePlugins/tests/qq-mail.test.js | 59 + DouYinSparkFlow/webui/static/styles.css | 527 +++++ DouYinSparkFlow/webui/templates/base.html | 1039 ++++++++++ .../webui/templates/dashboard.html | 731 +++++++ DouYinSparkFlow/webui/templates/login.html | 117 ++ DouYinSparkFlow/webui/templates/logs.html | 17 + README.md | 42 +- docker-compose.yml | 84 + refresh_proxy.sh | 9 + 87 files changed, 16696 insertions(+), 1 deletion(-) create mode 100644 .gitignore create mode 100644 DouYinSparkFlow/.github/workflows/schedule.yml create mode 100644 DouYinSparkFlow/.gitignore create mode 100644 DouYinSparkFlow/Dockerfile.server create mode 100644 DouYinSparkFlow/LICENSE create mode 100644 DouYinSparkFlow/README.md create mode 100644 DouYinSparkFlow/config.json create mode 100644 DouYinSparkFlow/core/__init__.py create mode 100644 DouYinSparkFlow/core/browser.py create mode 100644 DouYinSparkFlow/core/friends.py create mode 100644 DouYinSparkFlow/core/login.py create mode 100644 DouYinSparkFlow/core/msg_builder.py create mode 100644 DouYinSparkFlow/core/protocol_dispatch.py create mode 100644 DouYinSparkFlow/core/protocol_sender.mjs create mode 100644 DouYinSparkFlow/core/tasks.py create mode 100644 DouYinSparkFlow/docker-compose.example.yml create mode 100644 DouYinSparkFlow/docs/images/image.png create mode 100644 DouYinSparkFlow/docs/images/屏幕截图 2026-02-14 223607.png create mode 100644 DouYinSparkFlow/docs/images/屏幕截图 2026-02-14 224614.png create mode 100644 DouYinSparkFlow/docs/images/屏幕截图 2026-02-14 224915.png create mode 100644 DouYinSparkFlow/docs/images/屏幕截图 2026-02-14 224951.png create mode 100644 DouYinSparkFlow/login_desktop_server.py create mode 100644 DouYinSparkFlow/main.py create mode 100644 DouYinSparkFlow/relogin_worker.py create mode 100644 DouYinSparkFlow/requirements-web.txt create mode 100644 DouYinSparkFlow/requirements.txt create mode 100644 DouYinSparkFlow/scripts/start_login_desktop.sh create mode 100644 DouYinSparkFlow/usersData.example.json create mode 100644 DouYinSparkFlow/utils/__init__.py create mode 100644 DouYinSparkFlow/utils/chinese_new_year_2026_mare.py create mode 100644 DouYinSparkFlow/utils/config.py create mode 100644 DouYinSparkFlow/utils/github_action_config.py create mode 100644 DouYinSparkFlow/utils/hitokoto.py create mode 100644 DouYinSparkFlow/utils/logger.py create mode 100644 DouYinSparkFlow/vendor/webdeps/annotated_types-0.7.0-py3-none-any.whl create mode 100644 DouYinSparkFlow/vendor/webdeps/anyio-4.13.0-py3-none-any.whl create mode 100644 DouYinSparkFlow/vendor/webdeps/click-8.3.1-py3-none-any.whl create mode 100644 DouYinSparkFlow/vendor/webdeps/colorama-0.4.6-py2.py3-none-any.whl create mode 100644 DouYinSparkFlow/vendor/webdeps/fastapi-0.115.6-py3-none-any.whl create mode 100644 DouYinSparkFlow/vendor/webdeps/h11-0.16.0-py3-none-any.whl create mode 100644 DouYinSparkFlow/vendor/webdeps/idna-3.11-py3-none-any.whl create mode 100644 DouYinSparkFlow/vendor/webdeps/itsdangerous-2.2.0-py3-none-any.whl create mode 100644 DouYinSparkFlow/vendor/webdeps/jinja2-3.1.6-py3-none-any.whl create mode 100644 DouYinSparkFlow/vendor/webdeps/markupsafe-3.0.3-cp310-cp310-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl create mode 100644 DouYinSparkFlow/vendor/webdeps/pydantic-2.12.5-py3-none-any.whl create mode 100644 DouYinSparkFlow/webui/__init__.py create mode 100644 DouYinSparkFlow/webui/app.py create mode 100644 DouYinSparkFlow/webui/auth.py create mode 100644 DouYinSparkFlow/webui/login_sessions.py create mode 100644 DouYinSparkFlow/webui/ops.py create mode 100644 DouYinSparkFlow/webui/static/.gitkeep create mode 100644 DouYinSparkFlow/webui/static/multiPagePlugins.zip create mode 100644 DouYinSparkFlow/webui/static/multiPagePlugins/README.md create mode 100644 DouYinSparkFlow/webui/static/multiPagePlugins/background.js create mode 100644 DouYinSparkFlow/webui/static/multiPagePlugins/content/cloudflare-temp-email.js create mode 100644 DouYinSparkFlow/webui/static/multiPagePlugins/content/duck-mail.js create mode 100644 DouYinSparkFlow/webui/static/multiPagePlugins/content/inbucket-mail.js create mode 100644 DouYinSparkFlow/webui/static/multiPagePlugins/content/mail-163.js create mode 100644 DouYinSparkFlow/webui/static/multiPagePlugins/content/qq-mail.js create mode 100644 DouYinSparkFlow/webui/static/multiPagePlugins/content/relay-firefox.js create mode 100644 DouYinSparkFlow/webui/static/multiPagePlugins/content/signup-page.js create mode 100644 DouYinSparkFlow/webui/static/multiPagePlugins/content/utils.js create mode 100644 DouYinSparkFlow/webui/static/multiPagePlugins/content/vps-panel.js create mode 100644 DouYinSparkFlow/webui/static/multiPagePlugins/data/names.js create mode 100644 DouYinSparkFlow/webui/static/multiPagePlugins/icons/icon128.png create mode 100644 DouYinSparkFlow/webui/static/multiPagePlugins/icons/icon16.png create mode 100644 DouYinSparkFlow/webui/static/multiPagePlugins/icons/icon48.png create mode 100644 DouYinSparkFlow/webui/static/multiPagePlugins/manifest.json create mode 100644 DouYinSparkFlow/webui/static/multiPagePlugins/shared/cloudflare-temp-email.js create mode 100644 DouYinSparkFlow/webui/static/multiPagePlugins/shared/email-provider.js create mode 100644 DouYinSparkFlow/webui/static/multiPagePlugins/shared/oauth-flow.js create mode 100644 DouYinSparkFlow/webui/static/multiPagePlugins/shared/qq-mail.js create mode 100644 DouYinSparkFlow/webui/static/multiPagePlugins/sidepanel/sidepanel.css create mode 100644 DouYinSparkFlow/webui/static/multiPagePlugins/sidepanel/sidepanel.html create mode 100644 DouYinSparkFlow/webui/static/multiPagePlugins/sidepanel/sidepanel.js create mode 100644 DouYinSparkFlow/webui/static/multiPagePlugins/tests/cloudflare-temp-email.test.js create mode 100644 DouYinSparkFlow/webui/static/multiPagePlugins/tests/email-provider.test.js create mode 100644 DouYinSparkFlow/webui/static/multiPagePlugins/tests/oauth-consent.test.js create mode 100644 DouYinSparkFlow/webui/static/multiPagePlugins/tests/qq-mail.test.js create mode 100644 DouYinSparkFlow/webui/static/styles.css create mode 100644 DouYinSparkFlow/webui/templates/base.html create mode 100644 DouYinSparkFlow/webui/templates/dashboard.html create mode 100644 DouYinSparkFlow/webui/templates/login.html create mode 100644 DouYinSparkFlow/webui/templates/logs.html create mode 100644 docker-compose.yml create mode 100644 refresh_proxy.sh diff --git a/.gitignore b/.gitignore new file mode 100644 index 0000000..e9ebafb --- /dev/null +++ b/.gitignore @@ -0,0 +1,14 @@ +.env +state/ +logs/ +*.bak-* +*.tar.gz + +DouYinSparkFlow/.im_sdk_cache/ +DouYinSparkFlow/logs/ +DouYinSparkFlow/usersData.json +DouYinSparkFlow/webui_settings.json +DouYinSparkFlow/im_client_introspect.mjs +DouYinSparkFlow/core/protocol_sender_debug.mjs +DouYinSparkFlow/**/__pycache__/ +DouYinSparkFlow/**/*.pyc diff --git a/DouYinSparkFlow/.github/workflows/schedule.yml b/DouYinSparkFlow/.github/workflows/schedule.yml new file mode 100644 index 0000000..d844c06 --- /dev/null +++ b/DouYinSparkFlow/.github/workflows/schedule.yml @@ -0,0 +1,41 @@ +name: DouYin Spark Flow Schedule Run +on: + workflow_dispatch: # 允许手动触发 + schedule: # 定时任务 + - cron: "0 1 * * *" # 每天 1:00 UTC（对应北京时间 9:00） +jobs: + run-main: + timeout-minutes: 20 + runs-on: ubuntu-latest + environment: user-data + steps: + - uses: actions/checkout@v4 + - name: Set up Python + uses: actions/setup-python@v4 + with: + python-version: '3.11' + - name: Test Douyin Accessibility + run: | + curl -I https://creator.douyin.com/ + - name: Install dependencies + run: | + python -m pip install --upgrade pip + pip install -r requirements.txt + - name: Ensure browsers are installed + run: playwright install chromium --with-deps --only-shell + - name: Run DouYin Spark Flow + env: + USER_DATA: ${{ secrets.USER_DATA }} + run: python main.py --doTask + - uses: actions/upload-artifact@v4 + if: ${{ !cancelled() }} + with: + name: run-logs + path: logs/ + workflow-keepalive: + if: github.event_name == 'schedule' + runs-on: ubuntu-latest + permissions: + actions: write + steps: + - uses: liskin/gh-workflow-keepalive@v1 \ No newline at end of file diff --git a/DouYinSparkFlow/.gitignore b/DouYinSparkFlow/.gitignore new file mode 100644 index 0000000..71c253a --- /dev/null +++ b/DouYinSparkFlow/.gitignore @@ -0,0 +1,8 @@ +.venv/ +__pycache__/ +.vscode/ +chrome/ +logs/ +.DS_Store +usersData.json +webui_settings.json diff --git a/DouYinSparkFlow/Dockerfile.server b/DouYinSparkFlow/Dockerfile.server new file mode 100644 index 0000000..cda29ba --- /dev/null +++ b/DouYinSparkFlow/Dockerfile.server @@ -0,0 +1,54 @@ +FROM mcr.microsoft.com/playwright/python:v1.56.0-jammy + +WORKDIR /app + +ARG HTTP_PROXY +ARG HTTPS_PROXY +ARG ALL_PROXY +ARG http_proxy +ARG https_proxy +ARG all_proxy +ARG PIP_INDEX_URL=https://pypi.tuna.tsinghua.edu.cn/simple +ARG PIP_TRUSTED_HOST=pypi.tuna.tsinghua.edu.cn + +ENV HTTP_PROXY=${HTTP_PROXY} +ENV HTTPS_PROXY=${HTTPS_PROXY} +ENV ALL_PROXY=${ALL_PROXY} +ENV http_proxy=${http_proxy} +ENV https_proxy=${https_proxy} +ENV all_proxy=${all_proxy} +ENV DEBIAN_FRONTEND=noninteractive +ENV TZ=Asia/Shanghai +ENV PIP_INDEX_URL=${PIP_INDEX_URL} +ENV PIP_TRUSTED_HOST=${PIP_TRUSTED_HOST} + +COPY requirements.txt . +RUN pip install --no-cache-dir -r requirements.txt + +RUN sed -i 's/archive.ubuntu.com/mirrors.aliyun.com/g' /etc/apt/sources.list \ + && sed -i 's/security.ubuntu.com/mirrors.aliyun.com/g' /etc/apt/sources.list \ + && ln -fs /usr/share/zoneinfo/${TZ} /etc/localtime \ + && echo ${TZ} > /etc/timezone \ + && apt-get update && apt-get install -y \ + cron \ + curl \ + fluxbox \ + fonts-wqy-zenhei \ + fonts-noto-cjk \ + novnc \ + websockify \ + x11vnc \ + xfonts-intl-chinese \ + && curl -fsSL -x http://127.0.0.1:7890 https://download.docker.com/linux/static/stable/x86_64/docker-25.0.3.tgz -o docker.tgz \ + && tar xzvf docker.tgz \ + && mv docker/docker /usr/bin/docker \ + && chmod +x /usr/bin/docker \ + && rm -rf docker docker.tgz \ + && mkdir -p /usr/local/lib/docker/cli-plugins \ + && curl -SL -x http://127.0.0.1:7890 https://github.com/docker/compose/releases/download/v2.24.5/docker-compose-linux-x86_64 -o /usr/local/lib/docker/cli-plugins/docker-compose \ + && chmod +x /usr/local/lib/docker/cli-plugins/docker-compose \ + && rm -rf /var/lib/apt/lists/* + +COPY . . + +CMD ["python", "main.py", "--doTask"] diff --git a/DouYinSparkFlow/LICENSE b/DouYinSparkFlow/LICENSE new file mode 100644 index 0000000..82ece17 --- /dev/null +++ b/DouYinSparkFlow/LICENSE @@ -0,0 +1,21 @@ +MIT License + +Copyright (c) 2026 2061360308 + +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in all +copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +SOFTWARE. diff --git a/DouYinSparkFlow/README.md b/DouYinSparkFlow/README.md new file mode 100644 index 0000000..b6b385f --- /dev/null +++ b/DouYinSparkFlow/README.md @@ -0,0 +1,18 @@ +# DouYinSparkFlow + +这里是核心应用源码目录，包含： + +- `core/`: 任务执行、协议发送、浏览器自动化等核心逻辑 +- `webui/`: Web 管理界面与相关后端处理 +- `utils/`: 配置、日志和通用辅助逻辑 +- `scripts/`: 运行和登录辅助脚本 + +## 本地开发入口 + +- 安装依赖：`requirements.txt` / `requirements-web.txt` +- 应用入口：`main.py` +- 容器构建参考：`Dockerfile.server` + +运行时账号数据、Web 管理设置、浏览器缓存和日志文件不随仓库提供，需要在目标环境中自行生成。 + +仓库级说明、部署结构和敏感文件约定请查看上级目录的 [README.md](../README.md)。 diff --git a/DouYinSparkFlow/config.json b/DouYinSparkFlow/config.json new file mode 100644 index 0000000..dc68a70 --- /dev/null +++ b/DouYinSparkFlow/config.json @@ -0,0 +1,40 @@ +{ + "multiTask": true, + "taskCount": 1, + "proxyAddress": "", + "messageTemplate": "🤩今日火花+1\r\n", + "browserSenderAccounts": [ + "94262577168", + "抖音号：softwomen" + ], + "sendStrategy": { + "shuffleTargets": true, + "accountStartDelaySecondsMin": 15, + "accountStartDelaySecondsMax": 60, + "messageIntervalSecondsMin": 25, + "messageIntervalSecondsMax": 70, + "messageVariants": [ + "🤩今日火花+1", + "今天来补个火花", + "给你续一下今天的火花", + "路过给你加个小火花" + ] + }, + "dailySendWindow": { + "enabled": true, + "startHour": 10, + "endHour": 18, + "scheduleIntervalMinutes": 10 + }, + "hitokotoTypes": [ + "文学", + "影视", + "诗词", + "哲学" + ], + "happyNewYear": { + "enabled": true, + "messageTemplate": "\r\n" + }, + "useProtocolSender": false +} \ No newline at end of file diff --git a/DouYinSparkFlow/core/__init__.py b/DouYinSparkFlow/core/__init__.py new file mode 100644 index 0000000..e69de29 diff --git a/DouYinSparkFlow/core/browser.py b/DouYinSparkFlow/core/browser.py new file mode 100644 index 0000000..0be8515 --- /dev/null +++ b/DouYinSparkFlow/core/browser.py @@ -0,0 +1,63 @@ +import os +import subprocess +import sys +import traceback +from pathlib import Path + +from playwright.async_api import async_playwright +from rich.console import Console + +from utils.config import DEBUG, Environment, get_environment + + +console = Console() +PLAYWRIGHT_BROWSERS_PATH = "../chrome" + + +def _local_browser_bundle_path(): + return Path(__file__).resolve().parent / PLAYWRIGHT_BROWSERS_PATH + + +def configure_playwright_environment(): + if os.getenv("PLAYWRIGHT_BROWSERS_PATH"): + return + + env = get_environment() + if env == Environment.PACKED: + bundle_path = Path(sys.executable).resolve().parent / PLAYWRIGHT_BROWSERS_PATH + else: + bundle_path = _local_browser_bundle_path() + + if bundle_path.exists(): + os.environ["PLAYWRIGHT_BROWSERS_PATH"] = str(bundle_path.resolve()) + + +async def install_browser(): + try: + subprocess.run([sys.executable, "-m", "playwright", "install", "chromium"], check=True) + console.print("[bold green]Browser install completed. Please run the command again.[/bold green]") + except subprocess.CalledProcessError as exc: + console.print(f"[bold red]Browser install failed: {exc}[/bold red]") + + +async def get_browser(GUI=False): + configure_playwright_environment() + + headless = not GUI + if get_environment() == Environment.LOCAL and DEBUG: + headless = False + + try: + playwright = await async_playwright().start() + browser = await playwright.chromium.launch( + headless=headless, + args=["--disable-dev-shm-usage"], + ) + return playwright, browser + except Exception as exc: + if "Executable doesn't exist" in str(exc) and get_environment() != Environment.GITHUBACTION: + console.print("[bold red]Playwright browser is missing.[/bold red]") + await install_browser() + sys.exit(1) + traceback.print_exc() + raise diff --git a/DouYinSparkFlow/core/friends.py b/DouYinSparkFlow/core/friends.py new file mode 100644 index 0000000..0f509c0 --- /dev/null +++ b/DouYinSparkFlow/core/friends.py @@ -0,0 +1,134 @@ +import asyncio +from pathlib import Path + +from core.browser import get_browser + + +CHAT_PAGE_URL = "https://creator.douyin.com/creator-micro/data/following/chat" +FRIENDS_TAB_SELECTOR = 'xpath=//*[@id="sub-app"]/div/div/div[1]/div[2]' +TARGET_SELECTOR = ( + 'xpath=//*[@id="sub-app"]/div/div[1]/div[2]/div[2]' + '//div[contains(@class, "semi-list-item-body semi-list-item-body-flex-start")]' +) +SCROLLABLE_FRIENDS_SELECTOR = ( + 'xpath=//*[@id="sub-app"]/div/div[1]/div[2]/div[2]/div/div/div[3]/div/div/div/ul/div' +) +NO_MORE_SELECTOR = 'xpath=//div[contains(@class, "no-more-tip-ftdJnu")]' +LOADING_SELECTOR = 'xpath=//div[contains(@class, "semi-spin")]' +FIRST_FRIEND_SELECTOR = ( + 'xpath=//*[@id="sub-app"]/div/div/div[2]/div[2]/div/div/div[1]/div/div/div/ul/div/div/div[1]/li/div' +) +FRIEND_NAME_SELECTOR = """xpath=.//span[contains(@class, "item-header-name-")]""" +LOGIN_MASK_SELECTORS = [".login-mask", ".login-guide-container", ".login-img-code-wrapper"] + + +def update_collection_progress(new_names_count, no_more_visible, scroll_moved, idle_rounds, stuck_rounds, idle_limit=5, stuck_limit=2): + next_idle_rounds = 0 if new_names_count > 0 else idle_rounds + 1 + next_stuck_rounds = 0 if scroll_moved else stuck_rounds + 1 + should_stop = no_more_visible or next_idle_rounds >= idle_limit or next_stuck_rounds >= stuck_limit + return should_stop, next_idle_rounds, next_stuck_rounds + + +async def _ensure_logged_in(page): + for selector in LOGIN_MASK_SELECTORS: + try: + locator = page.locator(selector).first + if await locator.count() > 0 and await locator.is_visible(): + raise RuntimeError("账号登录已失效，请重新扫码登录") + except RuntimeError: + raise + except Exception: + continue + + +async def collect_friend_names(page): + await page.wait_for_selector(FRIENDS_TAB_SELECTOR, timeout=30000) + await page.locator(FRIENDS_TAB_SELECTOR).click() + + await page.wait_for_selector(FIRST_FRIEND_SELECTOR, timeout=30000) + await page.locator(FIRST_FRIEND_SELECTOR).click() + await asyncio.sleep(2) + + found_names = [] + seen_names = set() + idle_rounds = 0 + stuck_rounds = 0 + + while True: + target_elements = await page.locator(TARGET_SELECTOR).all() + new_names_count = 0 + for element in target_elements: + try: + name = (await element.locator(FRIEND_NAME_SELECTOR).inner_text()).strip() + except Exception: + continue + if not name or name in seen_names: + continue + seen_names.add(name) + found_names.append(name) + new_names_count += 1 + + no_more = page.locator(NO_MORE_SELECTOR).first + if await no_more.count() > 0 and await no_more.is_visible(): + return found_names + + loading = page.locator(LOADING_SELECTOR).first + if await loading.count() > 0 and await loading.is_visible(): + await asyncio.sleep(1.5) + + scrollable_element = await page.locator(SCROLLABLE_FRIENDS_SELECTOR).element_handle() + if not scrollable_element: + if found_names: + return found_names + raise RuntimeError("未找到好友列表滚动容器") + + before_top = await page.evaluate("(element) => element.scrollTop", scrollable_element) + await page.evaluate("(element) => element.scrollTop += 800", scrollable_element) + await asyncio.sleep(1.5) + after_top = await page.evaluate("(element) => element.scrollTop", scrollable_element) + + should_stop, idle_rounds, stuck_rounds = update_collection_progress( + new_names_count=new_names_count, + no_more_visible=False, + scroll_moved=after_top > before_top, + idle_rounds=idle_rounds, + stuck_rounds=stuck_rounds, + ) + if should_stop: + return found_names + + +async def fetch_account_friends(account): + cookies = list(account.get("cookies") or []) + if not cookies: + raise RuntimeError("账号没有可用 cookies，请重新扫码登录") + + playwright = browser = context = page = None + try: + playwright, browser = await get_browser(GUI=False) + context = await browser.new_context() + context.set_default_navigation_timeout(120000) + context.set_default_timeout(120000) + page = await context.new_page() + + await page.goto("https://creator.douyin.com/", wait_until="domcontentloaded", timeout=60000) + await context.add_cookies(cookies) + await page.goto(CHAT_PAGE_URL, wait_until="domcontentloaded", timeout=60000) + await asyncio.sleep(2) + + await _ensure_logged_in(page) + friends = await collect_friend_names(page) + return friends + except RuntimeError: + raise + except Exception as exc: + raise RuntimeError(f"刷新好友列表失败，请重试：{exc}") from exc + finally: + if page: + await page.close() + if context: + await context.close() + if browser: + await browser.close() + if playwright: + await playwright.stop() diff --git a/DouYinSparkFlow/core/login.py b/DouYinSparkFlow/core/login.py new file mode 100644 index 0000000..3a5fd2b --- /dev/null +++ b/DouYinSparkFlow/core/login.py @@ -0,0 +1,83 @@ +import asyncio + +from rich.console import Console + +from core.browser import get_browser +from utils.config import normalize_unique_id, upsert_user_account + + +console = Console() + +READY_SELECTOR = ( + 'xpath=//*[contains(@id, "garfish_app_for_douyin_creator_pc_home")]' + '/div/div[2]/div/div[2]/div[1]' +) +XPATHS = { + "unique_id": ( + 'xpath=//*[contains(@id, "garfish_app_for_douyin_creator_pc_home")]' + '/div/div[2]/div/div[2]/div[1]/div[2]/div[1]/div[3]' + ), + "name": ( + 'xpath=//*[contains(@id, "garfish_app_for_douyin_creator_pc_home")]' + '/div/div[2]/div/div[2]/div[1]/div[2]/div[1]/div[1]/div[1]' + ), +} + + +async def wait_for_logged_in_identity(page, timeout_ms=300000): + await page.wait_for_selector(READY_SELECTOR, timeout=timeout_ms) + + unique_id_element = await page.wait_for_selector(XPATHS["unique_id"], timeout=timeout_ms) + name_element = await page.wait_for_selector(XPATHS["name"], timeout=timeout_ms) + + unique_id_text = await unique_id_element.inner_text() + username = (await name_element.inner_text()).strip() + unique_id = normalize_unique_id(unique_id_text) + return unique_id, username + + +async def collect_login_result(page, context, timeout_ms=300000): + unique_id, username = await wait_for_logged_in_identity(page, timeout_ms=timeout_ms) + cookies = await context.cookies() + return { + "unique_id": unique_id, + "username": username, + "cookies": cookies, + } + + +async def userLogin(targets=None): + playwright, browser = await get_browser(GUI=True) + try: + context = await browser.new_context() + page = await context.new_page() + + await page.goto("https://creator.douyin.com/") + console.print("Please scan the QR code and finish logging into Douyin Creator Center.") + + login_result = await collect_login_result(page, context) + console.print(f"Unique ID: {login_result['unique_id']}") + console.print(f"Name: {login_result['username']}") + console.print(f"Cookies: found {len(login_result['cookies'])} cookies") + + if targets is None: + raw_targets = input( + "Open Creator Center -> 互动管理 -> 私信管理 -> 朋友私信, then enter friend display names separated by spaces: " + ) + targets = [target.strip() for target in raw_targets.split(" ") if target.strip()] + + account = upsert_user_account( + login_result["unique_id"], + login_result["username"], + login_result["cookies"], + targets, + ) + console.print(f"[bold green]Login complete. Updated account {account['username']}.[/bold green]") + return account + finally: + await playwright.stop() + await browser.close() + + +if __name__ == "__main__": + asyncio.run(userLogin()) diff --git a/DouYinSparkFlow/core/msg_builder.py b/DouYinSparkFlow/core/msg_builder.py new file mode 100644 index 0000000..06b995d --- /dev/null +++ b/DouYinSparkFlow/core/msg_builder.py @@ -0,0 +1,129 @@ +""" +core/msg_builder.py + +Resolve configured message templates into concrete per-target messages. +""" + +import random +from datetime import date +from typing import Dict, List, Optional + +from utils.config import get_config +from utils.hitokoto import request_hitokoto + + +FESTIVAL_WINDOW_START = date(2026, 2, 16) +FESTIVAL_WINDOW_END = date(2026, 3, 3) + + +def _is_holiday_mode_enabled(active_config: dict, today: date) -> bool: + return bool(active_config.get("happyNewYear", {}).get("enabled", False)) and FESTIVAL_WINDOW_START <= today <= FESTIVAL_WINDOW_END + + +def _render_holiday_message(active_config: dict, today: date) -> str: + from utils.chinese_new_year_2026_mare import get_lunar_date, get_random_festival_quote + + message = str(active_config.get("happyNewYear", {}).get("messageTemplate", "[API]")) + if "[data]" in message: + message = message.replace("[data]", today.strftime("%Y年%m月%d日")) + if "[data_lunar]" in message: + lunar_date = get_lunar_date(today) + message = message.replace("[data_lunar]", lunar_date if lunar_date else "未知农历日期") + if "[API]" in message: + message = message.replace("[API]", get_random_festival_quote()) + return message.strip() + + +def _get_message_templates(active_config: dict) -> List[str]: + strategy = active_config.get("sendStrategy", {}) or {} + variants = [str(item).strip() for item in strategy.get("messageVariants", []) if str(item).strip()] + if variants: + return variants + return [str(active_config.get("messageTemplate", "续火花")).strip()] + + +def _render_regular_message(template: str) -> str: + message = template + if "[API]" in message: + message = message.replace("[API]", request_hitokoto()) + return message.strip() + + +def build_message_candidates(config: Optional[dict] = None) -> List[str]: + active_config = config or get_config() + today = date.today() + + if _is_holiday_mode_enabled(active_config, today): + return [_render_holiday_message(active_config, today)] + + candidates: List[str] = [] + for template in _get_message_templates(active_config): + message = _render_regular_message(template) + if message and message not in candidates: + candidates.append(message) + + if candidates: + return candidates + return ["续火花"] + + +def _extract_previous_message(previous_messages: Optional[dict], target: str) -> str: + if not previous_messages: + return "" + + previous = previous_messages.get(target, "") + if isinstance(previous, dict): + return str(previous.get("message", "")).strip() + return str(previous).strip() + + +def _choose_message(candidates: List[str], previous_message: str, last_message: str) -> str: + filtered = [message for message in candidates if message != previous_message and message != last_message] + if filtered: + return random.choice(filtered) + + filtered = [message for message in candidates if message != previous_message] + if filtered: + return random.choice(filtered) + + filtered = [message for message in candidates if message != last_message] + if filtered: + return random.choice(filtered) + + return random.choice(candidates) + + +def build_message(previous_message: str = "", config: Optional[dict] = None, last_message: str = "") -> str: + candidates = build_message_candidates(config) + return _choose_message(candidates, previous_message.strip(), last_message.strip()).strip() + + +def build_messages_for_targets( + targets: List[str], + previous_messages: Optional[dict] = None, + config: Optional[dict] = None, +) -> Dict[str, str]: + active_config = config or get_config() + strategy = active_config.get("sendStrategy", {}) or {} + + ordered_targets = [] + seen_targets = set() + for target in targets: + normalized = str(target).strip() + if not normalized or normalized in seen_targets: + continue + seen_targets.add(normalized) + ordered_targets.append(normalized) + + if strategy.get("shuffleTargets", True): + random.shuffle(ordered_targets) + + planned_messages: Dict[str, str] = {} + last_message = "" + for target in ordered_targets: + previous_message = _extract_previous_message(previous_messages, target) + message = build_message(previous_message=previous_message, config=active_config, last_message=last_message) + planned_messages[target] = message + last_message = message + + return planned_messages diff --git a/DouYinSparkFlow/core/protocol_dispatch.py b/DouYinSparkFlow/core/protocol_dispatch.py new file mode 100644 index 0000000..eaf74e2 --- /dev/null +++ b/DouYinSparkFlow/core/protocol_dispatch.py @@ -0,0 +1,279 @@ +import asyncio +import json +import os +import random +import shutil +import subprocess +from datetime import datetime, timezone +from pathlib import Path + +from core.msg_builder import build_messages_for_targets +from utils.config import get_userData, normalize_unique_id, repo_root, save_userData +from utils.logger import setup_logger + + +logger = setup_logger() +PROTOCOL_SCRIPT = repo_root() / "core" / "protocol_sender.mjs" +NODE_HELPER_IMAGE = "node:22-alpine" + + +def _coerce_non_negative_int(value, default): + try: + return max(0, int(value)) + except (TypeError, ValueError): + return max(0, int(default)) + + +def _normalize_send_strategy(config): + raw = config.get("sendStrategy", {}) or {} + start_min = _coerce_non_negative_int(raw.get("accountStartDelaySecondsMin", 0), 0) + start_max = _coerce_non_negative_int(raw.get("accountStartDelaySecondsMax", start_min), start_min) + if start_max < start_min: + start_max = start_min + + message_min = _coerce_non_negative_int(raw.get("messageIntervalSecondsMin", 0), 0) + message_max = _coerce_non_negative_int(raw.get("messageIntervalSecondsMax", message_min), message_min) + if message_max < message_min: + message_max = message_min + + strategy = { + "shuffleTargets": bool(raw.get("shuffleTargets", True)), + "accountStartDelaySecondsMin": start_min, + "accountStartDelaySecondsMax": start_max, + "messageIntervalSecondsMin": message_min, + "messageIntervalSecondsMax": message_max, + "messageVariants": [str(item).strip() for item in raw.get("messageVariants", []) if str(item).strip()], + } + if os.getenv("SPARKFLOW_MANUAL_RUN") == "1": + strategy["accountStartDelaySecondsMin"] = 0 + strategy["accountStartDelaySecondsMax"] = 0 + strategy["messageIntervalSecondsMin"] = min(strategy["messageIntervalSecondsMin"], 3) + strategy["messageIntervalSecondsMax"] = min(strategy["messageIntervalSecondsMax"], 6) + return strategy + + +def _account_identity_key(account): + normalized_unique_id = normalize_unique_id(account.get("unique_id")) + if normalized_unique_id: + return f"uid:{normalized_unique_id}" + + username = str(account.get("username", "")).strip() + if username: + return f"user:{username}" + + return "" + + +def _merge_protocol_runtime_state(accounts, result_by_username): + changed = False + now_iso = datetime.now(timezone.utc).isoformat(timespec="seconds") + all_accounts = get_userData(force_reload=True) + accounts_by_identity = { + identity: account + for account in all_accounts + for identity in [_account_identity_key(account)] + if identity + } + + for account in accounts: + target_account = accounts_by_identity.get(_account_identity_key(account)) + if not target_account: + continue + + result = result_by_username.get(account.get("username")) + if not result: + continue + + protocol_cache = result.get("protocol_targets_cache") + if protocol_cache is not None: + target_account["protocol_targets_cache"] = protocol_cache + target_account["protocol_user_id"] = result.get("userId", "") + changed = True + + history = dict(target_account.get("message_history") or {}) + for entry in result.get("sent", []): + if entry.get("dryRun") or not entry.get("success", True): + continue + + target = str(entry.get("target", "")).strip() + message = str(entry.get("message", "")).strip() + if not target or not message: + continue + + history[target] = { + "message": message, + "sentAt": str(entry.get("sentAt", now_iso)), + } + changed = True + + if history: + target_account["message_history"] = history + + if changed: + save_userData(all_accounts) + + +def _host_repo_root(): + candidates = [ + Path("/opt/douyin-sparkflow/DouYinSparkFlow"), + repo_root(), + ] + for candidate in candidates: + if (candidate / "core" / "protocol_sender.mjs").exists(): + return candidate + return repo_root() + + +def _build_protocol_command(): + node_path = shutil.which("node") + if node_path: + return [node_path, str(PROTOCOL_SCRIPT)], repo_root(), "local-node", str(repo_root()) + + docker_path = shutil.which("docker") + if docker_path: + host_repo = _host_repo_root() + return ( + [ + docker_path, + "run", + "--rm", + "-i", + "--network", + "host", + "-v", + f"{host_repo}:/workspace", + "-w", + "/workspace", + NODE_HELPER_IMAGE, + "node", + "core/protocol_sender.mjs", + ], + repo_root(), + "docker-node-helper", + "/workspace", + ) + + raise RuntimeError("Neither node nor docker is available for the protocol sender") + + +def _run_protocol_for_user(user, messages_by_target, dry_run, send_strategy): + command, cwd, runner_label, runtime_repo_root = _build_protocol_command() + payload = { + "repoRoot": runtime_repo_root, + "dryRun": dry_run, + "account": user, + "messagesByTarget": messages_by_target, + "sendStrategy": send_strategy, + } + process = subprocess.run( + command, + input=json.dumps(payload, ensure_ascii=False), + text=True, + capture_output=True, + cwd=str(cwd), + check=False, + ) + + stdout = (process.stdout or "").strip() + if not stdout: + raise RuntimeError( + f"protocol sender returned no output for {user.get('username', 'unknown')}: {process.stderr}" + ) + + try: + data = json.loads(stdout) + except json.JSONDecodeError as exc: + raise RuntimeError( + f"protocol sender produced invalid JSON for {user.get('username', 'unknown')}: {stdout}" + ) from exc + + if process.returncode != 0 or not data.get("ok"): + error_message = data.get("error") or process.stderr or "protocol sender failed" + raise RuntimeError( + f"{user.get('username', 'unknown')} protocol sender failed: {error_message}" + ) + + data["runner"] = runner_label + + return data + + +async def run_protocol_tasks(config, accounts, message_builder): + del message_builder + + dry_run = bool(config.get("protocolDryRun", False)) + multi_task = bool(config.get("multiTask", True)) + concurrency = int(config.get("taskCount", 1)) if multi_task else 1 + semaphore = asyncio.Semaphore(max(concurrency, 1)) + send_strategy = _normalize_send_strategy(config) + + async def _worker(user): + async with semaphore: + start_delay = random.randint( + send_strategy["accountStartDelaySecondsMin"], + send_strategy["accountStartDelaySecondsMax"], + ) + if start_delay > 0: + logger.info( + "Delaying protocol sender for %s by %ss to avoid synchronized bursts", + user.get("username", "unknown"), + start_delay, + ) + await asyncio.sleep(start_delay) + + logger.info("Starting protocol sender for %s", user.get("username", "unknown")) + messages_by_target = build_messages_for_targets( + user.get("targets", []), + previous_messages=user.get("message_history", {}), + config=config, + ) + logger.info( + "Prepared %s protocol messages for %s with shuffleTargets=%s interval=%s-%ss manual_run=%s", + len(messages_by_target), + user.get("username", "unknown"), + send_strategy["shuffleTargets"], + send_strategy["messageIntervalSecondsMin"], + send_strategy["messageIntervalSecondsMax"], + os.getenv("SPARKFLOW_MANUAL_RUN") == "1", + ) + result = await asyncio.to_thread( + _run_protocol_for_user, + user, + messages_by_target, + dry_run, + send_strategy, + ) + logger.info( + "Protocol sender finished for %s resolved=%s unresolved=%s sent=%s", + user.get("username", "unknown"), + len(result.get("resolved", [])), + len(result.get("unresolved", [])), + len(result.get("sent", [])), + ) + return result + + gathered = await asyncio.gather(*(_worker(user) for user in accounts), return_exceptions=True) + + result_by_username = {} + failures = [] + for user, item in zip(accounts, gathered): + if isinstance(item, Exception): + failures.append(str(item)) + logger.error("Protocol sender failed for %s: %s", user.get("username", "unknown"), item) + continue + result_by_username[user.get("username")] = item + unresolved = item.get("unresolved", []) + if unresolved: + logger.warning( + "Protocol sender could not resolve %s targets for %s: %s", + len(unresolved), + user.get("username", "unknown"), + [entry.get("target") for entry in unresolved], + ) + + _merge_protocol_runtime_state(accounts, result_by_username) + + if failures and not result_by_username: + raise RuntimeError("; ".join(failures)) + + return [result_by_username[user.get("username")] for user in accounts if user.get("username") in result_by_username] diff --git a/DouYinSparkFlow/core/protocol_sender.mjs b/DouYinSparkFlow/core/protocol_sender.mjs new file mode 100644 index 0000000..4ada696 --- /dev/null +++ b/DouYinSparkFlow/core/protocol_sender.mjs @@ -0,0 +1,728 @@ +#!/usr/bin/env node + +import fs from "node:fs"; +import path from "node:path"; +import vm from "node:vm"; +import { Blob } from "node:buffer"; + +const SDK_BUNDLES = [ + "https://lf-fe-creator.douyinstatic.com/obj/douyn-creator-scm-cdn/douyin-creator-mono-pc-data/static/js/lib-polyfill.f81f86eb.js", + "https://lf-fe-creator.douyinstatic.com/obj/douyn-creator-scm-cdn/douyin-creator-mono-pc-data/static/js/lib-router.5ab9ff10.js", + "https://lf-fe-creator.douyinstatic.com/obj/douyn-creator-scm-cdn/douyin-creator-mono-pc-data/static/js/2105.f8d74876.js", + "https://lf-fe-creator.douyinstatic.com/obj/douyn-creator-scm-cdn/douyin-creator-mono-pc-data/static/js/douyin_creator_data_old.2f971672.js", + "https://lf-fe-creator.douyinstatic.com/obj/douyn-creator-scm-cdn/douyin-creator-mono-pc-data/static/js/async/argus-builder-strategy.5a053c46.js", + "https://lf-fe-creator.douyinstatic.com/obj/douyn-creator-scm-cdn/douyin-creator-mono-pc-data/static/js/async/7676.a4cd4900.js", + "https://lf-fe-creator.douyinstatic.com/obj/douyn-creator-scm-cdn/douyin-creator-mono-pc-data/static/js/async/4916.56c33d22.js", + "https://lf-fe-creator.douyinstatic.com/obj/douyn-creator-scm-cdn/douyin-creator-mono-pc-data/static/js/async/8198.b5c0b108.js", + "https://lf-fe-creator.douyinstatic.com/obj/douyn-creator-scm-cdn/douyin-creator-mono-pc-data/static/js/async/4168.b2e72401.js", + "https://lf-fe-creator.douyinstatic.com/obj/douyn-creator-scm-cdn/douyin-creator-mono-pc-data/static/js/async/7771.d27d1891.js", + "https://lf-fe-creator.douyinstatic.com/obj/douyn-creator-scm-cdn/douyin-creator-mono-pc-data/static/js/async/6682.2a991dfb.js", + "https://lf-fe-creator.douyinstatic.com/obj/douyn-creator-scm-cdn/douyin-creator-mono-pc-data/static/js/async/361.4fc40815.js", + "https://lf-fe-creator.douyinstatic.com/obj/douyn-creator-scm-cdn/douyin-creator-mono-pc-data/static/js/async/pages-chat.6f823210.js", +]; + +const CREATOR_CHAT_URL = "https://creator.douyin.com/creator-micro/data/following/chat"; +const USER_AGENT = + "Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/141 Safari/537.36"; + +function noop() {} + +function toCookieString(cookies) { + return (cookies || []) + .filter((item) => item?.name && item?.value !== undefined) + .map((item) => `${item.name}=${item.value}`) + .join("; "); +} + +function normalizeNickname(value) { + return String(value || "").trim(); +} + +function stableNow() { + return new Date().toISOString(); +} + +function sleep(ms) { + return new Promise((resolve) => setTimeout(resolve, ms)); +} + +function toNonNegativeInteger(value, fallback = 0) { + const parsed = Number.parseInt(value, 10); + if (Number.isNaN(parsed) || parsed < 0) { + return fallback; + } + return parsed; +} + +function normalizeSendStrategy(raw = {}) { + const intervalMin = toNonNegativeInteger(raw.messageIntervalSecondsMin, 0); + const intervalMax = Math.max(intervalMin, toNonNegativeInteger(raw.messageIntervalSecondsMax, intervalMin)); + return { + messageIntervalSecondsMin: intervalMin, + messageIntervalSecondsMax: intervalMax, + }; +} + +function randomBetweenInclusive(min, max) { + if (max <= min) { + return min; + } + return Math.floor(Math.random() * (max - min + 1)) + min; +} + +async function readStdinJson() { + const chunks = []; + for await (const chunk of process.stdin) { + chunks.push(chunk); + } + const raw = Buffer.concat(chunks).toString("utf8").trim(); + if (!raw) { + throw new Error("Missing JSON payload on stdin"); + } + return JSON.parse(raw); +} + +async function ensureBundles(cacheDir) { + await fs.promises.mkdir(cacheDir, { recursive: true }); + for (const url of SDK_BUNDLES) { + const filename = url.split("/").at(-1); + const filePath = path.join(cacheDir, filename); + if (fs.existsSync(filePath)) { + continue; + } + const response = await fetch(url, { headers: { "User-Agent": USER_AGENT } }); + if (!response.ok) { + throw new Error(`Failed to download SDK bundle ${url}: ${response.status}`); + } + const text = await response.text(); + await fs.promises.writeFile(filePath, text, "utf8"); + } +} + +function createWebpackRequire(bundleDir, cookieString) { + const modules = {}; + const cache = {}; + + function requireModule(id) { + if (cache[id]) { + return cache[id].exports; + } + if (!modules[id]) { + throw new Error(`Missing webpack module ${id}`); + } + const module = { exports: {} }; + cache[id] = module; + modules[id].call(module.exports, module, module.exports, requireModule); + return module.exports; + } + + requireModule.d = (exports, definition) => { + for (const key of Object.keys(definition)) { + if (!Object.prototype.hasOwnProperty.call(exports, key)) { + Object.defineProperty(exports, key, { + enumerable: true, + get: definition[key], + }); + } + } + }; + requireModule.o = (obj, prop) => Object.prototype.hasOwnProperty.call(obj, prop); + requireModule.r = (exports) => { + if (typeof Symbol !== "undefined" && Symbol.toStringTag) { + Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" }); + } + Object.defineProperty(exports, "__esModule", { value: true }); + }; + requireModule.n = (mod) => { + const getter = mod && mod.__esModule ? () => mod.default : () => mod; + requireModule.d(getter, { a: getter }); + return getter; + }; + requireModule.g = globalThis; + requireModule.hmd = (module) => module; + requireModule.nmd = (module) => module; + + const chunkArray = []; + chunkArray.push = (chunk) => Object.assign(modules, chunk[1]); + + const fakeElement = () => ({ + style: {}, + setAttribute: noop, + appendChild: noop, + removeChild: noop, + addEventListener: noop, + removeEventListener: noop, + getContext: () => ({}), + }); + const documentRef = { + cookie: cookieString, + referrer: CREATOR_CHAT_URL, + createElement: fakeElement, + getElementsByTagName: () => [], + querySelector: () => null, + querySelectorAll: () => [], + addEventListener: noop, + removeEventListener: noop, + body: { appendChild: noop, removeChild: noop }, + head: { appendChild: noop, removeChild: noop }, + documentElement: { style: {} }, + }; + function XMLHttpRequestStub() { + this.open = noop; + this.setRequestHeader = noop; + this.send = noop; + } + function WebSocketStub() { + this.readyState = 1; + this.send = noop; + this.close = noop; + } + + const context = { + self: { webpackChunkdouyin_creator_data: chunkArray }, + window: {}, + globalThis: null, + console, + setTimeout, + clearTimeout, + setInterval, + clearInterval, + Buffer, + TextDecoder, + TextEncoder, + Blob, + document: documentRef, + navigator: { + userAgent: USER_AGENT, + language: "en-US", + cookieEnabled: true, + onLine: true, + platform: "Linux x86_64", + sendBeacon: undefined, + appName: "Netscape", + }, + location: { + href: CREATOR_CHAT_URL, + protocol: "https:", + search: "", + pathname: "/creator-micro/data/following/chat", + hostname: "creator.douyin.com", + }, + localStorage: { getItem: () => null, setItem: noop, removeItem: noop }, + sessionStorage: { getItem: () => null, setItem: noop, removeItem: noop }, + performance: { now: () => Date.now() }, + fetch, + XMLHttpRequest: XMLHttpRequestStub, + WebSocket: WebSocketStub, + URL, + URLSearchParams, + atob: (value) => Buffer.from(value, "base64").toString("binary"), + btoa: (value) => Buffer.from(value, "binary").toString("base64"), + crypto, + }; + context.window = context; + context.globalThis = context; + + for (const entry of fs.readdirSync(bundleDir).filter((name) => name.endsWith(".js")).sort()) { + const code = fs.readFileSync(path.join(bundleDir, entry), "utf8"); + try { + vm.runInNewContext(code, context, { filename: entry }); + } catch { + // Some bundles execute browser-only entrypoints after registering modules. + } + } + + return requireModule; +} + +class ProtocolError extends Error { + constructor(message, details = {}) { + super(message); + this.name = "ProtocolError"; + this.details = details; + } +} + +function extractCookieMap(cookies) { + const items = {}; + for (const item of cookies || []) { + if (item?.name) { + items[item.name] = item.value ?? ""; + } + } + return items; +} + +function buildCreatorHeaders(cookieString, cookieMap, referer = CREATOR_CHAT_URL) { + return { + "User-Agent": USER_AGENT, + Referer: referer, + Origin: "https://creator.douyin.com", + Accept: "application/json, text/javascript", + "Content-Type": "application/x-www-form-urlencoded", + Cookie: cookieString, + "x-tt-passport-csrf-token": + cookieMap.passport_csrf_token || cookieMap.passport_csrf_token_default || "", + }; +} + +function buildImHeaders(cookieString) { + return { + "User-Agent": USER_AGENT, + Referer: CREATOR_CHAT_URL, + Origin: "https://creator.douyin.com", + Cookie: cookieString, + }; +} + +async function fetchJson(url, options = {}) { + const timeoutMs = options.timeoutMs || 15000; + const controller = new AbortController(); + const timer = setTimeout(() => controller.abort(), timeoutMs); + const response = await fetch(url, { + ...options, + signal: controller.signal, + }); + const text = await response.text(); + clearTimeout(timer); + let data = null; + try { + data = text ? JSON.parse(text) : null; + } catch { + data = null; + } + return { response, text, data }; +} + +async function fetchSessionIdentity(cookieString, cookieMap) { + const headers = buildCreatorHeaders(cookieString, cookieMap); + const params = new URLSearchParams({ + aid: "2906", + app_name: "aweme_creator_platform", + device_platform: "web", + referer: "", + user_agent: USER_AGENT, + cookie_enabled: "true", + screen_width: "1280", + screen_height: "720", + browser_language: "en-US@posix", + browser_platform: "Linux x86_64", + browser_name: "Mozilla", + browser_version: USER_AGENT, + browser_online: "true", + timezone_name: "Asia/Shanghai", + }); + const { response, data, text } = await fetchJson( + `https://creator.douyin.com/aweme/v1/creator/im/user_token/?${params.toString()}`, + { headers }, + ); + if (!response.ok || data?.status_code !== 0 || !data?.user_id) { + throw new ProtocolError("Failed to resolve creator IM session identity", { + status: response.status, + body: text, + }); + } + return { + userId: String(data.user_id), + sessionToken: String(data.token || ""), + }; +} + +async function fetchIdentitySecurityToken(cookieString, cookieMap) { + const headers = buildCreatorHeaders(cookieString, cookieMap); + const params = new URLSearchParams({ + scene: "im_send_msg", + auto_retry_req: "0", + skip_verify: "0", + identity_token_force_get_tag: "0", + passport_jssdk_version: "5.1.4", + passport_jssdk_type: "lite", + is_from_ttaccountsdk: "1", + aid: "2906", + language: "zh", + account_app_language: "en-US", + id_token_version: "2.1.5", + }); + const { response, data, text } = await fetchJson( + `https://creator.douyin.com/passport/safe/get_identity_security_token/?${params.toString()}`, + { headers }, + ); + if (!response.ok || data?.message !== "success" || !data?.data?.identity_security_token) { + throw new ProtocolError("Failed to resolve identity security token", { + status: response.status, + body: text, + }); + } + return { + identitySecurityHeader: JSON.stringify({ token: data.data.identity_security_token }), + realDeviceId: String(data.data.device_id || ""), + }; +} + +async function fetchProfileNickname(cookieString, secUid) { + const url = + "https://www.douyin.com/aweme/v1/web/user/profile/other/?" + + new URLSearchParams({ sec_user_id: secUid }).toString(); + const { response, data, text } = await fetchJson(url, { + headers: { + "User-Agent": USER_AGENT, + Referer: `https://www.douyin.com/user/${secUid}`, + Cookie: cookieString, + Accept: "application/json, text/javascript", + }, + }); + if (!response.ok || data?.status_code !== 0) { + return ""; + } + return normalizeNickname(data?.user?.nickname); +} + +function stringifyMaybeLong(value) { + if (value === null || value === undefined) { + return ""; + } + if (typeof value === "string" || typeof value === "number" || typeof value === "bigint") { + return String(value); + } + if (typeof value.toString === "function" && value.toString !== Object.prototype.toString) { + return value.toString(); + } + return String(value); +} + +function selectPeerParticipant(conversation, selfUserId) { + const participants = conversation?.firstPageParticipant?.participants || []; + for (const participant of participants) { + const currentUserId = stringifyMaybeLong(participant?.user_id); + if (currentUserId && currentUserId !== selfUserId) { + return participant; + } + } + return null; +} + +async function createProtocolClient({ bundleDir, cookieString, cookieMap, userId }) { + const requireModule = createWebpackRequire(bundleDir, cookieString); + const sdk = requireModule(61724); + const { BytedIM } = requireModule(26440); + + class AdditionalParamsPlugin extends sdk.BasePlugin { + install() {} + + async sendPacket(packet) { + packet.device_id = 0; + packet.device_platform = "douyin_creator"; + packet.headers = { + ...(packet.headers || {}), + aid_new: 2906, + app_name: "douyin_creator", + }; + return packet; + } + } + + class NodeHttpClient extends sdk.IMHttpClient { + async send(url, method, body) { + const fullUrl = /^https?:/i.test(url) + ? url + : `${String(this.option.apiUrl).replace(/\/$/, "")}/${String(url).replace(/^\//, "")}`; + const controller = new AbortController(); + const timer = setTimeout(() => controller.abort(), 20000); + const response = await fetch(fullUrl, { + method, + headers: this.headers, + body: body ? Buffer.from(body) : undefined, + signal: controller.signal, + }); + clearTimeout(timer); + return response.arrayBuffer(); + } + + sendByBeacon() { + return false; + } + } + + const client = new BytedIM( + { + appId: 2906, + fpId: 9, + appKey: "e1bd35ec9db7b8d846de66ed140b1ad9", + service: 5, + apiUrl: "https://imapi.douyin.com", + frontierUrl: "wss://frontier-im.douyin.com/ws/v2", + inboxType: 1, + token: "", + userId, + deviceId: userId, + authType: sdk.im_proto.AuthType.SESSION_AUTH, + devicePlatform: "douyin_pc", + timeout: 20000, + acceptIncorrectInboxType: true, + biz: "douyin_creator", + withCredentials: false, + httpHeaders: buildImHeaders(cookieString), + headers: {}, + webSocketLevel: sdk.WebSocketLevel.PushOnly, + debug: false, + http: (ctx) => new NodeHttpClient(ctx), + }, + [AdditionalParamsPlugin], + ); + + const initResult = await client.init(); + if (initResult !== sdk.InitResult.Succeeded) { + throw new ProtocolError("Protocol IM init did not succeed", { initResult }); + } + + return { client }; +} + +async function buildConversationCache({ + client, + selfUserId, + cookieString, + existingCache = [], + targetNames = [], +}) { + const cachedBySecUid = new Map( + (existingCache || []).filter((entry) => entry?.secUid).map((entry) => [entry.secUid, entry]), + ); + const wantedTargets = new Set((targetNames || []).map(normalizeNickname).filter(Boolean)); + const matchedTargets = new Set(); + const conversations = await client.getConversationListOnline(); + const cacheEntries = []; + + for (const conversation of conversations) { + if (conversation?.type !== 1) { + continue; + } + + const peer = selectPeerParticipant(conversation, selfUserId); + if (!peer) { + continue; + } + + const peerUserId = stringifyMaybeLong(peer.user_id); + const secUid = peer.sec_uid || ""; + if (!peerUserId || !secUid) { + continue; + } + + let nickname = normalizeNickname(cachedBySecUid.get(secUid)?.nickname); + if (!nickname) { + try { + nickname = await fetchProfileNickname(cookieString, secUid); + } catch { + nickname = ""; + } + } + + cacheEntries.push({ + nickname, + peerUserId, + secUid, + conversationId: conversation.id, + conversationShortId: conversation.shortId, + updatedAt: stableNow(), + }); + + if (nickname && wantedTargets.has(nickname)) { + matchedTargets.add(nickname); + if (matchedTargets.size === wantedTargets.size) { + break; + } + } + } + + const deduped = new Map(); + for (const entry of existingCache || []) { + if (!entry?.nickname || !entry?.secUid) { + continue; + } + deduped.set(entry.secUid, entry); + } + for (const entry of cacheEntries) { + if (!entry.nickname) { + continue; + } + deduped.set(entry.secUid, entry); + } + return Array.from(deduped.values()).sort((left, right) => + left.nickname.localeCompare(right.nickname, "zh-CN"), + ); +} + +function buildTargetLookup(cacheEntries) { + const byNickname = new Map(); + for (const entry of cacheEntries) { + const key = normalizeNickname(entry.nickname); + if (key && !byNickname.has(key)) { + byNickname.set(key, entry); + } + } + return byNickname; +} + +async function sendMessages({ + client, + cacheEntries, + messagesByTarget, + dryRun, + cookieString, + cookieMap, + sendStrategy, +}) { + if (!dryRun) { + const identity = await fetchIdentitySecurityToken(cookieString, cookieMap); + client.updateSendMessageHeaders({ + identity_security_token: identity.identitySecurityHeader, + identity_security_device_id: identity.realDeviceId, + identity_security_aid: "2906", + }); + } + + const byNickname = buildTargetLookup(cacheEntries); + const resolved = []; + const unresolved = []; + const sent = []; + const normalizedStrategy = normalizeSendStrategy(sendStrategy); + + for (const [target, message] of Object.entries(messagesByTarget)) { + const mapping = byNickname.get(normalizeNickname(target)); + if (!mapping) { + unresolved.push({ target, reason: "conversation_not_found" }); + continue; + } + + const conversation = client.getConversation({ conversationId: mapping.conversationId }); + if (!conversation) { + unresolved.push({ target, reason: "conversation_not_loaded", mapping }); + continue; + } + + resolved.push({ + target, + nickname: mapping.nickname, + peerUserId: mapping.peerUserId, + conversationId: mapping.conversationId, + conversationShortId: mapping.conversationShortId, + }); + + let delayBeforeSendSeconds = 0; + if (!dryRun && sent.length > 0 && normalizedStrategy.messageIntervalSecondsMax > 0) { + delayBeforeSendSeconds = randomBetweenInclusive( + normalizedStrategy.messageIntervalSecondsMin, + normalizedStrategy.messageIntervalSecondsMax, + ); + if (delayBeforeSendSeconds > 0) { + await sleep(delayBeforeSendSeconds * 1000); + } + } + + const payload = JSON.stringify({ text: message, aweType: 774 }); + const messageObject = await client.createMessage({ + type: 7, + content: payload, + conversation, + insert: false, + }); + + if (dryRun) { + sent.push({ + target, + dryRun: true, + message, + payload, + conversationId: mapping.conversationId, + delayBeforeSendSeconds, + }); + continue; + } + + const sendResult = await client.sendMessage({ message: messageObject }); + sent.push({ + target, + dryRun: false, + message, + success: Boolean(sendResult?.success), + statusCode: sendResult?.statusCode ?? null, + statusMsg: sendResult?.statusMsg ?? "", + conversationId: mapping.conversationId, + delayBeforeSendSeconds, + sentAt: stableNow(), + }); + } + + return { resolved, unresolved, sent }; +} + +async function main() { + const payload = await readStdinJson(); + const repoRoot = payload.repoRoot || process.cwd(); + const bundleDir = path.join(repoRoot, ".im_sdk_cache"); + await ensureBundles(bundleDir); + + const account = payload.account || {}; + const cookieString = toCookieString(account.cookies); + const cookieMap = extractCookieMap(account.cookies); + const { userId } = await fetchSessionIdentity(cookieString, cookieMap); + const { client } = await createProtocolClient({ + bundleDir, + cookieString, + cookieMap, + userId, + }); + + const cacheEntries = await buildConversationCache({ + client, + selfUserId: userId, + cookieString, + existingCache: account.protocol_targets_cache || [], + targetNames: Object.keys(payload.messagesByTarget || {}), + }); + const execution = await sendMessages({ + client, + cacheEntries, + messagesByTarget: payload.messagesByTarget || {}, + dryRun: Boolean(payload.dryRun), + cookieString, + cookieMap, + sendStrategy: payload.sendStrategy || {}, + }); + + try { + console.log( + JSON.stringify( + { + ok: true, + username: account.username || "", + userId, + dryRun: Boolean(payload.dryRun), + protocol_targets_cache: cacheEntries, + ...execution, + }, + null, + 2, + ), + ); + } finally { + await client.dispose(); + } +} + +main().catch((error) => { + console.log( + JSON.stringify( + { + ok: false, + error: error?.message || String(error), + details: error?.details || {}, + stack: error?.stack || "", + }, + null, + 2, + ), + ); + process.exit(1); +}); diff --git a/DouYinSparkFlow/core/tasks.py b/DouYinSparkFlow/core/tasks.py new file mode 100644 index 0000000..65b0fa4 --- /dev/null +++ b/DouYinSparkFlow/core/tasks.py @@ -0,0 +1,556 @@ +import asyncio +import hashlib +import logging +import os +from contextlib import contextmanager +from datetime import datetime, timedelta, timezone +from pathlib import Path +from zoneinfo import ZoneInfo + +from core.browser import get_browser +from core.msg_builder import build_message +from core.protocol_dispatch import run_protocol_tasks +from utils.config import get_config, get_userData, normalize_unique_id, save_userData +from utils.logger import setup_logger + + +config = get_config() +user_data = get_userData() +logger = setup_logger(level=logging.DEBUG) +debug_artifacts_dir = Path("logs/debug_artifacts") +debug_artifacts_dir.mkdir(parents=True, exist_ok=True) + + +async def retry_operation(name, operation, retries=3, delay=2, *args, **kwargs): + for attempt in range(retries): + try: + return await operation(*args, **kwargs) + except Exception as exc: + if attempt < retries - 1: + logger.warning("%s failed, retry %s/%s: %s", name, attempt + 1, retries, exc) + await asyncio.sleep(delay) + else: + logger.error("%s failed after %s attempts: %s", name, retries, exc) + raise + + +def _safe_name(value): + return "".join(ch if ch.isalnum() or ch in ("-", "_") else "_" for ch in value)[:80] + + +async def save_debug_artifacts(page, account_name, target_name, stage): + if not get_config(force_reload=True).get("saveDebugArtifacts", False): + return + + timestamp = datetime.now().strftime("%Y%m%d-%H%M%S") + stem = f"{timestamp}-{_safe_name(account_name)}-{_safe_name(target_name)}-{stage}" + screenshot_path = debug_artifacts_dir / f"{stem}.png" + html_path = debug_artifacts_dir / f"{stem}.html" + + await page.screenshot(path=str(screenshot_path), full_page=True) + html_path.write_text(await page.content(), encoding="utf-8") + logger.info("Saved debug artifacts at stage=%s for %s/%s", stage, account_name, target_name) + + +async def locate_chat_input(page): + selectors = [ + "xpath=//div[contains(@class, 'chat-input-dccKiL')]//div[@contenteditable='true']", + "xpath=//div[@contenteditable='true' and @role='textbox']", + "xpath=(//div[@contenteditable='true'])[last()]", + ] + + last_error = None + for selector in selectors: + locator = page.locator(selector).first + try: + await locator.wait_for(state="visible", timeout=10000) + await locator.click(timeout=5000) + return locator, selector + except Exception as exc: + last_error = exc + + raise RuntimeError(f"Unable to locate chat input, last error: {last_error}") + + +async def read_chat_input_text(chat_input): + try: + return await chat_input.evaluate( + """(node) => { + const raw = node.innerText ?? node.textContent ?? ""; + return raw.trim(); + }""" + ) + except Exception: + return "" + + +async def confirm_message_sent(page, chat_input, message): + await asyncio.sleep(2) + + input_text = await read_chat_input_text(chat_input) + if not input_text: + return True, "chat input cleared" + + first_line = message.split("\n")[0].strip() + if first_line: + try: + bubble = page.locator(f"text={first_line}").last + if await bubble.count() > 0: + return True, "message bubble located" + except Exception: + pass + + return False, f"chat input still contains: {input_text!r}" + + +async def scroll_and_select_user(page, account_name, targets): + friends_tab_selector = 'xpath=//*[@id="sub-app"]/div/div/div[1]/div[2]' + target_selector = ( + 'xpath=//*[@id="sub-app"]/div/div[1]/div[2]/div[2]' + '//div[contains(@class, "semi-list-item-body semi-list-item-body-flex-start")]' + ) + scrollable_friends_selector = ( + 'xpath=//*[@id="sub-app"]/div/div[1]/div[2]/div[2]/div/div/div[3]/div/div/div/ul/div' + ) + no_more_selector = 'xpath=//div[contains(@class, "no-more-tip-ftdJnu")]' + loading_selector = 'xpath=//div[contains(@class, "semi-spin")]' + first_friend_selector = ( + 'xpath=//*[@id="sub-app"]/div/div/div[2]/div[2]/div/div/div[1]/div/div/div/ul/div/div/div[1]/li/div' + ) + + logger.debug("Account %s is opening the friends tab", account_name) + await page.wait_for_selector(friends_tab_selector) + await page.locator(friends_tab_selector).click() + + await page.wait_for_selector(first_friend_selector) + await page.locator(first_friend_selector).click() + await asyncio.sleep(2) + + found_usernames = set() + remaining_targets = set(targets) + + while True: + target_elements = await page.locator(target_selector).all() + + for element in target_elements: + try: + span = element.locator("""xpath=.//span[contains(@class, "item-header-name-")]""") + target_name = await span.inner_text() + except Exception: + continue + + if target_name in found_usernames: + continue + found_usernames.add(target_name) + logger.debug("Account %s found friend entry %s", account_name, target_name) + + if target_name in targets: + await element.click() + logger.info("Account %s selected target friend %s", account_name, target_name) + yield target_name + + remaining_targets.discard(target_name) + if not remaining_targets: + logger.info("Account %s found all target friends", account_name) + return + break + else: + if await page.locator(no_more_selector).count() > 0: + logger.warning("Account %s reached the end of the friend list. Missing targets: %s", account_name, sorted(remaining_targets)) + return + + if await page.locator(loading_selector).count() > 0: + logger.debug("Account %s is waiting for more friends to load", account_name) + await asyncio.sleep(1.5) + + scrollable_element = await page.locator(scrollable_friends_selector).element_handle() + if not scrollable_element: + raise RuntimeError(f"Account {account_name} could not find the friend list scroll container") + + await page.evaluate("(element) => element.scrollTop += 800", scrollable_element) + await asyncio.sleep(1.5) + + +def _is_manual_run(): + return os.getenv("SPARKFLOW_MANUAL_RUN") == "1" + + +def _schedule_timezone(): + timezone_name = ( + str(os.getenv("SPARKFLOW_TIMEZONE") or "").strip() + or str(os.getenv("TZ") or "").strip() + or "Asia/Shanghai" + ) + try: + return ZoneInfo(timezone_name) + except Exception: + if timezone_name == "Asia/Shanghai": + logger.warning("Falling back to fixed UTC+8 because %r is unavailable", timezone_name) + return timezone(timedelta(hours=8), name="Asia/Shanghai") + logger.warning("Falling back to system timezone because %r is unavailable", timezone_name) + return datetime.now().astimezone().tzinfo + + +def _normalize_send_window(config): + raw = config.get("dailySendWindow", {}) or {} + normalized = { + "enabled": bool(raw.get("enabled", False)), + "startHour": int(raw.get("startHour", 10)), + "endHour": int(raw.get("endHour", 18)), + "scheduleIntervalMinutes": max(1, int(raw.get("scheduleIntervalMinutes", 10))), + } + if normalized["startHour"] < 0 or normalized["startHour"] > 23: + normalized["enabled"] = False + if normalized["endHour"] < 1 or normalized["endHour"] > 24: + normalized["enabled"] = False + if normalized["endHour"] <= normalized["startHour"]: + normalized["enabled"] = False + if bool(raw.get("enabled", False)) and not normalized["enabled"]: + logger.warning("Invalid dailySendWindow=%s, disabling windowed sending for this run", raw) + return normalized + + +def _account_identity(user): + return str(user.get("unique_id") or user.get("username") or "unknown").strip() + + +def _parse_sent_at(raw_value, local_tz): + if not raw_value: + return None + raw = str(raw_value).strip() + if raw.endswith("Z"): + raw = raw[:-1] + "+00:00" + try: + parsed = datetime.fromisoformat(raw) + except ValueError: + return None + if parsed.tzinfo is None: + return parsed.replace(tzinfo=local_tz) + return parsed.astimezone(local_tz) + + +def _target_sent_today(user, target_name, now): + history = dict(user.get("message_history") or {}) + entry = history.get(target_name) or {} + sent_at = _parse_sent_at(entry.get("sentAt"), now.tzinfo) + return bool(sent_at and sent_at.date() == now.date()) + + +def _scheduled_send_time(user, target_name, send_window, now): + window_minutes = (send_window["endHour"] - send_window["startHour"]) * 60 + start_of_window = now.replace( + hour=send_window["startHour"], + minute=0, + second=0, + microsecond=0, + ) + seed = f"{now.date().isoformat()}|{_account_identity(user)}|{target_name}" + digest = hashlib.sha256(seed.encode("utf-8")).digest() + offset_minutes = int.from_bytes(digest[:8], "big") % window_minutes + return start_of_window + timedelta(minutes=offset_minutes) + + +def _select_due_targets(user, send_window, now): + targets = list(user.get("targets") or []) + if not send_window.get("enabled") or _is_manual_run(): + return targets, [], [] + + window_start = now.replace( + hour=send_window["startHour"], + minute=0, + second=0, + microsecond=0, + ) + window_end = now.replace( + hour=send_window["endHour"], + minute=0, + second=0, + microsecond=0, + ) + if now < window_start or now > window_end: + return [], [], [(target, _scheduled_send_time(user, target, send_window, now)) for target in targets] + + due_targets = [] + already_sent = [] + pending_targets = [] + for target_name in targets: + if _target_sent_today(user, target_name, now): + already_sent.append(target_name) + continue + scheduled_at = _scheduled_send_time(user, target_name, send_window, now) + if now >= scheduled_at: + due_targets.append(target_name) + else: + pending_targets.append((target_name, scheduled_at)) + return due_targets, already_sent, pending_targets + + +def _prepare_active_users_for_run(active_config, active_user_data): + if _is_manual_run(): + logger.info("SPARKFLOW_MANUAL_RUN=1, bypassing daily send window") + return [dict(user, targets=list(user.get("targets") or [])) for user in active_user_data] + + send_window = _normalize_send_window(active_config) + if not send_window.get("enabled"): + return [dict(user, targets=list(user.get("targets") or [])) for user in active_user_data] + + schedule_tz = _schedule_timezone() + now = datetime.now(schedule_tz) + logger.info( + "dailySendWindow enabled startHour=%s endHour=%s intervalMinutes=%s timezone=%s now=%s", + send_window["startHour"], + send_window["endHour"], + send_window["scheduleIntervalMinutes"], + getattr(schedule_tz, "key", str(schedule_tz)), + now.isoformat(timespec="seconds"), + ) + + runnable_users = [] + for user in active_user_data: + due_targets, already_sent, pending_targets = _select_due_targets(user, send_window, now) + pending_preview = [ + f"{target_name}@{scheduled_at.strftime('%H:%M')}" + for target_name, scheduled_at in pending_targets[:5] + ] + logger.info( + "windowed user=%s dueTargets=%s alreadySentToday=%s pendingTargets=%s", + user.get("username", "unknown"), + due_targets, + already_sent, + pending_preview, + ) + if due_targets: + runnable_user = dict(user) + runnable_user["targets"] = due_targets + runnable_users.append(runnable_user) + + if not runnable_users: + logger.info("No targets are due for the current windowed run") + return runnable_users + + +def _account_match_tokens(user): + tokens = set() + username = str(user.get("username") or "").strip() + unique_id = str(user.get("unique_id") or "").strip() + normalized_unique_id = normalize_unique_id(unique_id) + if username: + tokens.add(username.lower()) + if unique_id: + tokens.add(unique_id.lower()) + if normalized_unique_id: + tokens.add(normalized_unique_id.lower()) + return tokens + + +def _persist_browser_send_success(user, target_name, message, sent_at): + target_username = str(user.get("username") or "").strip() + target_unique_id = normalize_unique_id(user.get("unique_id")) + if not target_username and not target_unique_id: + logger.warning("Cannot persist browser send history without account identity for target=%s", target_name) + return + + accounts = get_userData(force_reload=True) + matched_account = None + for account in accounts: + account_username = str(account.get("username") or "").strip() + account_unique_id = normalize_unique_id(account.get("unique_id")) + if target_unique_id and account_unique_id == target_unique_id: + matched_account = account + break + if target_username and account_username == target_username: + matched_account = account + break + + if matched_account is None: + logger.warning( + "Could not find account to persist browser send history for user=%s target=%s", + target_username or target_unique_id or "unknown", + target_name, + ) + return + + history = dict(matched_account.get("message_history") or {}) + history[target_name] = { + "message": message, + "sentAt": sent_at, + } + matched_account["message_history"] = history + save_userData(accounts) + + user_history = dict(user.get("message_history") or {}) + user_history[target_name] = { + "message": message, + "sentAt": sent_at, + } + user["message_history"] = user_history + + logger.info( + "Persisted browser send history for %s/%s at %s", + matched_account.get("username", "unknown"), + target_name, + sent_at, + ) + + +def _split_sender_modes(active_config, runnable_user_data): + if not active_config.get("useProtocolSender", True): + return [], runnable_user_data + + browser_sender_accounts = { + str(item).strip().lower() + for item in (active_config.get("browserSenderAccounts") or []) + if str(item).strip() + } + if not browser_sender_accounts: + return runnable_user_data, [] + + protocol_users = [] + browser_users = [] + for user in runnable_user_data: + if _account_match_tokens(user) & browser_sender_accounts: + browser_users.append(user) + else: + protocol_users.append(user) + return protocol_users, browser_users + + +async def run_browser_tasks(active_config, browser_user_data): + if not browser_user_data: + return + + playwright, browser = await get_browser() + try: + semaphore = asyncio.Semaphore(active_config["taskCount"] if active_config["multiTask"] else 1) + tasks = [] + for user in browser_user_data: + logger.info("Using browser sender for user=%s targets=%s", user.get("username", "unknown"), user["targets"]) + tasks.append(do_user_task(browser, user, semaphore)) + + await asyncio.gather(*tasks) + finally: + await playwright.stop() + await browser.close() + + +async def do_user_task(browser, user, semaphore): + async with semaphore: + account_name = user.get("username", "unknown") + cookies = user["cookies"] + targets = user["targets"] + context = await browser.new_context() + context.set_default_navigation_timeout(120000) + context.set_default_timeout(120000) + + try: + page = await context.new_page() + await retry_operation( + "open creator home", + page.goto, + retries=3, + delay=5, + url="https://creator.douyin.com/", + ) + await context.add_cookies(cookies) + await retry_operation( + "open chat page", + page.goto, + retries=3, + delay=5, + url="https://creator.douyin.com/creator-micro/data/following/chat", + ) + + logger.info("Account %s started the message flow", account_name) + async for target_name in scroll_and_select_user(page, account_name, targets): + try: + await save_debug_artifacts(page, account_name, target_name, "selected-friend") + chat_input, selector_used = await locate_chat_input(page) + logger.info("Using chat input selector %s for %s/%s", selector_used, account_name, target_name) + + message = build_message() + logger.info("Prepared message for %s/%s: %r", account_name, target_name, message) + + lines = message.split("\n") + for index, line in enumerate(lines): + await chat_input.type(line, delay=50) + if index < len(lines) - 1: + await chat_input.press("Shift+Enter") + + await save_debug_artifacts(page, account_name, target_name, "typed-message") + + logger.info("Pressing Enter to send message for %s/%s", account_name, target_name) + await chat_input.press("Enter") + + sent_ok, detail = await confirm_message_sent(page, chat_input, message) + await save_debug_artifacts(page, account_name, target_name, "after-send") + + if not sent_ok: + raise RuntimeError(detail) + + logger.info("Message send confirmed for %s/%s: %s", account_name, target_name, detail) + _persist_browser_send_success( + user, + target_name, + message, + datetime.now(timezone.utc).isoformat(timespec="seconds"), + ) + except Exception: + logger.exception("Send flow failed for %s/%s", account_name, target_name) + await save_debug_artifacts(page, account_name, target_name, "send-error") + raise + finally: + await context.close() + + +async def runTasks(): + active_config = get_config(force_reload=True) + all_user_data = get_userData(force_reload=True) + active_user_data = [user for user in all_user_data if user.get("enabled", True)] + disabled_user_data = [user for user in all_user_data if not user.get("enabled", True)] + + logger.info("Starting tasks with config") + logger.info("multiTask=%s taskCount=%s", active_config["multiTask"], active_config["taskCount"]) + logger.info("messageTemplate=%s", active_config["messageTemplate"]) + logger.info("sendStrategy=%s", active_config.get("sendStrategy", {})) + logger.info("hitokotoTypes=%s", active_config["hitokotoTypes"]) + logger.info("enabledUsers=%s disabledUsers=%s", len(active_user_data), len(disabled_user_data)) + for user in active_user_data: + logger.info("user=%s targets=%s", user.get("username", "unknown"), user["targets"]) + for user in disabled_user_data: + logger.info("skipping disabled user=%s", user.get("username", "unknown")) + + if not active_user_data: + logger.warning("No enabled accounts are available for the task run") + return + + runnable_user_data = _prepare_active_users_for_run(active_config, active_user_data) + if not runnable_user_data: + return + + with task_run_lock(): + protocol_user_data, browser_user_data = _split_sender_modes(active_config, runnable_user_data) + if protocol_user_data: + await run_protocol_tasks(active_config, protocol_user_data, build_message) + await run_browser_tasks(active_config, browser_user_data) + + +@contextmanager +def task_run_lock(): + lock_path = Path("logs/task.run.lock") + lock_path.parent.mkdir(parents=True, exist_ok=True) + + try: + handle = lock_path.open("x", encoding="utf-8") + except FileExistsError as exc: + raise RuntimeError("another task run is already in progress") from exc + + try: + handle.write(f"{os.getpid()}\n") + handle.flush() + yield + finally: + handle.close() + try: + lock_path.unlink() + except FileNotFoundError: + pass diff --git a/DouYinSparkFlow/docker-compose.example.yml b/DouYinSparkFlow/docker-compose.example.yml new file mode 100644 index 0000000..225d66f --- /dev/null +++ b/DouYinSparkFlow/docker-compose.example.yml @@ -0,0 +1,56 @@ +services: + proxy: + image: metacubex/mihomo:latest + container_name: mihomo + restart: unless-stopped + ports: + - "7890:7890" + - "9090:9090" + volumes: + - ./proxy/config.yaml:/root/.config/mihomo/config.yaml + + web: + build: + context: . + dockerfile: Dockerfile.server + network: host + args: + HTTP_PROXY: http://127.0.0.1:7890 + HTTPS_PROXY: http://127.0.0.1:7890 + ALL_PROXY: socks5://127.0.0.1:7890 + image: douyin-sparkflow:local + container_name: douyin-web + restart: unless-stopped + depends_on: + - proxy + environment: + TZ: Asia/Shanghai + HTTP_PROXY: http://proxy:7890 + HTTPS_PROXY: http://proxy:7890 + ALL_PROXY: socks5://proxy:7890 + NO_PROXY: localhost,127.0.0.1,douyin.com,amemv.com,snssdk.com,bytedance.com,pstatp.com,volccdn.com,bytescm.com,byted.net,douyinstatic.com,bytecdn.cn,byteimg.com,bytegoofy.com,toutiaostatic.com + ports: + - "8787:8787" + command: python main.py --web --host 0.0.0.0 --port 8787 + volumes: + - .:/app + - ./logs:/app/logs + - /var/run/docker.sock:/var/run/docker.sock + - /var/spool/cron/root:/var/spool/cron/crontabs/root + + task: + image: douyin-sparkflow:local + container_name: douyin-task + depends_on: + - proxy + environment: + TZ: Asia/Shanghai + HTTP_PROXY: http://proxy:7890 + HTTPS_PROXY: http://proxy:7890 + ALL_PROXY: socks5://proxy:7890 + NO_PROXY: localhost,127.0.0.1,douyin.com,amemv.com,snssdk.com,bytedance.com,pstatp.com,volccdn.com,bytescm.com,byted.net,douyinstatic.com,bytecdn.cn,byteimg.com,bytegoofy.com,toutiaostatic.com + command: python main.py --doTask + volumes: + - .:/app + - ./logs:/app/logs + restart: "no" diff --git a/DouYinSparkFlow/docs/images/image.png b/DouYinSparkFlow/docs/images/image.png new file mode 100644 index 0000000000000000000000000000000000000000..be5673e20be1924d93af3fc73f444933a25ef171 GIT binary patch literal 19699 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⒡X^W#_=C9d56`v<-j2Q>%tvB znqryuzt8@^Td-2~+`Zz@4UPUx=yqN;H%QmJAPhgLLJaDzK4&+mOKg(!YPQ=C`1T*%YH1^L&&eAb6NOFU+{>9? zTsZRe751+MN|AAFC;{=Q>pMi}jYo!cQVIXPaG@sfdGsDTTgnVU2sB;8s8JF*WyC zx*L67nTZ|l{O89vgSWI`p!J05+O!|O|M+s6mCWY$%cY=UU#n%Rq|mErq7dQ&)A=-qb!whY&|M(x$lFcFuLA6nKaI2&N-P;VV5*Omyycpl zUbArF({A>OyC79?DVWX+P>C4ocwj#w0bln;6{2n0QW#M`Yb!85YtfA%4g0A5YlbD< zEmyIRdYYYx(}>iDXndsuuE6le$G(81R^>36O$C8a@;3wz5L_S$V3t?Fn=vJPtrvJ8H&yxu!}b`AMYbQ+aH^Pmz=kKh#Y%~2^wvEfzar}&N<$=yyi z5tABIQ#~ss2HXQrCq1gAY~0FF>?ZZ*B^9>&r&9jBkC#lrU{|bZ+cWn5*3T{s?h9SG zhnvL5KN^grpS3M34tjy_rN*R_C(}<;pIM<>?HS$CLQHo2Oyg15NqtR$L2L94m=VjF z8PN`GZux1)GE&v7N$zMH>8Q23d@~0Y@1h?&gPu+|Z09g-N}A%k{ANMcq&We(y!z73 z#M0QlDZF&w8*ln*jbDsmpuWTQ^@eW=ytD7svPL<)8r-kf0Ts?_w^Lj}^{_wr8uGMuU4%qnX zrY?yf#U^umx8#Rp|61L!jyC(opeflYxNEkep8CTRLZ_-8v}cQHaMMLl?4A`@SW`^m zGJd288RZKlhCuOUofT6c<;p@IxrMvKaqD{&FYDU$2nPDu;jD@%xG?jGnE4Ubup188 zlA*?~tqQ5@%#SXuC=}YI+?y5IIE9H+D)?;obRzTBvd`&@fS0cIZT$%dv6yPZx7(?G z@Wg?5Iqx4-Fh2j3#Z#4~Mgyt6%#?*b)fB}a9k*(>HJJH7;S&UH+ z|CAuc%+Bl^wbkC%=v3wnV3abcxcYUqwix*JW1kzXaWeqs>KQzsn~6yr3@TdVddqk35Q9N~TH|shrI|320()P@@ykn9z`Q1r#ZhXAe6?eMvDRd!5|mgQZNM0> z9vRLS_SYOIPaM29B~Kwua-Kky;qzbIWSPhtd~rqfP2x$5>KWqQON!}^IhA6{wCm2i zm`}JV7!T)?E1Yg`k^fZOP6}*KGkEYR7BoX5Qa`VA0!z}PGfx{49!grjf4!mEYiQWR zmG|-GIe)4qA&ww;LSJN5bILtFQL07EGrpa*$bh#w12~>tFqA_+qmYG{84v&4PtfxW zofQAhEVf`k#fGF9_Rh3pznEB@lM#+`nm3sDu2M~yrL>|C$KrR2W@ypR--b`;(m!+T zwWl|5WN`R`9q?-+E#`p=BOtym`Ahed4f%L9iN(p^;R#&=pPZwBTc7n=KbS22zqD84 z;PxP0!`N2474LP^eBTt|hR0B=9P{6hwiNf&&#*(!2^yL9eM2{ku@QV!5js6-{T(DA zPk-Q1vfz4|m<5`^@PeOp#^MF{&a^U*?i+s;{)AHGh7pr-=vx~s>WV>;Cd_JkEH~LB z`}Bg5k>AR4ag<<=xpapB2XfI_GsjIn3JQve3v65JW3O^l5u657T(F59pk4E?x2g@h zv*uZ$3PW)&^!eKrcF@ZxmeCH)Ox-ams!{7jyr9G)MB`RdsIXi|uRie%dtWbxt>rI$ zXqL$Zf!GNdBjDTT?QGn~zCFhmFOQ8Fq;&2#ghKMns9t}nwnwxJm7#+Y&IoyWH-u)m z$Dra199l-@4|e&5A#%5a4wqf1%5(E`Tmd}#Y`(78E&mgRmCryBy6!fip#&}a`8M;i zbKv<>V(U9^-c%;OV2hfSJ#lg#l=aC^K?lkq1=k?} zxIUHhHew>nb~j^9M9IN`CDv@qf~b6%GYnm-vaoWnCvH05n-+YI^!F{EhP>CmWPStV zQuW_B1*TNFa(i>12Mkx(Ts02;I+RT@d*4bM=n&W>g+Y>Om)YqU9LDZ%7nT8CDC=Q8 z+hp?r56v$Q=P7%lOk@n@Kw*;$HL75W5Gb1tDW`^>x3e^)6suLOkLAD3FJ=E8u6`HD z_Pb6zVJ~1DFY5 zXmYf?mjtfWfhO20kDqZ})M7*|t7c5sv|`NWFT-~dkRsV6<#-a%xe4jTFxb0=Df0x)MWh_Z*waqFTvwX>4^TIF3)O#mBs6l^Nxe z--`_cO!_nTOn1!_l(vIJzdDc+|M9vH?qBEYmh0%M9%p>Nw9y8nFW<&do?jawo{!yf zFW+2ZUc9Z=yxvfZS&O%PcC7S?vY>Tv4gS=Jcg4O*Q*e_79PTS@Z?wf6ST$VqOSV=TuuoUschfaLj0Z-EKih71L0pLv1u}M zrVl{;M|B!~Ck1@;h2=|{5YuP0^A+-4wTRJ%zR3bb$nn|Vzf+!QLAhJ|{k;Camg(UQ zcR6@IZ&0``V^FlLsi&_?g8zOU6K|&*L60aK7ogpZ1c}h4aUYKB1jDzYt}c+ zeiI_*l#46vDxAD60N*3KPr3M@E_IX02+G2dH`3aueieCRvC?G0czf+-Xu=M(OutoR za|xCy?T1VxX+dXwxdYeKq6)bP;#e-nWj7&9Bn_yLD%FABcc|!x*5$T|@t{doHxzu9 zi=w;G<$gmKSofw-im7fkF_nXQ)WJMssUG@&0s;j6`z#IQDW0mC3)zWwF1UN;EtCP_ zH;-Tv^@04m`HTOyhp&|v5dQb4`Qv~5f9Nrak(G7~R2FUI!4=EJhf5bp;c-ra%(9bM zBlDyN$65-V5b5iW%a|1lNt4u|w;U9dH~6%jYYcVJ={Qr5np-j`DZZjjB}+}4L8gdg z(NfXTi|jvPq3A?Kmyn^cUKEQ$O(IATB6Svr`%aVh$Zd+%wU5bAWh~<`Mrp| zqQoo^;{W+8zh-y|vf7S#>Chefm*1eU(hf{=xz8lZQLzr&O#l~(np(HBL zxAwT7^0&X!#@EUVfN9?NMQ4KhFD)|5PGXS^1W6NIH_HIaF;T_GZ+f1X+s}OV0wdA; zG(zWW6rGoLR&ifH(T5Letf_SI6tz=JZguI{sibEs&ngKE>a zW5V<_7tg=U^Dl1Y58g@d;!8kg*-0#t!Q`sy)Hr2Ks?+EgX82B+k|oK6pL*-&AT!^% zpQ5GXL@&I|Wg01R4l{Wey%nLhl`uU|?n$^0Q>=(#>Zyzprc2VId)7)jXzw}x45Q%^ zY?j11$y7$Uc$Pc2u<)Kr@}~cT$^ZF`VQ_4E?9bd!VOfOB&;E$%Cyce$$yGZsYSvKr zmyOs9E;0RA2e|wX#vLq>X6m5ytmAtdJNQcJG_N1u#2>zERY{EGsvRS8>L5vO$iPBU zU012yWAQOY!mVeWw}_ww=tJjX7E)}`s@j(7KAUX^nu3Ip{H9x~&R?AcBJKiA5F8+S zpX!n`)-A){x|SJ3QiXm3RmB~6ctTjN+9`;VqD};>ajE7)j1Y0EsZaz8K21@3>Xi5d z?%K$LG9Y|zb|R9ic2tU&VQ+85UI16l{wzB&$_2l%m0L=Ik6!1h2@ literal 0 HcmV?d00001 diff --git a/DouYinSparkFlow/docs/images/屏幕截图 2026-02-14 224614.png b/DouYinSparkFlow/docs/images/屏幕截图 2026-02-14 224614.png new file mode 100644 index 0000000000000000000000000000000000000000..5ceca78bfef33092c253710b8e3303046a34f0dd GIT binary patch literal 123891 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%0A9qgmyb%C>rfap$P5% zI**|J93Z1j+V+=S{`o{>f?oBUaH%&4Du}Zt#9aQ*is{MuP@>BF6j<+4?&Jjd5goUm zR`1UYO1Z0@AfmH(g&|p~z~t;e_7y(4B(C7UNCNvLXp*qdifgy@fw4=!;5VIDUMJtY zb3``@ML|s%^=3L`&K=FAzr;YSK1U_dM#7-`?wS<-G>fOC-mJqhO+1NwuNcitv6Nk2u@_QX8BCCC+CK{0<4829$m3A8k{ zd!ok`?opDC`o=VSXNQOy9_>e8422#RPDC~;qS1uQv3mM-Ac-K@h84*${k=E7l*8aH zlegBi_UQCz2-nKFW&!8wPxhmbZA--RYg;yi-@}&0N1mhj8S;FWn^iv7!eIIH}+ zf(io@kqpMyHjU%#8ayi{VaHb+tWANl%9p`;qc! zy@E7_O4oBug(|4%t#VJij9|p#tH`pNkEf-()rIIRuCq$g=GmzZ`%rM0YlLSrQkAwo zul{n&Y26#Ar1ke7&Zee`-o11-pC98c%gjS~oCPM^q#2QlpP7^74D{CFXT$7itWSQs#$2&9MGR?uLti$jgDo zBv%97p^2JVe&h=HJ0ieK;BW~n*6rN|WwE{-g~HzBt`ty%7nexSb)Ggkqh_nT!9ly? z7ij<4@U__41yl?{jj@h7f|trK1S&?O%U4n@K8h;)mPimUGazobE)J`W@YvmNq&vE3 z5ep3RJ)}R_;#Y!p2C_Rc^|3AY80(3b+XI^m8Pg+n*NNl6v7X(FV}tD z{9H=TLAMLY?1o0{n(o#WiG3uwE>hejI?8NbCM8E1I{kn~@iMi0(C@PLmAjb0|Nd(y)fL;MC z)M*l#VedVXxb%Fv&$*Mxng_`iV9r|t*E=c*DCXciK;k8XcuzN!VclcE(K3Z6klG+` zJ-r_OAk0byceHC@$X9o_?U3sH0V3GD(zDn2k$QQoI1N(CD- z;Bc2sI=_%+uYHjpyTW(f(?0s_0{uP<1Y94}9Tl&XrVhUiy}ojd^V1ax;mzVIueC?|^ATq)VGBD zU9xx&U6MDz|E_Ei*oa@@f+)q?48%ldo+~lJ-O*8T;4NpBs|J3$D|&8dZA&zE9=I06 zLzAv4EpA81Z)jIw33$#!{hXCWKheH)6eIn30c{g-zEu}XNw?j?$DDNRH%ScHpl)N4 z%*s&Zt0RHb4H8|0O%mur=lS&-1ahm<_}SJ9z7cva_o;+l;GkEs_=B*CX zuELC)U60JboqZWo#~DjcPh|G$cR^^lfSPQRj)am8hOxoxxtX^c+l+G1pUUrp+|8Yl zQ%xbkdl^C27dyt~1gYJDpU~@2iI#c93H_28^!khwI#sZdfOTP$YKO$96@J&m9&jl= z)B5DMds}JmS^$h$vlY8MsT&2Q{+pgkfB6~{^$;-gp(~JhKuZ5a#95l1YEjWgr4q^# zDH;p?$cWqWQSYulGxq|a2N0!z`$t^xH+xR}yuerZ$fI-5;`DFD*G!wa$l8d*^;H`E z#nXq@n`ce>HD?L&{>Hc*2;C0v;z@^#oL6)@2q&VzMYuDe}Nagi17b{RR znEIBx(4=??|L2Ob0Ep|#^9;ZNvYa5CoR!oB#fa9cV-LyZVB-N5+uK)yUor`%^MtV3 z^_!k$a@w$NZ67<9RizAO->PuCeX)T^>ZN{;L-n8pqAV0-qtWE4$wEZ`oM2xki=w*bVZHk8iAPT?<}szr8E!<#DRQ!9fe5 zJ517Y^p=QFtPYABpBSQLbaBifcu8jq&q#1P*rOe=w%_pEJ9K=Cv#xWw87vD@d?U*3 zUa}iOkG>|O6CLS0>y6gd{dFOa$gwsZ?__c|gC8^YIXjx3Tbf5ep?(ux-~!%TqizS@ zBSR1zc+nx|1^AuJ#u?Oaw{&XDEuow#f{kjOx7F&aKXfYgB{BVOhxj_?iT?bT^UE26 zg^FZQ7Rl*2Q8I}3627;c8-_zGd(K{Ujn!Wp7i`%x99kqnPChcF*wDF0puclr2%p~* zIq1|yQeq8ZIDDZ&y$(imWI33Un(74 z4Z~JtX;)4?FCJh6fRKx!v7WnVV6#Lsg4+x;oHFVf^^Wj5LoRma>a{dS z2D9mLSPzl}LZ7(kg9&<8n+x4o@2cOTn!hm3NDI#=GmOgTPE($I3tj%G8P@s3jyi$p9$cbWjt1x`gA@F8DHTuDAt z5lL4Dy^3~@4k#{6?J*V#oWGox)W3SL5Gv~Q3b0APe-ZMRSa0@dA3ZE2!)mp)`C8`q zqhe7Ao_SllobCAWMM!W%kMC`*0)-m(i27?2-iWa0Z)aMXBHC#Ec2cVO*594K;ZBKs z;uXkJ6v>b8j|44+R2?$S%zP*}}=yKK<5ErJ;RJ4x@FA!mz1VXT?a7M98 zI?!_QEMT#gpMju&9+3EDt1)^6pAs^Ek@M#S-L4)m9u#VBrH34N4%?$#pQ+UTV8d41 zmzudD;05GzT35ieA4qhpFonsfM)caM*$|~U3zWe*h}ns@wE+?ygmEYCn4`A@{B0T^LI@VbtyktAE8Gm9H}+)H$e8+DLj{zNF3^Y2CP{&n-(&w)SJQXH3Vy$u-n2zfedAwn zg*)kW2993Egg1!Ug@l&zFKCqdtC{coLB1Cku)&q;e4P9i+Jb_&I9 z6mg&l&lm^iW^GzmFS&~y65uW?vG(FmbZUw4#To$sYFh15rdy`z)8dr)U?o&Qk(I(4vbM{-8DR;;9a52hf)RS>8p0{fkyw!x7>mG>5Vf0vMnIPl_ zx$&=+nx}0!Q!F>)q+fJL(KU&1y$K;K*Rn!v0vVrUF71!){pN|@@ctE3AB=MH&w0zf z&7xWjK(-~>j+3EJSax}J^3HxHC*HQ*tu%k#+32rE+p3qo@iLpNsePgtC5@Opc;k07i9%aL#rM6>1#7^}riGKdhb|vRF?~v% zbtdd`g#$I^QEkdqYqfg)>D&j#gIxDmlbqb6FqV(6_7J^p51rtS*d2CttegL6OgX|t zvFv<+g;P(ZC6y#G{rVPFt*wV;kbPa4zJh20HOOO@ztT-*cH?tp0mzDzDoO z9Mi?;1qtl z3jNb()@eg%??dL_#X#)Rl2ZH1K4?yabUQ;|3>0ziK~SKG5Zlie-$g~psObgF%?_Am z8x*x{ zH~9PgYub|u_rtD1jV1{$kSC944_X}oi(o8ysVi}@RXFN)^<3sF&bW51$FKVE8JvNm z=wx$^Hi`-sLbFKzJKDT~)O&FJlib;OV%KC5n(OJ4c`70w5`oW@gmTMhtx#3Y)WH)I zkj)`QcY6$(R*AzD4tVP6c`VVgttD<3ua8pj{ENi$K_))#RKKq zV&49i_Al1WS|s@fHNW7u_O*$a_MT^_=YbQBuT#O!5`lVY_K!x@H`d?XDrkK;HBIL) zz_B^NufZJnFX}l4TxCz~d>Jlwkf%3WRjG?jl^sO8CeyxwVdc8QxGR-Z+JJYyez z>sU6kGKtgWky6&nUf`Y{BjVzWv!xJAJNelx?OU3NHmg_A1JQa!LL9U1Ml5W- zx^cS9{dT*XwFWHm7mqo<)yDu=WlVRN1cGpr5*F4GSuGuVe``7GXIj6ck}|4)+6Vya z)YyloJaTq&)Q+~Dpr~XpfqnL8U+_Es74q@B6rR|KkHGtPLQ;cq%<1u8b!$Zee~b*O zW#bGkBLijbu&MA{`k$F>gz7hT_A?CK#@(ZML~Pu#W5NDXA$3Q{?6=LS_3($3KD5{% zKVMX#ggWtohX)tIb+;SMoYK(&_?l?mPP=0##=XqL?%w6S@XIaVM+GaB=GLk@eVzS3 zr*}4c@fI;>#ZrviO=p(Q#wKr3Cc$HmaQDwfPdw=vhNYDFJuIyY)$A<}PJy-4`}Lw5-qa zVOda!|Et%34L2a_Hhy86*wSad>T5^U9w{;&J_n?+VqZOh6zhcgp;z#0d<5DI#gydw_JfRFe^!7m=x8yx6+k0kjX5Kl#!eb0ni+Bm(LWke?ZVk!i zc^^XSU-PL+Gt`v9pUGlDq$B{CI+T{c!JF>?)sZ5wY(N$xvnGK`G(K5@Umpv;K4Fc%|% zQ4zltjDnFgBK3|x-f5&D}+2B{q> zKdt@}Kl|^{1$?2+z=7xG<>jLUM7de@jNbsi`|rFu#lQYIQs>|wt~GC}8g)hB(8W1r z1D;*OC1vyNKb0j6yO(HaeDsI>POPuN*|A9IwE+oF24dTCqMwGsp}QKo5}xkMxn=$% zdot>GH1pHW9tLdgU16(NMf6h5y|1UnV3ug_be4o!XQAo!l&0~jRG*>N5S!WNrs zlLK4MRB+6nw^TyPJx|z%!%x?B(J>4b|6bf+{p+Sj1XKrIz2mM8O{cIwZ~ABX`tMv$ z98wgZ8Nk{JW4{Z~NcelvZAJIv07h8C>TY{76%TwAs1!0F`lur$J46Fmvg+}jDYc8} zCgvW3Y{?g$!8|*>2k&RgdP@QJ<>Z#0s|KQ2%s`7jqPc)!^cAtEGp_d zBWUj^XoHHh%4%KR1pQut-oY;^uZ!~-UY_D#Og`c6*VrJ*js1(=@|8Hl72<-2e>U?M zP{52i-IuubH=~)U-F@88kR()al6Og-@*0od`_QF*Fu;Vx&MFw+;C}LUK6Cs_v$gK< zAXbuq^`Y~z1+fcG0;TfZ4ChR3VI;l6EirzF(ua504MDtvgB6iJwxVjE5(?gK7WjM< z;g}vh=`HrWtj<34JS(r<5%hI2sEIXmX|}RhHX^+*Z9TC;svUN#CydH+>-(QCXYTgG zi*`@pSj?b9+HuwfIvX3sB%5@{mY^C)+s8e({QROo-^I!P?O~gssoB8fQf;xEIxTw% zfUEAtV9`_H4Np%t0K1H_#MPU9w~ttGl~`~oMY!Pjca|en^I*c9RW_9Gp5BpBs%9(5 zo#p6&XL~!~Y1wktNQY3tbSUoiRGl9J^rR|N4~2CFu4Qj$<_z{l@npI&c%x4p;xUdI zqCwn~s9ilqz0Az_0(zZjfK+BA=2pzCbP-j<74B*pzVqIk+Gcr#vAw@^D1lxv18hg} z`xTp$-bco~&n+YKvosQlqF;!Zvo`E4(zs?#h-7k=o-B)`6|gIibf4!GiG26_RxbaH zCJiaz@M^m^>r1=L_c~sUU^^^j1m}J1q)*vPnuYQuUI8+WqLq=+QLX%yUhdkM!lVAmnn_ZE@b7I}iIsL|e@_OE*i2@kqLg4@3q9p+DE*9*N1yB)^OKNK9jBmv z*ajKhq9eC6o?LaP*gzxnjopopsrf%Pwx{;{*M6Ji$O{$j^KIX@DC&V zv6q}-q59%SO9*>RWoHyAU%LeFaNv2~69U-k$B`|2pXk-5PLSkpjr z3UYKiqQIeLcmwFWB2$AHG3f;77Pg39jm>x0wfR|(s=@f_b~{R*_qwebY?izdV04z< zix1VNUoLk;iV`#;ZIrU z%umwK5Vc;yLK{I55qVAXSicm`Un$>yeM@`Igl}SS`%OUE^V_;5-zn$6&dE7i=TGUx z%-75MEokLa)Yr6V7T&k*eETSmN$%axJzcG~r}%A8pL`=_BGipSqSj2J5=_i^-?Jv* z>koJ1@ru9)M4%#k(I%UT=co)jyG`kcMn^5rPRphyy&4tEp!@ys){3F--+c;JvFAX4HPl7&!O7DhzS%5& zNdc7kwSNQE6rYdbfK32gKnlN<5ZdT!CHsb^cb4_#F$OkN`JY}+{0u`_zrXzbbJ5GS zGRgUwg3zLX^pS7WeYYJ(KXlS{IhXEb73$A`XoO`5HVcM1CEqVjZfp9|X}z9;R}kBK z8+3XArP?XCclvlq+BT^INov8|&F*o&s3W=8(N-@tm*75c9K{7U`|~)u?LkTQPm)*x>zl=>qwd-geZX z{L3vI9GusZMniHqI3w%HVk(*21PivGw@_Kz7EV-s!JGI_x$sI(nG!mhy#Ke(Ay*w* zBwnnXV*7ZjI8!HvYwE4+59zAr987m6hX|FxZou&&TSK5(tT`SFm3&NHhHNek}bq3-{U@}ZwAQw^%BnUP?U zUKCYNu;qRJKAJ)4LocoTZ^tGTlqUDY^`uhKE>)JD`%*FVfn{6c58Y?m2T;Y4gzC5* zl{e|ch59*~c}uZ}2Z<*w&r=LaG*O@S*^EjK7^>BZIl-)t=thF84aV-HPJNH+_Tla? zJZ6)e^z*d{eP794Z$tW^=S70+vCrMtR57+|s@X}>u2u#?wQmcTc`%bPqB^QMk{qx} zLJs=sAB++o$-ja}X@~M;Sw3C3WotAvj~~&^MC@jv_;ZzGNYpwWj1MD*rww4Undm4z z+sk3vxno8)%`@lYc$?R_pV+q2>+hd*$q=}dF8eq6ApDyO$`nTW~m^&4`I&xY8soM~eR9T=$6Xqh`y$W&LHRr}Ny~yT=<4HWC$s_bZq# zi@h#9ouk6jH{Ue#B(g!_qiaIuyD@%a_bG1{2U1e&9uAI*lp&mn2&R)Mz!LRG$HF5? zTC`+T^}liUo>5JFU)U%XL_t77KtRAk4Fb}ngNpPHN$5m60YZ`9n}Q-mLzCWH0zrBQ z6#)sogx(aXp-8WRJMs5_-?i@jc(WEOOyb8Hc_SEKJ%1pL0z7__&22?k_YQ`*x=ixN0t>LNzSod8h z^W)Ey+Wp24_y3MwCY)*)YbF_VI?XjS@s%0b_h@jCi@PW=E~}>t6xXFp){qYjFuxFK zveZ7V$>14pfihYnC8>r7yand&sgT3V{&Z=Ll} z?S~DJh0VJKKi;Jr{wmMvW4h?Rz-jok3`JH?#UCRU2@JPx=Te!HaZC7oX;2v3UNrG3 zYBoPs4JhCGOfI0R8yq@$IPgx#GJcvv{TSn<4ra^u-wK5mO3Cuyp~*jbGs`6T+lDgI z%WR)z{N3E*SEFy-(QX4o1-ZA^`?48|T z40&Jh4IrN%%9I;S`N2&d7_VFLc`9167_&^iVcS)u1Y?tjJkOrHvWVFI@SYjuRV9TN zZ<5`XQKyz;%Hv=w9f`4Aj2-;kw`O;m6%LC+viU<<#Da42VF3$A;w>IgoYUiG&*vT& zAJzk6LqY<3@_MK5DOit>ctBOLKQS$~XPq&!n{k2D^4*^JR`9?$v)4x+wxlL#$vQ^c zRW*E-*fOj9i7f~4JzzkE7#{OMhF-%LuwG5j=s32N1kcJ;nu1a@xi_Gg&b=+F`_OGc+^sj|!;J;_N*R|*TY*1xo5tqmq zr~`6>{1FL|YkSNEfxl!~Z~bdKcK17=3rR@y3!6NA7s7Jaq+ezEdPM8v2cD2te+0kQ zA@$*kFNfDBB6_N8D7SJm{l(rhDF3@uM9A#J72v-*dth^ywVVNe?zK8E*))8)6=p)2 z;M)IMWrco<^BUdTzfU~+ipQ$DgB((aYS$qh<+Rw|R)czec2&U*N%+8*Urdvtky@@q z6-_e#=uHCg`@fI>_x>^BNdNn|ARd3{NqqYE<|1+XK(9Os@vHbtr ze&Ckf6^j3R@&Bi*tLFbL-@o&juZV_cUeCvt!vBB$F`2kq)e%S0pdq&W%VSpZzmCWF zC%^vxB_0?JBU1oB@x4wQ7xm<3+n7A?&)9t;2eh5v!~zG;cJ-%P@i)XSkpzqVV^i#H zRpNMGT=!3cZ_$#Fj9ep9i{N*J|Hq*^R_Orago3jp8SOxFe!3k zV|Jozh*zVCt6EEr2Gd)i%)0($S;S3>O@(fsquc9TG zOOL*>1E*aOZU-q@PcN}2Bm(jh4yh> zR#og&UJ*$TBa)6bFqK#B3?AB~yv(&lH% z{FiiE2~Smt#;F0IEBtQ*V(k+BnhiX9PdhO&5gX4lECLoy*>iVNCl1^j5nyLv1m*1d zX#QEq>gU|tT-f}OPc=Iv9+=?Nb>3f=3X}WWos-^*+g$5%Ia)`*_a$Etx#R9M!-VyuS>H#BR2U4$Oqa#K*6xs=R0C0X;M+{Vso&T!W)1|^)a;N@vkIyow4TQy!k-MI?>Fn`^w1pwN&1wq*1f;cTP<^4aKZ z1h>FNQy+urM?)LX{jXYqfq@4S`6j*A|H<0hFElM~C+~zlsg%dNymCAJ zE>oFj&0*WF7yK9{BRTU>Rpy$zj>%tzba7vWB#yUrhGRQFjrh*j>Wn<^W^G@YEb_j9 zmQL*FLu-yOEn~YmHIHHFJ>GIA_bC^SYiZDva6Qn+J3g& z{J#V9;f#*~x`Q2Fp#N$gA0My&S@q``(0+E@_$j>9?SpATeqjj5bK=He0HjE{=76n% zo0O|KAg`Kzr@@na!sFQ~^*x=PeHM<>t=0!K`swiosWEGEb+rvO*(jQ4yO7i@ zU8JgNxBDuVuD!-dL7QmjzVd#T4}(CVP&0GJB9b7vWNYhv@_$?fG*OG|**hw;PwtDs zvH;3nXmF_Dqg-bk;TbcG0b4-kq8oC)?YE$&?nYQ!j+} zXvhMS+gPtX+k~;#j9ar%Z6PlqRoLC-nVsn7@phD z;T5Cn>UZWo;zRQ)^d!CiMCNfTC@M?(yfjQgZ+;8&sP~a%zLWRyR%6h&#a}kbtuHWJ z*?+cXOZ~`{)EG(+DnW5~Zsq@AR^nb%sx4M>Db{3@%&DaG<|oO@7N>r~0_&LyRUHd< ziQz5OwCu*V<0RufG%tM%0m&qxOJq_LAc;lzN3q-pcz9pLTi!FQ;l?Sa9v68iuHIRn zbOV+z5TjE1odDU}xU|tNS&01nl5*{iN(FUR*G>~^sGNWf(1xcJ@F&F=d7!Vqy{3;Z zqa;pdf64YP@+O^WT^30YKApbp3A=HEm4YTb!EjPvvjLTp*8mu$rP!xm?A-H{Biz5J zldGueHllc^+`$$rm+~{EO9<^MYoDH&%n8ht2-LC+CTdI|gR&;w@0QRbjp_^;hTP&? zwrZhpsfy}t^a3)o^@UNpg8`cgxn5mROpU**2{XrWgkterX&X*J7eqx3{Z`OxRHHw7 zj=>j7MR>)h+EfDY2otKBbg9793_gj_H!|WJjt3N+chE=T474#2?{_OUPPF6AsN8!=A3SybP^+ZF@Ci%`t z#al13e@IO8YPI8oO7)mB6|8`iy7B4*qLilqb`y~Ghd5ZCR2jeR!Qlf5?T-`AjD@Q@(kcjk@19fGO z%XKbOi2mr>J~eQa|KA*oaTL2d`bT|eP(^6UK%dc9i{I9t6S2ij!uxX5||=&9~05p}xI{mmmSLF2a- ziPw|BidOfpm%aiJ*nelMUk_cbnN*b*O2?1^r-Q?-6B8ylkT^LT!zAbzptIwDEN3j< zDvZz=cE4>#M3}+O2?+^4i=xD-oBf+wIJ8p3B3U4^vEK`wd z(N}11cd8B8DYlIt$Zv!Ols9}*BvL9uU0>M0g05zEn0D%_&`R(-QGXQmQ+U&C_?8LK zp9hhP^Y(v!U+L;ITM<(<&i}w5ur`}{ZgRu4!Qt#MD9dfRPwcx6k=*eT!&;Ty^K&hk zgC6yysUF|eGNTH|w+HKT1KgIc4~%|Ti>t^1un=QJbc9U8*5yK`?`A5>x;)WKt#$ll z1yS9cOdp)@bnMei`#HLI5nx7r@w=P}twQWv>n7V%1DOU7oy}EY%`4r80tATP0UJ2h z$=p$*++TGYrUuj0hCgnw3lUQFJoj9fCbt-?h3&6 z$r>UWhlX_dPPe$2gw~-P?yDHtE7u%;$(=6_a+L{~H5GZy8XLIIyy2hmnCmZCJv+ww zh}1gH6l`fV6L&AfR_&o0AKa($*!_l_Asg#)FYKEty=kBz`!K0Zkk* z!+(vj)VTGzeE1CNf8qk-;TdeCIM;DK;}_c-6<`a}o#4_!71bHU1^Sm2X!^ZGR=Ez_ z?5_)Jw}r=!6zkP{NDzqg4?~4m4^x29tv2QjM1|pWsf88zz0Nnep!g!N$%G?6pULgi zj+B%X-m{Tg{d>5-YP~hn?nh}YfC*tpx^s<|txMK6th)HoQqkX|RvR<5u-3peM$;zm zF7sCB*4>Qrt+#Tj$ncvjI)aFt{hiG7615}&2(vtHyXk1hgg{6?9Ko121s;Xnp<|$1 zozHG-@ZLr~e3(a<8CakcwEt$ZCVH4U=wr?hlBV=b8WOkV_iU?$a1rm{{bXah+W7Fo zF{SU%GTH+_%5<78<=&E|y-Yz40bYpY+SF#KBtocX#7cOm-nhX6(bdf{yf`EyI1ILW zEM$c+N&JQ`rb*@#r+Io9lrV-CY_^8s>%`WRNJrPtE!4E%P$D~!m=$%pVkr&%3-pohyt0ctgQP14Lfel7vC%h2Vz<)zsQ34+n!jZ6xj5noJQV2E*inp1psco^Y@)$-&_<*u&V*Bf_3Hdq@h1&@0Qi69^JeC`Fwa$;EOP=8BJE zf4H2G7gSY&&(F{K%YfhuhQBHVFt5o)#qGsheA>)Y2P{&=Z5DP72q7MMBJ(`AH$?2_ zNz!||21gN794hVY3{^heP{#1=%$cCf7cW9NRDix3Hb#GuQ&FMDZI`m;C6nWFjh$Fg zsSz{a@+Q3(N;Bei!Bg8+j)S`8<${24yWE#9a@={y&Ha<=q%J9GH5d)Oy?JOnYg6q3jyI|) zF?ARTCJ7>J24z4D;mNXw+r`BF{rvfJ--FdTyPepr;_<_Iz$-aFEdVzL;)}Qw5&;Ke zQO%x~rF4Er8<$`vyA^qPU_gjR#4(>gKlR-&a}&j{-y|x} zlQuTk=x*zUTzh*5=>EXTFgG{1!6WC!>YRr|vzQr1WS+2X-^x(Fnv-$WwWHJSC#c%u z$k^Dix~-^U*AgQ6wN2ZHK~M@10(C7>EinKUzdg4-s0@%^9UjYm2|ydg?RWSK;Hs1( z58(j4M1i?oOQ}D()?Y1)@Mv%KaDY0jdu=XUVoFIYXqGyi* zT^l58Vx+Upt>Ri<4oKcm60CG^Gb$=_k&%(nsL`o;N|26@0Y6^8fXplUsXQaL$mRQY zS(E@Y<;@GskPB+G}XPHk<$<7rm_r0 zw%4du1XNB=8!7fSYPmp(uqJOEHUU`nZ;Q?^)g>h*-!|ERIhz>kwj8qLN3j|66;+j! zCh{zFqWo$V*N)6ns_{GD-4isvPi(N^dk;ssyT`6vA~6vyDtQ_AS7XUsMc3TC97#ia zhn0S9;r69xyV_$1r8b7iOhT6%-B*!`=ZBUmLmRn@P=_(5Tk~atwXvg-T5`iXbiAU1 zi>D{60eX8A%jhcau87GdpAXk4?`82B*YZ61^7isNN~m$pC2aHj-1MYVZfQxpn@vH7m= zdixP_eS>YS-sAN8sn?pAv&=j2uRthEl3is}P+|d?)>#lQoazN#828ux8lqjKVkFgsbc_5#KKH z`8tI!6)cWfaE*F^4lj{V7Cu-iECJzv>L6xnOh1(x!T-)b*Q{j}&uX3QXopW7xNpo| zMEf4BU@i_j&}%6p3Q94o!$TK=IXbzDD;MXjjO32D4P2XvnxS8~71tl=TLuIQt3dk{ zEHb{}pwrz<_u+ZwnHXM?$KYD3R)t2-jnP(mf^lZxLH)`8Ms5(FzfzdP>lN&y|7pdDFv%)qmRZjT$}ECB0N# zu0zq})YM~5W9O*M*`TtsoAPV|7hpDiLK$#&ATIVo^})B%d!L(q4+buzca2F&4MP?~ zu8_5#3IJ@bo0RY?ef_692)`i^d-4kKm9xt4O8D5W@?Fa`JfE;n7xz)!nCw8QS%i{P zeDJux`-PnRgGiRM0OiV5<)zrbXCE?*i&!8Ghp8nKv~kjN8ncqU>5aM@oc$wt%%DR* zi=GAFhY~2LrB1snNtUFo!1P9vVN!JDs4^h%ZBL<%y7C2ZtVk(VwX#Ir+PVOUEEfA& zL|khj+B1?@6RAGnkn_NuU16)EEze%wgA=czyI*Ojd*K6&GHD8$i=~FcWjHU z21JH~gHyTUMepA)+8!$E+Wsbv%~L-%Vbbzj1!@6Y{UeU2E>E1(moS(yOc~9aLLynj zPu8#7(C@ZXRyHa~B#o5BV`^#&h_^uzFb>!N48E?_tByP2Ah z;{?%Hq#mZF#Wy+p*NykQU59M?`^{|T9ew+WSqf;_-AC$II-((&$|{C1{FXzdb#=@{ zQ7wZL@=lqKoC;Ja$xo(iFIE-@J%z7N&E*w8DseEN3pp63dTT#$w1tA@fyUTYi{5)F za1)v-C0DH2Fjl2zd5{Jbz0=Gwq_rPdP(u49wMG-V7E7(;6E&4LV(k~d<#?0IGRn&g zc+HQZGp5Tk$awvL7Ux%@d!i)1{yh%i?x|lrB|J$e1|~iV1fGS>%^y&~HX!L`uK{+( zr@Nsn%({N1J_2Ab5CA>yJj8krH_rDjTE}6qO@nNKvw!lRc=U!cB}Lz zRV7ql2xaYX2hIjO5G=QStKDI*InF&5%sPq~KyK*Z!kSQh8$(C|Df^M;IBcxzOIS!ID}(}UDB_(c;vjdV{tfOlb`Y30+!#AE`G|(O1#Rmw@)HJ^!r0V zyd@nv8in)JR8!Gh?sPBD zJgXAh8^U6*bcm;)4u!ccmJUzXONp+$R~b4Tt*Hrs$b{c1E7y|F`?G?juSe#+6)q8! zT5k;O9Btu9X>lo>NiYT11K@b8yEh>j`7l3UWw@a0u9zm%Q}xLA+xtI>AetLf)^T{F z?5IY5j`_~Vps+zDs>kVUWnQ? znR+u$7+;y%8bm!(a<6G6w4{r(WrrL>CC-m_vBot@tA@?Ip$h3qG@ber`cPjV?NtMX z)L`Iv}J(f1iiQ}1K{XE$(#Nko$Vl=^0=Cf@lu70V*{d6%KB22 zgL-|`8-_OJdR!&z23c}A>~rLCibp91Y5wCPZ^D#wg^ip&#qW{43rwc9;U8Ttnr-IBOHp^*(5X~h$?ragv+bCz4iIjaXgMMC;Z#czC+vUH zxsB|@uN(H)e2U@T^)I54f|O-d^+oJ1Tp`hBc$4rq8Ib7o9tp@c;eA};y;0lD9*BXR zokIJfSaJkWaRSnga!ByuXa0VUTg*Eb%L=QQhg0RfGdn2DsnyYpwHneI`)DB`8$Kw74x^J)AYhop#?w-to zih`?B9w4o?r7xwqC#+I(V)~I=xn`c-4I1jM0ndQ=t*M~k(E7yC-fB!Y%wK2eg8)|C z|MOR35JJwjpGQmAJwA0bkIqfNh|i36JyEpbT@fgI*(Y6ws~FO&FXLCE9O=S>&5$t$ z&tgX>HputAnbUjA(h31r;hLhsjZALt$3r<6{wCXm;Fjh)^z=D^iD3EJqkGV$H(6s@ ztGSe>yYuB6-G;?RnKOkTbH}CpLcn53!4H{cOv8Tb+qZ9CNpY7)On#GuXEJ4?{W%~% z5(4}nb1<-aRNnN?{qlnadxnLa^Ge{=WUDVR>`CUfWURw zb}n022@^2^E@Jzs)TA~2fr@0=p1>h@D?uYgGRN`}CHB+QeaP*|z57M+STs{VuByc{ zK|+Wneg73RkE)L3)~~1Q%U&IlTOdFZC9w&_+n=1D6qcn_l4E2 zoE(64Ex1^IN}H5B0ean@(Lj;ssitm><+ByA8AemtUcY;4F%rT0^Rr;A!$Gc2LicO? z`dp(}Ub799=5uR@MU-rV^QgK5=I4$zW#BrquE^4pN+?_&~q90 z#oRq=EL3&FILB*vfw-focJ)Rzqbzcp1u_2l&9GT)bO#Gj^H4jS&*og-K&b>sxKjEL4m@guMN-)i4R+goLhKlIP_HG~aSX1*Pl5d{{lKHd% zss@21D+NZxEo{s+>qWBVj$gZ{Pc(%P4M^OqtYwsDF#hqZT6)JKgK6s{b`{<4@5-6>2FXi(oj+AS%!%NP*~$hx z_Zd!{b819Q=Znpur31lRv6@%^$Sytkxru~n@?1j;wBkdzp}yKrmWLIfM5Eh!Fxs9RA(Vs z{+bR%91X4e{au&pMWDzk8`yD}wn5%26-gQ0nAuSGIU0?*8Kp`tPM+fo!AT*n>;i|1 znX^c;Dmx4$`RE5FE2|Kvnc!qGpWjYGnxn&|Ms2AyL~4un2jAY2yq$pM!scwR;ry03 z#5a4eOebWPTr8mQKuaBEcj>ebyAGO?py0&&Ir7LM-g_P@>s0W4p03rC0uTjcsvQVn z^QmYgNcdKHNJtoVL@^E(=}>w#m6WV?2NE23*z*UWc8d%1 zszi$Q1>ie>6s0hox_Z`{$rh$gQM(l`**#SvDo8;u{?_i4WGWeF?VKQ7{)XsTCkuP> zf$`dC7mIr;%qL8|a?Ru30cxtieE@;H*;Z81N4|0bF-+0rNK2h;Jux%o^C~DnI2dI< zu|O91{u0kv?~FsFv2_L}@9vTVB`mj~IfK!SmTx+z!T~%_wEv{3fV8H#A9~@%L)kS_ zMD@J#nzNHKQgslBxh|g3w=3qp7SJeq8QWCYAdT>nYcEDaYK-{f>zV=qe}!TF$rwSs z!{U>)ga9r%jAya1NI*8?Jx=ziL<9DGO%UTm%QiNiroXr8Ce=+XsHg>)xh?S?L&p3+ zIssJ{=Es632@!GovRw5>f?nZJus<6Sul?}`k|}kgd#idr5`4Yn{Bd#CO^0S}Jr4}Q z%`?f{VQk(P;y`Ewi$$9Gm+zcLu-d0d1XWg)0BK(d>&Pf$C%BOtB?Ciunna~*tSyBi z$7+O}<2W@jLzDH5=%mdAvI2@!gtEYppkG4}!dE;<2nrs5%*Q-o9B8X`yTQGAbLN3nz6$LruA=`T6H||seOZM(e>Cc@=haG7)O-wT~@Q=_Bn%2=ei-M(FpSWf%($63FuVoUwL z#6>_jC&GD2hxFvMtH1x_uVpTI(1pFS(BhVJg6SlPoiYNeI-LEw!j~?8*P4>YVgF(2 z5MYzP!{dwqc=E6Asu!pnOKFN`wr<%&p1NeACMvDf(~VBQtlGzYdQhofw$@EcYkg08 zWyX@vWX0h9&Kg?i8dZF~2bxZ?j)Kh*8E5T(0^ev`LUkTowmjUNj9|s|)fN_L#0ff^ zZD8V3d3SroSgufMad4_qOKUeSt6oWSa2BS2TvQ&NKk?I9M6Du_Kbmc>q)o)jBtZN- zm#%K!r$^RN%wtucs}8R`S07s2K>6+7W#al`PJ4u7=+ZSzFFnyr|Lq)U z^M)9G94BV^2GoJA*9GEFJpMuJ5wt5MsMC=qG4$rfEQ`Ld-bU}%>)F7{G2Z720jPJ5 z5Yxp3&oYgZN4+zRrMtgYWr<947{xL8TUo0} zdHy^*Fz#ogecII}RG?9rL54vcud{VmOUwa3Wcceg5Dp4VJz&)-WhP#x^F*9KUlr3uLLKF83O2uZS5hYK3HR6YF zmGjg2KQ%Pe)r`S8Rn=sN2-mnE=D#*nb9iux=`XcWH?qQ1BcsM(&PM~>kJ^|bN@dXO z3%Rjtta-N9U4Y7nAo!SQq@~!)aHh%BuIaTyh9fA5lkvigwdL3&gcr>X3?Z)NRe{Yt zV=%8%Z%<=aW0S`L=k+}jZuhpBZE0vrZ=o0=1e}T!2Dn)XvVkjXFW_@OU&&1gqT=Ah zdY}8OZZ@V`*{xPIY_AqtpZ%hy^qMbuoSZHx0kfs}gy8dZc*SqLRDqp3T6xrO2 z4;XLjCDUXQDiMMCY5499uJHn*T4Ff-s`ITEv8;`R`Coz?D6$lhz=UGs?=X7JEQ;%! znP=l{_OyatvpJfzh2&R0>0BVcZ5+INyu44%!Qp_ZH*W(iZ{tUbf5~4FL#Rc!MKB9I zt|%KV))Lp-KmPQY+j4bivYMU`5W&+qDN4mPy32L&Fylg!L3xPr(@``{X`R86SIdHs z<6fQ2-=Tb=O#dN5fBuh`jQBBF09~SH-OXTd|NN{Ou#Q0&jZ1T6z;c`UcAc`t6jAHr z{1>Bga>7py4Lw>^rv&k@TkB4JjFUzu`9VLKMN00;PVesqwS^b#*M+DN6RBT2{wrvG zCJZ)lghWlW4oV|ZqVx(&Tx@r&@V%N-tq+hqC_1^$RA7*#_!@Z4t{w; zq78BMw2x#6RUQ+=yD*5W>wea29BPt`SiruaESpX z(kBjBrg_nSWxPeAyXju2YOKgo?{3LXQMk+3COp4Gi;Qx*lwXbMi%`h%{u&y3w6dOw zNZ0T|OIyxLqkY}Jzv-ahOcl>F;N)(w> zc$Y#+M@bnLN)6_2p};=OYyrT#f2>9m1uYeG?{%8g^fY`#{yy_L9W~bAng=Q-f|dT2 z5^GB_GEyNfjnWNJd*Fz^n5#vx1I(-!pAx}pO@fk*ON>vgvM zSggS*`NWdVND&q^7)BN#m55sJFBj&8ip&~d6lggOb~zfz8-;`em<&?7lZ+XVaiw!G z{?Nn7jV5?!47QtxM~Kz0=d|;0A{ndQIH3#%W1Oa90a;Fq7p5k&`44K@&>nEcmAJj*X2GpLxKxd7>Pl>%<gU~T ztX$agtly%y-5Gf(pv8c3E*qMERmRfFX>Q0h($(J3aei#oDDb+%EkW;tC0UT4iRrqr zs47qx_Tp`bSqj;g0EYcUaD0$i#F~$$Z==B`Zo6S1M~&J;Z=>HC0?8CUSo4?4nQV|2 zL%OfT^+P_7R3DroIHzT(nHS2<1xHSTg39ol7w>m*aJb~fcv-^!NM-aBdNnl5>YDcX zwCs3u8GpQ-6K#QP(O*i*+YgPOTZN+>?F8p{%4{%LTDQqFhr}{o`)mi$(RiDYRv<7wHLe3oD@C z?H&?0NHBZx?!GJVLrTbef60L-hcH0h>E2(g>=nh>k7;ibK6O^yai^5wH?DG8{2O4` z&)js~!ZV#N z$8EH{v!7ATt`@JUoEqrk)_Kp+2|K}a(Zy%Zy;^2(K~$+SpZLSr3e_?n>%TNHDee0o zBi*F1oYNew`D{J`t-T?Q%jUVW2W-=&yvJqSf8TeeW2l1MGLW1XFZ0D_$GO{Xq}Y<0 zFMUa+lgq1kTXXRzQyJ2xs9`e0W%K}TXWKH^0vTG*Bu|U%7UZ4DjM81*l zA8O~$hSMUupR-6Q@*`nkWgkyc@JlPw5LojU)r^ zDa#%mg9BkBC$cWDnT_}f%Fh=%e4QQprTOUSaHnZ?l4IYV^W}Gl&&`T+K{5d0bCc>3 z*B7;o_73!K@7?_}=zLn0*?rbeleFO##(Gp7l`h5H!eQ^~+TO3Vz$NGDzd4igSXi*U zqTRDTn6XuF-Z^7$c0BN~6`A*JYrXVah7{dwpc;t(V0P}tVvpBcIX{2|UrbeDOa_1X zCiC#%0+Sf=qoDN>6*L401CXSMECD4|B*C^+Y&9*MT)Q1G%XhJ5KB*~p7}OXUg<#&_ z%*!XxNj-zP`ATdaOkl~MJ@Gzcrb3xM9b&sbM7?&G)ryNnotKM0-^~aDp128#1ACh) zzl&lNHYw}xi9g@X3}@?H&eS&%>4-+RoQII5!M2Pty(Xp}yoN#*ToBWNe$}{+wmx3& z-XKDEBT<(<3(Eq^2S`XVRwwkr;YQAPpN1C|bx3IH;c80hs5U1#Sj1oPQBWs2wa#p7 z5Mfj6ar7M)zWogczNzvy@}DU1DL4-Kkn$dPZh#*TkBX#^?oygWA8)dmzm5$WDwKg} z^7);TKA>Irp_hy;zTCZdq|){g^>vR5uQI$x^Z*T`r($%4?EQtDhM_b$SjV3(O3AB$ ztAY>xK)rT%p|d+pw)te=EXcG2aNdEC#e4Y`ad*3Y$~3;XyxLjhQ8SQB8~F2|t?+Cz z#X$^K+{*{iNnWwTJ)ebb#LIluRX&w_yDlC|NQmky733)o4hjKUKeG47%cR5H+w?XN zQ%U2oHmTisvudDh#?4riy{{)8ScRxqS^Fc;293e*Z$}p}5?96A+xf!;WeDyIF{DU# z%Z{5#a&hsAoQP>|O2(llWc|IRN5}Tk$9cO5-vf8nB7Q>)Q#sB8^A68aA3Pr(KddEn zG4M?JUG-)=151*vjS<@{oJuYTU_Hj1ShWIF1Wur?p;cAwr(KUe`CZrD43$(qN1^6t>UYuc7_4PG~a^dtz&oqhR6g*ZQ*OPIUKyyV;Fw^@9AQY6)= zd1*5vqT{f2%e@{xh6Td2BpUzfB1!zQ?$Gx5&*Lr$LK-U2#GWy;I0^qc(V#pj0AJES z{^)u^z(FO_$4ZNeoGf2MTvt)3>r_$2dNa;{e}52)ph`&ON2FakHqt14mwMN2NqrfB z)5SeI2_J94Cq>5a8@#>E8-&BsG9Df$UiN6Vv#*4G9RWIXON*S-zrH_jEwk16Y%468 z0KmoW_dnn=FV)^YbasqOYAn`tIC$z*a-F+ZGri>F5M)Y4#rFix$o%xDL1hOj${ncM z6?}1L%Kx*A0H>nwKI9NU7)Fr9wg_OqMGN!8y7~_GuS?ss9HewF=WL(gqotX~h10;X z`agRdKQ9kgv{$RHt)t-u*gAonw;sznNBjmiH)@zs@<%-!Su(|=J z&M<1D3p4L;zVfrQvl-|;kj->Z>+XCGs!Ale*|*F8?>F?*0T&~QnLB_JUC}UMP>oGV zy49kmXZ$yetT|A5_k#ea)phK0O&a>yFo5-pq2t8Yf>B$suJNJhlIPw;?rm$WV7bES9 zqIUC39`jatL4T!xw(H$jJ=LG1pm1w#$@<#Z$;+QupjFF1HgLHn6kUI3&R5NMy*!2Y z@-MK$&lR}eQHD%uO)o@_yWHx1d_p^!GeB+%H;8!a+dOk|F>X#>UDH#N%d!&i6&9Kg zt^D^siTKq(E*-C-N6+FKy^L{j9~j1@ZUOlDUW-_vdO4`wgfyYX6-)`rU$b<5N_KZz zP5BFGN4oe+RkEz9jbjO2#^Tb`>2W4Cd;8&=&433!0!BB~>2WPTw^ohxxVQ~|N+}Ai z@of(EBAi5i5UmNW24rd2lGAy!LQ?JGQL-cs43?pcq*(Mdww%8 zW;7+BZbgM+JQ5M~_eyf#q~yh_*3hF^Z%aFX^M8eirkq4XvNg_dXz^i$wRQSw*G+qy zY;{_j&joLH?#ZtE z2ENoE8nT*oj}t+p-26_}pHEc%G2Qkkl(bh&7R?YgfsR4O>5>C2jYTzYb*~rPc}5cC z>0r6gfn9b$7=29?E>Qopnn&4i+|D3$oi{ZqG>4+$b^gl&EKsQ-#LgHPh`gy%a7G|- zsDzux2k~Y0Vyl3s2-MDXgv2R4v;4cetM`Ez1D<22Kx7q?qQ9mH0j@qO0-<|=Z`GW{SS5$x~W z;Q=-5WcC-&;ryXO`cBQzFvB@Dl{dct>%SqIOfAbj{KU$0jlEJ|Ai2C;D1y3n>8^XB zGps*0A|;xM11S7rq@W+!1jJ6rxj|*gp-i-=t|{MEi!taZ3|RIuCEb}fH-uzQelFVY z3IxHM%D=ja5~6kzqi*u>m6{)&2r*>5H}V4Uu#Jvs zd8Q5}$$=GOiXKRn{)^C$5sQcrQ{~22PK+{N_W@-RUj_!2^x^f+ z?+XNaaN}I8y06`PQ?ER$q-6!=`XS4dLO8L?bL6~9CQkOUyHQo%<+eCK1qCOxdepmjk~is{-o8AxW02tuy7SV$=rQ#0;Q z@L-hgyd;7g_;_DM_x#wRy=KYTp2UTC$D7_*mTPZ=#>rCFzQul@;G;Wi`l-jIRCa@I z6xH(EqGaJdcoDBn)y0n3LA_WiJ#f0>6xeY2*N@Mg`!9EJ9^LGaX)j_~6?>!yu)Ezg zKVHBt`p4Ry>BXmjcAYDETQi?(1nw>!J4qu|3klGrn46g~-z+^Ja{FzT$G7n%v9$>!ZJXNv^K`f#c&Z_k?J6%a%F-1I60 zavOXF$RRMBYkSy6-GiI{boOOS7Y^L#O~UsqXF50e(C9p>HTSZxAYA5~5?nWmWtzJP zY(BJAPyT%-&K76@ga~@?z4!qj3f`nMT}M6?o$vTkdn$iD>C3BrafWgS_>)!YZ56)2~DHV4G!;ZE|K4MF%P=OU+1-?KuOd`b|;TbtCPsnUiWC;OsvNk9mz&wCB!>GzDofdC~`jJ3{q}L#x(!%c2j9TAnZu^0XZOlicuVEYO(CElu*?+(Zk>)^(sL@xOwO zk}8i>4i!^cDGA58^f)w-f=*;NdAgVczvS9QBtLY5IJZ@dHCQkXGybJ85QQG@Rkb z$Ns~k5y$z}dq*W1v*eX7YkD#m+oW3^;rsJvk?e97%fi7FJ}Alq4-#m!V>WUS6olU0 zT;JY5UPcCtT{3v;x{{f|& zPcqSc~f3IGPCv_s?9^jP-(m*JJ1qz^*QO=wE0rkd9A}xhTj5er4D8b%b4(4&js2cXq6B)bUJwLTZ1XOr zJ&NN7WxtQq=tZjzI^y~BW-7XCGTdHG_%#eaoG>hVa@y2F5XAX44c(D4wLHM=bNXRK zJh9xs2eMWI!PSA21E+6<^N2st1n6thz0I-;7v+NVt_fR=IdkbY9N=xHr%JDfGUqyz zvzZD&Nd2OaiA{l6jvq8x^QRuRP)m)1jg8uqTPjfKuDpRWX;QBz-xG82cpjQcuVK*) zs7>@!c?c=?I$vldUhYJO=&W|}GR}|mgfnPCF1P3Z31*Co!Q@UP4>PB{M@$GQHnvMn zKb{BQHj&~p=Pi_}&wST_-rWD9GzW38(*eDMsKSSBqz{#El%s!i2ntCa?LQOEUC>d= zJhRRl+KIuyCJZ^6BfX{3_^?6+f#ScQJ`@xpKoLdPIJgk|2fES$0`_E#^&R`CbFd9+ z=YKR2u}KC{V}+#X>qV!mjRLxen-)PqU5!ik5;SrjU*cqw@9acPd=%7ze=s(qLD#%0 z@jo0l;uWs_Hh!MIUlN_ob$v2Xyk7o{U;9Ww>B5;5sWj~`%^<&YN}+V0G)kaO1c#}# z%_-Zz?D$>tH#<-;Hk7kkLEW$Q=O;?X7g5sB-fzZ^CnOA!2vcI0!O~g&RCYC-r=XGE zx_4ZOWIktWv5;J-Tf1M01b(MRwg2|$X0AgMNp4K68hrycheO7$c!o1gXDh&cC)1gg zInOvQW;J)AVkL;M%l9RWmeEBd$;?9E843S>Ws0}Lr1kt~{7w0KQ489swjb5b&RiQY z+shY~{QF2d4v6ezL*a~!Ys{FMH(KvSlp?hryvY8~kgFs6-W- zNIw*p#F*Ys+wK^-ej1k-{bCo+%XzQ8kjKc7?axVi-9yO;P>0W!n9TV!r~K7lPjmQd zKJy8oyaY#!;9a_nb*7wiAd&m`pGZj1wpK%eY3y85F)wnG#h>@;$V|yhx?WPT7Wmp_x;fp&X#rU3%W_4|B2fZh~wQ^ zEl(8N8+gdphHW`vq-C23Vn#?xXfWNu`b3zFaJr*PTW$E@HWQtw^U$Mwap#Tb@#=6b zbe(Q6_CsKxW>Qv(t+Zvz#6xwnS(Cv~O zx-&Vn*)K-jJ~Wh_qnKb;Rt^H!uGj9^ZQJ8d>bu7zP1*lt*P@cgEr;up$VE?YD1u4->AN1{=4Af~ z0JEN*i)+&UX1%qnwNthd-7R@80svW}*mG9wdRetR~hhmZU&s$vjk~ezWJUnAfBzPlcXZa0XEA7 zbm^4@kO;*Vc7Y@|06-iD*iYzs0TYe~5db>AALAZK%wIM(sC9;!_+BN4QnQ9Pjz_Tp z5Pumbo(V#g%(haB)+J>aba!9s#uJ`lv`v?Q?sKI>)D7~288pgE7sfeXS9L1B)v@$2 ziB7FEtJv!wjK>tL`WaY=S`aPUO0d)ZM9qxYY9Y)#2sbkJJn*jK?k_)?F^qdx>JOk2 zJ8DaqZGA3UEwDMlYs|&qd~WPQrQSt4ip}o$9{0gJD2Dm!<^}_u0G#yI_gw%n127Q74%LZ?oZN=@ zH@}^+0I(Hs=-pmsbJ?;6R#mrly^S_!X}AP08(A~o1N@PGd`tYz(aqD$;)_ja^(fxv zvgQaT18h+u2!7E{`D4OPyfJ_ALepfCXAyFlkB>9pyiVl1_J^kLv7bfxHRi?e0?SUN zHU$NxMFVVfF7uvjkA;p7{zqP};hS>D;qA?N{o0|@Vbv2=Z>t}H(ErjKm%ilFB9u~I zN(?3~Br@#Zf{^6XF|ZLK9vKkEpjce#R~+&HcsfJ@p6)(&Y_|Yp1A3j&$?@)5F*48lu84t664PsABVG$4j=rCS%GMGO*KiqP49dEG$p;3u ziGKFd1yy9~4Krmf%xZCRVWo&?Z?RcVu&OzPIhXyOl^A0d_zXftYreRuw_5}N1Ai)^ zbyXYUxfK4QF=%awA(Ui{9@6fFh}>Nq1{+{(5AmXKXxMb*;B2nz)VT z6SsD=2JYTVE2L%^tzyfbQEM<_``hk724OsgIHbsTL->ib7gC{ERP(J6$F^3?a4ymP z0gRCB%Fmlm{Cd=^~~xT5r$mGlw{ zxN&vMYcv8uL^!K7}a9m>kbxM@*}OkY^MrltRru?AQVmsnXA%U)im&v5`7jZY))gE^sZ3aDZB9 zYf9mYuXmzp!L{P&#@qA@Pb}}Q!gPua$ zt@NQ{*KtRS)t~t_;;&}e-RR1@ohiA;S%wjSYK-L}^f7*_uSYRP1qSkA{2KVSoUhgF z{s7LB=btN)LW0569^*o_-&!YUUME0Fy3=o%&~!RX4eNulQz>V-g>@`rV&U!6t#00{ z2|?4Y^|JlKyl);`ReL7Oz1bB}(`s^%l?l>9;@+3PdMDuZW^#LSq`m=H-Q;g;x1=8D z5~Q#}!qdCV{OC%Hx&%eDj@I(B<(NwT`mOw2!ejaCG(IFREfyqt1XlhMc8CUeBV-)= zy)NsX*xAplxL)zX|3p*w&E@7yE*%Gv^-}bK*8?-xKcsVS>AuL`GMdbN!gtA2Ikhx$ zHfojX_eG0K);CUX;R--0n&{^Q5NlL@uRvvO35ck-l1!vB(kAvanzl9!FD;Jh3=a00 zWJ9aA%*Z~S!SoUvLX`U0SM#?ak{gO-yJ@k@qdvHBBIo@FBaqsA*lzgHR%fV+ z+dV0hh5j@hIY0;-QKw~6e4ya(zaY`p{sUC(=M`pWzc>_|-64%;`eWOlo)CQVqlChS za7gy7-^L&2jz9YS<9py`t#j=|Ia8N7U0f_A4;wp@#2N=}hHpBG``o$xt?+RZmIo`O zlzhK6>ikoKvmAPxf;X<~;-oyHg?(%75*DH>)A>a7mZywh=0M;nF4{b>aa+`_(1*rM zCWh))>)NmO_(!ca7BM0&xt}tgGXTyR--VP=PF=J8T?8&$;iv7Cn@&pW3#%SsjH}_= z*07{wl0NSRTG60}QKN;{Z@-qth6^`b*TwnsUVd@z=I-5_7;Q^CV4d`D*+~m%YtznY zP7>j4I>?AGeh>^sckJ()?+K@MS|DRsL#sofWbgg;x{zA5%f|6T)`$O%L z4Tn=Qz;g~}ako!dwmbyka}mfwt}F|XEJ&0gXvlpO@T&Nf*bYmwo7_fdzqof#-?8Ez z>rZP;Gv9||l{H;j0#y7Hy+xptRzMg?R{9^fv{o%CDpfP{!`$q7C3AZRvzo3|Wao-X zq5uw9oM=woUIKYnBv%8%b-hE!|U!l`#>O$P;a->I`Dpq>=X)_H1L%v6F>^Ixm7ZgP7K%WE8(4${M znQOO~TJrM|b>=beX1dzVpbQ%g|3X0<6KrqoVX4|(M;C;VdfbZ=Oqo2F)SjV14P^97 z@m8L2^&#nC2%i2>A~3GsDt@3mfWr2o*~c+SCZD6(e7%iD%K~-;Ksyk_p;6Sb zuaIlA9Ld{{WHBj~#A|JLCfjza@&M>-0JZ1?KB?U&q~9m-D=o`Ov8iRJUMk0LE{rn% zBg6)(y8u2iFeW5KJH`@jtbTY9@y=X3c8f5oZkjRD;8A%|;}eFgJpU~K+26Lc#K#8Q zHYg%{C6(e0~uN=i)+L1@rQ-(RF8X6?4)Up=pb*Sv5_p4gB!a6EBf4IEZ91 z8_w%CEPvLn$cuzF_I3y=rU{mrEaGElcR5G+%WY-FU6JU!SK^q$~i zk2mgL^+0bD&q%Eu5CNLO9aq6DtTkSi$lJs^3krzp9^(&xxd4ik}JjbP@Z@XIqX-+tXd@7xOSI8g?g~kt54M80%Mx_w4EquD92#PK%ibDfF4y zCKpE94rFIk%)5Fna0tfLN-%eXH+UaTfn%8UGYS&sN!IzZX9vt$yfv}H_9HOrIMHG; zkAp@91w}vslzHQw_D8R^uTKGqQomgX3*df;^{vzN_xE@w6Umr?Ewy8pr|_u&LNI+m zh@y1+_BUg(DXomUUx^w$w4`mf7C!*bajfZ2#gW$qauLlUh}Y5t3y^D#SHXL1pg2Xoh+a$uinb z-s#>SPP3JCx3rW_dMzIlgHYoBqg!9$y=!8UkU+DLryZH}$K2-EL%Qd|3avq21gmi3 z?|{_cY%P|%LL40Gu2qDLka5Na$^NFo*@Esf*DET_59Wp4(hlpobnQ$0+4P>y!2NL> z9`c~n8cqSdjOp6nHq~-#WQk6+txhPx_Fvw^@P>r+w!8vUZ!XB@})nWCod_V9=mU%WJ$bUf!}Z=}a-RD}?3E>jQq9CT@LQyW3{Z%bh`CXO+*^bH8C`eHO)pF1I5#49(5f2xVq*MdGJ7+m>`2 zotZPUN~jG+W{9&7gGi~==>CZDDe49faJnFf2~lDWpkf&uo@OXp!$Ofd@Q6^M7J%9X zAO`zT!~F+vA%LCZClb9)QFy__-r8!wO$KKa78f_%G~O$kZ`{z~*57i3HtuVH^NP)r zLqG40brTNO_`)vRpo?Dyzq-)TN3oCMLeHJ!L&4*Scz>P73|m(AJxRmOz?s)}rQL<% z$zg*4rEktGu3PeVdorIiY4I){Z_COaXZe4?J93-zdfb=01ENA-{h&i95#;5=M>9cp z(F-a7?BWp1!K-j?{$cu}BH?dMkCj!p(&+V@=38FMIS@*@v+tW6TAq;ALM)dntdc_k^ekg^$_I z^v|CZ$kt^kFgdqhR+8ZMdlo2*teHug%Hkf=BtQrzAM`STue-}U)=@*-a#_J90m1H` zkMvXsn$UwJ4A$oDFB}ebqMi(Eh~jGbJj^u>n9J6$v3$xs=&?#I5TZ3GF;KI#(5eb3 z$t|d<29v*cXsRdc{MJrXTH5W_ew8521LSA(E)2#5W_}ZOfw8r}ACYN8wlZ*N374?y zrZN#tjmpE$W_KX~$&Hs=sJCt6Y^s2e`moboB^R}%pnaf(>eRZRuhvuEZHjFx?kkY>lH2Y&F}@s#lC0`*1sRmw<#;+o6H*D{)$|74UHf0Umrqy)~RLjeBj zF>&r%_E;r@!{O1DzY}l##sX&w^vAdFfqZ!{3-%>}`W_#x;S5m2} zXi`d=sFbv93%6#%P;*CBe4K4Rb}b*=zOCK%tFm9Ayu6w2_$BL>kLl`_kojtS+9fd3 z*1D0Lp4PMXaM`1~0gg~gjZC^)vWQN8*RMUlNdRPuUj>h7@&)q4;&`y0eRKeS6ngQ3 znj!WqkuC@xeCmF>#f7}?sPPWL4LR`Di9vkBBRSn{q6Vtj{0ryZpoVs*>UWdCwD@Xp zmP;+GvGNoJ+W!O)tT_Odo=XMdX9T*t7;8AVxMR$J3cLhl!+dNB7AR3Esl(HBn{A45 zF<#=bkG@QYp1l+co(`}dNo$AXruXy{Pn5Gc{sd2L7j2`!{r8FMS4W;Lgz?ri9hZ7e1EH7r&guI`c$<+RSxPh&1_ z)8E@{J8D^Ek$W}EIEgPQv+iVY2XEKq>yy62w`$EqTy{T-is|jl7DQ?pXvghQcymD$ zJnAK-A*Q=gF*Sab;BN3610}kInAMvJ#SE~kOn(<+B*3&grW{A^lu4I#P%_G(;g6&{l+?j@C@_1QNxS7}>S-m2Z^=~KFy%nc z@WqtxFpxcGJma)JQog)l_c65MP4#HUuLFcTT_G===g(rPd#Z1 z8>0^=&v0>8Xf?H~u^5TEY4)!gF|DE#lO?0zRfHtB;dH;{(Y#>v!wMtcWIz^*XzYi) z^H5do7R3PIJEeJ^q3jvf6@}V5+9icAG4-FKLuQC=JPd0cP{-wvz(cG)8 zY0edR@(i*L(jqD0N|~E6nbp;Y3`NgI+%GR@f=-xAlgPu)%q|PYlIrjs95BriixRFH z^kj)$rl=vN4|0=^@%o<)$=Xv>Dc3~r-}>6ZTzmWsR8vPgZQ=t1w>i+Ei(3i4!G#L) zBq6bmtg-v)h+q?EjI~xF3xa@!T z_&HP^kBMd9ih&uI3Hpz)DiyaY@TyzNN4bTB+oZuzuZ$WT`fm1Dk9SCLU^GBaY<1|& zFX^;Ejn%%C2)K~0A@zT0OT^+lRSsU;rnEN;LgW0z3FV=9mK4#prDh&uL^h^nmp0e} zbb&P~D$?`%PZX+G_|gz~Hqye3#WG58(1HsyY_;KbADizd?(ExE;Rp3ztmGZ4I!t<5 zU2mgWjr~=7g;`=IHWca)W(XM7!d3##b*il{wnR6_f{Sxu_@eEYdJA;_n`rGMh#rCl zD6lE}r+j6ga<_Kz&~AB_(P@3b0=(~+?Qb*x+A$ko0uf{Ks`Gu9S` zk|w|5TlzD|(k^mujMiq{<5uN3DEOkS^1%z!AakWsN%3Gb9x0LM_(64{CY?`Ol-E2XuisZm-!!Rf_VD z04t$j&@wjdeB66fm?Jyi8(Z?G&nR%VVy>vL*KLVsO$=C|zCURt+HFfKzg9W_w#yRY zww0*w6)dMdBT=$wF9&)mQGAJqa?8;EmN&X_%`TC^v@q&_9skwW2G(C)BNKUVTN79y z@aj!oRfOU@4-`x6e^t2-Hn>LKZW~;LcDd@0w06SbJvmLtW*5IGyPU)|`g9T6N z77;lnC+C4J6vWQ8)L*&{p-Bm@h_Ky@xEL9U{%k+(=-yWlYLVCfhYLcsbW>jZy|Mp` z6R^GKjyu@7_i@zj9go*r$CJC>lujaC0VYhZU!njk|HU2NgErI2uYOI0?IM3y?rvNgL@Yj^6*Y{a(Lj#F52cRhX3x z(bNkQ0NV|)h7Fe(lHe87eFOK=6#8!_Nd53UP#uDdrGxr(`8R`d zyZ!l(Bv+hn5%lly0!sQzwBW&|U%MgHGQjyBa25Q4+4kX&U3G}$bgndqqmK8X1HXc!E8h!~BE zWCY|&5kG?U$>60Kz5sTd-gpTeFh(LqQebE&qc)mkD9$mZ0eTXJ-Sz^Ae!ZYdoB^B7 zzQ^hNH97Dzu5R}MWn~_3uuyncZ#PlYkCdr^Msr_~AF4}ZCECkT4SX&o5HF&uB8G~1 z52ubjVT#KPg!WkKGJ8_aXr_ZQzd6bL2NM2r*k*;%Z^wcL)UX-O6X2-vXYkUv z-$tgwiMu0ry{dwYSagT=j<+^2KuYnI`KPU4<;6sC6)4HF1=WwOtniRM#w>9y|71)B zIF5Y$mV(T^Z(t{>giQUu0ofQPV0bUz@A#zI@=e&*bLYl*wQ0*n%F2RMSRXxfK{uS` zW}c#~Ft(L2))#5u`%F(7G9pI2Oy2EF8oB$YaT{(_WE8l~U^J528+?5N@>b?zo$>8B zWt&M_bTo*5W)>q0^j(VOt}uDq{TOIo_H<}M`5Fw{h?K7UjzD;g=qe$yYR6+zhhmWi zZr`(F3%)7bbjtFsjm^Hrw$-3^_p~A0Nj^swW$V1moU#@<`Z)=_f#3R2!U_F)0H=V` zazF#zl7d{%sxQ?)*KgjE(r<SjaP3o(`mP`jkjr2W+OPKhT^mL~tGaOBI@MAy|(6pZ6!EVsVe|xGO zKleSvXwMDtK;e0NI4Ye%lxsccFM44<`DqKHLVwxoZ^c{WuDD5|CI{5c85tc+q`z!9 zGyjuwgI7YErY$dp#PP65WM1pL%s6H++w7C&ZNifCc`#bvDCyrGPC)GVx%tkq_8 z`RN7=Rp!dm9U6mN%bCp9rd`EACm6b6R zGc4-X9E6pJ{Y^8LQ91LBtZ<)Z_&%{n&c~f;bna^eJ^z6vLHU7{Y=Bu#w`>*m zH%)L;72a_&cdB+WbLtz6C#Ya2J_#uXzQ%mHfw;V(AG*Nn9aoT5s6;O{RL6CF$Prs%3rEoWp?XyY3Lfx)J~40$yz zro&UD32PaSS#aZoYleQ*@!9*#C8X~xnjX*=2>aV@J2|^dHyEN{6|NDz!MNix_c4}N zTz&3l++5W|_)6wR^H>%xSb0%%(837e)Yd7J5gJxt|CFANj+3dOxI2z5rB|mp`-A&> zOwwLkff0jE|D!x%l)AUEp4g7v;rg|%1}Et@T1B=%ME!eqWiI@u?Co`1s~tq9v^|6L zQuO&S9=VFi%X{eS`LXX{BQiMq1tCs_LD)v`#_w-gn|~tMcbqNO7-<0+7a!*{^)EEu zC#)+d@f5Xnw(9d9JA>CLFRi2pemzxdKMl$jK+NT)DVy&t<#I@NKwbnF_6_VRc5kQD zB&KfIRlV(6Z1y^4>2}AAq`wH4yLh=@eXNxN4zZ)X@%FKF+GL@>gQynP^pvKO>12%y z_fTpKSJmpv&xkE-33>+2@%uL?H`)Z->aFuCJ?!C_&%(K{NG?8cO{+fIt4Fb>-d_ou zfuR@S_}~KI2pDDspYXjUXN35nV37y-X8)pjd};m8^)ZDZqCHb(TEm)V>Kj%-$SHqb zTkd1_riiFp!JDWVv%Ho0;s+R&X`8v|Qyi>64$>-b@fhgI!sV{W)4Q9&#%se>OS*TS zeZPKZ=|^XBmxaZc=sZscmt<+rFbrto`p~~bKdPI5 z$c`EVjEKgPZu&&n_wVoRCIVcHAFD7=c2Ff&qDsDN>g(qo#gixzw6~%^#SGGihWM%- z+U#7xs&vXP{-9E|=p82Gzh_b+TB8(pP%Y~WLEq<7h4FCVUtAzGELgH_VKam@x=H>uRiw< zzQmyfzWAe5VjS-mgWSW@~9vM;3H*wkyv4}ug>%(R< z&VmYtA|}X}3ckztS^0F=CEz-de(U4)^B=W&xRB{n>*wn~mvArTWot_aus%|CoBie$ z`cbtiEjrCbZYg1bhIz;!WIZCu^9{=hYvZ2hdYt6BLrq^ydCy2-Se)CVhfm(UE48iu z3-gfLf_M}@QqrCp`#Ysatmp@J)>i^dTBn%1#UCP1a+>})sU%vaWU?xrnd}(JB@6Qp zyCvO5(9UL+CZOsD4?sF3a!42wyT4B}B`R-rw3i)}9Gnxz_HEi#*^W9x43kRMY9<9< zzq-JUjyCej$2tuCFfh39)_pt2Q9sL-SR}1mMZ(M!7e0JOcEIH&Yc*6^;q-BiNIkRD z?RNF#1KaBver68Z>sAa^R(PS5vy^>XxBydHtssS;;q+q?T&dCMQWVSPHkspSgg9Qp zs%2|6Kp0LIV7X7Y&Qvmq)_Ekod2fc4s;_+}iOvmhZwOg=q$&|nicIZ+=%aJf?rlfw zvtAtCQ542@Lu9L*an7Amst_7(9oSoGV@mJ95p|bmeUdLPL3%dWg?rVq-bhNsmuGGNA+!Udbp= z=}n0Ny&$@Wy~`~X6yowrT(_gmV`D_@HT3m4J3n)102cF}4M%cp)SslwSjQQw$|Y`4$w_i2W-G3V1U=i3-0vP6kly*IN=rk?23|_q8M11h=ao zM`1#Je4YRvo2&(RzyGwf|N93hhr|Cg-~WXOYskNRIx1|>SGOo3T;}t@3qRsE0Z*ZE z94|k<(b~DA(sar%0)-dA$v3}P6K1|kcT^zE_Y!#LQvUvSDW=hm8pbZB`iEn&Xh*aD zF+N}?1ddoMD4(>}1Ux0z7xC;;QmyAXw3xNK&U2B^aXH6`q(&`ZZ&S+a7=U=vf12b| z$~&&5uBp;ZM)^vdr>e6|@S&DF1yli!Lq*I-=S^d?|0<*eQ3dU#DooeJmm}K`ZuI*R zMY$CW>Q zeyrk)?7yd`bdIC(F{Wi^E=4;i#j@s<9;mair{i<%XZWxVR8-<@i`j zWqtlA?HzDa@XZHsM6H7OAV9RqUANX}hdD*ULs|F|T`>@O@fCP>{7_WQN2x>l7eHoZ zB+tVUx`#W58&6RyZv=WFTv8@%@(8o7`*cB7K#54;Hju9Nz!d;RC8X8YSLBx3gHphM zAGhZZol2reC#gshJ`K;o`+X{3>p8EVB2VXtEc3rAqv*6mPMr{NL0#Z{@L+4Bv+=*;Q429lSiv>F`l~t&|qel~GcgSxae6Z~f*1wvj@rLTLnWdP~#aN{i&;@poA( zQ=b20y9=mK(8WNj48tgHxDEwu*A!w^2FNF>w}=Zs{3!oRt&P(7sD2D7P}JQT-kVg* z`KY{-1OOoN~x%;k#Kq^AOeC-&D2V`Ts%?=C*lFb|%VBVfz+Zl~&@iSx+tAW=j z!BZucq5oMx1Db|}TcuHZ%w>F_ZO|`t5dpm&U%9TUtk_?jRu7$ zZK2TkpARpF(|aXdY#qqyj&q%V*~|(C`Xx*g$RUl4AO%-zfoPKa(6^rFAXuoa_T>v{ z8-0xegP=i!m65-9X_6u(*6Y6sxwHtpx#?+Gb|qjq$6>2UQyv{&d-skLk5p^_0Dtu! zU`&8%iP#jSu8g-i_jLiZyBltZGMXy`d?@!x1f@9?!w z$JA>h=?j29&fu4l$VFy)G845Ua8}wW-2v>tM@Zc zB87OA#oSkij64oi$s__Yx7T2V^UinEhBT=)4QTy6CA(3`KuK0J(EGWE1#>~4&=!Yq zS@~D49AwynDM@ZafZ}{6xU`DrY;3Hku!~bh&KE^zA3(irpJ0q>M(bUAK89jFrMDhV zO5HP7z!Z?D&|Fks`+k25xIR`G!@3lKmMwDA)NDg^_z^!gOPMx?hJ_KPhYkyM;HlmR z{&}Ny{o6SBXxc(^_KzQZqHnh1wf%`P%upa+?c48cJPUw6c@#MoifT=Yl)tf}q+y|o zltGT^^WepdGybcS4F6fb+7!o+(aRLKQOOCwQCJv}g1U@mMvo27Mi#?I{J-#Oh&89)!) zfooCOJD{#?r3+PlR5~0p<~|xRdQ7f>#7buWLh^4pARrBZogL^Eh%kzn*ueGo;J?ie zddOjR<0{Dd$3>1BkO@jrLRRbb|Mm_rw}56*xh3viEtaw-fu(Y&Er>cQxdO$NY7%wm zje|Rv5LUUC==X9=16E>tiv@brTJ{b8>ld5EJVIVGeg9@(5-;|gqNK7C0^^SM-9dUb zye$)d^@$}b&vK00z+UQa>g}jnWtWB0=yvf^Pz~pFq`o4V7y5PRJf|5bwhiv;h=*6T z`82s49QO|RxeTy*N(!SqeXTzM${VQB4BK^d8WBTt;l=xsmOZmEF<)pZawN6l*lmWg zBD5kWWj?9BB!RN8D8v|q0Z>3IA--)JMZ;tXgQ0<9)nbnEu&f+%Sa*Oz@Nzq#kY0Qo zO21R-o%3e4W3k{*SCebfV?F3Ft*zI%oSR}q1*hy@c*O;ctY~p(-Cp*8CkMz${B;Eo zktD%Fh@Om}s|CjpQ5+57GJL z9_#4wWNAsgCw^71%9LO)1!dPMISS+aHbr7>7s{v|`DfTVk%O5TrGH^UYl77Kmvg3YRyFA5M z)JS__xB9w3EvlMAv(=~9L$tP}*L&&fZ*OpyDy`k5ka%Zr1tuoN;>#=#XV_?Ft6Cn6 z{f)ZWCUYdkN_m5?Rv^2RR^F>dr+rYJ-pE9$QVi%fNoc6>U6n}!y|Fi#XwcxEv|HCc z-Vm4#{g*fr$uAn```j9p9+@$Z zUZcU_iWw_e3#hq)a_Vt=+fN6GzLiX<{~pZ++Yk4ly_>WghrCgPD}|6B`WWb>BmN7= z^qjA&h4+8K{%tFm3cKy0ZD6^D<2WSx7bE?ssHXlOKqlarjc!{qYo$}*92WtD4`22M zJcv~TX#T-iTg!}p0|}-}GcU1H=r?3J*Ho(=Xy&og$L~!I!ghIJPv}0O z@JxZKPT#1}RjC+_d$GeAP4V$~1STXz|p6i^!jay&k zAM3K+{C?x**TCL$Qy;sYROe^BMyEH)IvU2S(b<*I<;n$r)6cQCa+*7D_OFVvd!zVByk1lknU($B=;nGEt4^s)3SLA+L>|6FAo{+& zVCd-?k8tBZRG62rUbHyzypi*$vj*bJR4H0shVc<8`I@@%Kq)-E6^L^xl{aNwzhSxb zE2K-6_jq3sI6Bc)h0W4vEi*95tDd{Xig3f`HV=LgHCCfp&N;f@TNw&|>8-o-a*v+$ z_VSfw3#z)0;D0hStonky>5i^RzjEZb8;y*N6v}!Oa{l!}8Td|`8X64XYD)XhP0aMP z^W&&~-)Z+bJ_Dt&P%`xYwzr@E=i&38tN-)x`RsolKA*@PL#mEHcNVZp|K}D|RJV`H z82aWfm%ZgNSMhsyU^AscSZ7ZQ^yWCe?UN+w58jlu8cv)Y zZ&}0<7|1n7g7fDkNc}rO*3$oe_j|zqb9+--IW^*XoWL&O-MTY^Pq6-k&Pl4pmxU@R zL$DlPIhZjKZo*li!z-U#vDO+{6ZFQ0@PLfhVGW`BH*sSP%4RfJ)|tdZr93TaeT7cu-LtJ%w|2ohD3x zIPUzWz2npbyB+p26S&VP#y1#DdY)$(UxRF8;G+QiXNK{=yV_g#XSyMu^NWjNtRl0s z*RL_rIHgs|&%S5SUDYeEit0k!9H``srF5Lq@E9wo3BZo?{t3kQVd6Ymm4P^AGjQ)nQx1 zva7=%vtKYtXqN^m#un`Fo|9L%$4Kf&i<*!=SV5y%N8SoOcQjOd9-A8y+xQDbT7^1czDvA z0IB_OXh_6)hgTwZj1+I=`AAMSSY~M7P#HGcyvI@VCFw7!XJ()~9T1XAj&MwVF(mEu zMJhJ0zgxX_`Ub17m2Q84DaJPcK6iTZof&w_RAQWLWDGWikR;wAqU~ph_bbyoB(L0Q zA;!0OuUbsHLKE2s3`iKb^)$?a@=Bx1b^72BLXV$|-B3aXJZjKoGP%qoKR%^FvB{e- zvSxbkCb=g6m!r%A5FnI3By4n@X7N{~OpqD%Oa9TnRrExP@)Q7>LmP@Z7@eLj1E z@HbU$=FHWmodZj)x4==pd<{*AVwcw^O4-q%Ya>mxX5adi zlhz|Gy&~L5TXemNB9rjt^~p;~fc7!usXdn*l3FlhD2Q~Clyi|V@M*J8B68l%O=mm(}9H7K(kyek3pU^uf#5AVt1qE+9QJGfkoQwj!m$A_Q^ z29s2iUnd=D26{I~sj;2+rYqe4W!L={sMNt9e)8H>FagX!6mRN5ctqOcf{Kcoz>u-} z1_AK$8W@w z-vt;FOg|6Bh*$&tBaY3%Gg{i(rL*kH%d{$ox!=%C++w-l5wJsw$>GdWHI6L6le!oE1sUS(K=pJE56YLvDwoREuUa(%o3UmW z_^+GyfgbYe%GKva$S8bMOTBb$5&G(OSaM^oSd zg_Cxp`o;Gsop-o1o~8+1js`12y?wDM)4*F!@tQ50d4)2Erqoa zn3kG$eh+m%tuPZ><_$FJACJex;A;PM@yk2pwr$+3M>6;_@59z&naG7w)P9eq^TZlkbJ#j3ekCfIeS zW{aX22(rS0L9_7sWRvHYg7>Zv{w^)`2OLw=I#9ZSkFMMa_>l^5RRZ@T_*E+X1+YgG z+*58rrkY&#$1A21{K9yee&{*Y{Au)A@ElKxkW(0eAIzTPHmrCl)wpBY0;PAseJDb< z{9nXjzP>cGZ_nQZIeXJZ#Ka?I&7Rg}Qnh6XuMtn&*oj;dsjVRj0&t~<qaKyTuCg`z{m#&j}nMHO|AgDA6bglCZ9M{`1P`$x#dUc_VseHcJpV?YDC+S zUF@ccW*eU0?yH(h)JDeUp(>ug3a|oc3#!YXPVSGqvHR?OEi4s_#N02(bdV&8DR5() zbA@2m?_{JO3cd6`)Hh{d>cQg_MLF#f4XVR`5+{xuz&GS7M>#UMQYzlWr9uC;sy4$C z@6TW@#!L$&Eu_-CQi8@TfDOu`pzVY45XY1)_mL#{X=R1Bqce{GO*Z`>b(P*K>K!@U z`5sn$T7z=bKrX^iN}wkC?%XwXMQBC@E!|2&M<=7bik z#zJUYpH6)Jp9cxP2LO0r;IHGB?+py_sqsPg4n^Eo4#S_9StcBVR|Ur%B-;>3qW z6Z1#o1YD|#)nSf$f-{#_C7%o|4JTr_{)PB~dlwn|_SvL_aICr^x+C{Xx72?QaU*W` z5I$U~7KQKeU%_m4i~HchJMlBa#A+3b_b!z#V1(Acuim{?QMZdgL{}hXlBC`6c6(d( z+NDs`)k>yPk&|@);?Z+fNB{HL8)*Out-6;R{J;FrQ=VOZr!}u% zfjmwC{iZ`QJUz20oN)v+I=s^NAR~-=9Yo$^KL3g2!H)8Jp7K`-eUexTKK%36T?IEb z_`%H7yk!2K#Q)|zHw1RQ#i)h%4gM4}!E2WdGg_b4z4vPFoSj%U9+J6`C0}#O^9(#G|qKdASwI^e`WLGnj%!A8 zkB%G&%YN7i3N+Y7954lw6Jm{8J`fAFar;$QPtzkr+w3+ zI!{cJ0vyRt!I}@=aFb}Qx?AP2d|t-tQ=Tcm3sVFQQ#*O2&>gKI!`~=$hrPcb;$!kCe;2e$L!w^@N0H zw-&;m+FGy6A#+7h%xd3sH|Oc9h<`JH-jvAyDZ@1E3<(k|&3>QLCyu#WSuF|@O4ltM56Rf*M(G0n#X zqH;?XU-_#mc1!T59Vp_L`S;#)+z_}43!A?dIA1Y0(H71Y#!OHors615A!MJ3Y zbWA#s?rn&az_W~d$fz;OWPv+80-INC)haRZ=aU_Ax~{>-%5B{5%IZ4C{t~1ttM;~W zz4o=}fA0YYhXCK$xAXaB`UblU%9}TOrdC!HQyRkO6g^zSdfMz0+7 zk1Tk}P}`4ANLBXgG}hWHGbN++4?i|hbaqL#IQdbGwZA^cU)6EchGM5BBS)@z{bLo( ziN8w^a74bK%3ja+{PpM%cjc~ANwi@@65T;_8NEd5&K;4{Qe8u5d;Zt6MBd*H^+|8! zBWezIazq-w23GYduzULYDrgfL(ZM`8(mh+*R#L$tfJhc1%3d;7wf8>GxCRoB-e(^uR5h zAQlEjYAftJQ1#ta_RO!l@i0P}T9(nt&#P%D_ge=!aw-1^C2sUueYx8ivF#!urB^LV zL7?-~<+U41%VxWk9C7Iv3JTgGHTN@A6b7ZP!r+eV-va%PY3-OL6$xeKL8%oB%S()s zA_ve`7fn1v9vXat{S)o~`&JtFGPUoEb(j$4+n(l*07|}2(z7!hx!kWqw!{KL103T# zO_;wsVVEa@s)*v?QnKs%=Aubfc9?CY*MJAkGXU2;lzxy;`^?{g#0uL!zX(wsSo-A$ z&Pyzxwj2|V8?BF=#K3}%?qQLHXyUJ5_rFtm;d#Y&sLF*zER`Nr8b9kXc6@BT#>`B| zNK>XeQ#^F->8O!9Kbe1vK_KSyOF4imW0chmGA*r&EoNx(&}7g~*yv;LR(9Q4q&ecV zq-A0_1%aIY?LZ95DM>xRQKbsUK-4wZHtOgwQ8+)XA!Sv>w>GXGh~-bAi2cvB{pl07PfIMnUvEfc@{D_ID}vBg3ugI zW)Mk7r;PZ40moUA?uQSc1Iku8{E|!x9w9H|F^r&W<~IFG=H7Httc?#gW-F&o30Egi3bA0Xem~9<$`EZgM<*Vu3^{JES*Pr z2iGGQ)+Jyp33IvCaRRiu(hN>bn>#2P9;2&+JQFeU$;P%0U)9vrmAu|A-jq(TfVi^O zc{G(g5}7SRlS%8ZUn3Pgui^42x2k4fKcwW8&LuLGjr5aAJt--vPNX}!psVJhkmqH; z&FJNDOSIuee*qZjj%=hiM2e3hCL0>^9y%X_men*fd_qFz(p%}I%*pt^`ot!r(x4veFn{SMv zNJ%(NudunRUP1t735`Mj6?7?h=9Q_bLv;H@9W&=U2AtcmV-8?^LP25R4lRjF=%z(} zI?bjNcHaRLk8J}|g3Dc6=)`P=&K*x3{WbGdbW5QD(mt&3G+Z76E&_pm5yEfK*}2+y z0_{apSq)xYaln0YvCE9tl%=F$53j$8F0V4(-gW~sNcy-1Mbn8i9UWn`q7Lf8gEw1B zetYh9*DS+MDR!-*{_KRs3QHId89^@^qV(htxu+`}BF#@`i1sZtgmUnJ;v*;tCteqFyFV_5B=I@sn ziTEww(}QWoATW@SRfAE`eTKMt20Cs^(_=JFJ4ZO}AaaG=DqSX?azpT4cuSQ$7 zxqsG!fZrx2Nk|~iJi8IdX1#lPJw`Z@O|OT)m~#5f>u^Dmuh>CTn$jj(9w$x-Tnk-A8Z-5)=* zF81(=^0~n->pD}*Q_Jha+3}esVy9}!W;%s1Bdg>_YG0{5){pM@sNTcmWsTERO|FU?~0iLUs zeHV>VJ*;*;Vf-17==^4_0b^{J(lQ1GaoAC9KUYZUv=Z28tt4}03Lh_9#0d5!w0 zNKg{>v>Nv7Br^GE?YAhX;V!xh*)*KN7}h@<_MIm$>qu>QoqbAq|3G&JrvLOX>7ybd zn6Y&rMKASZ&Ty8h0SZOaH>K0dk{W1MOXLT{8*t2+D#c^nbri>_5&~vSnBQ@d+pA%y zUZl+OQ8l>Ybm!6NHzz2wX-r}rsYik4TW@a4gFI z*qV{z*oYGoD};EE^i2$wggiw>@5wu7tYgAOi;ijJf}xjKaXvl*{wm>DLZP98 z3^qK19w-Rh`kfcGH3gNhGR28=<6wT0UYAC)C`BbF(rIa&`$BPYmz(mrrstbwSZt{o z+`(h~>DbLWmLc*?_+V9-fuZMi1+aVc+M4UD*(U^?C!M4JG{{2R>VpET*=5b)umQIV zUqp2#{2HJ|x5J(|T?IVVOVa^pq;s8_E#eH@aWV!s5fB8A*42TXx_ragma=fDIqr>U zdTI@b53ga$cRyA373sPRC2z*b!NC$b?nlsH_eZ_pySLh36}J-rm(Q z_C=Noc_lOB+4Bh9Q2<5FaVfy62A?N4B9UFtg$2^gT8+;npQ9}3+LYPBFLBA@w{@D$ z?~>*c>zfV}J}*niAJS3tt-lgZ^Nz|j%uFcy7qc~%E?Chhco?FW^F;6>k!nm z+n%J?Q%`aqa*(r}qE`-_+Z#);kC4zoVz*i<+Xten&b@xk!wv&oF}$qJhLAZa&-eRX zdG0V-)Zf1YRl0R2gO1>r$_I_fNmW(jRXQ7=Z2ObpiK^H7W9JC$NOiZGmy63J)>>mTcbXVv zeL;EDX2#TPs5WOhRrlT>mWL_C6^4KESdFG<4#`*q;jEnP*fWZ?h2yi_(bPnJfdnRl z0@wmAXSoJbXPcpvhQP)9vug`Zj8{h!^E0CMiGi}HyF-4N=x#R<-i2zsA88=0`uxN) zL*c{cb&9+iZ%;r6cC6C!X0kPd$!EL>%YVMyEs`k~qfL39IU3S1i!DQ--#_=d>R*+%@19V-aUf|+&-#CrtJt{Dl z9_0vS)z0uf4Cg%bJH~O~qSvLwY)`wO0D~;oM)WEvJ=hCa4_GB{2rm^hqH~K{&~Whr ztIbJ^xExZ<2SyVwjCL-FZpUcX0eV<=?MQu0u5#1d@fhK8~Ch<1aWwJoV+O8s!1j#;Vj6(GL*htxr$_FPxo{P-wL|AA>{QDyXQ{4V!4RU z2FwhJ(Xx~XmVJzQsC?S^@#n?6A_}z8#>$^U&yJvJb>%EK85x5NjRsczBO;cYko)_k zrg1#m3Xz?uksumtW+wR<=Q$d~1vlFEAe%U||Lo&B9=P*-R0*2XYzqq5EgJ9+v5!o8 zYytu@J&6xMa)#T{fg_EtbVeXNg*5-D2_*WjFyE>84GkUA3>h4ltbV)z%Ja&BVQD3X zSciKtvqNNAvFDN4!S;gAv7OVHSP}KHnTj4p*9p{<$ATL84;RQAWL=O47KBU&pe0#U zVobFm$Bn1|C_$co%t{fX{1gy6Vi-o~Q_iAdi%Ei4e|$==U%oRCLhDxQ=4XJU&f0bJ zP&j>Pix?r5b^Q@c&cry{FZyd$)vxLODvy>t5mp`xQ|+asDS$w z$FuaB9Uaus!bvhGdx>V>R2if7g)u1JlD#t4qt4TIEw zcCwNHlAZ~4xuLYpV4=cZ4z0M|bouO$46{d;HtsABidxyjxVLNEqSPdDb&=4r-tw~4 z#%SOqQwrF+Ioz6pWxrpY%L=n$HMNm z?{sZfQ{KNx%*tL0FLy15C@0jbvALx{$BYiQ(UAFbqu4Ej%=qcfGb*Nd7W1b1MNy9l zSJv)IJ6sEk5NnU1saqY7`1``K_-ygsRZIsz&$H#;> zb@vf>&=_Hlb=0j+*#Yq7Rx?%~+hZqh zI1%Gt`jEW5+)8GVAXswysuJ;YC9%N@)z_y2-I`r*ZnL8`z&*>$lGU%@6c-6qoAL?Y zr$>317ee%pNoS6}Apaa-yS@4B82xkd=3ggp_JQfdIaC7$PuRfC)L02ai8=xse0-MA~F3ahg zu@_EurF~LE|G2fVL9j-bVFZgIe=HluLXnzR`s7zT$7(8AI&3PTphMT>*L~yj;add< z?Izs7AmXfa2^ssz-+VvzST}C1q~CS|!Cdpmd-tZ3mx|xU$={^S<>-OwKF;CU2OfiA zWOS??<+Zp2ePP-~*bTr^AQ~^d9T&|w3D7ppKaq2czImPT5|aWky)OFV3n49ei%P^r z1J}t2A0N`P?Oz@z#0?Tre$LX9!N+#cqL_$LcQ4tMWLG6jT7CqSwYsN$SuRA@{ zsR+tRHpR70&=<{r4BL0YN=-L^c{#SO;cF|N#PqkU@64v5w@y;?Rl>l3t+@6ufp8pOPhEbXc?dK;Gnj48kSlh%x+C)CkH zJ?hx|SI;?UKbqa37RG+53omw%ylrddnVryX>vQUG%zET{ULzXa5GqKV-*)F z^&m~!W#xJK`VT%NH+KQQl-5i z(Est{Mv0_nTiXXD$azHKh22O_7=mcs?c42>s7_PkZS(xPl++NSYJYzQTeWq4Z2g`Q zZIftGMt@Q0^n5JtDc^|fA@1&<3fuxA=&iu$wvMaVAR+SM-fS4Wz@ClSN@=9v({+2_ zmo-bvD6kK#29YrV7jFf!yB}E22ivbdPb!Q1B5l#>NXH?=0RSLKF|Pdw#N$Bi)Ce()yuv1rz`Jr}29|`qX zbRC-%9Kh~g{Rdw5G8#^IEBDw~^>gZ2zgX%%#SlxM8bn;|rAefH{Zfz}k0XZZ6|v9k z;mG)>u&(zt0F@m{b=2`w+quSN9nUd&2{g6VQfa=kv!oECUJHxPo}N_ZOcF`dHxyS2 zLH;mR5EIj}uzBQkb$3>`3(m@`5TX@*@LR+R-vSICO*nr|s&gkT^`hJObv{F#i@i_J z0Z(MWt;_lG(N?!o_Su2$rXvuvIo;2g9)Na9vcK#BOhl=I8ze|X1{Gen)yRMR<6JNQ zF)K}0#lZqPO{vK_}U8rnbvU$)76I<0(~#FUdCsCtG_ zwO^u?H;52}ohxYs;B44D!}i2Q!hzd%c1+kN$6`^oYXl0at*cjnu%_|Q~R zHT(@hP<;%0+s)(!?>dY6A=}ewoL5kk|9G2<_YIJO*$qx%9(Dv;h}026EiCjz!p=@S z`x5-#mRcB2&>+Cg71WCAV=>Uxcjw=qF{4K_kCcmWeq=2289)pIP zMRVg~R_mFKkkkTszG!)kJg4R#ceJbTlec>8MbpX6ugbBh0blQbI5J*D&h%O~HQLxh ziysG3lqp!(SsBZ=>*FgQnvV#ZQolZeol-KKyZgR>G&wmWkGRl2Ttb@mAg_KGX;ZPB zA3X!`y2m4CUY!r5C4v(K zHn+bLH%glvp8;(|RW$$csy)S+u}?OBIa8U+CK(EP_)p5`cw|e#aC@h&1lER<7s}Qb zna(-exV@Dfx?^+_1LuEv_=9?g|LWKql;b;tZkM%^E;nzPg9oX6-@3CX_9e?LLL}k~ z!>`-frbLiAzZWL`aMaTJaxNbvb{E_9jgBlGTqC=(Vfj_pOj0%nO(t)YHEdS5WvN;K z3~_Q!=4yW!&U(8NxO4zPEg#7BTG`yuxhy~<#G84ih26*Y=*_WHPfn`Y?=tN*LUoQm2eSXk=F388!~9H|8U+D zjFQkj#*xz@8z^cdfr+2Oe3iIwNvRExf<&WVxtaS;&?P9<1cy3S>I0|3!HhS{LvW_* zfz3Z^jW>RU+GQ`sayOVQWh!#A8a3Av{AXTmG4bP<>oAZF8q`a6N>~4y-)GQ8w&h(? zLr^(dY;`)mGi0sr;`iH(t-0>-I&EY6Po4n$bo%nd_*P4MyHhwPXLjJ+MmRk^?&3Ih z*u3Y~QX931g+7KXk}nQS9e< zt7D8hz3;TTIm<3FSazTKdtkB23!XC4!I0i$h_i@aR{Zmh% zlG&^^8ZtXH_lmXXH{?cF=zgJDuensl? z$^HSRQ7-3iUP&&VLu%SzF=M8WBen__(UVtO{ZMxXsOTUY%bBvlkp}C;z1fS^MxXwC zigdsK6`na6HejL-kKSuU&P-v~Tc`JBp-m_CQ4SM)a~ggUV)9Z0iDa%+-n$LvKS1x>=Z;1iqZQ@f z?@P)kcnFEDRtlHaR{Vn}ltWX(hi$W`EU_#UnrGRqoYT`Sot*I{HG7E}Q5(O$vpVTb zZTm14n_}o(8HCDy*8KcTdODIpr`z0m1i;PFb211=0hPfl9|G^MfU_I&xNFQtY)#Jp5W$o#I7aIeHQP|be0q%OlzIC5XKL3m2cWv&f5zQoAYFSox~CuKBmbgqLZFt-RM+U5_ zcz#Y8ax3Mq%q(wT8w3ZnC_54G>1i(ml7tDW ze{9Tx{;Ki$Qi^4nZIh)&bD*-qDl=J4^Zpq?*?=N@NEiDr^SlyG$G1g|1%f#&5Oj}b zzU-yTxUEmhr02}_;g?Pu*4oiF!cXOF$vpdW!WFCbcsS(mQp^11ONt{r4QFh3*(o~4 zGxm`~e(n9~$NjasV$M3#^)n7kpOLYxkP$%hqC#oWO#N4_C z*~-;XZ$-Q$Pl;hA>qw^37+^ER9G!>Zud2XsK-Hx`JBtLI8sGK9rva8c4CPU?9_}_f z=P4$h*|BuuueFFT&-V|cuC@p<=TJg30Q4ZQP9s2lmI5BkjHXli0t_Hgq zOIKJR7+bF#sBg@3bT6e-z-Ez5oAqllnpirZQJO9P~za0d2Cdb``Zd6^ufLSm%R2!y@H}xbsz2F!&G%uk{iQyX%K& zZogjgW<>t!y_wZW4IDaraw?tclpW-=9o(V>KsJs?4DZkS;kZhXYC+%M9b!9V7DZQ} zb`A9|C^+XwjGyQshQ*0L41hKO+%WU-d0ba5+yJNw{m=XlG5z}c1I@qn3{wHpVIL61 zod1FxuZ+9=v`%`G!kp>|t4i1)!GG>=M^I?K?vL+%!4*G2O)p<1selff%uq zl&lv~Jv})WNHM3ix77M|w{KTG>8@9P`TaR!VPP^7p8Kt<%&q%%lN|OMTk&uG5hL|k zp2NU!-Hf8-SFiVK%RnP+_|uyl*fZj!eRLbO96k*G_fMp)xNXca%kAo$5j#Fcj3=RZ z>4DS$K<%+3MhVryF}_<>t%RCBQ*}otN!_wkc+mJG!$NV<&71_;O9{-Enje#vVj&BX2QdZMEzF6TMpBtE4Z650VD>wvG?3y zCC5bh-JGp-9?mnK*;~G8c7o5iUS61&-%l}n$R5yC2o|D%0SV={Zg%m+u;~dFlg1U` zL6tn$BzKs*jd_NA$Oa;2c)XabY9?io88xM?1l?sKd}&N*FTR1bS_3lY&p_sv7bMa)Me?EYGl8>>ZqVn z4`cnuExu2Uf1;t>a}|>vYDTCUS~YJkP17bXRV;w9W};(U&fYl^z*v%jQ3c?BAo(AE z{`$>GrS$|c!Wz&I>oz+gZ`ykB6-4Y<+XuPBeR5b)01&xe)HlT)QIdE}mkqE+8zv4? zhf)q@0`bspb_Xy2Ao}yY!E)7uT{FA*@{Bp1s8$XHE9CJ>rjv%luRTVwu2iwKdx<@O zFU!PRQ9NHReLwRlSKe=_f3!U*AaLfAQ4KJUOOcP9Yyn3*NG+=~3nnr>AVM6utN+wI z&b#mBRR8cHJE?wKP(Dw0Adg z5vSdW_q;mgQqinsf;!Ic2!Yk&e}T~Kfl1WI6fuucWA;hjm)Csrl}c@p`Q1a8@C9iZ zNmcex8QX~3AV#O0UZeQs)s=d2l=av}BnGo3kIrb1_{Hg^&>tsDAuh%M-jtKOmtKCn( zJ9nn}r9DlGI#j&RddES~{8C+u-$|1}p+4v^-e#XgKz@k&ozpIk(It{60ZvujrEl_j zV#ICS7A4F#?LqmJAHJIYCFk<_3efr+HVy=O+k++9|xX5VTaIax0_sh5zzS*vwoe_VqD71A)CtK_kFlF8=rtN%Noz zRx5obIOj-)F~nh~G;g*-*GpZer+1lF3R#rkbx5f zW1&cc4>|5h0LxUcu*rKB6RWbtYKfGw#@PpDy_XBMOFVd>j@=SwBmXcmq=8=cd2Z*P zIt^ppnx zCLO|p+EG|>sj+@l?MjF8Wy5{b!h)$Iw3)dZdk^ZE;>zcT+t^9t1?`O5%u)8|zMvVp;Gt8Pi$s<9rzsGAm zGAdl^BvZkitUot89j_F&FNiW$>nC*NR+#mq4yl&Sq&4JlecAh%5$Hu}p6wLkHB3rU z&wB~L0+K@Cn7L1T`yN_r$kZOAvr`1uzBlhTsts%!$Lmkn4qezIe0{2c+FyX+ZVz`( zt+f|H9K5v4lXPCW5(U4&cg(?K^mkSf8LlpsXbpqGsIA`U)nuvDhi0c&c|OneteZy) zoapH3N@g~3@mN^R&FVNhCfZQlZGXAhRzv>wR%-ngWuWOC9GtD#f9BMw#LzqCT{x>u z)SvU*ZY_rwREA$uI&=rJt35jhXFCmsEc~kuK2bH+i>QuSuKe5m!w1$-k<4E&G9Q;i z9GlAv?OKB-7Y<5M`K2;=N5k+Zy-zq@s)@GJ=`XeF#!jpchr&JC8|dxwqST!-&(7HW zhDBA6W7DCFs!vv5i|32%d{dh%DJdjqi~DTj3CB@Pz9CVug~eA#cOipa86IQX%_@Z- zDVmji{lT1EgT6wHoQcvf6~+o0NSU>@?T*|7k{giX7yAWGAOO=^Hjq@l+U0xLw0q?5 zpxK$=;aGowlS*(Z|E0$I-Fb)|&mPJ za^x(V3I%2gj#gcIIx0v8fDGF(N7f+2fpl&%qRu_%&_OK24l_7jE_D`_6QT>j+TojH zSwpup%DF=4d$)(q8gyH^w_wygA_fLB%YL-CB?K-dgYn3wuNTK%AaqXnY# z;32I>Km7>=71FHk?7n1U;xd+aAMy2mNBb2S_u02i(3rtKaL6!?)UEE2~0ShdNCL%uiGZx-qe55%5XnN`ST{V@0-2 ze~hXIR@G0ekJlEumZDmVLvMC&E+hSX>s#G>7)Jyh0Tah$JQ^sRI$ia(cc(GPLRcw~ zO=LH2F=f+p;_B;LpgrMsMsMDG5>#S-06=!NVyHLv!5&MXpkUfgbh)+#Uh&SYy$_GF zYG0oekOa+^bGlu&2(KW+^hRs^31!wo>zikEVQhI$mS0+r7_Y*k*<3v}g7vXi0gk%_ zEr5HH{Ddjwa|7m$rGZj=Co0{5uzVNeP49$*ow%@DA@$Gi!!eJ`2ZXah5=X)=+1ln+ae^*xl zh8G;ZW$gr_tX4h5-OMaH1G}SFGI2AC z;h5wUvCv;yH0jD4QQFqEhKH?*jBIxM=nVu3K+jA$tKZ5#PXQ-an9(VmAY*MV$Kj8D zwEj^Q?Qt&8E0g%+$2Y3|zOR6J9c9onhnohBI_)Y8e{qx*0E-`T>CzuB)I6^Ut$v`+ z>%vWhxVJCvt9!}(Q!6gsL9B;M$-%}6n@U}3mTI>krKeKQD6Qq~vZvgo1ocN+-lT}Y zDmkos__z58gs{fAvXiN9RLm8kfNhm9q0!`nVg4(EoF+#|WqsdN<@Op^Zq zA1~lL9_qzhcPB0>G0f7_`)hn;LV55!Oen)z;v=HLTGj2CU84*{D7}5;*b?2C!ln5% z#QEiS0{B!+nXVZU?Ow>NNI#JF9h{s<>s&-Gvs!|PU0@X zQY5fr!@tTlOAI~@OvZvstKh4N@*K)$jF`?*+K$*I3bpcS-Y$Dr#2!A5d)tBET|>K2 zrKvij=fq1CM`X`y&<|mnR}vJj?zSR`I9Ff|%*o@=yUO;z-x=uOLupHF}Lw=52-s>)a+_1hAu+cxMPj#_RGX;9molE9RQ`En=uEu!zYapMj8iqFzewq@tU4m!yxvGJ*t;_t&WLO zc=7@|1icxx*2I;U_2tcrq4Zzlt^nd$xZm5AW9`;+nihMniML8sYXVQPjrD4S0Ij~b zW(jopt>`15j$G+WZbZeH^Gal+jZ*tlPx?>fI_O_sS z-~jVu(+QvX1PpaY_aBUH&~I7Je+fjt%X0w{tLNbMVOC~AU8#eArr&roCr0r%t|ZJW zYZ`BsXPeEc)2p{EC!nkK7(lmV9qI@DIrDA<+j2=#cKP{x9?p~iQ0eBZniYn6Au77R>_vvMiMcji)vwTs{`)7@f(hn}lI)2a@jO-yV`{jC1>_v) z<>Bh$a`9Ez+Jn_F)^dCz?MVP`BSU$hD}XXlM>X>du-@8sbw86Ys(gA^>m2n`^>XmG z%ji3^AXEa_l>IO>rxzbXdB@`96i=><9#Okbn<-WBd7O#ApSC^~(=V3xF-L&@+BWD$ zFmpZX`)3vENy0UXd@`5}Jd0kCyy@stLPsrTD=^juc&hJJ0Zu<`D&vZ~=DKO7)1+b= z^V`0Na#gn>$UD`n(O0v|p4rn?k!>=+px9S#zP zqr{Zv;<($FWnYXmPShK+*6lN)Ld5D;PEMe>1sDC4-+-?>s62nEY`F%gDmJCxA#!4LJ;wG$b z$_#nLmt@3mf?*Vk6L6poy1yw-*x69tV%-5BB;Sc2=+(am&pJcf`tW7Y*0?-}b*sp$ zzQn-e5$=fLpRjRCk!ByD+zOhHabT|RHbL1folOLlV7isjx=KO(B+#;e()p=g@kPpP z2ZZ$rFR)vV#?!WN<0MYEh znaOBa3r1L}1}Rc}2y*ogVa}>ZausImd1PbMWTscfx6gSeUSpXE(RK_~k!CZQT5aa> zCUj!~W;RKWE0y+p6hm{jCe}h5!=z>h1`G&GZTGwsFmNqvVD2WXbnr<=+xGd#B7qi2 zX+BxsY+Wv*ukb{|U+0P6N);+YC|}t-&OkU^J$n9v`ng8YQIW7-Z~j`GAk_>m*f?K& zVarAopE#Nn;bCdL5{7y?Gh=QRY7N8&lk^PLR^XNhcH5Nl7~h*CqX+o{0)LBU8J&iW zwOz`>E*g(Mc#vHlM65;tg4_VTxEQD!s0Y+wu*P9LcBEqhkDALNnxZW%VEDP(5BjqO zqOsu&#CDI;gsS1roJn`1JsgASPDurc_Kb#>^_&Hs2l8D{7XbIUaonH@iudw=Dqt1; z?=|Eii)(IyT2Y?ye$Yn2rT5!)oLZ;36aj&I^U3#m+}dc_in;J-HHw&{ED?sE5ah^k z?!*g^S$OBRGeMmiiWSohbN?NF+}6@AJIH({$w;x@-pyH()7VM^h>`V&p4_>!YN*J6 zqJz~6z2;_Mq!cy0xlEebobN-58!1|ha=lh}GyfhBs%=72+|FbwrW4Anhi5_nzu(=+ zBMiSn83roG^z=shuk0_E(p_km4zG{lVfvNhMEryPu{mB`y_0#adsh z20xuVQVpDrgv2EMszt6dZG7~P$M~ZxO7t0ceML32q8ESt*j^4zRJ!0X8O1;Mi-qf-@u=rcu;t*YnfH5xOV;Y z`)vVejilbuknFgu~TzDGJDb5($sR&?e2iG()|kT`vwE(Z0Yd?7liyH%AIt`XT}T8c1e0`@WEY5-!AZ z>)tLfuMu}5WUmD}qlP4)#lfK>-mL3ibKxh6{r2$NawxKL{$2^Z+ihAL-hv^SMU4K4 zcqajx9`s)^S)V>$r0W;Nb;Vo1fAMErF>L?e$NyXOtaQc_6Vvhe_Y~)i`Ljbq-P{6j zc*CB)@!BZDEz)fIeUG-k`ARvb^C!B}W#Cgb4P#Z$18`;jT$cf-EfU(bn3Uo;=5Rn8 zl>0P9tRzL+S8KAz_dnKt*#Yn&w%o;w8HC9Y_+m{>i_vq#oF$&&i$JtDN3H^+g_xQu16JA*;22lHO34u(y0V zw!LkR3h>$B61nDuEy})Ho;TZ>Ne}n7P|{s**4?czZ2g&jzfbrMSBzKOV5jhAKeV~ z2tX+p)|ot?;c+9JEv>hC0BZ0S<+78fQ)#XbZ8X<2!w}o{%6Gz{%lX7cR5+u0ixswO zQUNJ+Z173-P{}FcP(=eHz?~K$Y`;-&e><;EcyX)q0Au1}{STW(sPDqn-QP>nYSDJ< z1)^EoqkJlU^mu~f#6)#^4jllUFuDRLcAVH)GzX=OsSYHkmPz%y?^)qPUYqyV8v;K+ z_RK8VEo21Hsa#2Lo;au^&E=6+vFSUy%4MuAVz+(<~$^V|`-N5^f$GQ-N{=Q>^D}ZWMm) z-T%UEI3o!(jh?ZP*|nMx{2F)^EyN)PQ2#{v4tG;v+uA!1VbjPzY*(+8~w><$#~Ob4SLtl4&CckW*wU z4_G_S67DEo?XQXhip@O+w_|7gJ0>f>fBNd~*_)cs3#<0yIRlqLgbKe;_&>b8by$?$ z*EWn`D=47Sa7#){3rHv+jpWdvbR#Wo5h5W&cX!tSLnF}7pvA+-G$gdEq%W-R{iecOr z!px_I_9wy>DAY6))?OU@LmH!qLCuXZs5vo!^FAq}9WC0gd{!i2T@9Z=`z(mMBVis@ z$J9)W9e|^&VG^X=jDK}N0lb#|y&4d1>OD(sun6b1gcb@q#rslfZoB|{SSD++#R(q? z8S}=lrs8CqII`r*m29i>dOgVWEgg_N1#Nya{1wm}Y+@L_k#s4=lJPU)-hkn;F2uUk zc!&$d&ixIiXKM#r=Ohatna9BJesomwi!pk!JsUZhliuUAC#$WL6A3k1=B9b_4>}_( z(-5OW&hry923o`NxNS^)DjHrrYe9bT^IH}%*n@G~eW`zH?|C!=u~14{cefn_fz~Wi zv}xq~l`G3DId<~%f5M;@Hz@8WPSDe$t&Lh?0;RKpp*LCdJdFPac@liYhdDT)5n4psOy-q)&Nd#`by6%`y3#U{@uE1NGXHvoJa)3zV03Q0Zp zS12r_5ac3aw+&3K9$$$UuslAs)vh+R78tcz^IuknYfN(qUoR*qX{zu}cVQI+IfZ?s-@2=XM zIH?PO@}-4O;MH$@cJnD-DK1ea1PHB9MeWN(YCBYdwy7V=(z#SQeH^jx(VQsE#6cHp zEU)XO;43L&5X>i=7~8M4+odwSY-6ury-kLeXB6?;mavs08;7Cs9N-9vL?ooQEerl` zL^c|8SN^cKMTKE$CII8#X&z4BaV_V>FU}*l!7FWnT<5E~I?_yTy&}t(CqX|0C`BCR zIGouK35S8vUes!wO2k2a`sNSPTr!&a_n*9(u57>T2dzFc`?_pf3%8IR6Hz0MA(=uxv+?2bs!-qK9l!_nJCKh4TO-Qo5q{Llb-FkH~R+y3Y}L?wD+-A$D8WVaF-2Y){qvQNU29D!2> zpQt~WM&7_btG7qkB@-ji-XK~=A9lh~kU`nz;U)2F1hJ!ae}EX7$F|FAs<=&JCtb0> z3tScCBVL5^lHmUMAp@L~^KSbtv^rklsKI{I^)x}`T=6aEiFLgRlPGq5#=lGp#@Zn- z>YxgyCSxl0t+w(jE=m%Rgav@b#TV?CR9$We?-iXPBzUa8GSWj>n^A__U)a#!e zKe-jq2sDPAIugBr^X~Z@U928*5zYZ=(0Un?9 z_YNV33}1TM!7efGeG+RG^a0l?tFc%1C7@Xt%n`6oPU15U-7L}-;n|6|5++x`PY#@@ zZ1;Q)+ot>hV_~xy`OFQRc5LHQTo}phW2wrN(6yCmE-PK^9HXlTO^0EuBnXZQ+r z?`FRl)&8QaniQ4p3g`Bx%SfmA*hifL*KI=vR4agL#8n9uv|H1@&%9mUDq6JKM0WNS zyWlwT!!=Oyv<8aCG%d$;L?22eRKmywxmAHd0JRnXn_wiJfDdz)mb6i&b|r1#TamxQ zEDK~0oQ&u)xMjtltr1>yrl!LsC!i6?J}Sw?X9d1JI#H_zO8Dcx=)4Gv##OhT0P^0f zLKFKUu1(aSkMi`evxEE4uzJE_S%Fwf^d$Gt?KArD^ssRSqa!09v0bk=qM^yBhrdAp zlBXt3XRy4tzi-$v#Fegw3Qr7Ke)B=wf~tC!0yq1-9^)tz+-d+D^8ME7>5c+jMdbkB zcB1&_ZUyLfM$b=4_~_G1K>SZn+=6Y=X8f5R61NiG26`B}oQPI^ zUM5G*c=k@&%YJrm$jQDsa~L9^z-MNRSor;$QJ7MzGuoY1JL_b4VWBO7f0u$kcC-fB zXxI4Af>^BO+ba#tg2{(G)dMVIjI!&;p!Es?QzX^UP6>H$p$;P|Mx~*|`Y)0MN?3?Rkg{}yHf_u6vUXhb0sODH%0Og}P4aEl5qnA$& zhCnM|MRm@`R4kW}u%mheBJAf7!ECxd&gwd#GM_U_&xpUz{S#n(Hdc-qTSmH?`f(+j zHq3l26nB4y%7q)ZTs1|?j=phoF&c-QH7Y4H%a&QLS!Lc(!CC5J}<(# zHSJYLBI#2eR04WC5UePoUk(IwQB-ofRd);mLf1m|fTf|~46jf=TK%oTTs(1eZvIyN z*K7D}48&N*rE=T4w1o7C3TiK9P&I;#+PCY@GuVwvWV7ykKs;Zy-=1c+Ynes*J5?15 zfKg;yNY!=cDjszSTUYOb0CM4nG{AKN&B6t*8&6nvZm7Cxn7%tsANhEvL)76rXXVYf z5m?u4-roEQhbw$5#qbx?67}~4z*1~r>SEX@ulYSNqA}(I*(M%)uM}UM$LSimm5uw0=oX9?Gsat`A=gBRp@1 zG2;D9{^FZf8o}gjG?)J3aHC2{{0ZW-AIW`L)rOmL)lS5U!s~XPt_8@d8SkDj%BAWQ z%aV0OJgOd9IQ~FL#2fCxaR56MbsL?|ha=DVHI?8JkjWfAHV~fB7D@&<1w?@~r{m9S zM+=$*QF$47J^9X)ny-`=g|1y~^fvCO;6JW>=dy;hx>CnuSRoyIx57)aSS~7^%+|I@ z2d0~HU(f}WbjgZSI`ff60cyP1F{}2Yf_c!3(YPcs5@clg7j;@@*ai6#3Q(fjIlv7W z9=*GjV*g58MSJT8i^KcC;M+Z)Ta~XxZMz$9N9Y6i*}#kIXo~{$@zUtHtS}DWCma90 zKahx0Oj!po7G9&?fd$*9dvwrotBzFkcJ%Zdl)S*^ zI#_dZ5^nBL*xNWASpm2wd$PJf8Iydoe^W;+MC4lcnfK7Zg2DBPy`zc!+O^vydE&Hm z-IN{T6;JU>?dnwy24BjDiOn>IFyrBOc9y{CRw65>I<~tYv~hD1l#40y zIXEQqm-2;PLa}Us&M@}c#u*U-O^B2qt*cK~sWfT~|B?=;9Ptt}rganL0 zk#W7!G^i-d$$5E4$8)q|G+50|Hpj>HwM!n(yD#?v!P?Z=kO`I)o6~7;vA$i*MnO(N zS=H!y#Qg~Lt(y$8c)DI68uf&ozR=&dT>3C|V#u)v5sbb^BHMGX>M21{Mx{)aB61iP zFhU*?;sY>xh3jz%QB6%SNNb6Ywo+I6Nad)36iabkJ=4LYQ_pgyZ1RCSm3EvNyDno^ zR@?(y{G_AJ!8Ua#{=J&%G^x~RJ9Y!LTRK*>KlJW%C*Pcgv;XF}9HOD=%D4T_J@939 z%x`CA1}TWCX$HG79%wp9`KCEKQN`F*zmg2AzP>%!hIUB3$&5o15UqC?6wB4(EX)N= z+KWKl5ekYLu`lIUD+bMT86Q3~mku7P{gIX*5PckSplAJ)l>pNU2YBb^OsV+ z$Kmv9H^xUgT0ysD(3SaAZ{g9?16p4~p#6JYz{~GZdH9?)qjIIxH+6v!<~&_TsF*-HxuK zY6hFhR+Cw}M-@J`drCBL$#KdI@Q7<68Rmv^C~FM4xKM zI>*dQQv`sKgf!lnLB8n2R~$UK*I6#jeg{l#1S9|#N&9?5$SYG4P_?Cz2`E|~Y_PHPt`AJy20jS$kyI}b$U0}(Fd)y@|#Cgb^x90uf*GY~qw86-) zP$eUNM(~GKy0E@Fb2}fN-OwY;*=A+VEcbY;D#~9lTap(pStcCHZ-f+UC=1289;SKY zVLlTp-nYQOPE*KmEW}n$P%)GQetsSgU7Rt_0od9)zyLNV>yuKQi8~M)tgcAsE1v>7 zfbT){yPwM7hz9_58kyVjl<9!F(i^bUAsd>s0WDxcArz3~?p}@p6sUG@W=vc5Q0M-% zmR&-L4>8V0Pl7@nFXVz>x&?6O|cx) zy*wYb$$ZlSr={2fna=Nh;Q?Na223C7E;yAf4@u6)K{KfE*GVt z(ZTs>sPXI?eO&5Z#}K44auTrD%I0NI{qgPkxh_>IyHu&G4ltNW`**Y+ z7^w3c0#^CGb=$D9bGz#hJRI>BR}xCq>Yc}ae%kNNA^r(@QPHO7cS7$kTaj8PU>xiZ zr`t4BZN(p*HPk2|KIe!C<6M4j%JAF{)F1%1)xU)+SVmE>jCv_M={2)V3-Xx(;Ub4g zc=+W%G`OkqbbuZBE?9lBs}B`>ivGi#+U!TiHuN9$7$DN=K>Ocx8UN>$u>b!nU4Ykk zar_TSb+8f;T#vY(N~&3Xg*Y69)@K+ z6k-S6WzARY_s?HOYLrUE9Jp8wHPb69QReuBdk@p4d*;TB(86rzJ9t)l^XpGO5l~|w zhUeZf=jBcr0~|Ct8$@jZZ~ZRL+pMX9vK$_n2wDfc#yI#7!Q0U*B}ic#nMiEPH#DI+ zOZn{9F)qw8B!4rAnsA!0v|0ksQuHEIxnt zW7{VW!7Zy-_5nW5!wR-yu|+Yk^RQ(-rv&I#`cEF(7bn+qwz9T%S>ANlND|GM(9sPY zBX#*Q%lj0E*WXR{lcb8n=b7o!arALG5m;!H?-|~uKJhBo!d}BIv_YyJFTl@3kjiYz zG%skKI!hzvO#ATVNm^oms50lpTf@!I70Pm2>FIrUiOC_ z(;T`YyiYHWU3UIdTKd=}>^jg_6R|kEiPJ3!3N?OlK8mErrx23tS5W~XB{_{>#FOl%x<6niwyN@ySBjn~eVPH{_BAe~;D625r3?zGP8X_<`y~j2LNS61Fh0 zHz)5=-C?d)E$`g@OV@d0wsGs=%kJsiA*yq;ft+jkQaAa~d6Q2GjgTzHZIb496H!|= z+WRkMtGKm__UEsp(N82JN~m&x`vWLH8DxQtpLoyuXaLymknJ+J{i`mEK{%EA2Xp%H z$`ZAnnQjZ_X*zA5wy9#ljFQpV?bZ|CLx!{B)cm!{s)0NnCUuoTyMPjNFq1g87Swy@ zrm5U={yuWwbL@ul`m+S@LN;?eApONw(;&|ASXemLzM@^9B&oUmH!$)_a5hd#{WP9Es-knX(G8$Qvzurq! zl`M(}Ow;_mUgbTYrr-!{KY2oYAv<7Y22~qaZe_fM1!q&Ma)b{Ew6I$Q)RIh?%|T`Z z$;%*>Cq?nwU<5^;3~Bmi?LNW?*o`ecPOlbmDp{VL;jAkAiaAI|5VuvG`j5QA-(s?5 zWrlpt^g*0Uh53f(a7pBBoC?rbti;WoAgZU*39H(w_B+Kk?nt!?*-Ph|D+D$Ab}N!o zp^9d7n&c+GGp)@fFj{}zC}j{f92meGKw;iAWoy)hx-a$q{wUuy`Z8v-FQvR1oNr%M z(l>;fTLMAj@R{}|VyMZxs@ELB;vJ7NJQ>{m7VpxM1kcXN45B(gNhjPFF-ksvX{6p9 z;G&IqHsLY5A1(IpnDjjZKnF9{WdQ@C3=9J(k#s%^%qw-i7LC41aMWF0h^@(Xj!fL` zwm^~g$%K$qJQJ*~(@2K6QJXf-Ae8CbD#wFZXYS6zwrgVyLM_8Ad>Z;Hwtbl4!gM=U z9Tf%xJQP9kPYf2UWxBNh=Q4TijW>i(eAYjmNFCU=vV+Ebz*X0Da%|Jh!PZw;Db33y z^nAd<_IQ<{!IM#CH0&(7cx~6sJGQ}~pgi+h&U9uOo~P9$;#OsoQTf$YnE{6_WeAUTk+)vu=^IJc_h*WSdMqJXF}bb9}JKA`J$F9ipSQ^1^e3 z#mS|Za*(>8$Sqb2aN$Rb^L`&#mB7sE@ed4VX4efdf z3KmbR`5L6PPCY$pv~Vuqx8(tcx3))w9hFy>(RrgrijSvWg!JzymV>oHmbLOZ&AfAA zjVRa6-u^XFfi))09F`XYsr{oH@OfO@C-sK+KY!$-m1BA0q1<+_#3$>@1X*%!n#irE zmzL)i0y3$MqeusLBsQq~_06q&V4KH(7v4JpV2qX687I_lW7)A`Qqt1!bK9EuTx~$S zjm5zn2O-nE-}UviiwhP1z}M?tmAr-pny4{f=(71eW+xP*siLf^j;|$h8J~qJVh*1e z=t;q;6CnBKUSIe+Ve1V5mZO`#996t<_Ex7jd3-1BAp6+na4P!`w00UMQm6Rx>YLZA z)cuO)Jt?*zJA_J0KJN@je(CvBX%wRrdN^sStYFyN*4EK9?4C3NqiPz02?YqbD5*}p z(H}G}5M>j|4I=c;N^fB4XNW&e5=UxCJMVm=ZzyT?bw^<2N63=Y4DnrlN8Q8}e_Z*w z=Da&9BsTj(al=8qvy)&wmbS8Kvl1>yB*JcvC+K-z2oI=!T>qC%`OgSFWaj#&Cc9Rg z4Q82h1Al2_(W?j|;t8*&7U>+B@!AP(ep$;ihN!I(b0Cw^#FKa4Q(U6&ZT`-xjgVPx z*vcDLpl4|*9hJnMWi}-CqOj#*-q61Laj{;MP|jK#9WGK+l@T9lxbhF69?zsLGK4`K zzTka|YnCdsFA)`jcohnDHtMj;SaLDeG z3+I-IJ}s5^RJs!t)D(51GDRE3CE*(@nhE@Qe5ITtOf z%8B-(%o-UMmI0nyxZOXUuZ}TdB{BX0AP|mUQ9tVCnzw|#udXW}&n^2!5$=*ZtUYcb ziwapI;SpC&K8TSYqx4=P`<#P?TUhw^Ck{Abm6Rr09y2^u51{GD;<7$?*@Ipz} zW{yzF5Llz~w{TA9LdVi#QqqTh3|5~+`@WTUS~dBvT~mD8CDC?g11gG_aD4smUVD)t zRXZBst8fINF!}9=0SpAYpQ67J7xXhL6(PPBG^okxvuoq2Ysf)cn5CWOJI+JRu0%oa z0mv?q*~2Ee4&T$4L(3rgam;*T_v zVO!`VAGZS!{guFxymcdQ7vATC#kB*UlFM57vPU7_H5iF@@@!#F%hgdE!w{;cTFC8_ z=dAqlJkqx{>w9u*emhY)or(+Gftuit1fHuNRM!eU;FGOBh%_-wPwUS?^&p(GL}zWFfzUH<=Ae1G16qgUVft9=j@Qjf5fG!|ny`zeIzpA19U??*0A1i7vA!>ucQ(mtPD007*(AM@5s4UQk| z_Q~Q8IXw{4f*Mb3zF?t@;1#BmiYrJNWNkKg3c^t?(ugwU$kU7~PlG;HzmfTy*!`j@dnq_HYgt zh$4>gM3PpUZ2RsXZmhAA>(=kiofn-1bOJ>z>A%l(9jo#u*=T*R2!zm7oYf-@eD|rg zI3L*r@RxKG3$sXt;uCaRJd$1-X8Qe+3;$Z$ zzoSd0)oR*C5$AfPGK^i<%>uZJaIhV-6y#%jez0zS1XIW@)Buhi4mNK3LQ^u5WNfdp z*ZexoK&fxc^~`X*anfcIG82C0A+ka>Ew&cm_(J&fATKX3+@w94y$%L}(St8lRj{7n zAuE%4Q+A!+<6T5ib+?=%aAZHlJX#R_E8cb0cGy)L$d{0&;Xu1o-FQz0fZ;PwOcHF;>` zukk#f2p|LG>xrM&(BhClpEWGFjPk9WEX4TsgMk505ikzMrNq1`Lr@cu4gOi;Ppkq4 z$btwf6^0dO0s4!{uBAQi2>@vDyzUVWNo3}w8y>S0w~M-u3l3=5hfuN+i<{oB8+$4L z1dbX8-g?;3>niGD?q9s1kMAyo)&%6gfMe{K8v|fb{#>{EbA~ND+ZoK~b0kb`eV|b( zggiF0)96~Bp@|_XaFu$U0oD<>Zw^lP{92fAL4CT{+1b(SEPYWWvHCqvsD;bllc#QA z8&36hvTrA)GD|Q$Lho>Fv7hVs3h%^)rU<1~tN;>dOZNF>rSbm?!ubw_Gk!O9GKLTjHu{z_?n+f5=dn=Fjp?^~|6K<6Ke{N|TDc^D=MMNbJO3ZS9PrcsEnUuk zulGMhD}XHG|M!Zcw7}e^VofX%tic92Ao>N!^-UD?-BM6A1ZtGX^}|SUJNqfbEqu9f#6mE0cle1|$XL0El+ccn5)ObPO%t1u|y;9^Za+ z$vNLV#_rWXs@wwfM)0~1JOOevK|iw@S;4&+E^ewznQB;&j4Lc@b22*}L!tz#jIpvb zJJ9kDAtR0R10c`W#dl2Q+xG8CaYQfNZvd!5v1gMVh%OQaQaM>5bX=q)Ws=P=v@+JJ zy-=GQ+VI5n<}xhd)EX22rBz(Ggzx>YehX*}1I-&sIiT7aeL&L(b|MIfcR=v|!D$xw zPf?K-JmONXwetw%RaL^}*1dOg2}oo^Bg2F6d;XnKVA_D%SnMi;c5TX;dnNkgQ(@7# zB_K@$P`d8MGc&9%(pyeha-J8e4wel!+xPTqS)%BdSnBMSmXh_BWXKo)$^Q>1cO766 z&NpR0OVGEgDGKtp`a-gVyKD+--sY%B79{yN(RNnxRLhVXvvA&tIgyTA%F2SO@|sC1 zNB?JJaAL3$OQJD*opl=$VncD$2+nsPPRm$d%G-7hEn)Bhj zGt$9p6DyTeL4hdwTUTN(kJmPNA^79X|Ky_AVS{Eiv_V>PWN)RiQAX|}^uwJp{1`?I zu#SC@1CP2bS$@DQD5b-k~c5MA+v-i&S68ta3a;-J(@oT?4|G zU!G20M6jI?)&YiG*n4J@s`Dw!5Mdm0D$iyB84T zJf_cIi%o&7ud9?nJEE$XHOV99h)-Hswt6fb@7eaD8!I@zWEQNT{h?)Y2{CEvOY046 z82$o;wM-@E6O1DiLXC^A@Zgj8T zzNapy3d$C~Y*d5NRSh7s+|x;=Zf0VltZ{+DiIZT(cHbh;y0I%B$bd1)Ci_lTuul6k z5cC5MZLkiP;`H5*WIn^Z>LtL!FS^MFbRA{0SePR+9i#5agB8RWxFM#hDV&v<#E8Sj z$sU!+Og?R>I&S9;SseP!EPH-!6Uadh$GNOEhNN5~UyPLd5_V$abS+JE{c^Ua+w#Z_ z0+FyEoNw8&Rp;*xS@CI-h+aW*D%}*%QdJ$h54sGBOtn!9iU98K`6-aAATNJw*XrVh zh|Bj~eL!Vr`0Wxle;T{`2=wwnq_W~Pw5#(6Z1*x9$VriXk2Sx7n%(c%mnEm#xuP8^ zqmmCvsEx`{z;Q<^x2?$y1Sh`!+WQcNTX< zOWD0K`^DUxUdo@LHh%#!XNRVtdFfaQEP#fsVa2}oAQ}*$qgLM0WW)^&C;+LT^uY8m z8VV~R?Zyh}z|T6Q5EfbEpE3ZLsnP`YM#7=dR*i~4&96rKq)>By{hEJ3>7n3H{RNR}4&jW%?XI8A7Z`jGB% zKNhDi)<6Vakbe?<@gpBFYnJbevyxx`w0TR4ZDsPpFdrsFTr%_ZNrKdE?T$ALPPH*JPX105|8ygM4i_GzcX>y z!H0)Um(Eo^h_XXN2^J{?@3}4Kwq)vByy(o*V~$oFOl0}1J>?6`g-sO3xsA36lYxYR z9x$7a0LFDzYZfmJugdNoaW*f8aA*}Yh)#;^Gn&_qh|%i1g)tADm~t|An)92wkI3u9 zZ4Lbv#;bM+QLHm`3k!FIaQ=Q;++cl*Eb!7iyQz+2A=f0@pP!efF}@oFu>R&N*`P6p zj!ptt+47E1&D`v4$k~ZxfKAe$=d@G@HM)Y=eqs?c$S6$scooMR<~|u4d1OQ$7jVDZ?=Ow|6t|A+U5-hczm4r)Z%RrLO^hG zy2wulE1vb!WYuoz1fj_jdI{&f7gJ-(&2u{s^+O~D@%%7OjdK0zUMC#v9j9jMCw2ve zqD6G3ZBa)_W(R}UE}rV4@%f$87O-s%mAF-=(|SIl zeOfPdcm+pM&`>QSf1L+RJ5@fusuLwIF;xBa6^)Uuvpk#8;J1eVdtK6+4GfP~^s(3z zNNmBgMBDSWhG{n%!}qXD*v91!(5nMxDt5;&hi&(PB8B`n8ft%P*2)c)*ET>p0rWfr zIG=Y!Bm4%=>XgU9YH?Z&{!kfl6pOG*T2oA9UUoMBP$%x2_c!j`Q7fUI9u{B>8Y#IL zQ0IpLqrc&Xtp>_UH&SC5SC&}|4jbH@v96!y1x6su_;ff5TknBAr4Wl8 zuqgqK|DwPkMx_J6t_e2I{X1iU4}sOV1eR1zPGM)0ho5h}Vw#L5XS^D*X?3TL$NAQs zbO3|1V55WpkB5Kn9|z~5ILM2q8+eXFs55MfUhSh!J`8u{)wwJ9M|a6twKz~THMIbE z{j_q-^@-@epAsL%dNOYUg5Q7tnNA02arbZCTnY{=aGQi(jryZ)&dg^V9v!@M{2X|| zlT+(0uDMtcK5K$i>q=jo%{W{FkkZJ(pQiO=8!w}h60lEvuUijrPFx)NIAE9{L;0^nfxyS|0@+V2o^xr!LfpMpsI-KySdHDP z(QlXZQn5r8&Y9Ra<*V%^dGr(dS&*E{(!qQ)lZCW#{407o@eWH{V0Q%#vJppq;ZSEF zKPhWgY?@k94G#fQpJzT2;i^2_B{b@|;!IcpzyH>$q}tF7`cBo64fY-1bN-)dqTnIs z!MpBlYkant`rZL#%Qh{~$f>CE00avddiK1g&vr=!-QnDPwNi(=jjWnkJ(efCf!T*H z)6ca#QwC3HQxsjyb+G7`X)WC2{48kFW}*|G1^jZGUT;1(GgIP2Y_z7i0>Ui5rIw ziD!YD!w={Nj;7fSkN2k2sRLxl>)o{ff~EIC_%{d8!~IGRs=u1CvyDJ^aH!xP58#*< zmkv;79KScMbzOcSyQ?;=rM{|y&8pZcuVHtg6#^#3*;wtT*idHCEwT5!M)_kl#{iKg z#rR$!s6tuygBrdf`-J}E_QYx5&@<`sOxn_X4YWl;1thkC1#jW%r#F6o-*TTLz>{z| zL>qaSH?Z=sK-hA}%g#(|nXksTvA6LX%&mfz_xCNl2(0TN7{tGNCer9hBFh|hK1kcR+fJZB#*0G;65;QvL&U*wC;Nv$=U=?~9ybYK6RrWsc(=L3su#8J$wY;uSUNxe#^}0YT4#aC_Ms zw`Nvwfl6KduOVFB!@j`*#*qC_VPI`o0Ehgg@F-a2g}^ryK^w%y7h;$EvDbyCZWNzS z0IUhNW^6nutOgVYN$FtPvX^BD0O8z3aWppn;WAnEV68&mB~0s&l4r&)OAiFW^!F9v zh>v1jX;6f=bdy0E3p-$q(kQ}98e5SC@|wASTCTBtQz~UQc&dRICpIhtzx7ZSV2aM2 zKuS)vaA4W=Q59C8z7*oQ;p5(`V_MuUfSwjq4BZ?q?w#I4os?sfQEB6Jr}jGVITzDo zb(?Md{Xgyga!zV*v((X3gdzR+&T!z@u|^Q+j7B@9V&f%jK~GCDhMdP{6-zZ@ zSITa)Pj7iJF9m1Dwrsq5-B6NkmYHw|q{>cP39zch+!YOmZa}kGeqen>P6!0s>Qn|W z<+x;9X1J#V+`rnylD(#PtTIn-x>SdiWD&OA_@9eE?*ipecA%2*9X)V^azSS={hEx! z=XCw|i_LEX0N%G4Y(MVRL7;|RKTGTD$A_#%zPTiLv(L>YQNE^VJ02Qc=+a63|E@%8 zMH*c0u1A}adj6?Nlv0XFL45p#GG~t3P2gShZcpEz6qW;y=(VL-d#{7gnd5bdrE~9U zfc%j~8q*$~9IO{bB7=vzHT6n_iyLd#C@R1GABnXCr7$Jn+75zV`s2&c_K@w1q9<|r zL{TRQ;vS7!tZAN`dglDK-zsmlKpZyAJUleAI+W+cBBq^HP8L1FB#Wb%8XFZ)$QZm>`gQa>nOeYCIFDtVy(4e`b0q-*>Ejk%^uqt8)? zM28?;H|R!;$0u1r^*R@w*TopPwyJuKW9atC9Yc4Sx}ZIY25wNe_5MQt6kLs@(mp6G z&o_k>C>q{GslpRQxm4B>OfSGwTJPGX9PO7lPZd9Y$N-OiEGzOI{Jjr6jz+E~5NhRk zb6R!1QUfC!-xT{tK)sKQN?0ZDaVKrA%|~#an-y%}=kd+S`rUEiY!vG=)6o%j1wm=o zwUFMK8z}IU%~yh(NG}Xa^Ob^AlPnKuDSr<#eFJ2!OjL@EkJfRICXJkk;MUMmEejjs zc)dlr1bAM0%|``)B;55%!PLkxXn^}+KUHEd?R>IXYlcigA5N=2*=Odw{yO^D2iT8F zVgT}Dk2l}2!Og`>>tFH<@GHp9hK-|X#9W{iN+e$wa+Lf%Ko~uX`!glv;`ecIa2GZo z0drm$E~*8!i+ioD&n^-O zrheE$Aye(3!0Yyhd|-(GsRU#NkbXKbjjmuz@}q)QEPP)l;vRp#kbMlz^!4?Po9UYD zn{6zau2mQ%Xq2O&In@(8SvU>Vp#`HW1$?w;n!36LJm$T5BQ8)%oIdw4SkXRT6{tyc zDP~ldZfRMP6#x&`m&I zviN0U?tT^DiEm0#zptGE!0W-M|B(ThRcd}w(eT=!`3;s!skd^A@`l%V%<&*LVDy_i zi}O^DF}hjyjVWnCZs++E9V~u_$da9z2A9Sf$>B+{DDP#3+!*(7@w`WJAwd)@vO(8x zjsEy%EK#4{V=L1nkD6k~6!&6Glaf!`+AeCV-Z46~(|lO(8h5Jny7G?W2P~^%rH7d< zQ4EWMkgJ|!AbFbtoGgXXcUsT)y@MJy0&ac@j-*fG6iSak7RIm@U$f`5yfJDau3o5= zSghO|NDZ$HQ{$1IPIal{_xG?&g7W-KyAczrg88N8w+jceP9Mj&>>rDsB(axL3^>lu zs;c;rh$GB+9r7r*L>Pf7Aq%;g+x^ew>vxG{{!#fvAH>WbYxI$eW9(JL*q9O}lS5*+ z9dvqe26YlMwRqxj$e6HUQ=YJXFXrt>TS^j}VB5H5Tz;v4E(hl0UVms3!a|gLdLEm; z#*Z3l z(s*JTED`XjEK;*N&e-WOnWC2-ET+TXYCglb*3QPR<_iNj0j;-W_oK|-%IfNXy6d#G z0}@p0HzAUel0R~?sb~gWi-T%RbAI;um0ovTm9VUT%wCQLBghz z{YW2N%h%`h=?yLiFXJBXAzt0_H#=0@oplkp*NHKRx|jP_yJpmer=)I*`agHHzSy3T zY`8Dkq-onw1kewbJ+J0q>% z)>|{bm3Y~R3@TGw1>MR@xl~H;Bx+3b!r^de>1h+v{++E}C&sh$P*#@o+tNX2q>oSZ z!*H%CJ{Pj=>%{Cax{2=RZ`P`{k}7aBzKL(OdRWC<#c|UTfBbg0@+ro1+)X=PFh$-r zM$jki_B%oc+1nIWS7$wMHFeNc*rI&OvlBymlzuXXF2dU7Nr}i>=qS$P0HySvZ?ta= z*NqGd> zea9&biay!B;fwhhW(gna>L#|I#jv5JjpozwqM5s&Ud6l0PksE(*K30r$85YVFDZrp zvw5bT_8^KrLmjb!xKKeI8%W;v^AMw#H;5QcL^}Q?W^NY&5gQM(Ims=(B|O^6(JD z*e^9bW)Y18^K4g){|qsMyiG_*819q#D(mvnb@dZ88+Pr`(mGac*xVBR{h5nDIxzFK z*Li?>ZB6x8`2cwf%&8NOkd97jLqS4+u58?o8Nj42$jEukSg(*rerRqQbV;bD(JO zCP6am!)b2+HRcF1F}5hR6wSxX?zmTPZwfl~k)2wDp^PRL)`s?L^wu(u)BpIP0_;b@ zH34B=wnn#2iAG*0KDv1*Zgd_ji~5}|BfE*k;@#wFGz&0$mv-)q`hI>b(Jd(@xwlx3 z#QuS^Pmc8etPGF%rPPyJQ4ygi4fD9dqOWgfzcBnUVcch34af0?DIpD&{BvhY-^LXt zgEeCXmCPSZ*VvlC6#n%J3>x@;anNLk)8SampqO_%V?3_l>kGn7x9Z=9$0l0RPq|Zo zCw}d{EmczaGnO>a*`3|^F}ym_#xkp-C?xRpgJ7sE>*KA06`k ze8@#gOa!m1{n+vS_xO(&cUs@QrN;>o?Z?MqUqWDeCw#YnB?P>qZ0_4wc`Zjhv*2?3#X>+9x9t%9ZBh$M>#T;B22<-wW~|v5&05|| z(AP&%Pze5D*Y|Q}yZSM_r-z_=Eu4_i-y<`G>&iCngIDIqqT6o|th=aUdcA9_D|nqm zk27-iUf!a4-5d9@#~DdA`E4U$=1|ASXX1AAgSWhGmkAi%oL&32RqRTu`n-IQ)|1w9iXi7@Y5Bd}DktA#qSJx*>D>c?y2 z6;OdVp{Daay(~e})pnQgQZw)?cd$+Q93KIf4pgJ=-Oj1sC@Y<9hab*XT{pj~^ z8S~P810x;1Vy6+h;zYAz$Rooke)k*N?F;QRB2oK_dYiJnN}b(KpUzeVcb{e=sHzW(rFWwZ)$xpRAsk) z>gn!P*GQkAo^7JH^OTgl4W7yCvVvPK<-jPJmvZx4J;GG(5cUjd>~@)NOh4BtXX%$&ft_4vKdG;P7+&KFqDr$g%+Q*;~7ALP*V|o*p_SPyybnF+$xafUe z~lR*XFtF)lWT_`+l9nzz$z4dn`B2 zYYWb~UgyeA>{bO#Q zC!ADoDc+6VX=uxwTLTtpe?tS4P=V5@gz3{Vk9>FXG(^>%uN*e~#9ynZ5%p$td#T%l zvg9d)4e`+0J#kQxNV+tA7A2i)Z)>9N#a(U6`TFN-9%TvhLP3e>OoaYJumcPru`kDM zNBM?BnS^%z8=sQB@$xfc0%{hpbAy)$j*}>^{;pNT={5WWMB52k%ptEb80Mrw8gTm| zqrkP!mODn2LXnyFK1m0?VmW26C_<3-59hXpW%TOe^V=|*hniN8A8)eWArxUqxP>{V z(Gzum%4aP}-lkF7{JwE1uxW`g`17v*ei${A(a{?sBnDSvrE7aqj#L~hZ*Eh`t2hA# zFH4*D0yX2Y+nI99v;rxAXzjvY?IEYHG_cu*4R-8cLx}y#8@e~aQ}0moPTCBy0ox1{ zJ7N&i+G8)4?=}UGuNcFz*VDfh9H{8%I=C)xD#4dkmD8>mr{L;%HOU$45C5d2+4*?r zL(qI@1}%tRq&UU3#KQI|Yvz%yyobNjASYLW`@%GO+>A{)t zXD-J0B=J^cgfWXwXNocL$1{_dj)gBY#=D$ejUy6R`KtvtWm=f$JP`MyUaOv z!)`Tx53Hg8sr~a!IV^n={S1t?Nh)c+RbkQ`$EVwNzK8SfC6*X>#Pt$O#cmRb4rG&| z`^TEGw5i7VY=fwcZbjta*iaYA=v04!*NG-Ym8tnF1@Z@HyyB7`c@=}`=q;h{1ADwN z&ubf-t8e57XJ!aUS2H7eLJ5T4_Yh3hE8SM;P3}u+B>~3n#uq&4&e&Lfp{dpy7D`s( z&fl_@53>|~Pd#MRNisD<;I48hC%G>xo_eJx{<=>0BIDA>{=iF{7y+Cl$+0>e{;@g% ze$o)w6=7QpSB>+R%@d^fAog+Is2)jv&o9f1W1kee`fB(4@sCyl7bR;Os{=WtMfmuF z1B)0Y5^=hWXXVwM;Cct+DE*>$50z22W9ox)CCg-+E8{c_$a?97y~lr#+Hz(s=GRNt zg&3Kb1TkC3zM92r9&M79f<0%KNe2#dBow@e%6@Xo$kI0UIyHUgjVyC&Yun80o^3?m zuety4S-|%ztfqH&hN*1q>jLpPzG#F^E18Lvv__T%+hcl7&+4ODf7IgLyBGcKSEFqM z%Z0!6=Zhu>_++yn+@mP}V4TcaCO$qM5LawxK%)QKFVPYa+=O(zlUGto2akUThVprJ zu(+5h`Y1fW*nZE~fWzPNa7S!;cz2>;@=>0pU+kO-yLM}Q{habH2j<|^V8YmJr_U{h zYozuK#WjIb;gT5fk!j42_&~*;dYgsUI^)Ly2xVnHXqI79Oiftw3hE;yduCrun~%`K zKK*w_cYVbnJzux&yU(kOH>Tcn7Ii6xlofsF+Ft&};C1#z_Fm)ft93oF56to5$8Htd z%e*$s)1#*6n+yi5h3QEaFP4iIZwb7l?a}G7wy&3WFlCMHGGVVznp_Sod4wUg2||hRapn<`%X*gd!eSts6@}{U((r_e|EH*(t~o z#mO!|*qv;*v7d9E^Q^DP_{7r2AC}w;=j=9DMceeQ?*;hqoh z%*>g6_Uyg(ir@OJz3o*5M1<@5Jh}OJCZ~L2w+go?wv>mji@q%t@;?fGKD}^tl1;*4 zX2!t-f81k6$moe^_hi`7U5rZ`(i<`mDQ4L+>f!7K@ouUOuwO9mUZy<9=06W&37$5B9yX!~ojp4%i7NxFIccGrO35t7mVVueT^`{C0BWsQ7 zai?5LTw70Z7=7|_iu7Qb;_{0|J@3zJtrf>5X}VV-h$1{_ebkEDG;eT=Rs0WrkA$?E z?BistU%*FPL|HtUExDWcS=H}`rK_u@IKNbNBNt)#jny=#zY>Z3=@}+rP`<7ugB7_n zmq|S#3}}u3z-R04;2?>tb+5(y81ckirQC9#e4i+?H)b+Dgx1K``f+?Nr5xR(?`3!= zF<%0;H5qcmB>|5p4e*FC`K2z(oGmsl-emLfwXTGhn<_}8uP-VF@Q>BxKC5oOW3j8` zTORg?THRGQgmwM0Xryz+oGeVc+7@S$QvBd3w=0b_AC>5U5}LxBcp9)0RKm!b-aRNq z`N}@Uwui93-5BFTA@d&?wn3i*;<$m#JO19MDW&>zG-GCcgo_k`2GcLid-9TMoBdbz zizh<&Racm1Jq(t^&RDcMP3(JiZN5-iK1GIu zVBGr?g{guq8DlYk9;e>2>ge691 z_IfQIsoVX(4QUi81ylDeL|}cm0|7g=`%1vQv3K7A?{W$7E|KUPYiotHb;Q(a+)D;# zbH$e?&h!XMD4H{e17ylg%H`Nr))U(eY-oS`X{xoL@eCTR=Pec5kR4R%L zb$ED$9Iy7V$rhVC+MCY7BRq{)X{mg!sBe&s=|@fMoH!PW!v&n&hy!Fcz^-1CvH_)nUXhNjER|CNvip>&)_DO|G8VUMUH$isfKp3-~})$B`Kd1aW#Nb z9{1*3u>)`hWFD+R`c^oNetUR?qo|mWcXQa7vCeLD#!vq4*uk$6veoX$>0abDl4wId z{HZ%t@OTi?aEeLmWE9EM4-FF&DEwPeeJ}RYhF1?<&J!8l(sHPt2p(SYvA7>6l+jJ+x^kj zvamcitlJ~oFp4%5985pIuuw&NdFiy>*IHw@&X(OadWR801v-VBn8jG_zjB|#hiAI# zHp)FHe@%`a6xz}?2xjeZ`G`oOKB+ zO$tqMZeY4!vOfxzYNZE!ET3d`D1X)wA#i%|)pvuMV*m(RVSVb|5g*~ZQmNiMCU|e1-F;V!y ze~>wugGo2aw`=s%D>sx>ngFoKVgS-6aXJZ>dfDDpN2^e+zLC2lQ_Z{W-I<~&-uX<* zQoSEhCLYyKzX!*QoM_A#2o2dc7_RCm(8zONc*#9Dp%NSO=IlhF$28%szC`@^c9-Mly>Y3s{{_NZIpee4Uu!10^_ z@M&b!=yO*6Pen}yiG|^1TDZZuRuk49II(YC5)+W2+q-8$wv=aYvU>}+3~H;H|I`^~ z9`Pg7SM65O<-0Sa|9EPu^f`{kdsZ7A$CE3S;H3|TVenXMYRfH~n${I^`)#x_XSEcr znx^8>YbGL-fo4}K6ZAvx)7h`?>}Q8V_{|9ncTVJevV)d`Z6VrCOT+9|v@-Z=YOR@s zcdFu`F!^SGOmzQy%!2irloTT5WEj8OC5jQf;K(AjE*-Uz_eaPaFh$GF%;Ul$#jW}bx{o{8bpwTH;nkAJG0*ySw? ztG9!i7|#zA+Xz)BpC?(GE5hIV|5PC^z3I&}wV9I;Qz2$}R?3QSItlt*1_wkVr zxYx9Dw*;I0(*w>Q_2&9;y2S05no*z?;MH{yOLh5ijlGKKcnb(wy9McoxTfG-AU zHwQxKHzUsXMx3eFv;i&$r3>8f+)J~LJMsdCA-9vu(lUFE996W4b^ekvd-LwfFYL*Z z5~hcoAEvd=vQ$y7n+eCf6%b0TBjCv{1q9oqAUP=hW z7CxblK*I!J$2^>%bp&Rngv2a3+37J2mL#BH>-YB3;0#(j)?kwe*_z(+L}YVY%LyXD zWkvpBR`4bAb0h$!4_R^t-{9K40_#5LLt=US2)w5ia36HQoA8}rl6RJ4;!qJLYnRF= zH2(hG(#}d9h!MN7g;T@-gA;}Js~PIUAaTVpGAmp2fuMY@5 z5Uo~#1bzL2o-QiXv^{`xdbaqb_&7LCGsHHA=L=^{54IQRH&WCA#itEM;0rl`8Gc10 zz`1Gxyq)25zdYOb0g*44%z9yB^|uQWHW@3zK7Lk5SwHF%fG=qBp)%3^sH<7eL>`RT zke(Thx=0-j=zWKW)5J;4{#z#ebK*lss5y~zSoM3~9#%0tfJyU4&)kts4@qr#k22F) z#3qSpFl!rN4R+MjL6MzCIg`$MgNp1#kwo(gJC8BZXn<(0injY}LB!vtoc1k0wQXa5 zAgT1_tMcV=R4Otme2_aa7N&wRpp#!7Qct+l5Vl*iM-nL!+}!$8jsH3^Q86zFva|$; zj$0mH8hr2Ac$wGqO%1AZO<%#wR3uyWBbyQ@);e7WknJ$;R7-2?B5^kGdx@^GzKS?x zV8xS@!^@bla3sIWrGI_uIu*+cDPUJ|c@rWY;GB5wB>37$`%MzmU0c7fH-=s4 zIi_QT!bA)$H8q5@t~5c!jGH7ZEbRN)gjroB(6fyQV1)9hJ4Lbz_PzZWpw^}NwC?M= zMSn+0`pGCns|uA2Fr~}kVNrzzR-*PkF+=Y5#H8@GQ@!=4B6BKT0)@ei0jYC_*CI8| zO=->uj9K?*k_rx)pQxRCR!)LmE)B~Acq{0W_G{l!OKwhD`m`TE01X`R$?7#Vu4L2- zouHqi4L1qLdx;k>U-tY?A%a#U2qJ?7L)nR{X84Xh^~JRYnf}U>X3-doq;iH2_apl| zix6E>S;I0q@_S0!)^;x|nK61%0upz7^S-YRfL4;&7%WUmoUo@>pr=*^b+jnmJ=kE&MNK=FSmYDvk zLrp`?PJ}hOtS@v$UQtboR%$)_gW1kty!Vghx4GkM)MavldGWqV9zxdoG&S+-LY z^S!;cUo(oUD)?R}FHma9n0BhQXl-aIaj=PKV@7Oj^|f`iU{su}Cx4@Y8nlVRFxlEK zaf*iJu4XiA_}3W6ObkC}<*8*w5xhCK-D<^-ZniNbV48{8j2C_BFq*Ze*I9Ath#ce0 zCfdjqzh1F0xGK_SVd*+uw|CK$`^VMbD(B0tMySl-TA{ZFmx;&W(srqtHTew4x`TU5 zg3H|5csuo5sB}NR44^%mbmmNwB=g3lAdBazne`mTp!o$3qDU8)d9W!b$*TM`DzJ8m zl87jSyZ&m={^`{dFxsfPzv7qiRWh$GoCKFBO{?rEsRKQrm1T_Kw@Lgi9CJh3vFgJs zvd?B4?cZPn=M1}7eO<4(k0J~w=}hRq{5hAhFzR@@P3+cw%@md48FR2q*1|OBOj%a+ z<43u5*H`@;cmrxixHPpOTQXJcM`43uxTgPm1=z~TTR*Z$#LUT1!(c~(gqt6)xMl9~ zZ-LTeqnk#(FGoQO>YQ_`hOKlqD{vBFy3DK1 z8lbp*?wnCC?fgB^gpuuBRhJkmLm-cXa|_1$r&`Y}t?i473zGnk7PZk)rF>Z{7M;-MtTRL~o|){Ny71 z2`~K3YK;IkhalB&a53YXk+u3h3gcdOyn2FUU`W#jg;&7w15sx)(SM@bJ(ATZ;eYh* zBDs^2kz;ChVT*~jN;NHClb(kT7!K@PHUALO>k;VXwBMBF6xQ^v{W5=reSAyWhime< z(krpl@!niFXM!^xy{$UqD9e?dH$DMk+bMgJP_QU6w&%{|t*QwHRbTZslrzjdaoIRN zA2Tp@pA`Ex%FMvSqnznBFqHXxmCxvE_0dIqRuX}ZIbb?%{~2H!GBNp}&ee(eiOnGq zeqGJ^iJ$=@F>w>Fv&a$JR6IZ;D{}tjyDq0^mPetkSW{Xs4kLu(_)E>b)5+-)TQJlk zQS-|eJ-cQrzILCAFAC|hDIO5%3R<%wStO!%%b#4AXdQJ!PTyna{B+Id zBU(Q;2`fLlECL64&xlW#>1vWfY?LZ-Gj^L@#Z# z9^ZbeH6uiZ?~yv|(|Mcw@bI(el2If)xZg?|XD0|uS!Cqpowb*b&R8AaFeRCu zyj}bp(pcmvY!7EykLSDZU?9ySc3sL8YUJj6i!|}x9JKzZ&^oWKr(Q&^BPo|^S4{uC zWK;WE)Lzf;qAX-N)Hm-X(1QQ^A(~;z;Lm4v`c~PKR@Uk=Qs{t!adT;W%p5qXC{M5Z zwkEeKEV!2*M9xM4vc2CuBz)`YY502%r>)amXOzrHNt>&?kb{el?$i+XB5ddb#p164 zFX`cwf!f&EM_{+u5;-P|=X-gzIKhR0ilhfEqCP0LU80C`?4!0xBCL8!9#ERXyy!U4*cAPtyV2l!}*YN`w; z4?z+qNnHnDrMb-#^-BI~nh|bku%u2>ua72E{=8F}gMw54pNOPjO za0vAGt^48(WkWJ=U}keiTJo#s%*yulPjMTT{CfWg92C0w}Gja6H-*Yc3ANLJ~C@wfAfR_Y=~}TbEj16-`a_@noTJ$QYBIv41D8EKElxBYj8$?-6*3TC)^j z10jwjk`&~3KfQN2VqP%xOwV(DYa@c!mvbT`A(2nX@0VnGYT3DcK8#I-sW0426e-D0 zWTW3qqL;+e2sL3R;UFR7bHCtVZq-qD11n*hve(wj>pL-Bg%}ze#v@MqU(0D9?L6hp zWZmk?&Nlba0BzMflZoiOmn#aZ;$yRrY-m;{ABqz!a@r^`9({Qel}$EieEfrGzO;Z$ zM7?jr+kzvAH>&*(P;Z7rHS(w{!AZkPgQHJMn2OwisT-dx z=ciGpV+`Qgo4kIv2ZF@uu?ok(35uf|*slT+seG7mk`a%Ke=MI@pY zOY2!dV0lMD(1IN1ua0`-(_fa{0iBkxWnSv<2vH(<`TUs2d6VyyUU^;tmUPOmVp28s z;+HAXmY8*99_!lAiSoiCqXVM|(nxfWX(VVlPDa1xOFj=S0UV9~>2jFB%IY#VZeCT% zOS(ohM%xt{OjZm5u;1CsAKbuHEOme=QkJNb0-FQKF#~0hzH>Ht_I!BWt|}kCfXP)u zdE+g)zcB2rE61U;BwwlQbZ zZF+R<)iTTm|& zEQR>q$X*blXBy~_KgWcXTU<>iov<6@L<!fsY(2)^4LWkiza@Us^I00wK|VRZw=zwUn z^c>D+esC8=RTLc^Zf4x;VZNcb-=`WDswZ&ciVEX0+QF^adxBe88!0t6_j0yYp%$GX z=rPN_m9XpO>yp1w3Z_Vweg_I%f$7oX*H~ylt#Voj(>$Ce|wSs(0i6I=!f>>w~=PjW9_Gq`3ghLyqxu*t?K9FFcWs3oB*h7eJ z>VtX@>Ri2!u|LGLbOY%sgWVQ)MI;MYGROO7pLC);1h`ITs+Fo;g~xh4NLNj2sR_H+W+_{#_sSe22PUUa#cP){iB*`c6;yqU2R?3sn)V)2ks$pZS9D= zuja>ef@-< zAV#g%5O!U5$9CvOi>pwbxiSAUTIz`+0DI9FGbOmWQBij#Rao;? zMP^}i?yO8`pxX5 zJrG#S6@la=&(DoS%3~X(d4 zf4E$MCJoEpL;_etCb@`?@3+$m07=a@sRO1W@^hlo$j_xC(kzyYQE{bm`XOiY37@ta zda?psoE^$6F?qwK&d>J*NdZz!at^k1JJQheIF#+ZL%vT1aspoUGJjqC32dLQcS1#; zb)WZKo|2I0(SIIeHPmmHx_th@3tb*jt!|e8`m&OT$hBB<$bix>Jj1d#UZF1?q#=k33&L)Nr!dSJv5XwyPeU)t*-twhol zXj6#V(w)0UnNXs7gOb^ALxOyNz1J7P)zKd3>uAU5-U30}E7pn9NOu(N;#hZ{bk11H z*LRAm*Y<#8Db-yqs`~-d{XDF2$C!ywSBKc?D|*z%pkq}*;;7=nk$b^0=0g;~1E@?J zdh`4m_j|D@3eleN^&)Vc&ESs>iqfj2AoMpMH&mHB@fLb3e7v}(Jz*ZZ=~1isEHRfJ z(@t#{BUk4>d&mk&C#?+RlVFsna=JRyyTX&-@#jgIJd`J=lcG>7GGw_0CyQkN^dd6k zVH#4c1C7c@H&(Z(HUaD=E>Xt6tUd|kFR(ppvshQ z%6#l`_uJsK4XSBtsfYEWQTYD}S$(2KG1sxq_5q=7Akjtjdp7azQPS%CU^U)K8MA&+ z((^2RL06BuB+Q%7xlHZP>f0N`$BI}l$dM`uPUaUvh}~{U2+qYiiftB{Y<^}B7cUeU z!+qTXT}jwoKIcxpXygUAMn=7Lj`8tUD-`=XYnAqzMSqHyx+=H1e~b1-bP7;FrkmP7 zL(*OE=?$0^jgEXF&U80^tFlb?TKXIpXb4aK?IGgNe$5*Cq-dv}@J|!#k4A3=B_S6` zE3IW7iq4N;w?0bD6iLR$|FLKLVls|BVHenV36;5EMIYcm9vL$YBr#ot*a3ce|667B zeO%rn$Ewm+1TVc=6!w+9B%E7=)lh!0ALrJfEso{_ELFJw)SMn?W%E!v{*>t*S&f}cIw3>W&>u+-WJl=KQa=o%C zXXKEiZ~_7!XYwYp)qV0h*2zU(J{Y3SO!DHm~H)>i( zsLA_-1|#C0mF=r0p91H1KS`&KavKhXOV7GM!+jx8#fE!fK+V~%t)hB;#CcB=@&K8A<8F(MrKG#AQ(>~?P@i$vA*cw|HMEA|Q zCT;PbxwSum@?jg3KQYd*UOCS?M z@`SZKa*-K`KpUMGy@q|BiOazJ;M|5*9T!KeK$o7i-0{R;|EJeublYGq5bC+6J`%(& zFKQ;2^>uuSHPwPKll!0(rRN-fy>(#U4GxW3PG#K5TMZ}94|ZEc6|{&w5>1J&qGlH6 zz;dh1C^6=J%BLb(W)GM>%5WX(`^erWD?4$8HP?YVRAoR-ZBnV(=jbz&h*w4&-qc-f zwm4$P@N?et@58xCR?6FbzFdqFv(dgLtIiwW<}Lob{G*!fYp5<(u73Nf%d%TKW<3x4 z7_)9U&U~>~)BIFh<$5VmWBKmIv4CTNo<)SF^k2m@UDt{5gv+iU5JLyO&yQZdJ^du} zR4gdruJ9{oMKgetN@B|80J>*{rHq@q0kKUdnQsB0=s?~jxL3k(T)#bSaEPM<{778e zsxce@laU^1Lh2fs76_?qP*9@qOG?6_E?5Ojl1UDOMiNDRdWw_7L9>!)Is;V_eWWJo zM7^Vb)mqe0{b^$2&1u+($X4O(y=ZKml3)7x{h4!?Zx`?L{0c|8AP%F^Hi)9&;8nqXP`eP?8|9rhZvBbm^0+%}919IN7yJIofL%n3_?*bO zdcMzA2mlJ>d0vo2*qk$TuAx08!7LXV&tnV1r&u)_@u?sPvfC@84yr+aE6#3g`Yd1G zoftOZpM}wOMMJPkWN{plp${jT3XELry1>U-R245sIcZA7lhKxuE;s9A-ElVM3jF&2$Y5b4HWu?Mh5MANiag`+UWH>8`uy&dq~L1uBYqz$I|niEvum>LAFj7KI>c0bXaaTYPdwC6e^xb63(a=BWcqOazn{(6u}`3fod`iNu9F$$biVngP>lG@=1 zaYYEB`&MT2X(Zny7rI7fPOIl-Eo{MVm>AaUbvX#pK*2ZqB`vT~*ZXDz=i${ly~t>j z0_zo$0Hv!*Ly*$xy%Z9z=>uSabvo0I8?DXp!HLptjU1==FG7pyD&BfA zb_=)Io0+KGf7)J$#=fq+LZY*#2RASZIR)JEFT9!udzWESDerbwuc}ZKUsH{N-41q{ zu)R|y*|1*xK4pwvaSGvIk+RZ09C6L?T|-@HOaUNT%x4DrEy4UNXJ%rIfpXi=47`Tj zcBAbQ6@4x_7ag#%*}ASKc7h;7Rh&`H5SDE($Fn~RDZokCjRh>=kPv-?q$})U+L$DQ zp{yXY1dei8LCo|yFI2)xfUj`DkXCz0VEl!gBzV0?5zm{qO+GlU^qf!(wSp4!^4-c& z+|b!(Mx6t?8HKAdm#qMHh4a&IHj9A*+u?HjRr_XfPUL1zQ`18M-ojIR{-k;nV#0`v zUlXnujqPM7Dr30`754R$cTSN5i>;#uMFoPFd9ZVSL;RI>W|O%Ya%5P)j>m7e2!Y*S zUNM?{@U`i8HHh%$$>vLwB~!S8d-M>PuV!SiPNAMK9$0X2jRPaK@9ns>G2T$&4RDL{ zLGjA(b8$=9{Mfra{ci)1)dB2CWk{ItSO!NK2Z(IG|C zkf;afo`Xpa=zQZ?Jg|9Ezy96`@5M^usGn_z*}`Cbn|vpRV2c5Bh?nB!n~=FWcquxt zCe80G>spNze;vab1 z2Z7xhYNBjdeWlnBFJCPfI;yK%R5F|MAdf%4_Ii0ixQ0CDeZtSVhF#NlHg8=KGBIhC z#XIVTeW(_Uw;)2h-s|l#tF01s(siciNXBIEjcWU@_5A!)WSY;FJF*#~;QX}w@$*;i z(+ZU*ufF_UP>?I@l6y_VqLK`e(WUaY`Y}{uVArVAJ&OJQlOWr5t+mGU_4^cza(}o< zu3jFBZL}fP;>Ekxkn^6C3^hhbmGS|lU*bt8#?i1#=`Y9O#wE?cIYZvj&AV+!ziZz+ zGU$C1_XZ+0`quL6Y9DwA`(zIqS#|efL6NxibKG;kwO9i@%yUZdOI&8@pRWo5#vwOf z{Nd!i+!Wj0FM<7umHS6$D+o&3yCG2~08Y3aBoYdfzW3T{Is?{Jo^C_sm{7wqG}{6U zuR)!10(`tl243Yg0mOqpyqUtXM3@w>clr6Y<`>6|Xlv?ji|c5)HVZ~l+z@isZAJ7? zSA~l%o2kH2CpO4Lxlg_HFgAR}oG9O(ysX6<<9OJ(F zU6EmX0@A+|67j;4UKbuR;zqmTGGc$6dT=G+N)b*!D~g>yTKeIUs{)!iOIB1*)+nb5 zD7DvIF^R{G#rkk~Nb_#lKk4a?R)l&&qF^D9s=>It`K~1lsm^ZiOb^;5+&Ku*T+lY?UM}Qs z@U>5I$Xhs{n&vTfSYVT!NN%(bfrw-~rX%VFqiVoj(d$;+d`p{PxQ{s<(5%~hQ>OP= zF9+;7 z!>khr*IRbYCXU$I*z9h~WU2?BFlOgPF)22ag=G0hk}(z^^H+eQJ~lYPMc?VKeMkaR zh{|onT9q0f_$9;M@r{O+-%hJPZ?Glj&78)NGU3-94)p3f`aQgSTeMW4+wz@QeD^Y- zFK3^`=5)Dm%G0Mu1rh~rH+hp(NJGYm9h03cB)&{Y0U5gnjoGrtH*}w+9A1`)b}!eU zaT0mJxzD`@vS*P9{)Ydmj$pI40TEo^(yaPjcpAF4R^-=gvtEE}flS8om~3a%OUOEC_Lh0o57Vs_q6RU2<@^rf zIcb&E+jaBUF!~y~4Z}s@$-bcE>H#A)C%gRSW(r{IEOM%S;X{UxBkb3d|X zhU#Ge6pXIHadI1R6FeXsGnn*o%!f6Fl>(70^TH9S-*q>3>(*Aet}Q|eKxR%%Ibqoj zlnor7R}G$nWpXpXjZWl3N1um05+*(SMfOX%GRwRnI2AX)1t`ok=dVVUEcos-`t*bA zbai$N&V?@EI+-k-*>_awVBIVL?b=*qUARoOTem4>hI+5K`1~-BcP2-A zy^Eq@`T~PHxWJm^a0z$P-C7Q+hlqHa8lpM~A0RqdF3|igKrl+%Sf{tEw&iHrO}Qpv zE1b_TtE*hdejfOg+K)UR2ev<$Z%INbZayzEA9}pE0Gh{o+->FB{TA`gL-Z+yQEq# zLC=@?b=VNX!AnD_jzJbM#)b3jN*!b=irj3x+=QT0ZcdTKfiShRjV*>4Ue+Yx9#)o` z{h`s8D#5<*Fy1SzQNPG}=fRq~kD*?bY`7y;$}RDl7pYBxqQ80idcA<2-QXwXd*d&~ zAx)Xotuc#No-Ai%i%T9Up6`_~jI`PH)xDbK$S`$eE4knF*=v3=7@X~ryI6Ex9R;o+ zg^C4OM+^Kun^~zk&~PhRSzlDazH_}G+qn}4%dH4IpAPw!l0q2M?QE1{5C)pOod>zT z*FuDQAafR|M9>9K4wL@a%pXMC=hl}N1-gT)eTi&KP1#o^%|?A-mI`6Ywy$$76K>4G z+?cKR6goand60g-E$HtcK0ep&7CB-YJ$lV{x3OY%z2^H&^;>_y16n+&>0aqO{@#X> z8G~Z;Cu*na97?)%(AJiq{!F~+v21GHmXuIkuM+R*5oJ)n!HAkt`SX-+h!HVO9~p3WZ6sN9*V~R8yIO&^_stn<5q^L8J_6f?S4vs#TwcDcJryL_ahdmu%(ka?zsmLcHVJb;zEKZ`r>0=2{S6 z=pGk|m~Ro*4pXxh<`Ibo4l711uT8Jf6LBSn98f|zu`WQc0S-OgaGnIS{mojqM;Kn4 zmuy5|vt6_E?UN7BqieTLxrfoQRlJ@}OmuoxV_NHxScM_i<1IquAiQ*E=N?@&3fL9d zTP=w~Hp`uqqCO#_6pz=69`Au_%Ilx*0?Xqh#Ai5if9sA&>UujfqtY;bWF~0OvGwkn z#h=-{!K=Yg9M`9m?F(pI1FT#T4(L6t|ZJ*4QeHU=I0VH6DhB;y=YJZV)>nGm+K_EBi-15T0%>QLrQSey1nygoWYI z^o;R-1RV{BG|2y5nUV#&=+^=m+;wO4N_niD0T4G-LDpLe*wc+=N470sRE*ZQ5G8C)JIG^TiXr%C2U~cIYCGIaI%UYvzy* z;af-z5Xi;D-9odpGB#WmN(5ZQp7Dvi)vuAmEw%**M-{T}$`0l~hHkRj$oNqg^52@(Q)~pSNhSwajKM}3YKXa9{kEE!t=TM8 zb2_XUA(Yur35)H`9K2z*RDr^j&uV6iDRzaWEjTBQACi3uWv`y7UI>e3d3lwgyt+jL z!o>Q3=@K>{IA4IVAmIecWA0}6#lpx3XIj-f^I4H>Rj-n{j91S7aiV+6J_)Ww}FQ)T+KMcvEG^YPh2jjj!*8>+&H-)zqkt)!-fAzy@s@-X|4$2k}8(;OwxG z)BuF#&sPwEX3zZ{N`QWXQPIvitV=`fWcJJ~g2;d9^c3|o?6~c&1IZ7%&a-0ZWjNWI zRA(=~4RgOD%~nJk(UJq=F7~w3qxzksk6{jl8MiZNMCpoN0o8~s_}v^QGY-k%>k^n> zCh7`7fVpA5F|F1p3wYYa0=5=M9)~KI+Duu0o=gptJl$} z&Mkp>1uv-U*vQc)a?~<`Q6Hhzor7~j&RzBbWC-f0h^JwrRy%l-3sIBR zkM^vHMuv&Q#0EEEm(MB{&TrE=sLIkk-Ruo7SNN=$!M@MTNp7+#1twV2#9Gc2Qbn3H~i>_OuQ1%wGGSDvv$NGeGU}NiE zq}wfycUPjLL$YJ2O=GUmzkZWF<)xrS%NVlZCj0`S#aE${OU{tHbm2o8E&|W>y%Qqb z0GazoVffuYsk}vom&p9Wy-jK_uO+jNuE5J(9=n+q!;U&T!q66GA=uqr1baX4tzll$ zSCl~080sRuYT0N6GLE=z4{O@l<>b0Q$lCj?;T*moO)NmYm=4VJd)WTamn>G%%h^7J zfI7vydB^X`P@3|YS)$L4P&hz zg}1Xbcaq#^CtnN=-*jy9rJLmDW~f4|H*JgOKt}O*et^`b#Wjd|j!`Y@}-7D*+ zl(GuUGG5Kxr)ZgTnWynP7F*lYPOu0H;CNMm^P!wvZNNj|Ia2~vSzToz;@-%XinIfH z%vAd!$`ET7W0(kpV|DPgFu75SDsI0nH}T0%=FLaBrUfV6hJ=M7n4h9HaK;B^O{r#Y zEFTL2tkXRM0l5I-_7BMgP72Odj`>D3Pq37`8XLAPK)d+~Sfo3>4#_WW%HG?|s)TvY zqZ|*j4opt==fnwrJzMpxyW)eKAd!k(fRo?{V$5?U@9aZUwxjC4 z4@LYXKbm;rTQ42vnIOTr$(XL;7ri5=JsIr*sYi+ULI(z{3mh?B6BPAtc4I}#X=>;? z*L85TfS5PIT4@zlc5p(t`+9M$F&H7>E(a($&@92}9obGI;09S5k7*<$RGw_YlM!0( z6)L_z*#K|j%@jiF6$Jv~Xw#!a&qn^Lb7s00<~pMz(b-8K?QITn?9^XDqF-WAP*BU41=>u2&r(~YJ= zVyWxd%nW{Vx!@*y*~GR>1C0akaIErmuO20H*X$`NW-j}&&g(6?n@$0iuLao5Pe|T! zKr2jt)>#YDEI2s>El!>0(E8S7u4|nJ5T95dRQ|d8r60e}P~(*doKw+9WK}iX;#+V} zShq!{!B%-3LayIu*8AC8dr%I4%C*P_>FGup7}Wqqf;Ulrr<>ArMxMQ1-$W|4TuaS6 zJBD*otE)vm;rGP1m4^bFZA*@fA_}x48q+@m-G@f%0}UZ-xppeJbiaJI0>Cx*B=JU15){PPtVz}AJu39yqM8@g!vpH_`dpti% z#`zpxdm!rVc{A1OInUxl_r)l)LTH34u{T*Z*#zS=L>tAkWY6TgCrk2V9&Sos^e>;o zO5o5A@Q6~=8Uv6P$S{~vqD(3%a!tq@8t!u6gS5Ybw7wV(`VDvv6%AWAi9S8mL82ZJ z?a5WE%jIB2!w${aKW^|E^DlN*_ej7~Vg3Uy6SB#$9x=FDD)HLu9Jx z;jPRhwl-~uuJO&V7$)u<6nDBnymmZ$tjoc1|UBGQytR+ zaN7vonrt9K6pl8@n&HFC6-q$DxVuwX-DLktR|cRxG<`awcX&-5q%ZunqV-o;?JMK~ z>#ud8SoTTrIC};DhNYiYbZr<(`*zhIkt5*& z)V~v;7y$o}t(b{pnY0CTh5JNFe>g65hr1f$Fl=8negjCN-UYhL$0US;%Yb8Z#u zYxNejf*6S&p5`m|_uKseY7T$1=cb1$hbj_2<0*;M6DvUU2|NHT!vI)V|GA!64$J;! zi2V1@(|_z=;J*J{w9J2NKK}bTP*zx}{NJq#{&P#$yUzbdBN%@vSpRJT*puS_pGM^W zmD~R9dw-qX>^DT0{$rdbS)aC@9tT1(iG1CEKk@%O`2S1SxXpo`NyhPt`2D`uYI>TQ z=f`t8JqE&aUp2=6^Q!?4jq-!JT4-)hX+>b4gR+6m-MDDnNw}Pf&c%NI_lao9qqDiS z3TZEZBAotLW*{$IaW&`0a4PBv>wn+Ae+9I>2)5xsLOjQJKD~TRVBk;wnnp@l+cj&S z(swX__-I4vf-=+xvBa{sEG#caf1%opIpnERrN*kpACUfB1h{1k~!h2Y?7Er3{pu zDj-Wa=seBM%{x9jyO#l%UT2HWk~O%qZL8_PNh>w$^S{l=7Eu{^;Ej~@HT`Aw{HHZ( zcRK zN=cxF0>!Po52OF-$^;o4x?lD;@t@A5UzlIHCKz4)YCu?jfJt;?uB&{k2{zM-!R9bi zmactp6DPcdAd%w&w2)SbM%KUH0Dqklxe}A(4{MF5{6dOoQPp!;Os2`H^U(V9;ZY`$3#+I(UJun?}1=N$egXR(I>u4`i8iXL38 z+OUHoDB9Vw`}~v0P0DDl_%Ahn9O4(f4uo%MZ=$O10H_t9#xuj!<%;xg9;(O zu<#cjJy6X4U9@BmFrBOtPLl;Thtl1wMOtWPwo#J>4`KV2d#yrB$L8L^BRyH1rZhmb z*9w!!{p(zxBBs*9T1RcW`|$yO!i5kx@yz^VC!c>eN{(Bf{pAjZ=!Q*BK=J>Um^5YB zTw5fSzX#f6FQ2#py)l%bd;g~UstLda)9(B3^UeN50)Yf<(ev@AY)`A}Q@c$DYE242 zalTW2pd@uzA~DOSXLS{hpfhT7jkhk$(4fy^k2*533=AlH1_be(Xvg5sgCB60++u)M zHjVmZ-t8Y_>fuM`Uw}fe){ld*=k9EICwV<(f1AmNV1KOC@vd90cU*70jQ6+bzqlW; zHWzx{3;#Du5R&wj&#n2rso|%aK^nc$AsX}bbfQuX z(1^K?U32D4YE730Jq|Ij@6}*HcyxHdU-EpR!RF+`=IwyaiLJ&5*GNj4L4YQdxp{MC z1#x6xs6HQXJ?zF{T~|?rQXy(e_Qi{;#BzW6dS>*h+IVM_Y*f(k_R$v1{BDisw-Z%&(*y!>z6Q~|fW34xqA(G9PsQ~K2P{!3& z(e!SNFge{cf#uOkmwHf|x-GK*^${)GJugOFmnQdr)Jv=pPqb zYaKRjL`y#}E$>1LP`rMY+rFB^tq3Rxl|}-;`*td!%9)2@xO(*NVxVdFPW?ZtryQy7 zY~L;+SL(Ve!=WFaeq@ad?Oz4B?$Xinru*@t#8qZdHTM6@UF78CL|9%djGW3qVKngK!BY0;6cqj4dEkHg_UZqho(f2Z zaiuP`!Cn0~F1-4$BG426BzpBo)bIGU-$fXY<@|buXis#u&$o8+{d*@@si7v-QJ#=y zd|;q7S=AabfZBg*l>gXmK0$kOrLxpn{}Rz_g7*K5v#$<|>g(E86qFJX2}uP35r!JN z1*AhdhHiwRyBnpuQ(C$^q=rViJ4QN&&hOywd7k%q|NFjg|1;M$*E#!~vtzBb*Sgoe zoDq)>nLu%5*5}!G5CDArfOgJ{9KO3jXG=wSRSGv-YKW9up&u0}m>ytATM!C<7k_z8%81ckqYmBH(4>&Bt&xGRBYcSmZ~ws9ow)1I2g z6)d~}(^2hVvQe^zgJ&FP?+zLkc8i~znW8A0zv__IAp}QdTg6k((`#m!%%R*}R1Okj zIjUU=y3?dLo#K1k-q5>a0gfDFAi)y&AYY072C{NCS1*+$JCg9b(j6419F>{?3bM-6 zFO=*4jqjf<@A9$j@uAY(PB*9kPhCfIC^2D&dzI_MtgcSpydb69m>fT`!Z*{wNbc&m zw^go_Wa3~+TaG57Ows>ZCppSKv*iq zBBonW6s_xjU_nzstA0pjj-(ZvnvSdAx#N$khHm<^pUKb6qcG8|FV-YgJNG`SBDtaE zzu3{$VK(zTM7GJ&s3>^Q;)_zOczEuJIl5pQHyHq4NNV^g3f^#+=xjWR7^sP^%6W*Z zB!nYp6vwSPE-f##+x$$Pd&EeY&3xLuG0({zOAw##AKP>+lm>cwJbAR%1#LR&GutgO zd905?Gp15;w!am^=n}`^k9%JhrptZb7r={KRh9Tnyg95Ii;mjN1bu^BOaHc}W4z{( zkV0bhHu^j-0Qi}tXQ+lu$y{+MLm zRMtAV&&hq=|@Q>LVnKNF77lnw)%AAwY?VV8&E2OFue(eMVmnebr;<$ zy%usNs;XwjWFWl_tYhU)=3`i!F$lPEt-@kddyuDF407C;?QVU#iN3)HIF*+qx=yKn zoA5x7H5~-;(pKSS-2d;oUEjqH`s!U|UV&5b7CkIxH}mkqrrR|Hc}c!Jn4Qg|Co)Ny z@iW+A^Q%P|BG#0sIuPw*F84O2Wg2Bf++e9HDdkJQqISEhrG=rkDJCfOB@TapDf?3I zpu&JK60v(KS*s!j=lSt4qUZ+N!3Ig(-Kl5yXCYGl$><_5DSXU&02AGHp)`ecj8Dqn5N=5~{(gvGq zt2>paa!sPZ7RxoUwqhiNE^5RZWi*>z)WP17^EcBf3G4$fzOQ_P#s|1%8;5VME8ST1 zEmdJ1>>;~cT0^@=V~ukhZn?2+>8Ind!(my*Cg#W(Bb|mz?NiFKltYI6o}QC$v^Z5$7I?CC^n<2fmp0ftn%`@dX763=hn1jQYiAxgNn7Iw63?YRnI3 zAWP3~c%w&$w;GUSQdp{UpFDgRjemAUI+gv?OZy(CJ);TstIMPU)@X&*lUC<70;tw^ z$OpHLsT)IC*4#`c0U{7C8DiHGeY$mR_{IpqME~M@hr!b%+UeU>a1&&!!by~s+v8f{ zu55#Gf&`CBDqTuK3RpvIh-7VxjO?6e8{i}Yqw<$UTR3h3J4*iY)9exNR&)nu)Ib)+v0pPWLD%NW#i_bnW=4 z_F|$EnYh4|l8Q3;CdF+2sHU{X^Je~Q|XbK%~{O=d%1iva18YvJ> zMj_pu7(KSUU-^7yA3{k@i>hEu3qLbo?$T5?zJqDslX%W5hS&?^U0&9&8+Xb<*6PZTb0qFJ@mYx}G`K+&;0=#rM4N2c?UMM5U%n-es@+p8w;pYyFUI z?a^5G64gUp;yiF(G2obwG z+R?k1g7q)R_1YJtg?U|^2w*Lv?^-_UrduBgjN^jP)WqN(Uh|vh9sk*Ba<}3-mqj?u z|1{U>biW^{&7JlMhu89S45NQEooNnSg-|!tKFW!ch(qj=4H)}jtG}>VE@&mqC^q8W zS(04Yw7dleiza1kFz(#nmhM^>7&^*P_RE`NPaoIb59ES%l5D7#uG=wILmz=&x1O+g za$0${HpLHzTc-bRK2|GP%k*pt``1ZZcb1S;8^?eS79h0y!Tc%R{NaS9ZQ+{n7PLA> zQNQYkY9p4!=u6MH9o}a3R&4Pl&)}_wVh^NzWU$+P|26Vy{T{<50_4$OKZ1d!MWE zBPyHodkq+!=%dz@m3OPZxoLb{gUfHnTG_I_3X+gtT= z-SWTk&f%3;OgBgP2R7Rsyea*yk#b?{N{p8yt;WBs=3q_I{A-uIp~Q52gT)2ySYE>8~xWDsg)=PQNVfE`l97H60?dLhA>tzNe(_^lTC> z)h))sXP`H$;bgj?nXbqbSLfX!DLt<)*R+j$C|5_l5asw#ve5jaDx7(SlZiKfvU6>JDdnN3M?Kg-rlob z+N8Z!`X;*+=~DbLj$@IQqu8C))6Vh1n{|KQ-9@#5!2;9Q(2vV@LC~f&$=#Ko%u~;bR&IWBv&ZHj)YJy&qaR|>E%Rh&nVj>~U$735 z<%2$zuXC=aAb9q&V|*)mx$W_6SlTKb4#C3OvHyozgB^=tbs6H448suKI+F@UixA$> zESb=;`qRzv5`4^VgX7$}Gw9{_=&HfQp&8!vS@mKWwLz8m`rJ_6`3fK%vvvS3=_tGZ z(>HB0lv)9UNq{0YhWIC?Wk6R=X<%*x2@YV%lB*Q2UC%586{D-d!uNkvB%~mVN=SU* zn(baUr7DZFDZ=}f*83xoet05xMJkys3Z$f@Io20$n~fvZ=Y;3*l9mOFKvNZe@9B_hds$Z{6~!r3-P~m`Q?94(Wef3y zh1a^oFU>BiLo(wj^EtpqPf`l+zNu)jTO&@vy~GyeM)|zw$FG9ay?;V)t_q-hXp>_4 zYp6l}UVjqjTX+OAUcLPo-*qNH>DREZX<-rb?c2#eN&U?E7hgYbNlL|B>xUSsGJn}h z`v65@SLHJ_+k1=_UP47nMEHU%gIMQEDqK0_&M-TtK{mgn%ASG<9BEFr&|_pE<)is* z9w|>oPH3L2jjlK3kiK3MLukIm9;RD9{mM8y)K-#{oTiI6e)j8-!z0Cttu3;OUX`0 z<5hS;ZTR}jft-$D29l2tNb<8Q4ncQc z>Hsr+Ne^1n4++nIohu`&`>j;!RrJC(H}l8rFNTkri<1c|l-_<3E-^)q)$;~p$OJZv(1Ybn@rDFp<=k@;VK(0Hbxyu=d?%pa-^1S?e zwhU0bdn!G>>~`s^8HlJXSXtliU`uz}0vr2C`k}f8L;0U)6UbKI2IU{v?*Ac@| zVN-@7)(}>Y<3qo#EzjI5V82Jxx1($4bG>^Ugf_=dXZ-{Z<3z8VkuV>HYM?&aP~Qji z`(8>MN3G0=9DUy+bG>-!aJNJqa3r=hQ7bbK$>qfl0Q8VUkBYVC#L8;v?a6|xh_31^ z^yH1KcH)h!%pk1XX|4g%)U-1vn_9=DY1l2d4=ik>!+`!YIViE`4Cjs5!T$0!>(55| zVQm!nHHn#lgU7306b_ZzWZAHR6?$0sgnAf4TsPIVyF-*INN*^1*8uKcFm&|3zAR8S z425RAj432Ez_!@c$#P1ng{`zOe5xPrs9@)e2X46B#pg67oC$apM$FqDxcQ3FfQccG z`Y}Ctjha$WiKKC9q09U)@1jSi@q~amRpPs<>0R2a?i_$GFRvEg%56Kudwu~WJiyp-1Kvm6^)fKipmKxGkmH;yCXr0y=<`NGl{6ot4m8t=Y@=CN?0HYq9 z>vy2r&k?z6T6V7kf-HS_d;M;zoOLdL;hHPGvv_k-yjer`Gp8{(6*JfG(n+F^AMSV( z3rx>yA9WK{Fw5(zfHb~V+AqcML>7o6n-_Bq?3C^s&L_Q5C61jM5xk5;8rm#2u!#Cz z0M6Ctvh%9(CAvhEthkwmHFp_`qHi1=Y^+vX8X$kPmEFnxnQ|O=sY=WM{unMt%$imp ze&&-D)!P?hJl2b60v$oeeArDvtnyW*PrZ)DnBA(}z>&P1=n@hf&9w=$iMFbCV`4#z zg+KnpYJXwk3qBGe;#86slCmLZseeirIA|b#N3S)n(iOLK7t#@3A-+N!DC_0?^vgyy zGrqo>4O}s-NpYawXXz+fNKJ|qS17qUrXz1V!R>&~$j(tAi@B#afFjTlk%+5jGyvp? zH{Ou3T5?vRY3n%}K5o66`Bae?LO!Zh!zM(0No)DOdaC%75Pp1PO7i(#*!jm`=OcLD zoAlT)&Y%8$LX;_Bh7HK&!oY8HED6W|MSgL{7;cBpw>s5oTZA>s$NxzVQ>WLU=?&wi zP5E3_X@y7+-x{3tS5;3K-xH9^$YJ87jmlBc&~!zE(aCJ=K7vjv5t?9qSWswpK~}$R=9`!PTISHE4Y3KIJA69 zc{+XGlYM7UI@~`sl;U;fG^SX~XAt~KMr0`06dh|9c7e4^+` zY;@atOKaIBbk^s&Y4PGP9$%|1CSsuOWJRNheoPQ9;$+;1$sdNA@3|FItEHKhf8Sz)}y2zjU&c$ z0`|krJ8%l^OgJk|Ffvxrd*}1}wJxt;65kT-sKa?#g4h@DBGzIlcMG46MZA}X7a7Tg zyQnZRId4koy*S9sVNFtt9&?TQF0Dva>w#eEwsa0I_BSM+Q9%wciGmI5jsy`U@|b(I z@)HDt4>Dnlt>;|HFVa>Nk31NKaoAk|a*)2gJ46vvH17Fu=GBH~N+G?jwmTuM8?ttw zaTK^BL_hG%_9xD_Fn#kOW(zI8V7arCUIghXPTIIA%bJ|; ziB(aS?iA7IT1x}JDvdcR4nlZKv)hX4gckO7ZR^Z7Oz&K6Q70?(USK5(X*uoy?pwis ziKEliJb3i!thj`_x=x?{fW-3_sV}_<=acJ#T{l-S8F4{Ic?}*Tb~IONS8zO|WfbKN zmOAQK{XGQlfH^Fs4ReY?U))k%$*6Rl7GZYTp9gqASw_V^qTYGvlBP>&88N4)l;j?N zQF*gT-{NaHrlI8>qSohlr^|BCqSm%Q`jyZO(ncUOpRh%z+T`avBw&J}R@l;U&Wt`? zX2?KYsBTgO{S^}-u^&1WIXPt?&60kt5{ua74lID0W|sdF)SzRuBd;&OjZsv#Jr<}g zE-DyPv+0-E%sqABk$&*he4^9E!{TS6wMqgEnA>=mCRJwymnG{`0zC1M_NL7?i7Bj? zmQ?Q;EqqI#6#mQ+g+WVdn|S~BiufLtYM~b^?JzR3b!)5t@(!op9nNb0Lff_7T{F=U z<}@itRN-NcHNz`TnB$HpFAwfU3g@aVD|=60Efcn)tvE{RS(!a|1`V*l(Tq__P-y|!`k^;cYQSH%nDya}YlEk*JCoFh74= zq*+fyf*3#w@j&lV@&*)757>Xq^Ib2o-&Fmtr(uMC&&3Ipg-IpOELUq9uX#+E$jN>vKy-|aiwlsj)?ku1kBrRx0!T8dG#Z3OMW4m_WeR`(tjqWS z9a;^4U|jiEn5wKHy-$5RtVO~Gb6{k#?#P#RT?sLZx;Sv)OUu*@x$b@{cfKFi` zzLlvA-1zAq_|f0{Z7`V$LjlZ`ULYZWaecGD`b|SAL?jDA3}Bwx{(Brm-e5eCumM91 zlx_mgcVX9m{2)LB5Z(VJv-{V`BRy2JdWA>G^iXZ)f7<`!3_py|{}q(zAucxc(}6H- z&v3_^`DfBBG@4w$N6n7fR=!>FM@6{my)JG6`}~kkRnOt;2L#o>+dAO`EBt3$>&H9i z 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 literal 0 HcmV?d00001 diff --git a/DouYinSparkFlow/login_desktop_server.py b/DouYinSparkFlow/login_desktop_server.py new file mode 100644 index 0000000..8eb3567 --- /dev/null +++ b/DouYinSparkFlow/login_desktop_server.py @@ -0,0 +1,175 @@ +import asyncio +import os +import shutil +from pathlib import Path + +from fastapi import FastAPI, HTTPException +import uvicorn +from playwright.async_api import async_playwright + +from core.login import collect_login_result + + +REMOTE_LOGIN_URL = "https://creator.douyin.com/" +PROFILE_DIR = Path("/data/login-profile") + + +class LoginDesktopManager: + def __init__(self): + self._lock = asyncio.Lock() + self.playwright = None + self.context = None + self.page = None + + async def start(self): + async with self._lock: + if self.context and not self._context_is_closed(): + return + PROFILE_DIR.mkdir(parents=True, exist_ok=True) + if self.playwright: + try: + await self.playwright.stop() + except Exception: + pass + self.playwright = None + self.playwright = await async_playwright().start() + self.context = await self.playwright.chromium.launch_persistent_context( + str(PROFILE_DIR), + headless=False, + viewport={"width": 1600, "height": 1000}, + args=[ + "--disable-dev-shm-usage", + "--no-sandbox", + "--start-maximized", + ], + ) + self.page = self.context.pages[0] if self.context.pages else await self.context.new_page() + await self.page.goto(REMOTE_LOGIN_URL, wait_until="domcontentloaded", timeout=60000) + + def _context_is_closed(self): + return not self.context or getattr(self.context, "_impl_obj", None) is None + + async def _get_active_page(self): + await self.ensure_running() + try: + if self.page and not self.page.is_closed(): + return self.page + except Exception: + pass + try: + for candidate in self.context.pages: + if not candidate.is_closed(): + self.page = candidate + return candidate + except Exception: + pass + self.page = await self.context.new_page() + return self.page + + async def stop(self, clear_profile=False): + async with self._lock: + if self.page: + await self.page.close() + self.page = None + if self.context: + await self.context.close() + self.context = None + if self.playwright: + await self.playwright.stop() + self.playwright = None + if clear_profile and PROFILE_DIR.exists(): + shutil.rmtree(PROFILE_DIR, ignore_errors=True) + + async def reset(self): + await self.stop(clear_profile=True) + await self.start() + + async def ensure_running(self): + if not self.context or self._context_is_closed(): + await self.start() + + async def status(self): + await self.ensure_running() + logged_in = False + username = "" + unique_id = "" + page = await self._get_active_page() + current_url = page.url if page else "" + try: + result = await collect_login_result(page, self.context, timeout_ms=1000) + logged_in = True + username = result["username"] + unique_id = result["unique_id"] + except Exception: + pass + return { + "running": True, + "logged_in": logged_in, + "username": username, + "unique_id": unique_id, + "current_url": current_url, + "profile_dir": str(PROFILE_DIR), + } + + async def open_login(self): + try: + page = await self._get_active_page() + await page.goto(REMOTE_LOGIN_URL, wait_until="domcontentloaded", timeout=60000) + except Exception: + await self.reset() + page = await self._get_active_page() + await page.goto(REMOTE_LOGIN_URL, wait_until="domcontentloaded", timeout=60000) + + async def export(self): + page = await self._get_active_page() + result = await collect_login_result(page, self.context, timeout_ms=5000) + return result + + +manager = LoginDesktopManager() +app = FastAPI(title="Douyin Login Desktop") + + +@app.on_event("startup") +async def startup(): + await manager.start() + + +@app.on_event("shutdown") +async def shutdown(): + await manager.stop(clear_profile=False) + + +@app.get("/health") +async def health(): + return {"ok": True} + + +@app.get("/status") +async def status(): + return await manager.status() + + +@app.post("/open-login") +async def open_login(): + await manager.open_login() + return {"ok": True} + + +@app.post("/reset") +async def reset(): + await manager.reset() + return {"ok": True} + + +@app.post("/export") +async def export(): + try: + result = await manager.export() + return {"ok": True, "result": result} + except Exception as exc: + raise HTTPException(status_code=400, detail=str(exc)) + + +if __name__ == "__main__": + uvicorn.run(app, host="0.0.0.0", port=int(os.getenv("LOGIN_DESKTOP_API_PORT", "18090")), reload=False) diff --git a/DouYinSparkFlow/main.py b/DouYinSparkFlow/main.py new file mode 100644 index 0000000..e39c4b7 --- /dev/null +++ b/DouYinSparkFlow/main.py @@ -0,0 +1,64 @@ +import argparse +import asyncio + +from rich.console import Console +from rich.prompt import Prompt + +from core.login import userLogin +from utils.github_action_config import print_github_action_config + + +console = Console() + + +def interactive_cli(): + console.print("[bold green]Welcome to DouYin Spark Flow[/bold green]") + console.print("[bold yellow]Choose an action:[/bold yellow]") + console.print("[cyan]1.[/cyan] Add account login") + console.print("[cyan]2.[/cyan] Export USER_DATA for GitHub Actions") + console.print("[cyan]3.[/cyan] Run task locally") + console.print("[cyan]4.[/cyan] Start Web Admin UI") + + choice = Prompt.ask("Enter a choice (1/2/3/4)", choices=["1", "2", "3", "4"]) + + if choice == "1": + console.print("[bold blue]Starting account login...[/bold blue]") + while True: + asyncio.run(userLogin()) + if Prompt.ask("Continue adding accounts? (y/n)", choices=["y", "n"]) == "n": + break + elif choice == "2": + print_github_action_config() + elif choice == "3": + from core.tasks import runTasks + + asyncio.run(runTasks()) + else: + from webui.app import run_web_app + + run_web_app() + + +def build_parser(): + parser = argparse.ArgumentParser(description="DouYin Spark Flow") + parser.add_argument("--doTask", action="store_true", help="Run the message task immediately") + parser.add_argument("--web", action="store_true", help="Start the Web Admin UI") + parser.add_argument("--host", default=None, help="Web UI bind host") + parser.add_argument("--port", type=int, default=None, help="Web UI bind port") + return parser + + +if __name__ == "__main__": + parser = build_parser() + args = parser.parse_args() + + if args.doTask: + from core.tasks import runTasks + + asyncio.run(runTasks()) + elif args.web: + from webui.app import run_web_app + + run_web_app(host=args.host, port=args.port) + else: + interactive_cli() diff --git a/DouYinSparkFlow/relogin_worker.py b/DouYinSparkFlow/relogin_worker.py new file mode 100644 index 0000000..3a1ac5b --- /dev/null +++ b/DouYinSparkFlow/relogin_worker.py @@ -0,0 +1,261 @@ +import argparse +import asyncio +import json +from datetime import datetime +from pathlib import Path + + +def parse_args(): + parser = argparse.ArgumentParser(description="Run a headless Douyin relogin worker.") + parser.add_argument("--repo-root", required=True) + parser.add_argument("--account-index", type=int, required=True) + parser.add_argument("--state-file", required=True) + parser.add_argument("--screenshot-path", required=True) + parser.add_argument("--poll-interval", type=float, default=2.0) + parser.add_argument("--timeout-seconds", type=int, default=900) + return parser.parse_args() + + +def now_iso(): + return datetime.now().isoformat(timespec="seconds") + + +def write_state(path: Path, **payload): + base = {"updated_at": now_iso(), **payload} + path.write_text(json.dumps(base, ensure_ascii=False, indent=2), encoding="utf-8") + + +async def capture_login_screenshot(page, screenshot_path: Path, prefer_verification=False): + verification_selectors = [ + ".pc-login-verification-modal", + ".semi-modal-content", + ".semi-modal", + 'div[role="dialog"]', + ] + qr_selectors = [ + ".login-img-code-wrapper", + 'div[class*="qrcode"]', + "canvas", + ".login-mask", + ".login-guide-container", + ] + selectors = verification_selectors + qr_selectors if prefer_verification else qr_selectors + verification_selectors + for selector in selectors: + locator = page.locator(selector).first + try: + if await locator.count() > 0 and await locator.is_visible(): + await locator.scroll_into_view_if_needed() + await locator.screenshot(path=str(screenshot_path)) + return selector + except Exception: + continue + await page.screenshot(path=str(screenshot_path), full_page=True) + return "page" + + +async def is_verification_step(page): + modal_selectors = [ + ".pc-login-verification-modal", + ".semi-modal-content", + ".semi-modal", + 'div[role="dialog"]', + ] + for selector in modal_selectors: + locator = page.locator(selector).first + try: + if await locator.count() > 0 and await locator.is_visible(): + return True + except Exception: + continue + + verification_texts = [ + "身份验证", + "以确保为本人操作", + "短信验证码", + "安全验证", + ] + for text in verification_texts: + locator = page.get_by_text(text, exact=False).first + try: + if await locator.count() > 0 and await locator.is_visible(): + return True + except Exception: + continue + return False + + +async def refresh_expired_qr_if_needed(page): + refresh_texts = ["点击刷新", "刷新", "刷新二维码"] + expired_texts = ["二维码失效", "二维码已失效"] + + for text in refresh_texts: + locator = page.get_by_text(text, exact=False).first + try: + if await locator.count() > 0 and await locator.is_visible(): + await locator.scroll_into_view_if_needed() + await locator.click(force=True, timeout=10000) + await asyncio.sleep(1.5) + return True + except Exception: + continue + + for text in expired_texts: + locator = page.get_by_text(text, exact=False).first + try: + if await locator.count() > 0 and await locator.is_visible(): + await locator.scroll_into_view_if_needed() + await locator.click(force=True, timeout=10000) + await asyncio.sleep(1.5) + return True + except Exception: + continue + return False + + +async def main(): + args = parse_args() + repo_root = Path(args.repo_root).resolve() + state_file = Path(args.state_file).resolve() + screenshot_path = Path(args.screenshot_path).resolve() + screenshot_path.parent.mkdir(parents=True, exist_ok=True) + state_file.parent.mkdir(parents=True, exist_ok=True) + + import sys + + sys.path.insert(0, str(repo_root)) + + from core.browser import get_browser + from core.login import collect_login_result + from utils.config import get_userData, save_userData + + accounts = get_userData(force_reload=True) + account = accounts[args.account_index] + write_state( + state_file, + status="starting", + message=f"Preparing relogin session for {account.get('username', 'unknown')}", + account_index=args.account_index, + username=account.get("username", ""), + screenshot_path=str(screenshot_path), + ) + + playwright = browser = context = page = None + started_at = asyncio.get_running_loop().time() + timeout_seconds = max(args.timeout_seconds, 60) + + try: + playwright, browser = await get_browser(GUI=False) + context = await browser.new_context( + viewport={"width": 1600, "height": 1200}, + device_scale_factor=2, + ) + page = await context.new_page() + + await page.goto("https://creator.douyin.com/", wait_until="domcontentloaded", timeout=60000) + await asyncio.sleep(3) + + selectors = [ + "canvas", + ".login-img-code-wrapper", + 'div[class*="qrcode"]', + ".login-mask", + ".login-guide-container", + ".pc-login-verification-modal", + ".semi-modal-content", + ".semi-modal", + 'div[role="dialog"]', + ] + + while True: + if asyncio.get_running_loop().time() - started_at > timeout_seconds: + write_state( + state_file, + status="timeout", + message="Login session timed out before authentication completed", + account_index=args.account_index, + username=account.get("username", ""), + screenshot_path=str(screenshot_path), + ) + return + + await refresh_expired_qr_if_needed(page) + + unique_id_locator = page.locator( + 'xpath=//*[contains(@id, "garfish_app_for_douyin_creator_pc_home")]' + '/div/div[2]/div/div[2]/div[1]/div[2]/div[1]/div[3]' + ).first + name_locator = page.locator( + 'xpath=//*[contains(@id, "garfish_app_for_douyin_creator_pc_home")]' + '/div/div[2]/div/div[2]/div[1]/div[2]/div[1]/div[1]/div[1]' + ).first + + if await unique_id_locator.count() > 0 and await name_locator.count() > 0: + result = await collect_login_result(page, context, timeout_ms=5000) + refreshed_accounts = get_userData(force_reload=True) + refreshed_accounts[args.account_index]["unique_id"] = result["unique_id"] + refreshed_accounts[args.account_index]["username"] = result["username"] + refreshed_accounts[args.account_index]["cookies"] = result["cookies"] + save_userData(refreshed_accounts) + await page.screenshot(path=str(screenshot_path), full_page=True, timeout=15000) + write_state( + state_file, + status="authenticated", + message=f"Authenticated as {result['username']}", + account_index=args.account_index, + username=result["username"], + unique_id=result["unique_id"], + screenshot_path=str(screenshot_path), + ) + return + + verification = await is_verification_step(page) + await capture_login_screenshot(page, screenshot_path, prefer_verification=verification) + + write_state( + state_file, + status="waiting_verify" if verification else "awaiting_scan", + message="Identity verification is required" if verification else "Scan the QR code with the Douyin app", + account_index=args.account_index, + username=account.get("username", ""), + screenshot_path=str(screenshot_path), + ) + await asyncio.sleep(args.poll_interval) + except Exception as exc: + write_state( + state_file, + status="error", + message=str(exc), + account_index=args.account_index, + username=account.get("username", ""), + screenshot_path=str(screenshot_path), + ) + raise + finally: + if page: + try: + await page.close() + except Exception: + pass + if context: + try: + await context.close() + except Exception: + pass + if browser: + try: + await browser.close() + except Exception: + pass + if playwright: + try: + await playwright.stop() + except Exception: + pass + + +if __name__ == "__main__": + try: + asyncio.run(main()) + except AttributeError: + loop = asyncio.get_event_loop() + loop.run_until_complete(main()) diff --git a/DouYinSparkFlow/requirements-web.txt b/DouYinSparkFlow/requirements-web.txt new file mode 100644 index 0000000..4d00dc7 --- /dev/null +++ b/DouYinSparkFlow/requirements-web.txt @@ -0,0 +1,5 @@ +fastapi==0.115.6 +itsdangerous==2.2.0 +Jinja2==3.1.6 +python-multipart==0.0.20 +uvicorn==0.34.0 diff --git a/DouYinSparkFlow/requirements.txt b/DouYinSparkFlow/requirements.txt new file mode 100644 index 0000000..b6f2d8e --- /dev/null +++ b/DouYinSparkFlow/requirements.txt @@ -0,0 +1,22 @@ +certifi==2025.11.12 +charset-normalizer==3.4.4 +colorama==0.4.6 +fastapi==0.115.6 +greenlet==3.2.4 +httpx==0.28.1 +idna==3.11 +itsdangerous==2.2.0 +Jinja2==3.1.6 +markdown-it-py==4.0.0 +mdurl==0.1.2 +playwright==1.56.0 +pyee==13.0.0 +pyperclip==1.11.0 +Pygments==2.19.2 +python-multipart==0.0.20 +qrcode==8.2 +requests==2.32.5 +rich==14.2.0 +typing_extensions==4.15.0 +urllib3==2.5.0 +uvicorn==0.34.0 diff --git a/DouYinSparkFlow/scripts/start_login_desktop.sh b/DouYinSparkFlow/scripts/start_login_desktop.sh new file mode 100644 index 0000000..8af3d10 --- /dev/null +++ b/DouYinSparkFlow/scripts/start_login_desktop.sh @@ -0,0 +1,31 @@ +#!/usr/bin/env bash +set -euo pipefail + +export DISPLAY="${DISPLAY:-:99}" +export PLAYWRIGHT_BROWSERS_PATH="${PLAYWRIGHT_BROWSERS_PATH:-/ms-playwright}" +export LOGIN_DESKTOP_API_PORT="${LOGIN_DESKTOP_API_PORT:-18090}" +export LOGIN_DESKTOP_VNC_PORT="${LOGIN_DESKTOP_VNC_PORT:-5901}" +export LOGIN_DESKTOP_WEB_PORT="${LOGIN_DESKTOP_WEB_PORT:-8788}" + +mkdir -p /data/login-profile +mkdir -p /app/logs/login_desktop + +pkill -f "Xvfb ${DISPLAY}" >/dev/null 2>&1 || true +pkill -f "x11vnc .*${LOGIN_DESKTOP_VNC_PORT}" >/dev/null 2>&1 || true +pkill -f "websockify --web=/usr/share/novnc ${LOGIN_DESKTOP_WEB_PORT}" >/dev/null 2>&1 || true +rm -f "/tmp/.X99-lock" +rm -f "/tmp/.X11-unix/X99" + +Xvfb "${DISPLAY}" -screen 0 1600x1000x24 -ac +extension RANDR > /app/logs/login_desktop/xvfb.log 2>&1 & +for _ in $(seq 1 30); do + if [ -S /tmp/.X11-unix/X99 ]; then + break + fi + sleep 0.5 +done + +fluxbox > /app/logs/login_desktop/fluxbox.log 2>&1 & +x11vnc -display "${DISPLAY}" -forever -shared -rfbport "${LOGIN_DESKTOP_VNC_PORT}" -nopw > /app/logs/login_desktop/x11vnc.log 2>&1 & +websockify --web=/usr/share/novnc "${LOGIN_DESKTOP_WEB_PORT}" "localhost:${LOGIN_DESKTOP_VNC_PORT}" > /app/logs/login_desktop/novnc.log 2>&1 & + +exec python /app/login_desktop_server.py diff --git a/DouYinSparkFlow/usersData.example.json b/DouYinSparkFlow/usersData.example.json new file mode 100644 index 0000000..fe51488 --- /dev/null +++ b/DouYinSparkFlow/usersData.example.json @@ -0,0 +1 @@ +[] diff --git a/DouYinSparkFlow/utils/__init__.py b/DouYinSparkFlow/utils/__init__.py new file mode 100644 index 0000000..e69de29 diff --git a/DouYinSparkFlow/utils/chinese_new_year_2026_mare.py b/DouYinSparkFlow/utils/chinese_new_year_2026_mare.py new file mode 100644 index 0000000..dd893de --- /dev/null +++ b/DouYinSparkFlow/utils/chinese_new_year_2026_mare.py @@ -0,0 +1,933 @@ +from datetime import date +import random + +# 2026年丙午马年 春节通用文案库 (每日30+条) +# 特点：全场景通用、无特定对象、强日期贴合度 +SPRING_FESTIVAL_QUOTES = { + # ============================================== + # 2026年2月16日 除夕 (岁除/大年夜) + # 核心：辞旧、团圆、守岁、年夜饭、跨年 + # ============================================== + date(2026, 2, 16): [ + # 辞旧迎新篇 + "2026丙午除夕，烟火起，照人间，举杯敬此年。", + "辞别乙巳，拥抱丙午。愿旧岁千般皆如意，新年万事定称心。", + "最后一天，把所有的遗憾打包封存，把所有的期待整装待发。", + "岁序更替，华章日新。站在新年的门槛，准备好迎接火热的马年。", + "长路浩浩荡荡，万物尽可期待。2025圆满谢幕，2026正式启航。", + "旧岁已展千重锦，新年再进百尺竿。除夕快乐，万事胜意。", + "将往事清零，与岁月言和。愿新的一年，多喜乐，长安宁。", + "光阴流转，又逢除夕。愿所有的努力，都能在马年开花结果。", + "挥手作别旧时路，策马扬鞭新征程。除夕安康，福暖四季。", + "跨年的钟声即将敲响，愿未来的日子，如骏马奔腾，一往无前。", + + # 团圆守岁篇 + "万家灯火时，阖家团圆日。今夜围炉话岁，共享人间清欢。", + "年夜饭的香气，是这一年最温暖的句号。", + "灯火可亲，饭香扑鼻。愿岁岁年年，共占春风。", + "守岁至天明，喜乐伴一生。今夜不谈烦恼，只叙团圆。", + "窗外烟火璀璨，屋内笑语盈盈。这便是人间最好的光景。", + "一杯屠苏酒，一桌团圆饭。敬过往，敬明天，敬每一个当下。", + "今夜无眠，唯有欢喜。愿烟火向星辰，所愿皆成真。", + "饺子滚一滚，福气进家门。除夕的饺子，包进了一整年的好运。", + "围炉守岁，静待新春。愿马年的第一缕阳光，照亮心底的梦想。", + "在这个辞旧迎新的夜晚，愿平安与健康，常伴左右。", + + # 马年预热篇 + "丙午火马，即将登场。愿新的一年，生命力如烈火般旺盛。", + "金蛇隐去，骏马奔腾。2026，准备好马力全开。", + "除夕之夜，许下心愿：2026，马不停蹄奔向幸福。", + "烟火升腾处，金马踏春来。愿新年，胜旧年。", + "迎接丙午马年，愿前程如骏马驰骋，一马平川。", + "除夕快乐！金马贺岁，福暖四季，万事胜意。", + "2026，愿如骏马，不负韶华，驰骋万里。", + "在这个火热的年份，愿日子过得红红火火，热气腾腾。", + "策马扬鞭迎新岁，意气风发赴前程。除夕大吉。", + "准备好，和金马一起，跨越山海，奔赴美好。", + + # 短句补充篇 + "除夕快乐，2026你好。", + "烟火年年，岁岁平安。", + "旧疾当愈，新年可期。", + "辞旧岁，迎新春，万事兴。", + "丙午大吉，马到成功。", + "万家团圆，喜乐安康。", + "今夜好梦，明天好运。", + "感恩过往，期待未来。", + "福满人间，春回大地。", + "跨年快乐，马年大吉。" + ], + + # ============================================== + # 2026年2月17日 正月初一 (春节/元日) + # 核心：开门见喜、拜年、新岁、龙马精神 + # ============================================== + date(2026, 2, 17): [ + # 开门见喜篇 + "正月初一，开门见喜。愿2026年的第一天，满载好运与福气。", + "大年初一，喜气洋洋。推开窗，迎接第一缕春风与阳光。", + "初一启新程，万事皆顺遂。愿这一年，所求皆如愿。", + "门迎百福，户纳千祥。马年第一天，好运接踵而至。", + "初一早，福气到。愿生活明朗，万物可爱。", + "新岁启封，美好开场。2026，从这喜气洋洋的一天开始。", + "晨光熹微，年味正浓。初一早安，马年吉祥。", + "开启新岁的第一份好运，愿平安喜乐，一路随行。", + "初一开门红，全年万事通。愿日子红红火火，蒸蒸日上。", + "迎着朝阳，许下心愿：2026，一马当先，万事胜意。", + + # 龙马精神篇 + "丙午马年，正月初一。愿龙马精神，常驻心间。", + "2026，做一匹奔腾的骏马，跨越所有障碍，奔向理想。", + "大年初一，祝龙马精神，身体康健，活力满满。", + "马年第一天，愿拥有骏马的速度，更有骏马的耐力。", + "春风得意马蹄疾，一日看尽长安花。新年伊始，意气风发。", + "以梦为马，不负韶华。初一启程，奔赴山海。", + "金马迎春，万象更新。愿精神抖擞，迎接每一个挑战。", + "马到成功，从大年初一做起。每一步，都坚定有力。", + "愿如骏马，驰骋疆场，所向披靡，收获满满。", + "正月初一，愿一马平川，前程似锦，无往不利。", + + # 拜年祈福篇 + "新春大吉，拜年啦。愿这一年，多喜乐，长安宁。", + "大年初一，送上最真挚的祝福：四季平安，万事顺遂。", + "初一纳福，愿福气满满，财运亨通，好运连连。", + "拜年进行时，祝福送不停。愿2026，皆是欢喜。", + "大年初一，不只是祝福，更是对未来的美好期许。", + "新的一年，愿日子如熹光，温柔又安详。", + "初一祈福，愿阖家欢乐，岁月静好，现世安稳。", + "春风送暖，福气盈门。大年初一，喜乐安康。", + "给时光拜个年，愿它温柔以待每一个努力的人。", + "2026的第一声祝福：愿世间美好，与你环环相扣。", + + # 短句补充篇 + "初一吉祥，马年大吉。", + "开门纳福，万事亨通。", + "龙马精神，一马当先。", + "新春快乐，好事连连。", + "元日安康，福暖人间。", + "2026，向阳而生。", + "大年初一，喜气盈门。", + "马到成功，前程似锦。", + "新年第一喜，好运属于你。", + "喜乐无忧，自在如风。" + ], + + # ============================================== + # 2026年2月18日 正月初二 (回门/迎婿) + # 核心：归家、亲情、欢聚、福满门 + # ============================================== + date(2026, 2, 18): [ + # 归家欢聚篇 + "正月初二，归宁之喜。带上祝福，奔赴另一场团圆。", + "初二回门，福气临门。愿每一次归家，都温暖如初。", + "初一团圆，初二欢聚。亲情的纽带，从未如此紧密。", + "带上爱与思念，回到温暖的港湾。初二快乐。", + "正月初二，风和日丽。适合相聚，适合表达爱意。", + "回门的路，是通往幸福的路。愿一路欢歌，一路笑语。", + "初二时光，慢煮生活。愿烟火气中，皆是幸福味。", + "走亲访友，传递温情。初二这一天，装满了爱。", + "归宁日，欢喜时。愿所有的美好，都恰逢其时。", + "初二启程，满载欢喜。愿相聚的时光，温柔又绵长。", + + # 福满双门篇 + "正月初二，福满双门。愿两家喜乐，万事兴隆。", + "初二迎福，愿福气不仅满盈小家，更福泽大家。", + "门门有喜，户户纳福。初二这一天，喜气洋洋。", + "双门纳福，马年吉祥。愿两边的长辈，福寿安康。", + "正月初二，好事成双。愿快乐加倍，幸福翻倍。", + "福临门，喜盈户。初二的日子，红红火火。", + "两家欢喜，一门和气。愿这份福气，延续一整年。", + "初二接福，愿生活有滋有味，日子顺顺当当。", + "福气流转，爱意相传。正月初二，吉祥如意。", + "双福临门，万事胜意。愿马年的每一天，都充满阳光。", + + # 春日随行篇 + "初二春早，惠风和畅。愿春风十里，不如相聚有你。", + "正月初二，踏春而行。愿脚步所至，皆是美好。", + "春日暖阳，照见归途。初二这一天，温暖随行。", + "春风送暖入屠苏，初二归宁乐陶陶。", + "马年的春天，从初二的欢聚开始。生机勃勃，充满希望。", + "花开正艳，春意正浓。初二出门，遇见美好。", + "暖阳相伴，清风相随。初二的时光，惬意又美好。", + "踏遍春色，归来仍是少年。正月初二，喜乐安康。", + "春日迟迟，卉木萋萋。初二之日，愿心情如花般绽放。", + "迎着春光，奔赴团圆。初二快乐，马年大吉。", + + # 短句补充篇 + "初二回门，喜气洋洋。", + "归宁日，幸福时。", + "福满双门，好事成双。", + "初二吉祥，马年安康。", + "欢聚时刻，喜乐无忧。", + "亲情无价，岁月留痕。", + "初二纳福，万事顺遂。", + "春风十里，不如团圆。", + "回门之喜，福暖人心。", + "马年初二，福气满满。" + ], + + # ============================================== + # 2026年2月19日 正月初三 (赤狗日/宅家) + # 核心：静养、安歇、蓄力、宅家 + # ============================================== + date(2026, 2, 19): [ + # 宅家静养篇 + "正月初三，安歇静养。给身体放个假，给心情充个电。", + "初三宅家，慢享时光。在喧嚣之外，寻得一份宁静。", + "初一忙，初二累，初三在家睡。享受难得的清闲。", + "宅家的日子，也是一种幸福。初三快乐，自在随心。", + "闭门谢客，静心养神。初三这一天，只属于自己。", + "放慢脚步，享受慢生活。初三，宜休息，宜欢聚。", + "窗外年味浓，屋内岁月静。初三宅家，惬意安然。", + "暂时放下忙碌，享受片刻悠闲。正月初三，岁月静好。", + "初三时光，用来虚度。愿日子慢一点，幸福长一点。", + "在家纳福，平安喜乐。初三这一天，简单又美好。", + + # 蓄力待发篇 + "初三蓄力，静待花开。为了更好的出发，此刻需要沉淀。", + "养精蓄锐，马力全开。初三的休息，是为了未来的奔跑。", + "积蓄力量，厚积薄发。2026，准备好惊艳全场。", + "暂停，是为了更好的前行。初三，在宁静中积蓄能量。", + "休整身心，整装待发。愿未来的路，走得更稳更远。", + "初三时光，用来规划。愿马年的每一步，都走得坚定。", + "充电完毕，满格出发。初三之后，又是新的征程。", + "在安静中蓄力，在沉淀中成长。正月初三，未来可期。", + "养足精神，迎接挑战。马年的精彩，还在后面。", + "初三纳福，蓄力前行。愿2026，一往无前。", + + # 平安纳福篇 + "正月初三，赤狗日。宜居家，纳平安，避纷争。", + "在家纳福，百邪不侵。愿金马护宅，万事顺遂。", + "初三吉祥，平安第一。愿日子安稳，岁月静好。", + "纳福迎祥，阖家安康。初三这一天，福气满满。", + "平安是福，健康是金。正月初三，祈愿平安。", + "福宅安康，万事兴隆。初三纳福，马年吉祥。", + "闭门纳福，开门迎喜。愿初三的宁静，带来一整年的安稳。", + "岁月安稳，现世静好。初三之日，福暖人间。", + "纳千祥，迎万福。正月初三，平安喜乐。", + "金马护佑，平安相随。初三安康，万事大吉。", + + # 短句补充篇 + "初三宅家，自在逍遥。", + "静养身心，蓄力前行。", + "闭门纳福，平安是福。", + "初三吉祥，岁月静好。", + "慢享时光，惬意安然。", + "养精蓄锐，马到成功。", + "正月初三，宜休息。", + "在家享福，福气自来。", + "沉淀自己，未来可期。", + "初三安康，福满人间。" + ], + + # ============================================== + # 2026年2月20日 正月初四 (接灶神) + # 核心：烟火、食禄、家肥屋润、三餐四季 + # ============================================== + date(2026, 2, 20): [ + # 恭迎灶神篇 + "正月初四，恭迎灶神。愿三餐四季，温暖如初。", + "灶神归位，烟火重燃。初四这一天，充满了生活气息。", + "恭迎灶王爷，福泽满人间。愿家肥屋润，衣食无忧。", + "初四接灶，五谷丰登。愿粮仓常满，日子富足。", + "灶火初红，春意渐浓。迎接灶神，迎接美好。", + "一炉香火，祈愿平安。初四接灶，马年吉祥。", + "灶神下界，保祐平安。愿每一顿饭，都吃得香甜。", + "正月初四，迎灶纳福。愿烟火气中，皆是幸福味。", + "接灶神，纳吉祥。愿2026，衣食无忧，生活美满。", + "灶火通明，福气盈门。初四大吉，万事顺遂。", + + # 人间烟火篇 + "人间烟火气，最抚凡人心。初四这一天，重拾生活的热爱。", + "三餐四季，温柔有趣。愿灶火不熄，爱与温暖常在。", + "厨房里的烟火，是家里最美的风景。初四快乐。", + "一碗热汤，温暖身心。愿马年的每一天，都热气腾腾。", + "烟火升腾处，幸福正当时。初四，宜下厨，宜欢聚。", + "柴米油盐酱醋茶，人间烟火也有趣。正月初四，岁月静好。", + "灶台飘香，日子红火。愿生活有滋有味，红红火火。", + "在烟火气中，感受生活的美好。初四这一天，惬意安然。", + "灶火声声，笑语盈盈。愿家宅安宁，幸福绵长。", + "人间有味是清欢。初四之日，愿享受每一顿家常便饭。", + + # 食禄丰足篇 + "初四接灶，食禄丰足。愿2026，不愁吃穿，富足安康。", + "米缸常满，日子香甜。愿马年的每一天，都衣食无忧。", + "食禄双全，福气满满。正月初四，祈愿丰收。", + "五谷丰登，食禄无忧。愿生活富足，岁月安稳。", + "迎灶神，纳食禄。愿这一年，物质富足，精神丰盈。", + "仓廪实而知礼节，衣食足而知荣辱。初四祈愿富足。", + "食禄绵长，福泽深厚。马年初四，吉祥如意。", + "愿手中有粮，心中不慌。初四接灶，岁岁安康。", + "丰衣足食，安居乐业。正月初四，万事亨通。", + "接灶神，保食禄。愿2026，日子过得殷实又幸福。", + + # 短句补充篇 + "初四接灶，福气满堂。", + "烟火人间，温暖相伴。", + "家肥屋润，衣食无忧。", + "灶神归位，万事顺遂。", + "三餐四季，温柔有趣。", + "食禄丰足，马年大吉。", + "正月初四，宜纳福。", + "烟火气中，幸福绵长。", + "迎灶纳祥，岁岁安康。", + "柴米油盐，皆是幸福。" + ], + + # ============================================== + # 2026年2月21日 正月初五 (破五/迎财神) + # 核心：财运、破禁、送穷、发财 + # ============================================== + date(2026, 2, 21): [ + # 迎财纳福篇 + "正月初五，迎财神。愿2026，财运亨通，富贵吉祥。", + "五路财神齐到访，八方来财福满堂。初五接福啦。", + "财神到，福运照。愿马年的每一天，都财源滚滚。", + "初五迎财，开门见喜。愿事业有成，财运亨通。", + "东路招财，西路纳珍。初五这一天，装满了财富。", + "财神骑马到家门，金银财宝进家门。马年发大财。", + "正月初五，财门大开。愿八方财源，滚滚而来。", + "迎财神，纳千祥。愿2026，腰缠万贯，富贵安康。", + "五路财神护佑，马年财运亨通。初五快乐。", + "财星高照，福气临门。正月初五，恭喜发财。", + + # 破五送穷篇 + "正月初五，破五送穷。送走烦恼，送走霉运，送走贫穷。", + "破五之时，送穷出门。愿2026，轻装上阵，奔赴美好。", + "鞭炮一响，穷鬼跑光。初五这一天，除旧布新。", + "破除禁忌，送走穷困。愿马年的日子，蒸蒸日上。", + "破五开运，万象更新。愿所有的不好，都随风而去。", + "送穷迎富，福气满屋。正月初五，好运连连。", + "破五之日，百无禁忌。愿想做的事，都能如愿。", + "送走旧岁的穷气，迎来新年的财气。初五大吉。", + "破五重生，焕然一新。愿2026，元气满满。", + "除旧迎新，破五纳祥。愿未来的日子，一片光明。", + + # 马年钱程篇 + "策马奔腾赴钱程，马不停蹄赚金银。初五快乐。", + "马年行大运，财运滚滚来。愿事业如骏马，飞驰向前。", + "金马送财，富贵花开。愿2026，钱途无量。", + "马力全开搞事业，一心一意赚大钱。初五吉祥。", + "如骏马驰骋，在财富的草原上，收获满满。", + "马到成功，财到手。愿2026，盆满钵满。", + "金马踏春来，财运随身带。正月初五，发财发财。", + "驰骋商海，如骏马奔腾。愿财源广进，日进斗金。", + "马年第一桶金，从初五迎财神开始。", + "财运如骏马，日行千里，夜行八百。", + + # 短句补充篇 + "初五迎财，富贵自来。", + "送穷迎富，万事胜意。", + "财神驾到，财源滚滚。", + "破五开运，马到成功。", + "五路接财，八方纳福。", + "马年发财，钱途无量。", + "正月初五，恭喜发财。", + "财门大开，好运自来。", + "送穷出门，迎富入宅。", + "日进斗金，腰缠万贯。" + ], + + # ============================================== + # 2026年2月22日 正月初六 (送穷/开市) + # 核心：顺意、开工、送穷、六六大顺 + # ============================================== + date(2026, 2, 22): [ + # 六六大顺篇 + "正月初六，六六大顺。愿2026，万事顺遂，顺心如意。", + "六六大顺日，马年吉祥时。愿好运连连，幸福满满。", + "初六大顺，一顺百顺。愿生活顺心，事业顺利。", + "天顺地顺人更顺，心顺意顺事事顺。正月初六快乐。", + "顺风顺水，顺理成章。愿马年的每一天，都顺顺利利。", + "六六大顺，福满人间。愿所有的美好，都如期而至。", + "初六送福，顺字当头。愿日子过得舒心，过得顺心。", + "顺气东来，福气西至。正月初六，万事亨通。", + "顺顺利利开工，红红火火生活。初六大吉。", + "顺境常伴，逆境不扰。愿2026，一路顺风。", + + # 送穷启程篇 + "正月初六，送穷启程。愿霉运清零，好运加满。", + "送走穷神，迎来福神。初六这一天，焕然一新。", + "穷气送出门，福气迎进门。愿马年的日子，富足安康。", + "初六送穷，一送永逸。愿2026，无病无灾，无贫无困。", + "鞭炮声声送穷神，欢歌笑语迎新春。正月初六快乐。", + "送穷归故里，迎富入新宅。愿生活蒸蒸日上。", + "初六启程，甩掉包袱。愿轻装上阵，奔赴前程。", + "穷神走，财神留。愿2026，富贵常伴。", + "送穷之日，开启新程。愿马年的路，越走越宽。", + "告别贫穷与烦恼，迎接富裕与快乐。初六吉祥。", + + # 开市大吉篇 + "正月初六，开市大吉。愿2026，事业兴旺，财源广进。", + "开工啦！愿马力全开，业绩长虹。", + "初六启市，百业兴旺。愿生意兴隆，客似云来。", + "开市迎财，大吉大利。愿马年的事业，如日中天。", + "鞭炮一响，黄金万两。初六开工，红红火火。", + "新征程，新起点。初六开市，未来可期。", + "开门做生意，笑脸迎财神。愿2026，订单不断。", + "初六开工，元气满满。愿工作顺利，薪水翻番。", + "开市纳福，生意兴隆。愿马年的事业，一马当先。", + "正月初六，宜开工。愿所有的努力，都有回报。", + + # 短句补充篇 + "初六大顺，万事亨通。", + "送穷迎富，开工大吉。", + "六六大顺，马到成功。", + "顺风顺水，前程似锦。", + "开市纳财，富贵吉祥。", + "正月初六，启程出发。", + "霉运清零，好运加满。", + "红红火火，开工大吉。", + "顺字当头，幸福安康。", + "马年开工，业绩长虹。" + ], + + # ============================================== + # 2026年2月23日 正月初七 (人日/庆寿) + # 核心：生民、健康、成长、七菜 + # ============================================== + date(2026, 2, 23): [ + # 众人生日篇 + "正月初七，人日快乐。愿世间所有人，平安健康。", + "传说女娲造人，初七始成。这是属于每个人的生日。", + "人日吉祥，喜乐安康。愿2026，善待每一个生命。", + "初七庆生，福满人间。愿岁月温柔，不负韶华。", + "所有人的生日，所有的祝福。愿平安常伴，健康常在。", + "人日之时，许下心愿：愿众生皆苦，唯有你甜。", + "正月初七，祝自己，也祝你，生日快乐。", + "生而为人，何其有幸。初七这一天，感恩生命。", + "人日纳福，愿每一个人，都能被世界温柔以待。", + "初七之日，万物生辉。愿生命蓬勃，充满希望。", + + # 健康成长篇 + "人日祈健康，愿身体无恙，精神饱满。", + "正月初七，宜养生。愿龙马精神，常驻心间。", + "健康是福，平安是金。愿2026，无病无灾。", + "在这个属于人的日子，愿健康常伴左右。", + "茁壮成长，不负春光。愿马年的每一天，都充满活力。", + "身强体健，百病不侵。初七祈愿，健康长寿。", + "愿如骏马，体魄强健，驰骋万里。", + "人日吃顿好，身体没烦恼。愿营养均衡，健康无忧。", + "正月初七，动起来。愿活力满满，元气十足。", + "健康的体魄，是梦想的基石。初七快乐。", + + # 七菜迎春篇 + "初七吃七菜，福气自然来。愿生活丰富多彩。", + "七菜羹，聚福气。愿2026，集齐所有的美好。", + "七种蔬菜，七种祝福。愿马年的日子，五彩斑斓。", + "食七菜，迎新春。愿日子过得有滋有味。", + "正月初七，尝鲜迎春。愿生活如七菜，清爽又健康。", + "七菜同煮，福气满屋。愿阖家欢乐，岁月静好。", + "吃口七菜羹，全年万事兴。初七吉祥。", + "七种食材，七种好运。愿马年的每一天，都有惊喜。", + "人日食七菜，健康又自在。愿身体安康，万事顺遂。", + "七菜迎春，福满人间。正月初七，喜乐安康。", + + # 短句补充篇 + "初七人日，喜乐安康。", + "众人生日，平安吉祥。", + "健康第一，万事无忧。", + "人日纳福，马年大吉。", + "生而自由，爱而无畏。", + "七菜迎春，福气满满。", + "正月初七，岁月静好。", + "生命可贵，且行且惜。", + "人日快乐，诸事顺遂。", + "龙马精神，健康长寿。" + ], + + # ============================================== + # 2026年2月24日 正月初八 (开工/谷日) + # 核心：耕耘、丰收、事业、启程 + # ============================================== + date(2026, 2, 24): [ + # 开工启程篇 + "正月初八，开工大吉。愿2026，马力全开，再创辉煌。", + "初八启程，奔赴前程。愿事业如骏马，一日千里。", + "假期归零，快乐不归零。初八开工，元气满满。", + "新的征程，从初八开始。愿脚踏实地，仰望星空。", + "初八开工，喜气洋洋。愿工作顺利，步步高升。", + "收心归位，全力以付。愿马年的事业，一马当先。", + "正月初八，宜奋斗。愿每一份努力，都不被辜负。", + "开工啦！愿2026，业绩长虹，薪水翻番。", + "带着新年的喜气，投入工作的热情。初八快乐。", + "启程出发，未来可期。正月初八，万事亨通。", + + # 谷日祈丰篇 + "正月初八，谷日吉祥。愿五谷丰登，国泰民安。", + "谷日祈丰收，愿大地回馈，仓廪丰实。", + "初八是谷日，预示丰收年。愿生活富足，岁月安稳。", + "春种一粒粟，秋收万颗子。初八祈愿，收获满满。", + "五谷飘香，日子绵长。愿马年的每一天，都衣食无忧。", + "谷日纳福，愿耕耘有收获，付出有回报。", + "正月初八，惜粮感恩。愿每一粒粮食，都被珍惜。", + "谷物丰登，福气盈门。愿2026，物质富足。", + "谷日之时，许下心愿：愿世间无饥饿，人间皆温饱。", + "初八谷日，福泽深厚。愿马年，岁岁丰收。", + + # 耕耘收获篇 + "一分耕耘，一分收获。初八开工，愿辛勤付出，换来硕果累累。", + "如农人耕耘，如骏马驰骋。愿在事业的田野，收获满满。", + "播种希望，收获未来。正月初八，宜行动。", + "不驰于空想，不骛于虚声。初八开始，脚踏实地。", + "耕耘当下，收获未来。愿2026，满载而归。", + "像守护庄稼一样，守护梦想。初八快乐。", + "辛勤耕耘，静待花开。愿马年的事业，蒸蒸日上。", + "只有播种，才有收获。初八启程，开始新的耕耘。", + "愿汗水浇灌梦想，收获金色的未来。正月初八吉祥。", + "耕耘岁月，收获幸福。愿2026，硕果累累。", + + # 短句补充篇 + "初八开工，大吉大利。", + "谷日祈丰，五谷丰登。", + "马力全开，奔赴前程。", + "耕耘收获，未来可期。", + "正月初八，宜奋斗。", + "业绩长虹，步步高升。", + "仓廪丰实，衣食无忧。", + "脚踏实地，仰望星空。", + "开工启程，马到成功。", + "播种希望，收获辉煌。" + ], + + # ============================================== + # 2026年2月25日 正月初九 (天公生) + # 核心：天长地久、祈福、高远、玉皇诞 + # ============================================== + date(2026, 2, 25): [ + # 天公诞辰篇 + "正月初九，天公生。愿上天庇佑，阖家安康。", + "玉皇大帝诞辰日，一拜天公，风调雨顺。", + "初九拜天公，福气满乾坤。愿2026，万事顺遂。", + "天公作美，岁月静好。正月初九，吉祥如意。", + "叩拜天公，祈愿平安。愿风调雨顺，国泰民安。", + "初九吉日，天公赐福。愿所有的美好，都降临身边。", + "天公生，福满门。愿金马踏云，带来祥瑞。", + "正月初九，诚心祈福。愿上天眷顾，诸事皆宜。", + "拜天公，纳千祥。愿2026，福运亨通。", + "天公庇佑，金马护航。初九安康，万事大吉。", + + # 长长久久篇 + "正月初九，长长久久。愿福气长久，财运长久。", + "九为数之极，寓意圆满。愿2026，长长久久的幸福。", + "初九之日，许下心愿：愿健康长久，快乐长久。", + "长长久久的陪伴，长长久久的幸福。正月初九快乐。", + "友谊长存，爱意长久。愿所有的关系，都天长地久。", + "初九纳福，愿好运长久相伴，烦恼长久远离。", + "幸福久久，好运连连。愿马年的每一天，都充满阳光。", + "长长久久的岁月，长长久久的安康。", + "正月初九，愿这份祝福，伴你天长地久。", + "久久同心，万事胜意。愿2026，美好长存。", + + # 志存高远篇 + "初九天公生，愿志存高远，心向星辰。", + "如天马行空，自由自在。愿梦想无边界，前程无阻碍。", + "仰望星空，脚踏实地。正月初九，未来可期。", + "心有凌云志，脚下万里途。愿马年的你，驰骋万里。", + "志在千里，壮心不已。愿2026，实现远大理想。", + "天高地阔，任君驰骋。愿如骏马，飞跃高山。", + "正月初九，宜立志。愿立下鸿鹄志，不负少年时。", + "胸怀天下，志存高远。愿马年的事业，蒸蒸日上。", + "心向蓝天，脚踏实地。愿每一步，都走得坚定。", + "初九之日，愿眼界开阔，格局打开。", + + # 短句补充篇 + "初九拜天，福泽绵绵。", + "天长地久，幸福安康。", + "天公赐福，万事大吉。", + "正月初九，步步高升。", + "志存高远，马到成功。", + "福气久久，好运连连。", + "风调雨顺，国泰民安。", + "天马行空，自在逍遥。", + "初九吉祥，福满人间。", + "长长久久，万事胜意。" + ], + + # ============================================== + # 2026年2月26日 正月初十 (石不动/十全十美) + # 核心：圆满、稳固、十全十美、基础 + # ============================================== + date(2026, 2, 26): [ + # 十全十美篇 + "正月初十，十全十美。愿2026，圆满无缺，万事胜意。", + "十全十美日，马年吉祥时。愿集齐所有的美好。", + "初十圆满，事事如意。愿生活有滋有味，有声有色。", + "十分幸福，十分美满。正月初十，福暖人间。", + "十全十美，百事无忧。愿马年的每一天，都顺心顺意。", + "初十这一天，愿所有的期待，都得到圆满答复。", + "十分好运，十分福气。愿2026，好运连连。", + "十全十美，千金不换。愿这份幸福，伴你一生。", + "正月初十，愿生活满分，快乐满分。", + "圆满之日，喜乐之时。愿马年，圆圆满满。", + + # 根基稳固篇 + "正月初十，石不动。愿根基稳固，如磐石般坚定。", + "石不动，心安稳。愿马年的每一步，都走得踏实。", + "初十之日，宜固本。愿基础扎实，前程稳固。", + "如磐石般坚定，如骏马般奔腾。愿动静皆宜。", + "根基深厚，枝繁叶茂。愿事业如大树，茁壮成长。", + "石不动，福常驻。愿家宅安宁，岁月静好。", + "正月初十，愿初心如磐，使命在肩。", + "稳固根基，才能行稳致远。初十吉祥。", + "如石般坚定，如水般灵动。愿马年的日子，刚柔并济。", + "初十纳福，愿基业长青，幸福长久。", + + # 十福临门篇 + "初十迎十福，福满门庭。愿福气、财气、运气，统统到来。", + "一福平安，二福健康。初十这一天，十福临门。", + "集齐十福，召唤好运。愿2026，福气满满。", + "十福齐至，万事亨通。正月初十，喜乐安康。", + "福满十方，喜盈门庭。愿马年的日子，红红火火。", + "初十接福，愿幸福像花儿一样，朵朵绽放。", + "十全十美，五福临门。愿2026，好事成双。", + "福运绵长，十全十美。愿每一个梦想，都开花结果。", + "正月初十，愿福气东来，紫气西至。", + "十福相伴，一生平安。愿马年，福暖四季。", + + # 短句补充篇 + "初十圆满，十全十美。", + "石不动，福常驻。", + "根基稳固，行稳致远。", + "十福临门，万事大吉。", + "正月初十，圆满收官。", + "十分幸福，十分美满。", + "马年圆满，事事如意。", + "初心如磐，未来可期。", + "初十吉祥，福满人间。", + "十全十美，喜乐无忧。" + ], + + # ============================================== + # 2026年2月27日 正月十一 (子婿日/宴请) + # 核心：相聚、情谊、款待、热闹 + # ============================================== + date(2026, 2, 27): [ + # 欢聚宴请篇 + "正月十一，欢聚时刻。愿情谊长存，温暖常在。", + "子婿之日，宴请亲朋。愿欢声笑语，充满屋宇。", + "正月十一，宜相聚。愿推杯换盏，共话桑麻。", + "宴请八方客，喜迎四海宾。正月十一，热闹非凡。", + "欢聚一堂，喜气洋洋。愿这份热闹，延续一整年。", + "十一之日，美酒佳肴。愿吃得开心，聊得尽兴。", + "高朋满座，胜友如云。愿马年的日子，贵人常伴。", + "正月十一，把酒言欢。愿烦恼抛诸脑后，快乐常驻心间。", + "相聚的时光，总是短暂。愿珍惜当下，不负相遇。", + "宴请亲朋，共庆新春。正月十一，吉祥如意。", + + # 情谊绵长篇 + "正月十一，情谊绵长。愿亲情、友情，如陈年老酒，越久越香。", + "岁月流转，情谊不变。愿每一次相聚，都温暖如初。", + "子婿之日，亲情浓。愿家人闲坐，灯火可亲。", + "朋友相聚，友情深。愿高山流水，知音常在。", + "情谊是冬日的暖阳，是夏日的清风。正月十一，感恩相遇。", + "愿这份情谊，如骏马奔腾，跨越山海，永不褪色。", + "正月十一，愿所有的感情，都能被温柔以待。", + "相聚是缘，相守是福。愿情谊长存，岁月静好。", + "把酒言欢，共叙情谊。愿马年的每一天，都有朋友相伴。", + "十一之日，愿情谊之花，常开不败。", + + # 余庆延续篇 + "年味未减，余庆延续。正月十一，依然喜气洋洋。", + "春节的热闹，还在继续。愿快乐不减，福气依旧。", + "正月十一，新年的余温尚在。愿好运连连，幸福满满。", + "年虽过半，味仍浓。愿马年的日子，依然红红火火。", + "余庆绵绵，福泽深厚。正月十一，万事顺遂。", + "新年的脚步虽远，祝福的心意未减。", + "正月十一，愿这份喜气，伴你左右。", + "年味渐淡，情意更浓。愿每一次相聚，都值得珍藏。", + "十一之日，愿新年的好运，继续加持。", + "余庆延续，马年大吉。愿未来的日子，充满阳光。", + + # 短句补充篇 + "正月十一，欢聚一堂。", + "情谊绵长，温暖相伴。", + "子婿之日，喜气洋洋。", + "把酒言欢，共话美好。", + "余庆延续，福满人间。", + "高朋满座，胜友如云。", + "十一吉祥，马年安康。", + "相聚是缘，相守是福。", + "年味依旧，快乐不减。", + "宴请亲朋，共庆新春。" + ], + + # ============================================== + # 2026年2月28日 正月十二 (搭灯棚/备元宵) + # 核心：预热、光明、期待、筹备 + # ============================================== + date(2026, 2, 28): [ + # 搭棚迎灯篇 + "正月十二，搭灯棚。为即将到来的元宵，点亮希望。", + "灯棚初搭，喜气初临。愿光明将至，幸福将至。", + "正月十二，张灯结彩。愿大街小巷，充满节日的气氛。", + "搭起灯棚，点亮心灯。愿2026，前途一片光明。", + "十二之日，筹备元宵。愿所有的期待，都如期而至。", + "灯棚高高挂，福气进门来。正月十二，吉祥如意。", + "红红火火搭灯棚，热热闹闹迎元宵。", + "正月十二，愿这一盏盏灯，照亮前行的路。", + "搭灯棚，纳吉祥。愿马年的夜晚，不再黑暗。", + "十二这一天，为团圆做准备。愿日子红红火火。", + + # 元宵预热篇 + "年味未消，元宵将至。正月十二，期待满满。", + "倒计时三天，元宵佳节即将登场。愿快乐加倍。", + "正月十二，心向元宵。愿那一碗汤圆，甜进心里。", + "春节的尾声，元宵的序曲。十二这一天，承上启下。", + "期待那一夜的灯火，期待那一碗的香甜。", + "正月十二，愿所有的美好，都在元宵之夜绽放。", + "预热元宵，福气先行。愿2026，圆圆满满。", + "十二之日，许下心愿：愿元宵之夜，月圆人圆。", + "春节的热闹还在，元宵的期待已来。", + "正月十二，愿这份期待，化作美好的现实。", + + # 光明希望篇 + "正月十二，点亮心灯。愿心中有光，脚下有路。", + "灯象征着希望。愿2026，如明灯指引，一路向前。", + "十二之日，愿光明驱散黑暗，希望战胜绝望。", + "心有明灯，不惧黑暗。愿马年的每一天，都充满阳光。", + "搭灯棚，迎光明。愿前程似锦，未来可期。", + "正月十二，愿这世间，灯火通明，温暖常在。", + "光明将至，幸福随行。愿马年的夜晚，星光璀璨。", + "点亮一盏灯，照亮一片天。十二这一天，充满希望。", + "愿心灯长明，愿福运长伴。", + "正月十二，愿如骏马，向着光明，飞驰而去。", + + # 短句补充篇 + "正月十二，搭灯迎福。", + "元宵预热，期待满满。", + "心有明灯，前途光明。", + "张灯结彩，喜气洋洋。", + "十二吉祥，圆圆满满。", + "筹备元宵，福气先行。", + "灯火可亲，未来可期。", + "马年十二，光明将至。", + "搭起灯棚，点亮希望。", + "喜迎元宵，万事顺遂。" + ], + + # ============================================== + # 2026年3月1日 正月十三 (试灯/赏花灯) + # 核心：试灯、璀璨、浪漫、初亮 + # ============================================== + date(2026, 3, 1): [ + # 试灯初亮篇 + "正月十三，试灯初亮。愿这一抹光，温暖整个春天。", + "灯火试明，幸福先行。愿元宵之夜，璀璨夺目。", + "十三试灯，点亮街头。愿这世界，五彩斑斓。", + "试灯的夜晚，星光与灯光交相辉映。", + "正月十三，灯火初上。愿这光亮，照亮心底的梦想。", + "试灯迎元宵，喜气满人间。愿2026，光彩照人。", + "十三之日，灯火璀璨。愿每一盏灯，都藏着美好祝福。", + "试灯啦！愿马年的夜晚，不再孤单。", + "正月十三，愿灯光驱散寒意，带来温暖。", + "灯火初亮，希望初升。愿未来的日子，一片光明。", + + # 璀璨浪漫篇 + "正月十三，灯火璀璨。愿生活如灯，五彩斑斓。", + "试灯之夜，浪漫无边。愿遇见美好，遇见爱。", + "灯火万家城四畔，星河一道水中央。十三之夜，美不胜收。", + "正月十三，愿这璀璨的灯火，照亮浪漫的人生。", + "灯光摇曳，人影婆娑。愿这一夜，温柔又美好。", + "十三试灯，愿所有的浪漫，都恰逢其时。", + "璀璨灯火，映照笑脸。愿马年的每一天，都灿烂如花。", + "正月十三，愿在灯火阑珊处，遇见那个对的人。", + "浪漫之夜，灯火可亲。愿幸福绵长，岁月静好。", + "试灯初亮，浪漫开场。愿2026，不负韶华。", + + # 期盼圆满篇 + "正月十三，期盼圆满。愿元宵之夜，月圆人圆事事圆。", + "试灯是序曲，元宵是高潮。愿精彩值得等待。", + "十三这一天，为圆满做最后的准备。", + "期盼那一碗汤圆，期盼那一夜团圆。", + "正月十三，愿所有的等待，都不负期待。", + "试灯之时，许下心愿：愿2026，圆圆满满。", + "期盼元宵，期盼美好。愿马年的第一个月圆，圆满无缺。", + "正月十三，愿这份期盼，化作甜蜜的果实。", + "灯火试明，圆满将至。愿幸福如约而至。", + "十三之日，愿所有的梦想，都圆满落地。", + + # 短句补充篇 + "正月十三，试灯纳福。", + "灯火璀璨，浪漫无边。", + "试灯初亮，希望在前。", + "十三吉祥，圆满可期。", + "璀璨灯火，照亮前程。", + "喜迎元宵，万事胜意。", + "试灯之夜，幸福相伴。", + "马年十三，光彩照人。", + "灯火可亲，岁月温柔。", + "期盼圆满，福满人间。" + ], + + # ============================================== + # 2026年3月2日 正月十四 (元宵前夕/月色) + # 核心：待圆、酝酿、惜别、倒数 + # ============================================== + date(2026, 3, 2): [ + # 待圆酝酿篇 + "正月十四，待圆之时。所有的美好，都在悄然酝酿。", + "月圆前夜，幸福将至。愿明天的团圆，圆满无缺。", + "十四这一天，静候月圆。愿所有的期待，都开花结果。", + "美好在酝酿，幸福在靠近。正月十四，满怀希望。", + "元宵前夕，蓄势待发。愿明天的烟火，惊艳时光。", + "十四之夜，月色渐浓。愿这温柔的夜，孕育美好的明天。", + "待圆之日，心怀期盼。愿2026，事事圆满。", + "正月十四，愿所有的遗憾，都在明天圆满。", + "酝酿已久的幸福，即将在明天绽放。", + "十四这一天，愿耐心等待，收获圆满。", + + # 月色温柔篇 + "正月十四，月色温柔。愿这一夜的月光，照亮心底的柔软。", + "月圆前夜，月色撩人。愿这温柔的光，伴你入梦。", + "十四之夜，月光如水。愿岁月静好，现世安稳。", + "月色朦胧，情意绵绵。愿这一夜，浪漫又安宁。", + "正月十四，愿月光指引，找到回家的路。", + "月光洒在身上，幸福藏在心里。", + "十四的月亮，虽未圆满，却已温柔。", + "愿这月色，洗去一身疲惫，带来满心欢喜。", + "正月十四，月色相伴，幸福相随。", + "月光所至，皆是美好。愿马年的夜晚，月色常明。", + + # 惜别新春篇 + "正月十四，惜别新春。愿这份年味，永驻心间。", + "春节的最后倒计时，珍惜最后的热闹。", + "十四这一天，是春节的尾声，也是元宵的序曲。", + "惜别新春，迎接元宵。愿美好延续，幸福长存。", + "正月十四，愿抓住春节的尾巴，再快乐一次。", + "年味渐淡，情意更浓。愿这份祝福，伴你一整年。", + "惜别旧岁的热闹，迎接新年的安稳。", + "十四之日，愿感恩相遇，珍惜拥有。", + "新春将过，记忆永存。愿2026，温暖常在。", + "正月十四，愿不负新春，不负韶华。", + + # 短句补充篇 + "正月十四，静待月圆。", + "月色温柔，幸福将至。", + "元宵前夕，蓄势待发。", + "惜别新春，迎接圆满。", + "十四吉祥，万事顺遂。", + "美好酝酿，幸福花开。", + "月色撩人，情意绵绵。", + "马年十四，期待满满。", + "静待花开，如愿以偿。", + "福暖元宵，圆满在即。" + ], + + # ============================================== + # 2026年3月3日 正月十五 (元宵节/上元节) + # 核心：团圆、圆满、灯火、收官 + # ============================================== + date(2026, 3, 3): [ + # 圆满团圆篇 + "正月十五，元宵佳节。愿月圆人圆，事事圆满。", + "上元之夜，万家团圆。愿这一轮明月，照亮每一个归人。", + "灯火良宵，鱼龙百戏。愿今宵团圆，岁岁长安。", + "一碗汤圆，一份团圆。愿生活软糯香甜，日子圆圆满满。", + "正月十五，月光所至，皆是团圆。", + "闹元宵，庆团圆。愿所有的思念，都能奔赴相见。", + "马年第一个月圆夜，愿美好与圆满撞个满怀。", + "花好月圆人团圆，福满乾坤春满园。", + "元宵佳节，愿天涯共此时，千里共婵娟。", + "圆满收官，幸福续航。愿这份团圆，延续一整年。", + + # 灯火璀璨篇 + "东风夜放花千树，更吹落，星如雨。上元灯火，璀璨人间。", + "正月十五，花灯如昼。愿这漫天灯火，照亮前行的路。", + "灯火万家，良辰美景。愿身处璀璨，心向光明。", + "赏花灯，猜灯谜。愿元宵之夜，热闹非凡，喜乐无边。", + "灯火阑珊处，美好正发生。愿你遇见惊喜，遇见幸运。", + "上元灯火，映照笑脸。愿2026，光彩夺目，熠熠生辉。", + "今夜灯明，如昼如幻。愿马年的日子，红红火火。", + "一盏花灯，一份祈愿。愿心之所向，光亮通达。", + "烟花绽放，灯火璀璨。愿这一刻的美好，定格成永恒。", + "元宵夜，看花灯。愿生活如灯，五彩斑斓，充满希望。", + + # 喜乐民俗篇 + "正月十五闹元宵，锣鼓喧天春意闹。愿欢声笑语，响彻云霄。", + "吃汤圆，闹元宵。愿团团圆圆，甜甜蜜蜜。", + "猜灯谜，赢好礼。愿智慧与福气，双双入怀。", + "舞龙舞狮，锣鼓喧天。愿马年的运势，气势如虹。", + "踩高跷，划旱船。愿民间喜乐，岁岁相传。", + "元宵佳节，宜欢聚，宜赏灯，宜纳福。", + "捏个汤圆，团团圆圆；挂盏灯笼，亮亮堂堂。", + "上元祈福，百无禁忌。愿所求皆如愿，所行皆坦途。", + "闹元宵，迎福气。愿2026，人气旺，财气旺，运气旺。", + "传统民俗，热闹元宵。愿文化传承，岁月流芳。", + + # 新春收官篇 + "正月十五，新春收官。感谢相遇，期待同行。", + "年味虽淡，情意不减。元宵一过，整装出发。", + "春节的最后一场狂欢，愿不留遗憾，尽兴而归。", + "圆满收官，奔赴新程。愿马年的下半场，更加精彩。", + "以元宵的圆满，开启全年的顺遂。", + "告别新春，迎接春天。愿万物复苏，梦想发芽。", + "正月十五，为春节画上一个完美的句号。", + "收官之夜，许下宏愿。愿2026，马力全开，一往无前。", + "新春已过，奋斗在即。愿不负春光，不负自己。", + "元宵圆满，万事胜意。愿这一年，步履不停，收获满满。", + + # 短句补充篇 + "元宵快乐，圆满吉祥。", + "花好月圆，喜乐安康。", + "灯火万家，幸福中华。", + "上元佳节，福满人间。", + "汤圆甜甜，日子圆圆。", + "闹元宵，迎好运。", + "马年元宵，圆满收官。", + "花灯璀璨，前程似锦。", + "月圆人圆，事事圆满。", + "正月十五，万事亨通。" + ] +} + +lunar_calendar = { + date(2026, 2, 16): "除夕", + date(2026, 2, 17): "正月初一", + date(2026, 2, 18): "正月初二", + date(2026, 2, 19): "正月初三", + date(2026, 2, 20): "正月初四", + date(2026, 2, 21): "正月初五", + date(2026, 2, 22): "正月初六", + date(2026, 2, 23): "正月初七", + date(2026, 2, 24): "正月初八", + date(2026, 2, 25): "正月初九", + date(2026, 2, 26): "正月初十", + date(2026, 2, 27): "正月十一", + date(2026, 2, 28): "正月十二", + date(2026, 3, 1): "正月十三", + date(2026, 3, 2): "正月十四", + date(2026, 3, 3): "正月十五" +} + +def get_lunar_date(gregorian_date): + """ + 根据公历日期获取对应的农历日期 + 参数：gregorian_date - datetime.date 对象 + 返回：str - 农历日期字符串；None - 日期不在农历范围内 + """ + return lunar_calendar.get(gregorian_date, None) + +def get_random_festival_quote(): + """ + 根据当前日期从 SPRING_FESTIVAL_QUOTES 中随机获取一条祝福语 + 返回：str - 随机选中的祝福语；None - 当前日期无对应祝福语 + """ + # 获取当前系统日期（年-月-日） + today = date.today() + + # 1. 检查当前日期是否在祝福语字典中 + if today in SPRING_FESTIVAL_QUOTES: + # 2. 获取当日的所有祝福语列表 + daily_quotes = SPRING_FESTIVAL_QUOTES[today] + # 3. 随机选择一条祝福语 + random_quote = random.choice(daily_quotes) + return random_quote + else: + # 若当前日期无对应祝福语，返回提示（也可改为返回None） + return f"今日（{today.strftime('%Y年%m月%d日')}）暂无专属春节祝福语" + +# 测试调用示例 +if __name__ == "__main__": + quote = get_random_festival_quote() + print(quote) \ No newline at end of file diff --git a/DouYinSparkFlow/utils/config.py b/DouYinSparkFlow/utils/config.py new file mode 100644 index 0000000..44adec6 --- /dev/null +++ b/DouYinSparkFlow/utils/config.py @@ -0,0 +1,260 @@ +import json +import logging +import os +import secrets +import sys +from copy import deepcopy +from enum import Enum +from pathlib import Path + +from utils.logger import setup_logger + + +logger = setup_logger(level=logging.DEBUG) + +DEBUG = False +CONFIGFILE = "config.json" +USERDATAFILE = "usersData.json" +APPSETTINGSFILE = "webui_settings.json" + +DEFAULT_CONFIG = { + "multiTask": True, + "taskCount": 5, + "proxyAddress": "", + "messageTemplate": "【AI续火花】", + "saveDebugArtifacts": False, + "useProtocolSender": True, + "protocolDryRun": False, + "browserSenderAccounts": [], + "sendStrategy": { + "shuffleTargets": True, + "accountStartDelaySecondsMin": 0, + "accountStartDelaySecondsMax": 20, + "messageIntervalSecondsMin": 18, + "messageIntervalSecondsMax": 45, + "messageVariants": [], + }, + "dailySendWindow": { + "enabled": False, + "startHour": 10, + "endHour": 18, + "scheduleIntervalMinutes": 10, + }, + "hitokotoTypes": ["文学", "影视", "诗词", "哲学"], + "happyNewYear": { + "enabled": False, + "messageTemplate": "【[data]|[data_lunar]】\n[API]", + }, +} + +DEFAULT_APP_SETTINGS = { + "admin_username": "admin", + "admin_password_hash": "", + "session_secret": "", + "session_max_age_seconds": 8 * 60 * 60, + "compose_root": "", + "ui_host": "0.0.0.0", + "ui_port": 8787, + "login_poll_interval_seconds": 1, + "ops_log_file": "/var/log/douyin-sparkflow.log", + "proxy_refresh_script": "/opt/douyin-sparkflow/refresh_proxy.sh", + "local_login_helper_url": "http://127.0.0.1:18765", + "login_desktop_api_url": "http://127.0.0.1:18090", + "server_host": "", + "server_username": "", + "server_password": "", +} + +config = None +userData = None +appSettings = None + + +class Environment(Enum): + GITHUBACTION = "GITHUB_ACTION" + LOCAL = "LOCAL" + PACKED = "PACKED" + + def __str__(self): + return self.value + + +def get_environment(): + if getattr(sys, "frozen", False) and hasattr(sys, "_MEIPASS"): + return Environment.PACKED + if os.getenv("GITHUB_ACTIONS") == "true": + return Environment.GITHUBACTION + return Environment.LOCAL + + +def repo_root(): + return Path(__file__).resolve().parents[1] + + +def _runtime_root(): + env = get_environment() + if env == Environment.PACKED: + return Path(sys.executable).resolve().parent + return repo_root() + + +def config_path(): + return _runtime_root() / CONFIGFILE + + +def users_data_path(): + return _runtime_root() / USERDATAFILE + + +def app_settings_path(): + return _runtime_root() / APPSETTINGSFILE + + +def default_compose_root(): + root = repo_root() + parent = root.parent + if (parent / "docker-compose.yml").exists(): + return str(parent) + return str(root) + + +def _merge_defaults(data, defaults): + merged = deepcopy(defaults) + for key, value in data.items(): + if key in merged and isinstance(merged[key], dict) and isinstance(value, dict): + merged[key].update(value) + else: + merged[key] = value + return merged + + +def _load_json_file(path, defaults=None): + if not path.exists(): + if defaults is None: + raise FileNotFoundError(path) + path.write_text(json.dumps(defaults, ensure_ascii=False, indent=2), encoding="utf-8") + return deepcopy(defaults) + + text = path.read_text(encoding="utf-8") + if not text.strip(): + return deepcopy(defaults) if defaults is not None else None + + data = json.loads(text) + if defaults is None: + return data + # _merge_defaults only works with dicts; for list-shaped data + # (e.g. usersData.json) just return the parsed data as-is. + if not isinstance(data, dict) or not isinstance(defaults, dict): + return data + return _merge_defaults(data, defaults) + + +def _save_json_file(path, data): + path.write_text(json.dumps(data, ensure_ascii=False, indent=2), encoding="utf-8") + + +def get_config(force_reload=False): + global config + if config is None or force_reload: + config = _load_json_file(config_path(), DEFAULT_CONFIG) + return deepcopy(config) + + +def save_config(new_config): + global config + config = _merge_defaults(new_config, DEFAULT_CONFIG) + _save_json_file(config_path(), config) + return deepcopy(config) + + +def get_userData(force_reload=False): + global userData + if userData is not None and not force_reload: + return deepcopy(userData) + + env = get_environment() + if env == Environment.GITHUBACTION: + raw = os.getenv("USER_DATA", "") + if not raw: + logger.error("Environment variable USER_DATA is not set") + raise RuntimeError("USER_DATA is required in GITHUB_ACTIONS mode") + userData = json.loads(raw) + else: + userData = _load_json_file(users_data_path(), []) + + return deepcopy(userData) + + +def save_userData(accounts): + global userData + normalized = list(accounts) + userData = normalized + _save_json_file(users_data_path(), normalized) + return deepcopy(userData) + + +def normalize_unique_id(unique_id): + if not unique_id: + return "" + digits = "".join(ch for ch in str(unique_id) if ch.isdigit()) + return digits or str(unique_id).strip() + + +def upsert_user_account(unique_id, username, cookies, targets, extra=None): + unique_id = normalize_unique_id(unique_id) + accounts = get_userData(force_reload=True) + payload = { + "unique_id": unique_id, + "username": username, + "cookies": cookies, + "targets": list(targets), + } + if extra: + payload.update(extra) + + for account in accounts: + if normalize_unique_id(account.get("unique_id")) == unique_id: + if "enabled" not in payload: + payload["enabled"] = account.get("enabled", True) + account.update(payload) + save_userData(accounts) + return payload + + if "enabled" not in payload: + payload["enabled"] = True + accounts.append(payload) + save_userData(accounts) + return payload + + +def delete_user_account(unique_id): + normalized_id = normalize_unique_id(unique_id) + accounts = get_userData(force_reload=True) + remaining = [item for item in accounts if normalize_unique_id(item.get("unique_id")) != normalized_id] + removed = len(accounts) != len(remaining) + if removed: + save_userData(remaining) + return removed + + +def get_app_settings(force_reload=False): + global appSettings + if appSettings is None or force_reload: + appSettings = _load_json_file(app_settings_path(), DEFAULT_APP_SETTINGS) + if not appSettings.get("session_secret"): + appSettings["session_secret"] = secrets.token_urlsafe(32) + if not appSettings.get("compose_root"): + appSettings["compose_root"] = default_compose_root() + _save_json_file(app_settings_path(), appSettings) + return deepcopy(appSettings) + + +def save_app_settings(new_settings): + global appSettings + appSettings = _merge_defaults(new_settings, DEFAULT_APP_SETTINGS) + if not appSettings.get("session_secret"): + appSettings["session_secret"] = secrets.token_urlsafe(32) + if not appSettings.get("compose_root"): + appSettings["compose_root"] = default_compose_root() + _save_json_file(app_settings_path(), appSettings) + return deepcopy(appSettings) diff --git a/DouYinSparkFlow/utils/github_action_config.py b/DouYinSparkFlow/utils/github_action_config.py new file mode 100644 index 0000000..33dd5aa --- /dev/null +++ b/DouYinSparkFlow/utils/github_action_config.py @@ -0,0 +1,49 @@ +import json +from rich.console import Console +from rich.panel import Panel +from utils.config import get_config +import pyperclip + +config = get_config() + +# 初始化 rich 控制台 +console = Console() + + +def compress_users_data(): + # 压缩 usersData.json 内容 + with open("usersData.json", "r", encoding="utf-8") as f: + user_data = json.loads(f.read()) + + return json.dumps(user_data, ensure_ascii=False) + + +def print_github_action_config(): + """ + 打印 GitHub Action 配置表格 + """ + + # 输出前置步骤说明 + steps = ( + "1. 确保已克隆仓库并在仓库的 [bold yellow]Action[/bold yellow] 选项卡下启用 " + "[bold green]DouYin Spark Flow Schedule Run[/bold green]\n" + "2. 在仓库的设置选项卡下的 [bold yellow]Environment[/bold yellow] 配置项中添加 " + "[bold green]user-data[/bold green] 环境，并将下方列出 Secrets 依次添加到该环境的 Secrets 中" + ) + console.print(Panel(steps, title="前置步骤", expand=False, style="bold cyan")) + + secrets = { + "USER_DATA": compress_users_data() + } + if "proxyAddress" in config and config["proxyAddress"]: + secrets["proxyAddress"] = config["proxyAddress"] + + # 打印每个键名和键值 + console.print("\n[bold yellow]Secrets 配置：选中后右击鼠标复制（没有弹出菜单点击鼠标右键就完成复制了！）[/bold yellow]") + + for key, value in secrets.items(): + console.rule(f"[bold cyan]{key}[/bold cyan]") + console.print(f"[green]{value}[/green]\n") + + pyperclip.copy(secrets["USER_DATA"]) + console.print("[bold yellow]提示：[/bold yellow][bold magenta] USER_DATA 的值已自动写入剪贴板（建议直接粘贴，手动复制可能多出空白符导致出错） [/bold magenta]") \ No newline at end of file diff --git a/DouYinSparkFlow/utils/hitokoto.py b/DouYinSparkFlow/utils/hitokoto.py new file mode 100644 index 0000000..b2a76d0 --- /dev/null +++ b/DouYinSparkFlow/utils/hitokoto.py @@ -0,0 +1,48 @@ +import requests +from utils.config import get_config + +hitokotoApi = "https://v1.hitokoto.cn/" + +allHitokotoTypes = { + "动画": "a", + "漫画": "b", + "游戏": "c", + "文学": "d", + "原创": "e", + "来自网络": "f", + "其他": "g", + "影视": "h", + "诗词": "i", + "哲学": "k", + "抖机灵": "l", +} + + +def request_hitokoto(): + """请求一言 API 获取一句话""" + config = get_config() + + api_url = hitokotoApi + + for t in allHitokotoTypes.keys(): + if t in config["hitokotoTypes"]: + if "?" not in api_url: + api_url += "?" + if "c=" in api_url: + api_url += f"&c={allHitokotoTypes[t]}" + else: + api_url += f"c={allHitokotoTypes[t]}" + + try: + response = requests.get(api_url, timeout=10) + response.raise_for_status() + data = response.json() + theFrom = data.get("from") + if theFrom is None or theFrom.strip() == "": + theFrom = "未知来源" + theFromWho = data.get("from_who") + if theFromWho is None or theFromWho.strip() == "": + theFromWho = "未知作者" + return f"{data['hitokoto']} —— {theFrom} ({theFromWho})" + except Exception as e: + return "[error] 无法获取一言内容" diff --git a/DouYinSparkFlow/utils/logger.py b/DouYinSparkFlow/utils/logger.py new file mode 100644 index 0000000..45dbdbc --- /dev/null +++ b/DouYinSparkFlow/utils/logger.py @@ -0,0 +1,54 @@ +import logging +import os +from logging.handlers import RotatingFileHandler + +# 创建 logs 文件夹（如果不存在） +if not os.path.exists("logs"): + os.makedirs("logs") + +# 日志格式 +LOG_FORMAT = "%(asctime)s - %(name)s - %(levelname)s - %(filename)s:%(lineno)d - %(message)s" + +# 日志文件路径 +LOG_FILE = "logs/app.log" + +# 配置日志 +def setup_logger(name="app", level=logging.INFO): + """ + 配置日志记录器 + :param name: 日志记录器名称 + :param level: 日志级别 + :return: 配置好的日志记录器 + """ + logger = logging.getLogger(name) + logger.setLevel(level) + + # 防止重复添加处理器 + if not logger.handlers: + # 控制台日志处理器 + console_handler = logging.StreamHandler() + console_handler.setLevel(level) + console_formatter = logging.Formatter(LOG_FORMAT) + console_handler.setFormatter(console_formatter) + + # 文件日志处理器（带日志轮转） + file_handler = RotatingFileHandler(LOG_FILE, maxBytes=5 * 1024 * 1024, backupCount=3, encoding="utf-8") + file_handler.setLevel(level) + file_formatter = logging.Formatter(LOG_FORMAT) + file_handler.setFormatter(file_formatter) + + # 添加处理器到日志记录器 + logger.addHandler(console_handler) + logger.addHandler(file_handler) + + return logger + + +# 示例：使用日志记录器 +if __name__ == "__main__": + logger = setup_logger(level=logging.DEBUG) + logger.debug("这是一个调试信息") + logger.info("这是一个普通信息") + logger.warning("这是一个警告信息") + logger.error("这是一个错误信息") + logger.critical("这是一个严重错误信息") \ No newline at end of file diff --git a/DouYinSparkFlow/vendor/webdeps/annotated_types-0.7.0-py3-none-any.whl b/DouYinSparkFlow/vendor/webdeps/annotated_types-0.7.0-py3-none-any.whl new file mode 100644 index 0000000000000000000000000000000000000000..319cf66fccec3fa29dbb1c6dad3cf3d01be370de GIT binary patch literal 13643 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

G3J{N~qEFqm~)cYy;E82@`87W*Oa zegR%H!GC~#UMRttb)_Q5h*+)9Pk-twNn^L>ck3O=l&ijcJ4rqL3=a0CpAAkei}98u zhLo5C#K8?UQ)s2>uk)Ph5qg7o;}~kQ&=L~My**8cA5xgFxBQR*lvXNq(ke>-y(OBk`h8p9?P05Pq1!8%%uHP4wiEmu>Gl!(yAZr@ zKKwlXkN5mJvH9gyj;y>yM^%pdgsJBPyk zPk$H=1OOlu>VJxy{_7I{FAtg?wW+8hF_fJvYN-0_{S23+RB(8h2@tR_5|~+&1r{Yq zstwdB)uO6p-XI^J+1hX#&D;sPGE3r}wT`##aO~oGnz`)V7qMf`j=}jd?&FF^7E{^;(b?3+f6{vMqh)r+V%~y}sN+Frs?3YQNb{Mz=KUl10Qm zRm<+zqMc92ypI?4=NR(=;IBn9poT*9cT9H|!bdOBMv3~03_G6ni%f+SnQCjzjg0;2aLam^tG>8@X*sIE9e*D@7p?chzQ7 zd=yc|7oe9XE=clAy6r*yUxH30fhj%wp8&g>26on9$Ui|YCi_PWvgW?V%ck zCkvWZeCS~EJDiuORJVHJl8?jWsVKCr~;TI_g13!D~#PhQ9c?`7|{6>O(>|($u+Y~c4dkbhK zNDF>k*tIV4g+!)ks~-@AO%BGaIz^bUhAi{z8CFW(ty^Ye?DRZiy|Le8A7 z91yhTSMYlKB-u7x`jUE+Wd%Z(?j`ac5Rfg@ebY59!y-o z`hK@eZ{{X)av3Sk))SSqFvSQv_ac#6DhpA%RZ5auF z_0_8uzv}Ku+@pSJsXV=lQv2DgM!%8OJ&tyArp4bz`{?S_;L|YL6BRcZ8-quB=gDTZ z&7Ipyzbh24ud>QsJUaU@)2mS%IW*N(XXT$#udbQNc8C4T5!SX9lphAhOM5u(v}pEf z-w=pzN)6hni2~}y)9%Tdek>b@x)vq&j&N<>DWg^2=+?4V2W4T;C!J7Sylo$mRMNAr z>ijpo)#leik#`A>KFej&dwP35)_F-j17$8mm$d+IKShkR>5Wi@m ziB=7Yu5-)w)K;Zdwa!+*#iU<4VVi3&x^+^v0i z1SUbNKY@PsEDaNkUM%!w6uADwq@P~xo0YRPRX-Ig5TjMl^bN|3Kp$8UYpH>Peor7v zXMh#0$>$%=uPO-)W_}VGOm1$2SA&4b=_9Ahw3`IjwS=Hk!YeY?8Kx& z!wM6s@4TSO8tw_p@@lAOLu)r!>#L}K7d5k0RO$B8&7g6D-erdG@$I9^Izn`Rcw*+* z#$#UyZ|!&Q*8b77oiY=PPBhlR>yY2Z*g=*0%ULxNyl^MXaHbXAi{zK@q?iTe<7td zbQcaII6JT2)vYHn+CAIOuCP+F5-67X>_z<^yN*Z=ORX-el%J?FFf(NH4O`QQ@d;5K(oqo4_z^j(-_2z1+uNMH#AJ%8c$K8enUn5#z z!u$pOtIZ;zXR@jK(hXD;6&n-_{FZnR$|#57V}faKzMi>gqMSl)tUSxSrsZ8c?6cuMu5$l}zsBXlO`HPC1UMQ6l6QwCWNZ5awe4_U()cG^V^ zs9lOLpX_L_bYiJ|Oe{NY88jFylIAx<&I1~zlw;!JxD1))^tOI_XO9xRi>64{w6=# zsI7}n(u{zD^e?x&j!i=UJzp0FU9Am75w7A#WFjp+UA>aNTYm%q6C=e}_!s^?xG3f} zQoy!=-~|P0@h|Yr481VpgIVcw_^xZ`MSxfE^#O>qyZ&ki&FvFv8I0ncgvBZWBx1Lc zSm9iH{V5uJHU

x(wwChdiF|&0+{c{x_aivHyMDOBlpJ3-){# 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

&H4utl8e6b2hm(ku|7 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

qH_>5|r07FCUIuJELX^ZY54NBr-%B+bzAB6VR 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 literal 0 HcmV?d00001 diff --git a/DouYinSparkFlow/vendor/webdeps/click-8.3.1-py3-none-any.whl b/DouYinSparkFlow/vendor/webdeps/click-8.3.1-py3-none-any.whl new file mode 100644 index 0000000000000000000000000000000000000000..f2513adc04a05f113c49d4cc16d9f3a29a46c44d GIT binary patch literal 108274 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%0DQI@;zN$~co*mTY@%fLV(vc!1@)4KF+PV8^v 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]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 XV8H7-000O4C<0GxTzTLb3h;jb!=sUL literal 0 HcmV?d00001 diff --git a/DouYinSparkFlow/vendor/webdeps/colorama-0.4.6-py2.py3-none-any.whl b/DouYinSparkFlow/vendor/webdeps/colorama-0.4.6-py2.py3-none-any.whl new file mode 100644 index 0000000000000000000000000000000000000000..f666ce989f84a46703ead9fa296a74c24e60b590 GIT binary patch literal 25335 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 z zphvecqB^!n(NR?rQMH_aUH2ElyEX*|zUO-mfPd+tVMdnmZjhU#-A#XR zd~CuMQb}Odql`AFTjHn`$0c=Vm`FyeQL&ue#w^-dnzh_80HflE`hSq~*m`pTf4lZ| z57m73_-6+gF)>@oU$wq6?6smc#?8@!bXhi)wG-!%bak>{1tvr{|y_*tkaAxDv z(eBL#8IB%xJK6P`bd{0JYv@#1cj|Fsm#sIeb2L}h7JcH}aYk1MWp3g@ASty@eMEI$ zqu-Sa0jkG_iCdw|UK3dj`=nU4k1r z7SPK%2O8FqgSVb(`mbUK2id75ydycHp<28`PiH?N=>(@9EZ~>6Gko)h;HAtc3`Fo> zl~>NXciFbn>A}Su>$cOmQ46hA`pF7n)N~r>G8D$T)24j-(vK#M?GtrO??Gwmn;6e) z9R@nyF2@Rk`&<_m&4skeYyPP_3V)wBc6JNKSigzM|KM+7`{wtq zsS!Aij!F~)zb_E%mqgUBx4b^iUG+TPaNUu@UZr$&6YigxD|MLc z?^`MUl&6GVAe%a!kBfVpA@Xy5y>elAo}Uc6K``+fQwBlV(?`ctK-c_b2xF?C)*cuI z$qJnd!u(!kE;CMm-_8EhDww1+bn9tVsDwQ90yFqTP8m=KmE-t(^Bd;;-D~^%q>3;4 z_V)L62YiAyW@b1EJF&i8rydcczz<)~RL0i|&7X135g=jTq>9rohmt_ctIbp7lVDSN zQqBdc_cs`2*5johC`LNh*e8(7yQV3d;KB}f&Uh2aX4o?`!LhF(-w+1onge5FT4I)r z%SvN<8{)UOGnGACg9*qAZdf~wvBuG?uzBRf*G{b8Pes>l1WDgOU-BfZnfqVtGq|tX z`(IFY>pBU2zfrxM8C$P-i|?`#?thVKPSQgQzh53~(8CSCU*GQ<5QLC&lr$Msh%o&r zcNVQH)ggYj&l!F{Gx+X%0Q|mtzkL8bB2GnXrx^9XhE;dM_!8*arAkE}bbry@J(|D& z*uXm}9x48E<|x4=q@n#TeirK#b|b3kE3sxAF!Ln2Oj!=HT@E{YHR z2|DiW3uXzP1v&k)I@mXHy_q1rI*U_454gPFk3;hfM1-4OI9Ssl^6USMQV9B7W;QP7 z0{xa#EDIUBcq@tk?*dKd@ROMt+UoOae41fd(LM%a@On^#lyf|1^Q2xWq)&Nga={_l zyJ?LuMo-squCsaIY>Eg?pK1HK%uWFW`Zy;t&gpXGeCnj$3wdN^j5GerIeS&6dT5Ke zJDoQAsBCGPK03QyZCA?J^~a)j;8oM?oEj_99P=6YqfPECejNXbuyl)F&4ACoV)nIc z=1^;OlTV@{&x)7M8D4?%_VRPlqj08l@0}WUpz+vaZdORDRfo;2l(w~}t? zvzimpT5(V?{*I%e32xXXY+75Cb4tArGP1vDC{4ZMof7=XBjLoQRi`vR_DEDY8pqA& z`uTuUd^@C0;gSDcEAU7%oNI4K+F4vTppb|ovy zahli&+ZnccW78U1oqhtLsrE0^*h4mc`Ti~;{CGv^|SM9;G$`7&X1So^Uj^6oHidz zLnYeXv+wwr?QbHP8tk5&qs|yJDq;{om$6khC*yY^4vC7m1kghp&2`Cwm1fyu#wX|A z_2GRI`76ymkFXWjZ`=sBUXVel4eMs`)*yazk%HmJ&EO}4_#}F(zC1i*s}M07987G# zBgA2<$+1=U(FA!&XX)dFfDp9ydeuZ>nX9FenhJgC;FSfYWGtDh*0<}UKp-*8xX?)u zl#QS3$+|UcVXo?>%HpqO&dFFeD9aH?M@BT#h|hgp5>sXb|bGNvp4j$o5hP-fXjIa^(@Pf>|^b&>OSE z-#**C#D?0<-mz4Lhf=hAW=vvA#k8Mrq?6?LI_5C#vxJ{yTFv6h=jAd7U~v1LvFmk6 zN3V!y(goOdWTngK}j+nQJfi!(bMv)*tSJ`)1VN0>bSXNC6RMb-U+jP#ZXwXdMqMDE~ zkW$&>2qzQ8+X+72O64XkY}Hoay$1$@TBIG4zxr_g7jzU7S+@ zt!GtA!PD)HQcPaf(9D_HJi36E7fNah&}Pm=B!n{1*~@jj_!|M;0Rz-B5JdL0i{`>{ znT8mr2sTW~;4B3eZy3PB`2uo@f%1^uQKVbv1BuE+A_1}Niui!QK1P`G&x&9{nU0AT zWHo@E8E{4Y27(Z4(nubx_$E&-;@t`y#hU=xUz4Yg&|Eq$Ghd^d-fv4M*3e!)Uc3tz zeUpm%Bw4>MFn{{$X{aWFgLbtu|80H-4eDvzQupX(lJyYiw=5GsZQN{2z~7pmd6h@mq*5vJjf?#O6|UrBheL zWs9-Ur!e$jtH0P7^z#Ofa+!3(INCw6&~xhxXo+HmKS%q0&2*dH?&+->L7`OY z3h?kf8rN&+j>1=o6mgGR#6%0g%a{oV)zA-ua_tK6QWg2IIyc!LqAfG9U^Lyq%FU6{ z4E-+9^~4_nNNI|@UI)EaxghAg`{H80hi&2qA#r}Pd)i#Du!f=McVEH)0y3I*VUU(e zS@8{nx{^Vs&x$01fxNUSTLX^UK-x3hF@klcDYkrk>u8&HO`0}&Ek|wTb_*y!Zrf}F z_&dLXu|-V;)R!TSwgsOaJYK4KVFyE&a9z=-!_Qb9Tg%Vv5Vw5q4YT1WpB&vjwhgQd zIBjdECUusdq3d&6Ji6*BMXH;tlw&tP_2`55Ca#5D=(38a|QIz_qEkI13M z=ND`JP&2K&i#QM;WaWN2t{pN9@;m4&oXGV+62CH`JDP(Z(c_ZoDnDOuoZ`9ix_izwwa##^!y1jjSA$7tN^^T zfwSR~90AWZz+pRSCsQrQQS7(I;^y_gg^!PEbmysvV+K$ga|e^Byd2!z9OgDI zu1{?oEFC%RZOkkjTr6BTRTQOVU%Zs%cxzs(Iqa|?h}U+;f+G6NA6$oiS>;{8IM1Y$ zVvrcQUr0BO4X=nLBP6-(XJu`*;V|N@Xgxdx5vZO-Ui2LZyCh=&P*MHzYxEXu&+UEt zBYK}hhtXs-u9^xR@|yUbffn9g!8pDbf!Ivo{R>r>CUq@P1 zE9MTzP6?l!fkWV`nv2y$Dyl&385yEF8xn zx6n0lkZTwhcQq?_XNGT1b{CcDm(a32uAWEBKYzt+wnBQ`Tm%QZD*kxZ8gfEJClvnF zmf`zlhxp6AM07;|0r?@;t}09}8Zr}u2~{YlhQ>^w#-WDS^4+Zl;yc5T<6`)w3+BlS z@qYhm;lMp#cZy#`3-#E(J;$OXR%8p-Rx>zjqPsQJQmy>{#fK#7da1>wLbZjA&(C4H zd?GjbeW3&G0w3=Tv5Gct^5SoaAF&%^HXXkydDN~igf+=?W4%U&yG&^+BqAVa8sMZ! z)A4u%({OMrmPTYQ76*NYDtktSnJ+tzCAb>1I)TEqmB+gRY1O*~?5!7$kb=rZ3GWF! z8ntnmY{^7zrDTE*Jj0V83i-V8 z+D7~#pQp)b;IwK@J}xQ+y)7Og*z4mi)%{A$y0WU)_TeL6Sa*G5FapB2Ho7Nk`-}IJ5iftWRN;0KHJbiP^KTJB7~- zr%BJ2Ueyfg^L~?pq+R}@1;@Fu`n1r;DeDBDAgzYVPxwZ)SOsquNp7Yywg9&Fjzyc<>sd}yv)I`oQc$kV6>>5=xfuvWartK zM5Nc&*xmZ(9`4`g8yp<10T@ zS%|bK_P4ioK7yIHwco-2EfdU$o_bttIJhPnI5?{Rl8LIUmZXfNmgJJ&s3T<`aodqG zw*uxX&Hj((1CfQ@ayE*JbNy9sG$p-R!hNxR&ykKWpp9uNgQNDFR z&RMRE#JG6jO6KFikL-OqV=s{rncS_Ghi)%?k3_{tLrWHq4^s<%Y7)yInE2pjpBYeb zr;~`-<{b5Tdyjt|aWVQ5JDbNYl`me-dQL5 zQE2yTCt8u<@a%B5gfgBm27bQ9$qZ`hZ}Oi9IargY(W$4pq7>^IIbe z-Wri%K@MxXlKJVZpnRzzlf~&B_GnA`Hn+}G!yoyOq1#T7i4skUEVbW%1AJV%|P9Yk+22#Bl1sWdZ$YE zMGQH)1ByLtosk!AIrPtX^N&beZOoal`S}!%(}&>jt%5ct&em+QO6)wIOM4pG5jm zeH6Lo2H}T)X4kfu)zY@V8%Zh@eqou5f*qro9{Z6irPj+O$*R>hL&WRuWO?GGlHRDu z-bb%r=40Tv&il`&1XWB#d2Bx#gV8>v$;R{pf0=vADk(4}`jVRJl7=g`VBFwq^n!oW zySvZn89cnC`dn|F=qfdbT~%j7gEgz3`Ir)nS5}*7soaqE6r+|sjYQEfK}Xk3M`E&@*0%aY-MdM>ehEr*)B%F0RtjI!EFs>K>XFZX!be-tC#G%9dOm*4%u{b<0~3@N}X{ z!GH!&#Rgr%fcANQ1OA={Q4cr$id%yHzjl7?`5lA6{8NwE2^v*F-Gb7!15Aw zbgH;s>sYd84b?l$zc)P+<1Hu(maQI|rvul)o}jJu5Im7Qk-}+}(zb#sihcMJGZMZU z0pFaMwMa}p>4o0OLW-WJ3^s6I4L2WYXzL0ltk@X|6lbIfDTL?=Sbb#gdOnh);acXL z*}rnk8_5V#SLGDq*XlL10-wx=UV9vT4z9GD;b1hUkl@-#z;w~U3p&9-X6<45C9^0o zMU{_*dn;ou_YHRJ!S$6zP7fz2SRuB~AjN6;#&A~2+^e~3Hzg7|SOQ;xdvscvv+F0? zx&JDk!kj(vJxF%m*-UbnU~?O(?s7N8e8=3*3Izj2=C!K--jdz|>2dC-f|Il`M?1$K zENn;t>=ztIb(DJ>MfRds5OLUXZadVui>bLX<+`xzTvDdqf&SWMG0maY?KwqNE)|u7 z{9}NlMi-|IpYI08()Yr#B-UD$`k=M63!at@uO?+Td_ifIe#`2^k3AxhfLWtLXksN= z**J$b`wm-smiH#}ee>!?I-Y@)ZjAo(d;?rWU5`g-6>CLuVbAhM^!P?viC2P*A4`_t znBb25{7OX@rK&^nhF^n9x5(ersi6k}DT(1{Zs7a0FQ%^|tCZJua6UWO0S_;mm5gfG z*1~cRFK@d#%nixfn{!|BgQOzWVAK_O6aVOQh?Qn1Y9I^!By0s8UlkELG{%yH^1gpB zM3LQQZhXME5N?q_O44GH&a}pO#bcJv)zJ7f+%iy*e<7AWvLQ$s_4VOAie-EaMpIG| z213oN=IAQB3z9G>?$@n4NgtFRXZ!nlJ3=kGle~sNjR~^@R$_-JQ+^-w)W?U1k3{I< zo+PJCCwXh_wy?Cmt%9_uhfT>nrV=C9uC*?KbaE6jE)Br1sO_(3`@8p%;JQb>EeLP&?!@SKFZAk%^5V@_h}xM#yQDk$tdd(axt4&H7vnD*RZ}e(bMu z;J}6a;;BF?kWvW(C;VqRrP9>E``nkwWJQ(8Ho89eBsBR3cjTScODR_>#Xpr}QpVSLqTG?DuQBj>Kbzrn|QLagV%EavwOZWJ1Gi<`Svs@^; zz`l3{n!1LBSJo&o7l3z&2hoc4C~ zH6p^Hw=2P-P$nxxciem5K=++G3fXmZgLJ2G!Z_AQy>V6io~~ehx(}6FU)o{oMuAn+ zAVeuW-^3sW<#|lKM(;FFp>4OVGu`!Pb^kUQ$4U2kJJC_`njW)Z6o&QL=!~-_Eg8%L z%q&&#P_JC^WB~{L>wUXHn;Z_01T;D%u>RfarenF!n#9@*C#1O=)h2XQe3;Rhc{AT_ zA05>nu&Iw(N`hZHsRhO{49k1IafDA_m%Z4 zdLqF#asrK5jvWlSNf*tZFNmqQLkgH1k~Q?kKhSg}!e5{{*k<=)2)yDB2$^l z$l1}VUUR>dTn;5)=0eC+dP1>c^V%-B&cfMj=KBreXKi))VEbN+IvJ6uxsaZi7fJQQ zC8P_q@7@Bp!s%}4I84(bG;~M_z6hsZRzF9!zNuSH<>TARI+UA znO;8e{yGsg&Stmo0(Ex%GgACn8eFqQUhB9kYL@cvU2W70$C{&I+IMTz7CggPs!e_^ zShUpgh=lG);HU4$2#`xc@`Mn5dEKO>2J)_ce(EtIF{QQ$Z9$<_P3akWnt%6A4(?N1 zTaahk>I)n#{ko_om#PJqH!PAIi{CJQS=R5ZrH5o~BFEu>a!|hSH_I>YB#LCEPAqC|`0c^6c~Z zPyxkYDSNA(&SCWPk=ULZu2vo&e!?4FmDsT$9J8T7VE5jZg)kKIVwc zt{Vyh1y~ww)f=DzjN#;FMa=Mwfp~FCaXrC3nth6n1(77N8u>OPlSBi z{IMiIpE)ivMZ&!-W1%&$i=L&uD%fdbq5skTt~yEaqsROZF4e?ba1|n3|A_#Wzum@X zf(n;6+P}V%Jo68f5ZJ6*!h!2*2q0xqqNwf5b1<0*etBu}jux(x<1kA^Z7}2&N~Ok4 zBD!r*@t738$bQCEpnjYw%C}cfcwh7CxCNxdfGM=E_6qK418bp`#R_OP70tY;iH`6_a#&gw-3N|=wG1Ljg< zmuXB^JU)HG5T>v#MJV}ZhslmFbNd05!lUxurlKve2ukzeD=U0p6JHTV*LI5SHd^4c zz=pnJu>Je$k@=0>_0f7eAQV2K2LB& z@HIW9^zYrKpk84mGmbL^_uMxppGU!*i;rPVZL z-i{9^7H|=TuK5~c&Z;7yMd>|}vrkaC!grOH4JRO$fyb}#E4Hc`%m5GTiCs*)d+3ir z1h}5bZ*z>mCaM$ zze{xak*JI0VHqB#NL+4)rr>a$9XBP+Enu&DiBuyJc+#z{X2l>u?#Je-xKG;qi!@s) zJR#>ipJ~FT4*AK?1Ph9@E?8Fpj(9ptRKaEiy1HiWkK|S|9Q6(BDaM#zjtr!mvx)p1 z`WJPHD|cca7o2PM`O78r83K_4?$p~}DB0c6c^1F#FO4ATzm}mM^wJBex^Q%M;(dXR zn-ETXeGsUL6P#axa1|eUqZB1tZuBGr^@4kN8lAg#SetL8j{31Khw7ocA8(NpsPCsv zNJ=tFV9{QjuTlopUQW-wTaTQC~C_GI1F`WvJ0!Y|Q8(z>z-_YqY(nDdN}kV+vHbqy z(D`#MoxXuSE#uwB+7>D@{+Cpsvp}8%NJUEGoaLMAen zjKFYhQQ_bK`kzZt0J7>I-VUzsOdPB%T>inmUsG^{6mTL2)`vat$5Irar~WT@ClfO} z6Dtej|B}Fi2k?UO+wz~=yWr0Vo*b^8P8Q~W-&MbC8yWGx0K2IH@o%}0{^9E8>cYqW zUwZ!gbnw5D0CpEH?DyRN50k@x&FP=!y#5^&1P}j@GtR%wfc-tp-zTj89R?lYpTqny qef9T9e}BdPcO*^Re~$F~>$ke{!!-HBIe-nP0~{dd_`p#O_x}JyXdZI_ literal 0 HcmV?d00001 diff --git a/DouYinSparkFlow/vendor/webdeps/itsdangerous-2.2.0-py3-none-any.whl b/DouYinSparkFlow/vendor/webdeps/itsdangerous-2.2.0-py3-none-any.whl new file mode 100644 index 0000000000000000000000000000000000000000..359ea0c5d10e319e3d89e13d58423f5b2f18938e GIT binary patch literal 16234 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 z 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 z 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�J+%&;F{54ZcFFD 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 Zx@iI4tia3$8h(>!_z$dI@3Db$007BQcd!5e literal 0 HcmV?d00001 diff --git a/DouYinSparkFlow/vendor/webdeps/markupsafe-3.0.3-cp310-cp310-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl b/DouYinSparkFlow/vendor/webdeps/markupsafe-3.0.3-cp310-cp310-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl new file mode 100644 index 0000000000000000000000000000000000000000..2168cc502e6ea1d5bde9798d0395eb20d0cb8013 GIT binary patch literal 20681 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 literal 0 HcmV?d00001 diff --git a/DouYinSparkFlow/vendor/webdeps/pydantic-2.12.5-py3-none-any.whl b/DouYinSparkFlow/vendor/webdeps/pydantic-2.12.5-py3-none-any.whl new file mode 100644 index 0000000000000000000000000000000000000000..aaaf722d5c2cd7f3f013e591508151f6570bab23 GIT binary patch literal 32768 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

~W;^!hH|a|O%RbL?e2w-d7I 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�q|{g5#RaSkD@J+iHgZ8fKJ#5|=cumM(UL zW45BRmjro9gdhP168uWV$%CgqDm3myP#@SX*n}F~llC=$*TG^6oG9Ea%7 z6fbbtD+g-_acxnCebTH*Ov%g`vuSMKsBNjW*Scg~EdMmqLq^BD@6N>opBEqz@K#li zuZ)hIi^HNJXNVyJM)zD25AD1#;r6TWp^uhQYfX3j?~0=&^_UuqLyDXg&UGt=rTiBF zkhnaWd`*M4pYRNkaod~(K0FVhWN3Vh=qQc3Hg|tNHYI9TpbYdb8{p;Yj(xo<=oJhc zvwpPVHth8Ncd6x@AgLzHx1$%1_UbtG~jIaTh-dJQ#qq7S5dd z0mHXj4hBni?5~-~<8sE?s(*HWUA{c6C*TRX>bBm>l0~^`t{okKrv zv2t{jfY>A8rFmzc3)z&`O@kgIp@u2@%n|Gx=n;BqavLqAW3Ngi@Xj}yx{5&t*Ls54bI-}P z`yI9R@;6fZ7ddA^KQ#R(oQUjJ?{n;}hEb>pG&0x5yxk7{Xmo(0FoUPg{QOL z{Ca&6=D(CNe)mKrXx(Dsiq7^dz5%-!S#mkY@uJRin++oqO1xz@1mBa;MTwWHb5b;j zvH3{vOsJTu<4DE58He=(+^}N;ExNp5HnM}Ty!6Ehwr9^^GSF72L6|RqkHhqFbNZ(b zOlG_eu!d#%)tv&07B7I7n(xWvq4|2y(X`#pj}f60wPlfB-8HR-f75up-frzUSc`_# zXEbHJV$S^YFjKBvR?U#bqt5vs;#0^?Ql`5$@QoEYi^p*4{4Cz1z#un4gLvaItIx;a zTP3l*Hw>;1UHpw-WH5MxLcUmHN2+!UPEYr?Kk0CnxbLvnBsFuF(6>_$Gd;ZthgG3D z&WwPAe^ETmS3(|ze(E_fA?Q(T%)4v*mOpPE&S|@AaPt6vK!qnyKroAyJ#lPsXo2jw zXb8mM`Gw`o>dD~*-D=Wo$YVB$<@#DU3UIes%$)pkk&16Rtff+KH81i_0 zMmav7zn~FE>pP{;^V!O#$X=&9$a$2TLYft=;IQuR0)>->4xY&#mrpTx@DeS*aR$Qx zHJ3|peGr@&tS%WR)3orpzDEE!n|JAMP?nchY+6?ymf;%uGu5$qOG$6ygflY7{0l-e zDy^Bh&*OI=HP(fzqn^!=DhzMLWi0CH=m6}Az=#Z$MO%LW)ck#)veMO5QKhnOA!p3u^w65N^s|(hoU}4_x zw(}o)_y_6t2R7P$5OZ~$(|qZJ4HV0?8EJ7ePOmE)fdjdT`%{r(qxUH#V#-~rD!d>A z=dmN$H4qNTFkYFj+n9EHN&<786zz<&GCp@GJ;x&|GEhMO8jSC_VuN5!&88(b;;nU(`0Fq{fF*LTceStdgHu}5F}`25?yK0Vn6TG zKL=?Z!J3{sKg^H0lrB3MF8a0=YRj7x%D3v#oNyvD&Q~R*q str: + host = request.url.hostname or "127.0.0.1" + scheme = request.url.scheme or "http" + return f"{scheme}://{host}:8788/vnc.html?autoconnect=1&resize=scale&view_only=0" + + +def call_login_desktop(path: str, *, method: str = "GET", payload: dict | None = None, timeout: int = 20) -> dict: + url = f"{login_desktop_api_url()}{path}" + data = None + headers = {} + if payload is not None: + data = json.dumps(payload, ensure_ascii=False).encode("utf-8") + headers["Content-Type"] = "application/json; charset=utf-8" + request = urllib.request.Request(url, method=method, data=data, headers=headers) + try: + with urllib.request.urlopen(request, timeout=timeout) as response: + body = response.read().decode("utf-8", errors="replace") + return json.loads(body) if body.strip() else {} + except urllib.error.HTTPError as exc: + body = exc.read().decode("utf-8", errors="replace") + raise RuntimeError(f"login-desktop API error {exc.code}: {body}") from exc + except urllib.error.URLError as exc: + raise RuntimeError(f"login-desktop unavailable: {exc.reason}") from exc + + +def save_exported_login_result(login_result: dict, *, relogin_unique_id: str = "", display_name: str = "") -> tuple[dict, str]: + unique_id = normalize_unique_id(login_result.get("unique_id")) + username = str(display_name or login_result.get("username") or "").strip() + cookies = list(login_result.get("cookies") or []) + if not unique_id or not username or not cookies: + raise RuntimeError("Exported login result is incomplete") + + accounts = get_userData(force_reload=True) + + if relogin_unique_id: + target = find_account(accounts, relogin_unique_id) + if not target: + raise RuntimeError("Target account not found for relogin") + target["unique_id"] = unique_id + target["username"] = username + target["cookies"] = cookies + target.setdefault("enabled", True) + save_userData(accounts) + return target, "updated" + + existing = find_account(accounts, unique_id) + if existing: + existing["username"] = username + existing["cookies"] = cookies + existing.setdefault("enabled", True) + save_userData(accounts) + return existing, "updated" + + account = upsert_user_account(unique_id, username, cookies, []) + return account, "created" + + +def create_app(): + settings = get_app_settings() + app = FastAPI(title="DouYin Spark Flow Admin") + app.add_middleware( + SessionMiddleware, + secret_key=settings["session_secret"], + max_age=settings["session_max_age_seconds"], + same_site="lax", + https_only=False, + ) + app.mount("/static", StaticFiles(directory=str(STATIC_DIR)), name="static") + DEBUG_ARTIFACTS_DIR.mkdir(parents=True, exist_ok=True) + app.mount("/debug-artifacts", StaticFiles(directory=str(DEBUG_ARTIFACTS_DIR)), name="debug-artifacts") + + @app.exception_handler(Exception) + async def global_exception_handler(request: Request, exc: Exception): + tb = traceback.format_exception(type(exc), exc, exc.__traceback__) + tb_text = "".join(tb) + logger.error("Unhandled exception on %s %s:\n%s", request.method, request.url.path, tb_text) + return PlainTextResponse(f"Internal Server Error\n\n{tb_text}", status_code=500) + + def render_template(request, template_name, context=None, status_code=200): + base_context = context or {} + base_context.update( + { + "request": request, + "current_user": current_user(request), + "csrf_token": csrf_token(request) if current_user(request) else "", + "is_https": is_https_request(request), + "app_settings": get_app_settings(force_reload=True), + "login_desktop_public_url": login_desktop_public_url(request), + } + ) + return templates.TemplateResponse(request, template_name, base_context, status_code=status_code) + + def redirect(path="/", status_code=303): + return RedirectResponse(url=path, status_code=status_code) + + def require_user(request): + if not current_user(request): + return redirect("/login") + return None + + def flash(request, message, level="info"): + request.session["flash"] = {"message": message, "level": level} + + def pop_flash(request): + return request.session.pop("flash", None) + + @app.get("/login", response_class=HTMLResponse) + async def login_page(request: Request): + if current_user(request): + return redirect("/") + return render_template( + request, + "login.html", + { + "flash": pop_flash(request), + "bootstrapped": is_bootstrapped(), + }, + ) + + @app.post("/bootstrap") + async def bootstrap(request: Request): + if is_bootstrapped(): + flash(request, "Admin login is already configured.", "warning") + return redirect("/login") + + form = await request.form() + username = str(form.get("username", "admin")).strip() or "admin" + password = str(form.get("password", "")) + confirm = str(form.get("confirm_password", "")) + if not password or password != confirm: + flash(request, "Password setup failed. Please enter matching passwords.", "error") + return redirect("/login") + + bootstrap_admin_password(password, username=username) + flash(request, "Admin credentials created. Please log in.", "success") + return redirect("/login") + + @app.post("/login") + async def login_action(request: Request): + if not is_bootstrapped(): + flash(request, "Create the admin password first.", "warning") + return redirect("/login") + + form = await request.form() + username = str(form.get("username", "")).strip() + password = str(form.get("password", "")) + settings = get_app_settings(force_reload=True) + if username != settings["admin_username"] or not verify_password(password, settings["admin_password_hash"]): + flash(request, "Invalid username or password.", "error") + return redirect("/login") + + issue_session(request, username) + flash(request, "Signed in successfully.", "success") + return redirect("/") + + @app.post("/logout") + async def logout_action(request: Request): + clear_session(request) + return redirect("/login") + + @app.get("/", response_class=HTMLResponse) + async def dashboard(request: Request): + maybe_redirect = require_user(request) + if maybe_redirect: + return maybe_redirect + + return render_template( + request, + "dashboard.html", + { + "flash": pop_flash(request), + "accounts": get_userData(force_reload=True), + "runtime_config": get_config(force_reload=True), + "ops": get_ops_snapshot(), + }, + ) + + @app.post("/accounts/{unique_id}/update") + async def update_account(request: Request, unique_id: str): + maybe_redirect = require_user(request) + if maybe_redirect: + return maybe_redirect + + form = await request.form() + if not validate_csrf(request, str(form.get("csrf_token", ""))): + return Response("Invalid CSRF token", status_code=403) + + username = str(form.get("username", "")).strip() + targets = extract_targets_from_form(form) + + accounts = get_userData(force_reload=True) + account = find_account(accounts, unique_id) + if account: + account["username"] = username or account.get("username", "") + account["targets"] = targets + account["enabled"] = str(form.get("enabled", "")) == "on" + save_userData(accounts) + flash(request, f"Updated account {account['username']}.", "success") + else: + flash(request, "Account not found.", "error") + + return redirect("/") + + @app.post("/accounts/{unique_id}/toggle-enabled") + async def toggle_account_enabled(request: Request, unique_id: str): + maybe_redirect = require_user(request) + if maybe_redirect: + return maybe_redirect + + form = await request.form() + if not validate_csrf(request, str(form.get("csrf_token", ""))): + return Response("Invalid CSRF token", status_code=403) + + accounts = get_userData(force_reload=True) + account = find_account(accounts, unique_id) + if not account: + flash(request, "Account not found.", "error") + return redirect("/") + + account["enabled"] = not is_account_enabled(account) + save_userData(accounts) + flash( + request, + f"{account.get('username', 'Account')} 已{'启用' if account['enabled'] else '停用'}自动续火花。", + "success", + ) + return redirect("/") + + @app.post("/accounts/{unique_id}/friends/refresh") + async def refresh_account_friend_list(request: Request, unique_id: str): + maybe_redirect = require_user(request) + if maybe_redirect: + return JSONResponse({"error": "Unauthorized"}, status_code=401) + + form = await request.form() + if not validate_csrf(request, str(form.get("csrf_token", ""))): + return JSONResponse({"error": "Invalid CSRF token"}, status_code=403) + + accounts = get_userData(force_reload=True) + account = find_account(accounts, unique_id) + if not account: + return JSONResponse({"error": "Account not found."}, status_code=404) + + try: + friends = await fetch_account_friends(account) + account["friends_cache"] = friends + account["friends_cache_updated_at"] = datetime.now().isoformat(timespec="seconds") + save_userData(accounts) + return JSONResponse( + { + "friends": friends, + "updated_at": account["friends_cache_updated_at"], + "message": f"已刷新 {len(friends)} 个好友", + } + ) + except RuntimeError as exc: + return JSONResponse({"error": str(exc)}, status_code=400) + + @app.post("/accounts/{unique_id}/delete") + async def delete_account(request: Request, unique_id: str): + maybe_redirect = require_user(request) + if maybe_redirect: + return maybe_redirect + + form = await request.form() + if not validate_csrf(request, str(form.get("csrf_token", ""))): + return Response("Invalid CSRF token", status_code=403) + + accounts = get_userData(force_reload=True) + updated_accounts = [item for item in accounts if normalize_unique_id(item.get("unique_id")) != normalize_unique_id(unique_id)] + if len(updated_accounts) != len(accounts): + save_userData(updated_accounts) + flash(request, "Account deleted.", "success") + else: + flash(request, "Account not found.", "error") + return redirect("/") + + @app.post("/config") + async def save_runtime_config(request: Request): + maybe_redirect = require_user(request) + if maybe_redirect: + return maybe_redirect + + form = await request.form() + if not validate_csrf(request, str(form.get("csrf_token", ""))): + return Response("Invalid CSRF token", status_code=403) + + config = get_config(force_reload=True) + if "messageTemplate" in form: + config["messageTemplate"] = str(form.get("messageTemplate", config.get("messageTemplate", ""))) + if "multiTask" in form: + config["multiTask"] = str(form.get("multiTask", "")) == "on" + if "taskCount" in form: + config["taskCount"] = coerce_int(form.get("taskCount", config.get("taskCount", 1)), config.get("taskCount", 1), 1) + if "hitokotoTypes" in form: + raw_types = str(form.get("hitokotoTypes", "")) + config["hitokotoTypes"] = [item.strip() for item in raw_types.replace(",", "\n").splitlines() if item.strip()] + + send_strategy = config.get("sendStrategy", {}) or {} + if "shuffleTargets" in form: + send_strategy["shuffleTargets"] = str(form.get("shuffleTargets", "")) == "on" + if "accountStartDelaySecondsMin" in form: + send_strategy["accountStartDelaySecondsMin"] = coerce_int( + form.get("accountStartDelaySecondsMin", send_strategy.get("accountStartDelaySecondsMin", 0)), + send_strategy.get("accountStartDelaySecondsMin", 0), + 0, + ) + if "accountStartDelaySecondsMax" in form: + send_strategy["accountStartDelaySecondsMax"] = coerce_int( + form.get("accountStartDelaySecondsMax", send_strategy.get("accountStartDelaySecondsMax", 0)), + send_strategy.get("accountStartDelaySecondsMax", 0), + send_strategy.get("accountStartDelaySecondsMin", 0), + ) + if "messageIntervalSecondsMin" in form: + send_strategy["messageIntervalSecondsMin"] = coerce_int( + form.get("messageIntervalSecondsMin", send_strategy.get("messageIntervalSecondsMin", 0)), + send_strategy.get("messageIntervalSecondsMin", 0), + 0, + ) + if "messageIntervalSecondsMax" in form: + send_strategy["messageIntervalSecondsMax"] = coerce_int( + form.get("messageIntervalSecondsMax", send_strategy.get("messageIntervalSecondsMax", 0)), + send_strategy.get("messageIntervalSecondsMax", 0), + send_strategy.get("messageIntervalSecondsMin", 0), + ) + if "messageVariants" in form: + raw_variants = str(form.get("messageVariants", "")) + send_strategy["messageVariants"] = [ + item.strip() for item in raw_variants.replace("\r", "\n").split("\n") if item.strip() + ] + config["sendStrategy"] = send_strategy + + happy_new_year = config.get("happyNewYear", {}) + if "happyNewYearEnabled" in form: + happy_new_year["enabled"] = str(form.get("happyNewYearEnabled", "")) == "on" + if "happyNewYearTemplate" in form: + happy_new_year["messageTemplate"] = str(form.get("happyNewYearTemplate", happy_new_year.get("messageTemplate", ""))) + config["happyNewYear"] = happy_new_year + save_config(config) + + flash(request, "Runtime config saved.", "success") + return redirect("/") + + @app.post("/settings") + async def save_panel_settings(request: Request): + maybe_redirect = require_user(request) + if maybe_redirect: + return maybe_redirect + + form = await request.form() + if not validate_csrf(request, str(form.get("csrf_token", ""))): + return Response("Invalid CSRF token", status_code=403) + + settings = get_app_settings(force_reload=True) + settings["server_host"] = str(form.get("server_host", "")).strip() + settings["server_username"] = str(form.get("server_username", "")).strip() + settings["server_password"] = str(form.get("server_password", "")).strip() + settings["compose_root"] = str(form.get("compose_root", settings.get("compose_root", ""))).strip() + settings["ops_log_file"] = str(form.get("ops_log_file", settings.get("ops_log_file", ""))).strip() + settings["proxy_refresh_script"] = str(form.get("proxy_refresh_script", settings.get("proxy_refresh_script", ""))).strip() + settings["local_login_helper_url"] = str( + form.get("local_login_helper_url", settings.get("local_login_helper_url", "http://127.0.0.1:18765")) + ).strip() + settings["login_desktop_api_url"] = str( + form.get("login_desktop_api_url", settings.get("login_desktop_api_url", "http://127.0.0.1:18090")) + ).strip() + settings["ui_port"] = int(form.get("ui_port", settings.get("ui_port", 8787))) + save_app_settings(settings) + + new_password = str(form.get("new_password", "")) + confirm_password = str(form.get("confirm_password", "")) + if new_password: + if new_password != confirm_password: + flash(request, "Admin password was not updated because the confirmation did not match.", "error") + return redirect("/") + update_admin_password(new_password) + + flash(request, "Panel settings saved.", "success") + return redirect("/") + + @app.post("/ops/run-now") + async def run_now(request: Request): + maybe_redirect = require_user(request) + if maybe_redirect: + return maybe_redirect + + form = await request.form() + if not validate_csrf(request, str(form.get("csrf_token", ""))): + return Response("Invalid CSRF token", status_code=403) + + pid = run_task_now() + if pid == -1: + flash(request, "Task launch failed. Check console logs for Missing Docker or protected log_file path.", "error") + else: + flash(request, f"Triggered a background task run (pid {pid}).", "success") + return redirect("/") + + @app.post("/ops/proxy/refresh") + async def proxy_refresh(request: Request): + maybe_redirect = require_user(request) + if maybe_redirect: + return maybe_redirect + + form = await request.form() + if not validate_csrf(request, str(form.get("csrf_token", ""))): + return Response("Invalid CSRF token", status_code=403) + + refresh_proxy() + flash(request, "Proxy subscription refreshed.", "success") + return redirect("/") + + @app.post("/ops/proxy/restart") + async def proxy_restart(request: Request): + maybe_redirect = require_user(request) + if maybe_redirect: + return maybe_redirect + + form = await request.form() + if not validate_csrf(request, str(form.get("csrf_token", ""))): + return Response("Invalid CSRF token", status_code=403) + + restart_proxy() + flash(request, "Proxy container restarted.", "success") + return redirect("/") + + @app.post("/ops/schedule") + async def save_schedule(request: Request): + maybe_redirect = require_user(request) + if maybe_redirect: + return maybe_redirect + + form = await request.form() + if not validate_csrf(request, str(form.get("csrf_token", ""))): + return Response("Invalid CSRF token", status_code=403) + + time_string = str(form.get("daily_schedule", "")).strip() + result = update_daily_schedule(time_string) + if getattr(result, "returncode", 1) == 0: + flash(request, f"Updated the daily schedule to {time_string}.", "success") + else: + flash(request, f"Failed to update the daily schedule to {time_string}: {getattr(result, 'stderr', '')}", "error") + return redirect("/") + + @app.get("/ops/logs", response_class=HTMLResponse) + async def logs_page(request: Request): + maybe_redirect = require_user(request) + if maybe_redirect: + return maybe_redirect + return render_template( + request, + "logs.html", + { + "flash": pop_flash(request), + "log_tail": read_log_tail(400), + }, + ) + + @app.get("/login-desktop/status") + async def login_desktop_status(request: Request): + maybe_redirect = require_user(request) + if maybe_redirect: + return JSONResponse({"redirect": "/login"}, status_code=401) + try: + payload = call_login_desktop("/status") + payload["public_url"] = login_desktop_public_url(request) + return JSONResponse(payload) + except RuntimeError as exc: + return JSONResponse({"ok": False, "error": str(exc), "public_url": login_desktop_public_url(request)}, status_code=503) + + @app.post("/login-desktop/open") + async def login_desktop_open(request: Request): + maybe_redirect = require_user(request) + if maybe_redirect: + return JSONResponse({"redirect": "/login"}, status_code=401) + form = await request.form() + if not validate_csrf(request, str(form.get("csrf_token", ""))): + return JSONResponse({"ok": False, "error": "Invalid CSRF token"}, status_code=403) + try: + call_login_desktop("/open-login", method="POST", payload={}) + return JSONResponse({"ok": True, "public_url": login_desktop_public_url(request)}) + except RuntimeError as exc: + return JSONResponse({"ok": False, "error": str(exc)}, status_code=503) + + @app.post("/login-desktop/reset") + async def login_desktop_reset(request: Request): + maybe_redirect = require_user(request) + if maybe_redirect: + return JSONResponse({"redirect": "/login"}, status_code=401) + form = await request.form() + if not validate_csrf(request, str(form.get("csrf_token", ""))): + return JSONResponse({"ok": False, "error": "Invalid CSRF token"}, status_code=403) + try: + payload = call_login_desktop("/reset", method="POST", payload={}, timeout=120) + return JSONResponse({"ok": True, "result": payload}) + except RuntimeError as exc: + return JSONResponse({"ok": False, "error": str(exc)}, status_code=503) + + @app.post("/login-desktop/save") + async def login_desktop_save(request: Request): + maybe_redirect = require_user(request) + if maybe_redirect: + return JSONResponse({"redirect": "/login"}, status_code=401) + form = await request.form() + if not validate_csrf(request, str(form.get("csrf_token", ""))): + return JSONResponse({"ok": False, "error": "Invalid CSRF token"}, status_code=403) + + relogin_unique_id = str(form.get("relogin_unique_id", "")).strip() + display_name = str(form.get("display_name", "")).strip() + try: + payload = call_login_desktop("/export", method="POST", payload={}, timeout=30) + if not payload.get("ok"): + raise RuntimeError("login-desktop export did not return ok") + account, action = save_exported_login_result( + payload.get("result", {}), + relogin_unique_id=relogin_unique_id, + display_name=display_name, + ) + return JSONResponse({ + "ok": True, + "action": action, + "account": { + "unique_id": account.get("unique_id"), + "username": account.get("username"), + "enabled": account.get("enabled", True), + }, + }) + except RuntimeError as exc: + return JSONResponse({"ok": False, "error": str(exc)}, status_code=400) + + return app + + +app = create_app() + + +def run_web_app(host=None, port=None): + settings = get_app_settings(force_reload=True) + uvicorn.run( + "webui.app:app", + host=host or settings["ui_host"], + port=port or settings["ui_port"], + reload=False, + ) diff --git a/DouYinSparkFlow/webui/auth.py b/DouYinSparkFlow/webui/auth.py new file mode 100644 index 0000000..5488a75 --- /dev/null +++ b/DouYinSparkFlow/webui/auth.py @@ -0,0 +1,73 @@ +import hashlib +import hmac +import secrets + +from utils.config import get_app_settings, save_app_settings + + +def hash_password(password, salt=None): + salt = salt or secrets.token_hex(16) + digest = hashlib.pbkdf2_hmac("sha256", password.encode("utf-8"), salt.encode("utf-8"), 480000) + return f"pbkdf2_sha256${salt}${digest.hex()}" + + +def verify_password(password, stored_hash): + if not stored_hash or "$" not in stored_hash: + return False + + algorithm, salt, digest = stored_hash.split("$", 2) + if algorithm != "pbkdf2_sha256": + return False + candidate = hash_password(password, salt=salt) + return hmac.compare_digest(candidate, stored_hash) + + +def is_bootstrapped(): + return bool(get_app_settings().get("admin_password_hash")) + + +def bootstrap_admin_password(password, username="admin"): + settings = get_app_settings(force_reload=True) + settings["admin_username"] = username.strip() or "admin" + settings["admin_password_hash"] = hash_password(password) + return save_app_settings(settings) + + +def update_admin_password(password): + settings = get_app_settings(force_reload=True) + settings["admin_password_hash"] = hash_password(password) + return save_app_settings(settings) + + +def issue_session(request, username): + request.session.clear() + request.session["user"] = username + request.session["csrf_token"] = secrets.token_urlsafe(24) + + +def clear_session(request): + request.session.clear() + + +def current_user(request): + return request.session.get("user") + + +def csrf_token(request): + token = request.session.get("csrf_token") + if not token: + token = secrets.token_urlsafe(24) + request.session["csrf_token"] = token + return token + + +def validate_csrf(request, submitted_token): + stored_token = request.session.get("csrf_token") + return bool(stored_token and submitted_token and hmac.compare_digest(stored_token, submitted_token)) + + +def is_https_request(request): + forwarded_proto = request.headers.get("x-forwarded-proto", "") + if forwarded_proto: + return forwarded_proto.lower() == "https" + return request.url.scheme == "https" diff --git a/DouYinSparkFlow/webui/login_sessions.py b/DouYinSparkFlow/webui/login_sessions.py new file mode 100644 index 0000000..c83ccc4 --- /dev/null +++ b/DouYinSparkFlow/webui/login_sessions.py @@ -0,0 +1,1275 @@ +import asyncio + +import contextlib + +import math + +import secrets + +from dataclasses import asdict, dataclass, field + +from datetime import datetime + +from pathlib import Path + + + +from core.browser import get_browser + +from core.login import XPATHS, collect_login_result + +from utils.config import ( + get_app_settings, + get_userData, + normalize_unique_id, + repo_root, + save_userData, + upsert_user_account, +) +import logging + +import traceback + + + +logger = logging.getLogger(__name__) + + + +@dataclass + +class LoginSessionState: + session_id: str + + status: str = "idle" + + message: str = "" + + created_at: str = field(default_factory=lambda: datetime.now().isoformat(timespec="seconds")) + + updated_at: str = field(default_factory=lambda: datetime.now().isoformat(timespec="seconds")) + + screenshot_path: str = "" + screenshot_updated_at: str = "" + unique_id: str = "" + username: str = "" + cookies: list = field(default_factory=list) + pending_command: str = field(default=None) + last_command: str = "" + relogin_unique_id: str = "" + relogin_username: str = "" + default_targets: list = field(default_factory=list) + + + def touch(self, status=None, message=None): + + self.updated_at = datetime.now().isoformat(timespec="seconds") + + if status: + + self.status = status + + if message is not None: + + self.message = message + + def mark_screenshot_updated(self): + self.screenshot_updated_at = datetime.now().isoformat(timespec="seconds") + + + + + +class LoginSessionManager: + def __init__(self): + + self._lock = asyncio.Lock() + + self._state = None + + self._task = None + + self._cancel_event = None + + self._background_tasks = set() + + self._artifact_dir = repo_root() / "logs" / "login_sessions" + + self._artifact_dir.mkdir(parents=True, exist_ok=True) + + + + def get_public_state(self): + if not self._state: + + return None + + state = asdict(self._state) + + state["has_cookies"] = bool(self._state.cookies) + state.pop("cookies", None) + return state + + def _find_account_by_unique_id(self, accounts, unique_id): + normalized = normalize_unique_id(unique_id) + for account in accounts: + if normalize_unique_id(account.get("unique_id")) == normalized: + return account + return None + + + async def send_command(self, cmd: str): + + async with self._lock: + + if self._state: + logger.info("Queued login session command for %s: %s", self._state.session_id, cmd) + + self._state.pending_command = cmd + self._state.last_command = str(cmd or "").strip() + normalized_cmd = self._normalize_code_command(cmd) + if normalized_cmd.startswith("click:"): + display = normalized_cmd.split(":", 1)[1].strip() or normalized_cmd + self._state.touch(message=f"已提交命令：{display}，等待远端页面执行…") + else: + self._state.touch(status="submitting_code", message="验证码已提交到远端浏览器，正在输入并验证…") + + + + def _session_screenshot_path(self, session_id): + return self._artifact_dir / f"{session_id}.png" + + async def _capture_login_screenshot(self, page, screenshot_path, prefer_verification=False): + verification_selectors = [ + ".pc-login-verification-modal", + ".semi-modal-content", + ".semi-modal", + 'div[role="dialog"]', + ] + qr_selectors = [ + ".login-img-code-wrapper", + 'div[class*="qrcode"]', + "canvas", + ".login-mask", + ".login-guide-container", + ] + selectors = verification_selectors + qr_selectors if prefer_verification else qr_selectors + verification_selectors + best_locator = None + best_area = -1 + for selector in selectors: + locator = page.locator(selector).first + try: + if await locator.count() > 0 and await locator.is_visible(): + box = await locator.bounding_box() + area = (box["width"] * box["height"]) if box else 0 + if area > best_area: + best_area = area + best_locator = (locator, selector) + except Exception: + continue + if best_locator: + locator, selector = best_locator + await locator.scroll_into_view_if_needed() + await locator.screenshot(path=screenshot_path) + return selector + await page.screenshot(path=screenshot_path, full_page=True) + return "page" + + async def _is_verification_step(self, page): + modal_selectors = [ + ".pc-login-verification-modal", + ".semi-modal-content", + ".semi-modal", + 'div[role="dialog"]', + ] + for selector in modal_selectors: + locator = page.locator(selector).first + try: + if await locator.count() > 0 and await locator.is_visible(): + return True + except Exception: + continue + + verification_texts = [ + "身份验证", + "以确保为本人操作", + "短信验证码", + "安全验证", + ] + for text in verification_texts: + locator = page.get_by_text(text, exact=False).first + try: + if await locator.count() > 0 and await locator.is_visible(): + return True + except Exception: + continue + return False + + async def _is_verification_method_selection_step(self, page, scope=None): + actual_scope = scope or page + option_texts = [ + "接收短信验证码", + "手机刷脸验证", + "验证登录密码", + "发送短信验证", + ] + visible_matches = 0 + for text in option_texts: + locator = actual_scope.get_by_text(text, exact=False).first + try: + if await locator.count() > 0 and await locator.is_visible(): + visible_matches += 1 + except Exception: + continue + return visible_matches >= 2 + + async def _enter_sms_verification_flow(self, page, scope, state): + sms_target = await self._find_best_verification_flow_target( + page, + scope, + ["接收短信验证码", "发送短信验证"], + ) + if not sms_target: + return False + + try: + await sms_target.scroll_into_view_if_needed() + await sms_target.click(force=True, timeout=15000) + state.touch(status="awaiting_sms_request", message="已进入短信验证码验证，正在打开发码页面…") + await asyncio.sleep(1.0) + return True + except Exception as exc: + logger.warning("Failed to enter SMS verification flow: %s", exc) + return False + + async def _refresh_expired_qr_if_needed(self, page, state): + refresh_target = await self._find_best_visible_text_target( + page, + page, + ["点击刷新", "刷新", "刷新二维码"], + ) + expired_target = await self._find_best_visible_text_target( + page, + page, + ["二维码失效", "二维码已失效"], + ) + if not refresh_target and not expired_target: + return False + + target = refresh_target or expired_target + try: + await target.scroll_into_view_if_needed() + await target.click(force=True, timeout=10000) + state.touch(message="QR code expired and was refreshed automatically") + await asyncio.sleep(1.5) + return True + except Exception as exc: + logger.warning("Failed to auto-refresh expired QR: %s", exc) + return False + + + def _track_background_task(self, task): + + self._background_tasks.add(task) + + task.add_done_callback(self._background_tasks.discard) + + return task + + + + async def _finish_cancelled_task(self, task, session_id): + + try: + + await asyncio.wait_for(asyncio.shield(task), timeout=5) + + except asyncio.TimeoutError: + + logger.warning("Login session %s did not stop in time; cancelling task", session_id) + + task.cancel() + + with contextlib.suppress(asyncio.CancelledError, Exception): + + await task + + except asyncio.CancelledError: + + raise + + except Exception as exc: + + logger.warning("Login session %s cleanup ended with error: %s", session_id, exc) + + + + async def _resolve_interaction_scope(self, page): + + modal_selectors = [ + + ".pc-login-verification-modal", + + ".semi-modal-content", + + ".semi-modal", + + 'div[role="dialog"]', + + ] + + for selector in modal_selectors: + + modal = page.locator(selector).first + + if await modal.count() > 0 and await modal.is_visible(): + + logger.info("Operating within verification modal scope: %s", selector) + + return modal + + return page + + + + async def _find_first_visible_text_target(self, scope, texts): + + for text in texts: + + candidate = scope.get_by_text(text, exact=False).first + + if await candidate.count() > 0 and await candidate.is_visible(): + + return candidate + + return None + + + + async def _find_first_visible_locator(self, scope, selectors): + + for selector in selectors: + + group = scope.locator(selector) + + count = await group.count() + + for index in range(count): + + candidate = group.nth(index) + + if await candidate.is_visible(): + + return candidate + + return None + + + + async def _find_visible_locators(self, scope, selectors): + + for selector in selectors: + + group = scope.locator(selector) + + count = await group.count() + + visible = [] + + for index in range(count): + + candidate = group.nth(index) + + if await candidate.is_visible(): + + visible.append(candidate) + + if visible: + + return visible + + return [] + + async def _visible_text_snapshot(self, scope, limit=20): + snippets = [] + candidates = await scope.locator("body, div, span, button, label").all() + for candidate in candidates[:200]: + try: + if not await candidate.is_visible(): + continue + text = (await candidate.inner_text()).strip() + if not text: + continue + if text not in snippets: + snippets.append(text[:80]) + if len(snippets) >= limit: + break + except Exception: + continue + return snippets + + def _normalize_code_command(self, cmd): + digits = "".join(ch for ch in str(cmd or "") if ch.isdigit()) + if 4 <= len(digits) <= 8: + return digits + return str(cmd or "").strip() + + async def _find_verification_code_input(self, page, scope=None): + actual_scope = scope or await self._resolve_interaction_scope(page) + return await self._find_best_visible_locator( + page, + actual_scope, + [ + '.semi-input-number input', + 'input[placeholder*="验证码"]', + 'input[class*="code"]', + 'input[name*="code"]', + 'input[inputmode="numeric"]', + 'input[type="tel"]', + 'input[type="number"]', + 'input[type="text"]', + 'textarea', + '[contenteditable="true"]', + '[role="textbox"]', + ], + ) + + async def _read_verification_code_value(self, page, scope=None): + actual_scope = scope or await self._resolve_interaction_scope(page) + digit_inputs = await self._find_visible_locators( + actual_scope, + [ + '.semi-input-number input', + 'input[type="number"]', + 'input[inputmode="numeric"]', + 'input[type="tel"]', + ], + ) + if len(digit_inputs) > 1: + values = [] + for item in digit_inputs: + try: + value = (await item.input_value()).strip() + except Exception: + value = "" + values.append(value) + joined = "".join(values).strip() + if joined: + return joined + + target_input = await self._find_verification_code_input(page, actual_scope) + if not target_input: + return "" + + for reader in ( + lambda: target_input.input_value(), + lambda: target_input.inner_text(), + lambda: target_input.text_content(), + ): + try: + value = (await reader() or "").strip() + if value: + return value + except Exception: + continue + return "" + + async def _click_action_button_dom_fallback(self, page, labels): + return await page.evaluate( + """(buttonLabels) => { + const labels = buttonLabels.map((item) => String(item || "").trim()).filter(Boolean); + const isVisible = (el) => { + const rect = el.getBoundingClientRect(); + const style = window.getComputedStyle(el); + return rect.width > 0 && rect.height > 0 && style.visibility !== "hidden" && style.display !== "none"; + }; + const candidates = Array.from(document.querySelectorAll("*")) + .filter((el) => isVisible(el)) + .map((el) => { + const text = (el.innerText || el.textContent || el.value || "").trim(); + if (!text || !labels.some((label) => text === label || text.includes(label))) { + return null; + } + const rect = el.getBoundingClientRect(); + return { el, text, rect }; + }) + .filter(Boolean) + .sort((left, right) => { + const topDiff = right.rect.top - left.rect.top; + if (Math.abs(topDiff) > 1) return topDiff; + return (right.rect.width * right.rect.height) - (left.rect.width * left.rect.height); + }); + const clickable = (el) => el.closest('button,[role="button"],input[type="button"],input[type="submit"],a,[class*="button"],[class*="btn"]') || el; + if (!candidates.length) { + return { clicked: false, reason: "no-candidate" }; + } + const target = clickable(candidates[0].el); + target.click(); + target.dispatchEvent(new MouseEvent("click", { bubbles: true, cancelable: true })); + return { clicked: true, text: candidates[0].text }; + }""", + labels, + ) + + async def _click_verify_button_if_ready(self, page, scope, state): + code_value = "".join(ch for ch in await self._read_verification_code_value(page, scope) if ch.isdigit()) + if len(code_value) < 4: + return False + + confirm_btn = await self._find_best_visible_action_target( + page, + scope, + ["验证", "确定", "登录", "提交", "下一步"], + ) + if not confirm_btn: + return False + + try: + await confirm_btn.scroll_into_view_if_needed() + await confirm_btn.click(force=True, timeout=10000) + with contextlib.suppress(Exception): + await confirm_btn.evaluate( + """(el) => { + el.click(); + el.dispatchEvent(new MouseEvent("click", { bubbles: true, cancelable: true })); + }""", + ) + with contextlib.suppress(Exception): + dom_click_result = await self._click_action_button_dom_fallback(page, ["验证", "确定", "登录", "提交", "下一步"]) + logger.info("DOM verify-click fallback result: %s", dom_click_result) + with contextlib.suppress(Exception): + await page.keyboard.press("Enter") + state.touch(status="submitting_code", message=f"验证码 {code_value} 已提交，正在验证…") + return True + except Exception as exc: + logger.warning("Failed to click verify button after code entry: %s", exc) + return False + + async def _capture_screenshot_if_due( + self, + page, + state, + *, + prefer_verification=False, + force=False, + min_interval_seconds=2.0, + timing_state=None, + ): + timing_state = timing_state if timing_state is not None else {} + now = asyncio.get_running_loop().time() + last_capture_at = timing_state.get("last_capture_at", 0.0) + if not force and now - last_capture_at < min_interval_seconds: + return False + + await self._capture_login_screenshot( + page, + state.screenshot_path, + prefer_verification=prefer_verification, + ) + timing_state["last_capture_at"] = now + state.mark_screenshot_updated() + return True + + async def _submit_code_command(self, page, scope, cmd, state): + digit_inputs = await self._find_visible_locators( + scope, + [ + '.semi-input-number input', + 'input[type="number"]', + 'input[inputmode="numeric"]', + 'input[type="tel"]', + ], + ) + if len(digit_inputs) >= len(cmd) and len(digit_inputs) > 1: + for index, char in enumerate(cmd): + await digit_inputs[index].focus() + with contextlib.suppress(Exception): + await digit_inputs[index].fill("") + await digit_inputs[index].type(char, delay=50) + + await asyncio.sleep(0.2) + + confirm_btn = await self._find_best_visible_action_target( + page, + scope, + ["验证", "确定", "登录", "提交", "下一步"], + ) + if confirm_btn: + await confirm_btn.click(force=True) + with contextlib.suppress(Exception): + await confirm_btn.click(force=True, timeout=3000) + await page.keyboard.press("Enter") + state.touch(message=f"Submitted code (digits): {cmd}") + return + + target_input = await self._find_best_visible_locator( + page, + scope, + [ + 'input[placeholder*="验证码"]', + 'input[class*="code"]', + 'input[name*="code"]', + 'input[inputmode="numeric"]', + 'input[type="tel"]', + 'input[type="text"]', + 'textarea', + '[contenteditable="true"]', + '[role="textbox"]', + ], + ) + + if target_input: + logger.info("Target input found, typing code: %s", cmd) + await target_input.click(force=True) + with contextlib.suppress(Exception): + await target_input.focus() + with contextlib.suppress(Exception): + await target_input.fill("") + with contextlib.suppress(Exception): + await target_input.press("Control+A") + with contextlib.suppress(Exception): + await target_input.press("Backspace") + try: + await target_input.press_sequentially(cmd, delay=100) + except Exception: + await page.keyboard.type(cmd, delay=100) + else: + logger.warning("No direct code input field found, falling back to keyboard typing") + await page.keyboard.type(cmd, delay=100) + + dom_fallback = await page.evaluate( + """(code) => { + const isVisible = (el) => { + const rect = el.getBoundingClientRect(); + const style = window.getComputedStyle(el); + return rect.width > 0 && rect.height > 0 && style.visibility !== "hidden" && style.display !== "none"; + }; + const fire = (el) => { + el.dispatchEvent(new Event("input", { bubbles: true })); + el.dispatchEvent(new Event("change", { bubbles: true })); + }; + const inputs = Array.from(document.querySelectorAll('input, textarea, [contenteditable="true"], [role="textbox"]')) + .filter(isVisible); + const digitInputs = inputs.filter((el) => { + const type = (el.getAttribute("type") || "").toLowerCase(); + const inputMode = (el.getAttribute("inputmode") || "").toLowerCase(); + return type === "number" || type === "tel" || inputMode === "numeric"; + }); + if (digitInputs.length >= code.length && digitInputs.length > 1) { + for (let i = 0; i < code.length; i += 1) { + const el = digitInputs[i]; + if ("value" in el) { + el.value = code[i]; + } else { + el.textContent = code[i]; + } + fire(el); + } + return { mode: "digit-inputs", count: digitInputs.length }; + } + const target = inputs[0]; + if (!target) { + return { mode: "none", count: 0 }; + } + if ("value" in target) { + target.value = code; + } else { + target.textContent = code; + } + fire(target); + return { mode: "single-input", count: inputs.length }; + }""", + cmd, + ) + logger.info("DOM fallback result for code submit: %s", dom_fallback) + + await asyncio.sleep(0.2) + + confirm_btn = await self._find_best_visible_action_target( + page, + scope, + ["验证", "确定", "登录", "提交", "下一步"], + ) + if confirm_btn: + await confirm_btn.scroll_into_view_if_needed() + await confirm_btn.click(force=True) + with contextlib.suppress(Exception): + await confirm_btn.click(force=True, timeout=3000) + with contextlib.suppress(Exception): + dom_click_result = await self._click_action_button_dom_fallback(page, ["验证", "确定", "登录", "提交", "下一步"]) + logger.info("DOM confirm-click fallback result after code submit: %s", dom_click_result) + await page.keyboard.press("Enter") + state.touch(message=f"Submitted code: {cmd}") + return + + await page.keyboard.press("Enter") + state.touch(message=f"Submitted code (via Enter): {cmd}") + + + + async def _viewport_center(self, page): + + size = getattr(page, "viewport_size", None) or await page.evaluate( + + "() => ({ width: window.innerWidth, height: window.innerHeight })" + + ) + + return size["width"] / 2, size["height"] / 2 + + + + async def _pick_most_central_visible(self, page, candidates): + + if not candidates: + + return None + + center_x, center_y = await self._viewport_center(page) + + best_candidate = None + + best_distance = None + + for candidate in candidates: + + try: + + if not await candidate.is_visible(): + + continue + + box = await candidate.bounding_box() + + if not box: + + continue + + candidate_center_x = box["x"] + box["width"] / 2 + + candidate_center_y = box["y"] + box["height"] / 2 + + distance = math.hypot(candidate_center_x - center_x, candidate_center_y - center_y) + + if best_distance is None or distance < best_distance: + + best_candidate = candidate + + best_distance = distance + + except Exception: + + continue + + return best_candidate + + + + async def _find_best_visible_locator(self, page, scope, selectors): + + search_scopes = [scope] + + if scope is not page: + + search_scopes.append(page) + + + + candidates = [] + + for current_scope in search_scopes: + + for selector in selectors: + + group = current_scope.locator(selector) + + count = await group.count() + + for index in range(count): + + candidates.append(group.nth(index)) + + return await self._pick_most_central_visible(page, candidates) + + + + async def _find_best_visible_text_target(self, page, scope, texts): + + search_scopes = [scope] + + if scope is not page: + + search_scopes.append(page) + + + + candidates = [] + + for current_scope in search_scopes: + + for text in texts: + + group = current_scope.get_by_text(text, exact=False) + + count = await group.count() + + for index in range(count): + + candidates.append(group.nth(index)) + + return await self._pick_most_central_visible(page, candidates) + + async def _find_best_visible_action_target(self, page, scope, texts): + + search_scopes = [scope] + + if scope is not page: + + search_scopes.append(page) + + button_selectors = [ + "button", + '[role="button"]', + 'input[type="button"]', + 'input[type="submit"]', + '[class*="button"]', + '[class*="btn"]', + ] + + candidates = [] + for current_scope in search_scopes: + for selector in button_selectors: + group = current_scope.locator(selector) + count = await group.count() + for index in range(count): + candidate = group.nth(index) + try: + if not await candidate.is_visible(): + continue + text = (await candidate.inner_text()).strip() + except Exception: + text = "" + + if not text: + try: + text = (await candidate.get_attribute("value") or "").strip() + except Exception: + text = "" + + if text and any(keyword in text for keyword in texts): + candidates.append(candidate) + + return await self._pick_most_central_visible(page, candidates) + + async def _find_best_verification_flow_target(self, page, scope, texts): + + action_target = await self._find_best_visible_action_target(page, scope, texts) + if action_target: + return action_target + + selector_candidates = [] + search_scopes = [scope] + if scope is not page: + search_scopes.append(page) + + selectors = [ + '[class*="verify"]', + '[class*="security"]', + '[class*="option"]', + '[class*="item"]', + 'li', + 'div', + ] + + for current_scope in search_scopes: + for selector in selectors: + group = current_scope.locator(selector) + count = await group.count() + for index in range(count): + candidate = group.nth(index) + try: + if not await candidate.is_visible(): + continue + text = (await candidate.inner_text()).strip() + except Exception: + continue + if text and any(keyword in text for keyword in texts): + selector_candidates.append(candidate) + + if selector_candidates: + return await self._pick_most_central_visible(page, selector_candidates) + + return await self._find_best_visible_text_target(page, scope, texts) + + + + async def start(self, relogin_unique_id=None): + async with self._lock: + if self._state and self._state.status in { + "starting", + "awaiting_scan", + "awaiting_sms_request", + "awaiting_code", + "submitting_code", + "authenticated", + }: + return self.get_public_state() + + relogin_account = None + if relogin_unique_id: + relogin_account = self._find_account_by_unique_id( + get_userData(force_reload=True), + relogin_unique_id, + ) + if not relogin_account: + raise RuntimeError("Account not found for relogin") + + session_id = secrets.token_urlsafe(12) + screenshot_path = str(self._session_screenshot_path(session_id)) + self._state = LoginSessionState( + session_id=session_id, + status="starting", + message=( + f"Creating remote relogin session for {relogin_account.get('username', 'unknown')}" + if relogin_account + else "Creating remote login session" + ), + screenshot_path=screenshot_path, + relogin_unique_id=relogin_account.get("unique_id", "") if relogin_account else "", + relogin_username=relogin_account.get("username", "") if relogin_account else "", + default_targets=list(relogin_account.get("targets", [])) if relogin_account else [], + ) + self._cancel_event = asyncio.Event() + self._task = asyncio.create_task(self._run_login_flow(self._state, self._cancel_event)) + return self.get_public_state() + + + async def cancel(self): + + async with self._lock: + + if not self._state: + + return None + + task = self._task + + cancel_event = self._cancel_event + + session_id = self._state.session_id + + + + if cancel_event: + + cancel_event.set() + + + + self._task = None + + self._cancel_event = None + + self._state.touch(status="cancelled", message="已放弃本轮登录，可重新扫码") + + + + if task and not task.done(): + + self._track_background_task(asyncio.create_task(self._finish_cancelled_task(task, session_id))) + + return self.get_public_state() + + + + async def finalize(self, targets, display_name=None): + async with self._lock: + if not self._state or self._state.status != "authenticated": + raise RuntimeError("No authenticated login session is ready to save") + + username = display_name.strip() if display_name else self._state.username + final_targets = [target for target in targets if target] or list(self._state.default_targets) + + if self._state.relogin_unique_id: + accounts = get_userData(force_reload=True) + account = self._find_account_by_unique_id(accounts, self._state.relogin_unique_id) + if account: + account["unique_id"] = self._state.unique_id + account["username"] = username + account["cookies"] = self._state.cookies + account["targets"] = final_targets + save_userData(accounts) + self._state.touch(status="saved", message=f"Updated account {account['username']}") + return account + + account = upsert_user_account( + self._state.unique_id, + username, + self._state.cookies, + final_targets, + ) + self._state.touch(status="saved", message=f"Saved account {account['username']}") + return account + + + async def _run_login_flow(self, state, cancel_event): + + playwright = browser = context = page = None + + try: + + logger.info(f"Setting up login flow for session {state.session_id}") + + state.touch(status="starting", message="Opening Douyin Creator Center") + + playwright, browser = await get_browser(GUI=False) + + context = await browser.new_context( + viewport={"width": 1600, "height": 1200}, + device_scale_factor=2, + ) + page = await context.new_page() + + + state.touch(status="starting", message="Opening Douyin Creator Center") + + await page.goto("https://creator.douyin.com/", wait_until="domcontentloaded", timeout=60000) + + + + await asyncio.sleep(3) + + qr_selectors = [".login-mask", 'div[class*="qrcode"]', "canvas", ".login-img-code-wrapper"] + qr_found = False + + for selector in qr_selectors: + + try: + + await page.wait_for_selector(selector, timeout=5000) + + qr_found = True + + break + + except: + + continue + + + + msg = "Scan the QR code with the Douyin app" if qr_found else "Opening login page (generating QR code...)" + + state.touch(status="awaiting_scan", message=msg) + + screenshot_timing = {} + poll_interval = 0.5 + last_sms_flow_enter_at = 0.0 + + with contextlib.suppress(Exception): + await self._capture_screenshot_if_due( + page, + state, + prefer_verification=False, + force=True, + timing_state=screenshot_timing, + ) + + while not cancel_event.is_set(): + screenshot_force = False + await self._refresh_expired_qr_if_needed(page, state) + + unique_id_locator = page.locator(XPATHS["unique_id"]).first + name_locator = page.locator(XPATHS["name"]).first + + if await unique_id_locator.count() > 0 and await name_locator.count() > 0: + + logger.info("Authentication elements found, finishing login...") + + result = await collect_login_result(page, context, timeout_ms=5000) + + state.unique_id = result["unique_id"] + + state.username = result["username"] + + state.cookies = result["cookies"] + + state.touch(status="authenticated", message=f"Logged in as {state.username}") + + await page.screenshot(path=state.screenshot_path, full_page=True, timeout=15000) + state.mark_screenshot_updated() + + return + + is_verifying = await self._is_verification_step(page) + + if is_verifying: + scope = await self._resolve_interaction_scope(page) + is_selection_step = await self._is_verification_method_selection_step(page, scope) + now = asyncio.get_running_loop().time() + if is_selection_step and now - last_sms_flow_enter_at >= 2.0: + entered = await self._enter_sms_verification_flow(page, scope, state) + if entered: + last_sms_flow_enter_at = now + screenshot_force = True + with contextlib.suppress(Exception): + await self._capture_screenshot_if_due( + page, + state, + prefer_verification=True, + force=True, + min_interval_seconds=0.0, + timing_state=screenshot_timing, + ) + await asyncio.sleep(0.5) + continue + + code_input = await self._find_verification_code_input(page, scope) + if code_input: + if state.status not in {"awaiting_code", "submitting_code"}: + state.touch(status="awaiting_code", message="扫码成功，请输入收到的验证码登录") + screenshot_force = True + elif state.status not in {"awaiting_sms_request", "awaiting_code", "submitting_code"}: + state.touch(status="awaiting_sms_request", message="扫码成功，请先点击获取验证码") + screenshot_force = True + elif state.status not in {"awaiting_scan", "authenticated"}: + state.touch(status="awaiting_scan", message="请先扫码登录，扫码后会进入验证码验证") + screenshot_force = True + + if "/creator-home/" in page.url and state.status != "authenticated": + state.touch(status="submitting_code", message="正在跳转登录结果页面…") + + if state.pending_command: + + cmd = state.pending_command + + state.pending_command = None + + logger.info(f"Executing command for session {state.session_id}: {cmd}") + + scope = page + try: + + scope = await self._resolve_interaction_scope(page) + normalized_cmd = self._normalize_code_command(cmd) + + if normalized_cmd.startswith("click:"): + + text = normalized_cmd.split(":", 1)[1].strip() + + logger.info(f"Trying to click text: {text}") + + found_btn = await self._find_best_verification_flow_target( + + page, + + scope, + + [text, "接收短信验证码", "获取验证码", "重新发送", "重发", "发送验证码"], + + ) + + if found_btn: + + await found_btn.scroll_into_view_if_needed() + + await found_btn.click(timeout=15000, force=True) + + if "接收短信验证码" in text: + state.touch(status="awaiting_sms_request", message="已选择短信验证码验证，正在进入发码页面…") + elif any(keyword in text for keyword in ["验证码", "发送", "重发"]): + state.touch(status="awaiting_code", message="验证码已请求，请输入收到的验证码") + else: + state.touch(message=f"Clicked: {text}") + screenshot_force = True + + else: + + logger.warning(f"No button found with text: {text}") + snapshot = await self._visible_text_snapshot(scope) + state.touch(status="awaiting_sms_request", message=f"Button not found: {text} | visible={snapshot[:6]}") + screenshot_force = True + + else: + + await self._submit_code_command(page, scope, normalized_cmd, state) + state.touch(status="submitting_code", message="验证码已提交，正在完成登录…") + screenshot_force = True + + except Exception as e: + + logger.error(f"Command execution failed: {e}") + + snapshot = await self._visible_text_snapshot(scope) + + state.touch(message=f"Execution failed: {str(e)} | visible={snapshot[:6]}") + screenshot_force = True + + if is_verifying: + scope = await self._resolve_interaction_scope(page) + if state.status in {"awaiting_code", "submitting_code"}: + clicked_verify = await self._click_verify_button_if_ready(page, scope, state) + if clicked_verify: + screenshot_force = True + + try: + + await self._capture_screenshot_if_due( + page, + state, + prefer_verification=bool(is_verifying), + force=screenshot_force, + min_interval_seconds=2.0, + timing_state=screenshot_timing, + ) + except Exception as e: + logger.warning(f"Screenshot attempt failed: {e}") + + await asyncio.sleep(poll_interval) + + + + state.touch(status="cancelled", message="Login session cancelled") + + except Exception as exc: + + logger.error(f"Login session flow failed: {exc}") + + traceback.print_exc() + + state.touch(status="error", message=str(exc)) + + finally: + + logger.info("Closing browser session") + + if page: + + with contextlib.suppress(Exception): + + await page.close() + + if context: + + with contextlib.suppress(Exception): + + await context.close() + + if browser: + + with contextlib.suppress(Exception): + + await browser.close() + + if playwright: + + with contextlib.suppress(Exception): + + await playwright.stop() + + + + + +login_session_manager = LoginSessionManager() + diff --git a/DouYinSparkFlow/webui/ops.py b/DouYinSparkFlow/webui/ops.py new file mode 100644 index 0000000..4dd33d8 --- /dev/null +++ b/DouYinSparkFlow/webui/ops.py @@ -0,0 +1,407 @@ +import json +import logging +import os +import re +import shlex +import subprocess +import sys +from pathlib import Path + +from utils.config import get_app_settings, get_config, repo_root, save_config + +logger = logging.getLogger(__name__) + +TASK_SCHEDULE_MARKERS = ( + "docker compose run --rm task", + "docker compose run --rm douyin", + "main.py --doTask", +) +HOST_CRONTAB_PATH = Path("/host-spool-cron/root") +WINDOWED_SCHEDULE_RE = re.compile(r"^(\d{2}):(\d{2})-(\d{2}):(\d{2})/(\d+)m$", re.IGNORECASE) + + +def running_in_container(): + return Path("/.dockerenv").exists() + + +def compose_root(): + settings = get_app_settings() + raw = settings.get("compose_root") or "" + if raw: + p = Path(raw) + if (p / "docker-compose.yml").exists(): + return p + # Docker-out-of-Docker: the compose file lives on the host at + # /opt/douyin-sparkflow but is not always bind-mounted into /app. + for candidate in [ + Path("/opt/douyin-sparkflow"), + repo_root().parent, + repo_root(), + ]: + if (candidate / "docker-compose.yml").exists(): + return candidate + # Fallback + return Path(raw) if raw else repo_root() + + +def compose_file_path(): + path = compose_root() / "docker-compose.yml" + return path if path.exists() else None + + +def compose_command(*args): + compose_file = compose_file_path() + base = ["docker", "compose"] + if compose_file: + base.extend(["-f", str(compose_file)]) + base.extend(args) + return base + + +def build_task_run_spec(): + if running_in_container(): + return [sys.executable, "main.py", "--doTask"], repo_root() + if compose_file_path(): + return compose_command("run", "--rm", "task"), compose_root() + return [sys.executable, "main.py", "--doTask"], repo_root() + + +def build_scheduled_task_command(): + if running_in_container(): + return ( + "/bin/bash -lc 'container=$(docker ps --format \"{{.Names}}\" | " + "grep -E \"^(douyin-web-hostfix|douyin-web)$\" | head -n 1); " + "[ -n \"$container\" ] && docker exec \"$container\" sh -lc " + "\"cd /app && python main.py --doTask\"'" + ) + if compose_file_path(): + return f"cd {compose_root()} && /usr/bin/docker compose run --rm task" + return f"cd {repo_root()} && {shlex.quote(sys.executable)} main.py --doTask" + + +def run_command(args, cwd=None, timeout=120, check=False): + """Run a command and return the CompletedProcess. + + ``check`` defaults to False so callers can inspect the result without + crashing when the command is unavailable (e.g. docker not installed). + """ + try: + return subprocess.run( + args, + cwd=str(cwd or compose_root()), + check=check, + text=True, + capture_output=True, + timeout=timeout, + ) + except FileNotFoundError: + logger.warning("Command not found: %s", args[0] if args else args) + return _empty_result() + except subprocess.TimeoutExpired: + logger.warning("Command timed out: %s", args) + return _empty_result() + except subprocess.CalledProcessError as exc: + logger.warning("Command failed (rc=%s): %s", exc.returncode, args) + return _empty_result(stderr=exc.stderr or "") + + +def _empty_result(stdout="", stderr=""): + """Return a fake CompletedProcess for graceful degradation.""" + return subprocess.CompletedProcess(args=[], returncode=1, stdout=stdout, stderr=stderr) + + +def run_background_command(args, log_path, cwd=None, env=None): + log_path = Path(log_path) + log_path.parent.mkdir(parents=True, exist_ok=True) + handle = log_path.open("ab") + child_env = os.environ.copy() + if env: + child_env.update(env) + process = subprocess.Popen( + args, + cwd=str(Path(cwd) if cwd else compose_root()), + stdout=handle, + stderr=subprocess.STDOUT, + env=child_env, + ) + handle.close() + return process.pid + + +def get_container_status(): + try: + result = run_command( + [ + "docker", + "ps", + "-a", + "--format", + "{{.Names}}\t{{.Image}}\t{{.Status}}\t{{.State}}\t{{.RunningFor}}\t{{.Labels}}", + ], + timeout=15, + ) + rows = [] + for raw_line in (result.stdout or "").splitlines(): + line = raw_line.strip() + if not line: + continue + parts = line.split("\t", 5) + while len(parts) < 6: + parts.append("") + name, image, status, state, running_for, labels = parts + rows.append( + { + "Names": name, + "Image": image, + "Status": status, + "State": state, + "RunningFor": running_for, + "Labels": labels, + } + ) + return rows + except Exception as exc: + logger.warning("get_container_status failed: %s", exc) + return [] + + +class contextlib_suppress_json: + def __enter__(self): + return self + + def __exit__(self, exc_type, exc, tb): + return exc_type is json.JSONDecodeError + + +def get_task_container_rows(): + try: + rows = get_container_status() + interesting_names = {"douyin-web-hostfix", "douyin-web", "douyin-task"} + return [row for row in rows if row.get("Names") in interesting_names] + except Exception as exc: + logger.warning("get_task_container_rows failed: %s", exc) + return [] + + +def run_task_now(): + try: + log_file = Path(get_app_settings().get("ops_log_file") or "/var/log/douyin-sparkflow.log") + command, cwd = build_task_run_spec() + return run_background_command( + command, + log_file, + cwd=cwd, + env={ + "SPARKFLOW_MANUAL_RUN": "1", + "PYTHONUNBUFFERED": "1", + }, + ) + except Exception as exc: + import traceback + Path("task_error.txt").write_text(traceback.format_exc(), encoding="utf-8") + logger.error("run_task_now failed: %s", exc) + return -1 + + +def refresh_proxy(): + try: + script = Path(get_app_settings().get("proxy_refresh_script") or "") + if script.exists(): + return run_command(["bash", str(script)], timeout=120) + return run_command(compose_command("restart", "proxy"), timeout=120) + except Exception as exc: + logger.error("refresh_proxy failed: %s", exc) + return _empty_result(stderr=str(exc)) + + +def restart_proxy(): + try: + return run_command(compose_command("restart", "proxy"), timeout=120) + except Exception as exc: + logger.error("restart_proxy failed: %s", exc) + return _empty_result(stderr=str(exc)) + + +def read_log_tail(lines=200): + log_path = Path(get_app_settings().get("ops_log_file") or "/var/log/douyin-sparkflow.log") + if not log_path.exists(): + return "" + content = log_path.read_text(encoding="utf-8", errors="replace").splitlines() + return "\n".join(content[-lines:]) + + +def read_crontab(): + if running_in_container() and HOST_CRONTAB_PATH.exists(): + return HOST_CRONTAB_PATH.read_text(encoding="utf-8", errors="replace") + try: + result = subprocess.run(["crontab", "-l"], text=True, capture_output=True, timeout=10) + if result.returncode != 0: + return "" + return result.stdout + except Exception as exc: + logger.warning("read_crontab failed: %s", exc) + return "" + + +def _format_window_schedule(window_config): + return ( + f"{int(window_config['startHour']):02d}:00-" + f"{int(window_config['endHour']):02d}:00/" + f"{int(window_config['scheduleIntervalMinutes'])}m" + ) + + +def parse_schedule_string(time_string): + raw = str(time_string or "").strip() + match = WINDOWED_SCHEDULE_RE.fullmatch(raw) + if match: + start_hour, start_minute, end_hour, end_minute, interval = [int(part) for part in match.groups()] + if start_minute != 0 or end_minute != 0: + raise ValueError("Window schedule must use whole hours, e.g. 10:00-18:00/10m") + if start_hour not in range(24) or end_hour not in range(24) or end_hour <= start_hour: + raise ValueError("Window schedule is out of range") + if interval not in range(1, 60): + raise ValueError("Window schedule interval must be between 1 and 59 minutes") + return { + "mode": "window", + "startHour": start_hour, + "endHour": end_hour, + "scheduleIntervalMinutes": interval, + } + + if not re.fullmatch(r"\d{2}:\d{2}", raw): + raise ValueError("Time must use HH:MM or HH:00-HH:00/10m format") + hour, minute = [int(part) for part in raw.split(":", 1)] + if hour not in range(24) or minute not in range(60): + raise ValueError("Time is out of range") + return {"mode": "fixed", "hour": hour, "minute": minute} + + +def validate_time_string(time_string): + parsed = parse_schedule_string(time_string) + if parsed["mode"] != "fixed": + raise ValueError("Time must use HH:MM format") + return parsed["hour"], parsed["minute"] + + +def replace_douyin_cron_schedule(crontab_text, time_string): + schedule = parse_schedule_string(time_string) + scheduled_command = build_scheduled_task_command() + updated = [] + + for raw_line in crontab_text.splitlines(): + line = raw_line.rstrip("\n") + if any(marker in line for marker in TASK_SCHEDULE_MARKERS): + continue + updated.append(line) + + if schedule["mode"] == "window": + updated.append( + f"*/{schedule['scheduleIntervalMinutes']} {schedule['startHour']}-{schedule['endHour'] - 1} * * * " + f"{scheduled_command} >> /var/log/douyin-sparkflow.log 2>&1" + ) + updated.append( + f"0 {schedule['endHour']} * * * " + f"{scheduled_command} >> /var/log/douyin-sparkflow.log 2>&1" + ) + else: + updated.append( + f"{schedule['minute']} {schedule['hour']} * * * " + f"{scheduled_command} >> /var/log/douyin-sparkflow.log 2>&1" + ) + + normalized = "\n".join(line for line in updated if line.strip()) + if normalized: + normalized += "\n" + return normalized + + +def persist_schedule_config(time_string): + parsed = parse_schedule_string(time_string) + config = get_config(force_reload=True) + window = dict(config.get("dailySendWindow") or {}) + if parsed["mode"] == "window": + window.update( + { + "enabled": True, + "startHour": parsed["startHour"], + "endHour": parsed["endHour"], + "scheduleIntervalMinutes": parsed["scheduleIntervalMinutes"], + } + ) + else: + window.update({"enabled": False}) + config["dailySendWindow"] = window + save_config(config) + + +def update_daily_schedule(time_string): + persist_schedule_config(time_string) + current = read_crontab() + updated = replace_douyin_cron_schedule(current, time_string) + if running_in_container() and HOST_CRONTAB_PATH.parent.exists(): + try: + HOST_CRONTAB_PATH.write_text(updated, encoding="utf-8") + return subprocess.CompletedProcess(args=["write-host-crontab"], returncode=0, stdout="", stderr="") + except Exception as exc: + logger.error("update_daily_schedule failed: %s", exc) + return _empty_result(stderr=str(exc)) + try: + process = subprocess.run(["crontab", "-"], input=updated, text=True, capture_output=True, check=True, timeout=10) + return process + except Exception as exc: + logger.error("update_daily_schedule failed: %s", exc) + return _empty_result(stderr=str(exc)) + + +def current_daily_schedule(): + config = get_config(force_reload=True) + window = dict(config.get("dailySendWindow") or {}) + if window.get("enabled"): + try: + return _format_window_schedule(window) + except Exception: + logger.warning("current_daily_schedule found invalid dailySendWindow=%s", window) + + for line in read_crontab().splitlines(): + if any(marker in line for marker in TASK_SCHEDULE_MARKERS): + parts = line.split(maxsplit=5) + if len(parts) >= 2: + if parts[0].isdigit() and parts[1].isdigit(): + minute = int(parts[0]) + hour = int(parts[1]) + return f"{hour:02d}:{minute:02d}" + return f"{parts[1]}:{parts[0]}" + return "" + + +def _check_image_present(): + """Return True if the douyin-sparkflow:local image exists.""" + try: + result = subprocess.run( + ["docker", "image", "inspect", "douyin-sparkflow:local"], + stdout=subprocess.DEVNULL, + stderr=subprocess.DEVNULL, + timeout=10, + ) + return result.returncode == 0 + except Exception: + return False + + +def get_ops_snapshot(): + """Collect operational metrics for the dashboard. + + Every external call is individually guarded so the dashboard always + renders, even when Docker or crontab are not available. + """ + return { + "compose_root": str(compose_root()), + "compose_file": str(compose_file_path() or ""), + "containers": get_container_status(), + "task_containers": get_task_container_rows(), + "daily_schedule": current_daily_schedule(), + "crontab": read_crontab(), + "log_tail": read_log_tail(120), + "image_present": _check_image_present(), + } diff --git a/DouYinSparkFlow/webui/static/.gitkeep b/DouYinSparkFlow/webui/static/.gitkeep new file mode 100644 index 0000000..8b13789 --- /dev/null +++ b/DouYinSparkFlow/webui/static/.gitkeep @@ -0,0 +1 @@ + diff --git a/DouYinSparkFlow/webui/static/multiPagePlugins.zip b/DouYinSparkFlow/webui/static/multiPagePlugins.zip new file mode 100644 index 0000000000000000000000000000000000000000..64b6e19cb01e65b57503cb546159ac26e4033dc8 GIT binary patch literal 74886 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 literal 0 HcmV?d00001 diff --git a/DouYinSparkFlow/webui/static/multiPagePlugins/README.md b/DouYinSparkFlow/webui/static/multiPagePlugins/README.md new file mode 100644 index 0000000..2afb4cd --- /dev/null +++ b/DouYinSparkFlow/webui/static/multiPagePlugins/README.md @@ -0,0 +1,446 @@ +# Multi-Page Automation + +一个用于批量跑通 ChatGPT OAuth 注册/登录流程的 Chrome 扩展。 + +当前版本基于侧边栏控制，支持单步执行、整套自动执行、停止当前流程、保存常用配置，以及通过 DuckDuckGo / Firefox Relay / Cloudflare Temp Email / QQ / 163 / Inbucket mailbox 协助完成注册邮箱与验证码处理。 + +## 当前能力 + +- 从 VPS 面板自动获取 OpenAI OAuth 授权链接 +- 自动打开 OpenAI 注册页并点击 `Sign up / Register` +- 自动填写邮箱与密码 +- 支持自定义密码；留空时自动生成强密码 +- 自动显示当前使用中的密码，便于后续保存 +- 自动获取注册验证码与登录验证码 +- 支持 `QQ Mail`、`163 Mail`、`Inbucket mailbox` +- 支持从 DuckDuckGo Email Protection 自动生成新的 `@duck.com` 地址 +- 支持从 Firefox Relay 自动创建新的 `@mozmail.com` mask +- 支持从侧边栏配置的 Cloudflare Temp Email admin 页面自动创建新的临时邮箱 +- Step 5 同时兼容两种页面： + - 页面要求填写 `birthday` + - 页面要求填写 `age` +- 支持 `Auto` 多轮运行 +- 支持中途 `Stop` +- Step 8 会自动寻找 OAuth 同意页的“继续”按钮，并通过 Chrome debugger 输入事件发起点击，然后监听本地回调地址 + + +## 环境要求 + +- Chrome 浏览器 +- 打开扩展开发者模式 +- 你自己的 VPS 管理面板，且页面结构与当前脚本适配 +- 至少准备一种验证码接收方式： + - DuckDuckGo `@duck.com` + QQ / 163 / Inbucket 转发 + - 可创建并收信的 Cloudflare Temp Email admin 页面，留空时默认使用 `https://mail.cloudflare.com/admin` + - 手动填写一个可收信邮箱 +- 如果使用 `QQ` / `163` / `Inbucket`，对应页面需要提前能正常打开 + +## 安装 + +1. 打开 `chrome://extensions/` +2. 开启“开发者模式” +3. 点击“加载已解压的扩展程序” +4. 选择本项目目录 +5. 打开扩展侧边栏 + +## 侧边栏配置说明 + +### `VPS` + +你的管理面板 OAuth 页面地址，例如： + +```txt +http(s):///management.html#/oauth +``` + +Step 1 依赖这个地址。Step 9 已改为邮箱资源清理，不再执行 VPS Verify。 + +### `Mail` + +支持三种验证码来源： + +- `163 Mail` +- `QQ Mail` +- `Inbucket` + +说明： + +- `QQ` 和 `163` 用于直接轮询网页邮箱 +- `Inbucket` 通过你在侧边栏里配置的 host 访问 `mailbox` 页面：`https:///m//` + +### `Mailbox` + +仅当 `Mail = Inbucket` 时显示。 + +填写 Inbucket mailbox 名称，例如： + +```txt +tmp-mailbox +``` + +脚本会自动打开： + +```txt +https:///m// +``` + +并且只检索未读邮件： + +- 只匹配 `.message-list-entry.unseen` +- 第 2 次轮询开始会自动点击 mailbox 页面上的刷新按钮 +- 识别到验证码后会尝试删除当前邮件，减少重复命中 + +### `Inbucket` + +仅当 `Mail = Inbucket` 时显示。 + +这里填写 Inbucket host，支持两种格式： + +- `your-inbucket-host` +- `https://your-inbucket-host` + +脚本会自动规范化成 origin 后再拼接 mailbox URL。 + +### `Email` + +Step 3 使用的注册邮箱。 + +来源有三种： + +- 手动粘贴 +- 选择 `duckduckgo` 后点击 `Auto`，从 DuckDuckGo Email Protection 自动获取一个新的 `@duck.com` +- 选择 `cloudflare_temp_email` 后点击 `Auto`，从 `Cloudflare` 输入框对应的 admin 页面自动创建一个新的临时邮箱；留空时默认使用 `https://mail.cloudflare.com/admin` +- 选择 `relay_firefox` 后点击 `Auto`，从 Firefox Relay 自动创建一个新的 `@mozmail.com` mask + +注意： + +- `Auto` 按钮会根据当前 `Email Source` 选择不同提供方 +- `relay_firefox` 模式下，Step 3 会优先自动创建新的 Relay mask +- 如果你使用 Inbucket，它只是验证码收件箱，不会自动生成 Inbucket 地址 + +### `Email Source` + +用于控制 Step 3 的注册邮箱来源： + +- `duckduckgo` +- `cloudflare_temp_email` +- `relay_firefox` + +它和 `Mail` 配置是独立的： + +- `Email Source` 决定注册时用哪个邮箱地址 +- `Mail` 决定 Step 4 / Step 7 去哪里收验证码 + +例外： + +- 当 `Email Source = cloudflare_temp_email` 时，Step 4 / Step 7 会直接回到 `Cloudflare` 输入框对应的 admin 页面收验证码；留空时默认使用 `https://mail.cloudflare.com/admin`，不使用 `Mail` 配置 + +### `Cloudflare` + +仅当 `Email Source = cloudflare_temp_email` 时显示。 + +这里填写 Cloudflare Temp Email admin 页面地址，支持两种格式： + +- `mail.cloudflare.com/admin` +- `https://mail.cloudflare.com/admin` + +行为说明： + +- 留空时默认使用 `https://mail.cloudflare.com/admin` +- 输入缺少协议时，会自动补成 `https://` +- Step 3 / Step 4 / Step 7 都会复用这里的地址 + +### `Password` + +- 留空：自动生成强密码 +- 手动输入：使用你自定义的密码 +- 可通过 `Show / Hide` 按钮切换显示 + +扩展会把本轮实际使用的密码同步回侧边栏，便于查看和复制。 + +### `Auto` + +整套流程自动跑。 + +支持多轮运行，运行次数由右上角数字框决定。 + +## 工作流 + +### 单步模式 + +侧边栏共有 9 个步骤按钮，可逐步执行： + +1. `Get OAuth Link` +2. `Open Signup` +3. `Fill Email / Password` +4. `Get Signup Code` +5. `Fill Name / Birthday` +6. `Login via OAuth` +7. `Get Login Code` +8. `Manual OAuth Confirm` +9. `Cleanup Email` + +### Auto 模式 + +点击右上角 `Auto` 后，后台会按顺序跑完整流程。 + +当前 Auto 逻辑是： + +1. Step 1 获取 VPS OAuth 链接 +2. Step 2 打开 OpenAI 注册页 +3. 按 `Email Source` 尝试自动准备注册邮箱 +4. 如果邮箱自动获取 / 创建失败，暂停并等待你在侧边栏修复后点击 `Continue` +5. 继续执行 Step 3 ~ Step 9 + +也就是说： + +- 如果当前邮箱来源可自动完成，整套流程更接近全自动 +- 如果不能自动获取或创建，Auto 会在邮箱阶段暂停 + +## 详细步骤说明 + +### Step 1: Get OAuth Link + +通过 `content/vps-panel.js`： + +- 打开 VPS OAuth 面板 +- 等待 `Codex OAuth` 卡片出现 +- 点击“登录” +- 读取页面里的授权链接 + +结果会保存到侧边栏的 `OAuth` 字段。 + +### Step 2: Open Signup + +通过 `content/signup-page.js`： + +- 打开授权链接 +- 查找 `Sign up / Register / 创建账户` 按钮 +- 自动点击进入注册流程 + +### Step 3: Fill Email / Password + +- 自动填写邮箱 +- 如页面先要求邮箱，再进入密码页，会自动切页继续填写 +- 使用自定义密码或自动生成密码 +- 提交注册表单 + +当 `Email Source = relay_firefox` 时，后台会在填写前先打开 `https://relay.firefox.com/accounts/profile/` 创建一个新的 mask 邮箱，并自动补一个 `tN` 账户名。 + +当 `Email Source = cloudflare_temp_email` 时，后台会在填写前先打开侧边栏 `Cloudflare` 输入框对应的 admin 页面；如果留空，则默认使用 `https://mail.cloudflare.com/admin`。随后进入 `账号 -> 创建账号`，默认关闭前缀开关，再创建一个新的临时邮箱。 + +实际使用的密码会写入会话状态，并同步到侧边栏显示。 + +### Step 4: Get Signup Code + +默认根据 `Mail` 配置，轮询邮箱并提取 6 位验证码。 + +支持： + +- `content/qq-mail.js` +- `content/mail-163.js` +- `content/inbucket-mail.js` + +邮件匹配规则以以下关键词为主： + +- 发件人：`openai`、`noreply`、`verify`、`auth`、`duckduckgo`、`forward` +- 标题：`verify`、`verification`、`code`、`验证`、`confirm` + +当 `Email Source = cloudflare_temp_email` 时： + +- 不使用 `Mail` +- 直接打开侧边栏 `Cloudflare` 输入框对应的 admin 页面；如果留空，则默认使用 `https://mail.cloudflare.com/admin` +- 通过 `刷新` 轮询当前注册邮箱的验证码邮件 + +### Step 5: Fill Name / Birthday + +随机生成人名与生日。 + +当前脚本支持两种页面结构： + +- 页面要求 `birthday` +- 页面要求 `age` + +如果页面是生日模式，会填写年月日；如果页面上存在 `input[name='age']`，则直接填写年龄。 + +### Step 6: Login via OAuth + +重新打开 OAuth 链接，使用刚注册的账号登录。 + +支持： + +- 邮箱 + 密码登录 +- 提交后进入验证码验证流程 + +### Step 7: Get Login Code + +与 Step 4 类似，但会使用稍微不同的关键词组合去找登录验证码邮件。 + +当 `Email Source = cloudflare_temp_email` 时，仍然走 admin 页轮询，并且只接受时间上能证明晚于 Step 4 的邮件；如果无法证明是更新邮件，会直接失败而不是复用旧验证码。 + +### Step 8: Manual OAuth Confirm + +虽然按钮名称还是 `Manual OAuth Confirm`，但当前代码已经做了自动尝试： + +- 在授权页定位“继续”按钮 +- 等待按钮可点击 +- 获取按钮坐标 +- 通过 Chrome `debugger` 的输入事件点击该按钮 +- 同时监听 `chrome.webNavigation.onBeforeNavigate` +- 一旦捕获本地回调地址，就把结果保存到 `Callback` + +注意： + +- 这一步仍然是最容易因页面变化而失效的一步 +- 如果 120 秒内没有捕获到 localhost 回调，会报错超时 +- README 中的按钮名称沿用了旧文案，但代码行为是“自动尝试点击” + +### Step 9: Cleanup Email + +Step 9 现在用于清理本轮邮箱资源： + +- `duckduckgo`：跳过，不做清理 +- `cloudflare_temp_email`：跳过，不做清理 +- `relay_firefox`：回到 Firefox Relay 页面，删除本轮刚创建的那个 mask 邮箱 + +## Duck 邮箱自动获取 + +通过 `content/duck-mail.js`： + +- 打开 DuckDuckGo Email Protection Autofill 设置页 +- 查找当前私有地址 +- 如需要，点击 `Generate Private Duck Address` +- 读取新的 `@duck.com` 地址 + +这个功能会被： + +- 侧边栏 `Email` 旁边的 `Auto` 按钮使用 +- `Email Source = duckduckgo` 的 `Auto Run` 流程优先尝试使用 + +## Firefox Relay 自动创建 / 删除 + +通过 `content/relay-firefox.js`： + +- 打开 Firefox Relay profile 页面 +- 点击 `Generate new mask` +- 读取新的 `@mozmail.com` 地址 +- 自动设置下一个可用的 `tN` 标签 +- 在 Step 9 删除本轮创建的 mask + +## Cloudflare Temp Email 自动创建 / 收码 + +通过 `content/cloudflare-temp-email.js`： + +- 打开侧边栏 `Cloudflare` 输入框对应的 admin 页面；如果留空，则默认使用 `https://mail.cloudflare.com/admin` +- 在 `账号 -> 创建账号` 默认关闭前缀，再创建新邮箱 +- 从创建成功弹窗里读取邮箱地址和 address id +- 在 `邮件` 页通过 `查询` + `刷新` 轮询目标邮箱 +- 提取 Step 4 / Step 7 需要的 6 位验证码 + +## 停止机制 + +扩展内置了停止当前流程的能力： + +- 侧边栏点击 `Stop` +- Background 会广播 `STOP_FLOW` +- 各 content script 会在等待、轮询、sleep、元素查找中尽量中断 + +适合以下场景： + +- 卡在某一步 +- 邮件迟迟不来 +- 页面结构变化导致等待超时 + +## 状态与数据 + +主要使用 `chrome.storage.session` 保存运行时状态： + +- 当前步骤 +- 每一步状态 +- OAuth 链接 +- 当前邮箱 +- 当前密码 +- localhost 回调地址 +- 账号记录 +- tab 注册信息 +- 自定义设置 + +特点： + +- 浏览器会话级存储 +- 扩展运行期间可在多个步骤之间共享 +- 代码里已启用 `storage.session` 对 content script 的访问 + +## 项目结构 + +```txt +background.js 后台主控，编排 1~9 步、Tab 复用、状态管理 +manifest.json 扩展清单 +data/names.js 随机姓名、生日数据 +content/utils.js 通用工具：等待元素、点击、日志、停止控制 +content/vps-panel.js VPS 面板步骤：Step 1 +content/signup-page.js OpenAI 注册/登录页步骤：Step 2 / 3 / 5 / 6 / 8 +content/duck-mail.js Duck 邮箱自动获取 +shared/cloudflare-temp-email.js Cloudflare Temp Email 纯逻辑辅助 +content/cloudflare-temp-email.js Cloudflare Temp Email 创建 / 轮询 +content/relay-firefox.js Firefox Relay mask 创建 / 删除 +content/qq-mail.js QQ 邮箱验证码轮询 +content/mail-163.js 163 邮箱验证码轮询 +content/inbucket-mail.js Inbucket mailbox 验证码轮询 +sidepanel/ 侧边栏 UI +``` + +## 常见使用建议 + +### 1. 先单步验证，再开 Auto + +推荐先手动跑通一次： + +1. Step 1 +2. Step 2 +3. Step 3 +4. Step 4 + +确认邮箱和验证码链路稳定后，再使用 `Auto`。 + +### 2. Inbucket 建议使用专用 mailbox + +当前 Inbucket 逻辑只看未读邮件，但还是建议： + +- 给脚本准备一个相对独立的 mailbox +- 避免收件箱里混入过多无关邮件 + +### 3. 邮箱自动获取失败时直接手动修复 + +如果 Duck 或 Relay 页面打不开、未登录或按钮变化： + +- 直接在 `Email` 输入框中粘贴邮箱 +- 再继续执行 Step 3 或 Auto Continue + +### 4. Step 8 失败时重点检查 + +- OAuth 同意页 DOM 是否变化 +- “继续”按钮是否变成了别的文案 +- localhost 回调是否真的触发 +- 浏览器是否允许 debugger 附加 + +## 已知限制 + +- Step 8 对页面结构较敏感 +- Duck / Relay 自动获取依赖各自页面真实 DOM +- VPS 面板 DOM 也需要和当前脚本选择器匹配 +- `Auto` 按钮名称和 Step 8 的旧文案还未完全统一，但代码行为以实际实现为准 + +## 调试建议 + +- 打开扩展侧边栏看日志 +- 查看 Service Worker 控制台 +- 查看目标页面的 content script 控制台日志 +- 当某一步频繁失败时，优先检查当前页面选择器是否仍然匹配 + +## 安全说明 + +- 所有状态仅保存在浏览器会话中 +- 没有硬编码你的 VPS 地址、密码或账户 +- 自定义密码只存在当前会话存储中 +- 邮箱和密码会被记录到本轮 `accounts` 中，便于追踪本次运行结果 diff --git a/DouYinSparkFlow/webui/static/multiPagePlugins/background.js b/DouYinSparkFlow/webui/static/multiPagePlugins/background.js new file mode 100644 index 0000000..b5fcfad --- /dev/null +++ b/DouYinSparkFlow/webui/static/multiPagePlugins/background.js @@ -0,0 +1,1767 @@ +// background.js — Service Worker: orchestration, state, tab management, message routing + +importScripts('data/names.js', 'shared/oauth-flow.js', 'shared/email-provider.js'); + +const LOG_PREFIX = '[MultiPage:bg]'; +const DUCK_AUTOFILL_URL = 'https://duckduckgo.com/email/settings/autofill'; +const RELAY_FIREFOX_PROFILE_URL = 'https://relay.firefox.com/accounts/profile/'; +const CLOUDFLARE_TEMP_EMAIL_INJECT_FILES = [ + 'content/utils.js', + 'shared/cloudflare-temp-email.js', + 'content/cloudflare-temp-email.js', +]; +const STOP_ERROR_MESSAGE = 'Flow stopped by user.'; +const HUMAN_STEP_DELAY_MIN = 700; +const HUMAN_STEP_DELAY_MAX = 2200; + +const { + DEFAULT_CLOUDFLARE_TEMP_EMAIL_ADMIN_URL = 'https://mail.cloudflare.com/admin', + EMAIL_PROVIDER_CLOUDFLARE_TEMP_EMAIL = 'cloudflare_temp_email', + EMAIL_PROVIDER_DUCK = 'duckduckgo', + EMAIL_PROVIDER_RELAY_FIREFOX = 'relay_firefox', + getEmailProviderDisplayName = (value) => value === 'relay_firefox' + ? 'Firefox Relay' + : value === 'cloudflare_temp_email' + ? 'Cloudflare Temp Email' + : 'DuckDuckGo', + isCloudflareTempEmailProvider = (value) => value === 'cloudflare_temp_email', + isRelayFirefoxProvider = (value) => value === 'relay_firefox', + normalizeCloudflareTempEmailAdminUrl = (value) => value || DEFAULT_CLOUDFLARE_TEMP_EMAIL_ADMIN_URL, + normalizeEmailProvider = (value) => { + if (value === 'relay_firefox') return 'relay_firefox'; + if (value === 'cloudflare_temp_email') return 'cloudflare_temp_email'; + return 'duckduckgo'; + }, + shouldUseEmailSourceForVerification = (value) => value === 'cloudflare_temp_email', + shouldSkipStep9Cleanup = (value) => value !== 'relay_firefox', +} = globalThis.MultiPageEmailProvider || {}; + +initializeSessionStorageAccess(); + +// ============================================================ +// State Management (chrome.storage.session) +// ============================================================ + +const DEFAULT_STATE = { + currentStep: 0, + stepStatuses: { + 1: 'pending', 2: 'pending', 3: 'pending', 4: 'pending', 5: 'pending', + 6: 'pending', 7: 'pending', 8: 'pending', 9: 'pending', + }, + oauthUrl: null, + email: null, + password: null, + accounts: [], // { email, password, emailProvider, createdAt } + lastEmailTimestamp: null, + localhostUrl: null, + flowStartTime: null, + tabRegistry: {}, + logs: [], + vpsUrl: '', + customPassword: '', + emailProvider: EMAIL_PROVIDER_DUCK, + mailProvider: '163', // 'qq' or '163' + cloudflareTempEmailAdminUrl: '', + inbucketHost: '', + inbucketMailbox: '', + activeCloudflareMailbox: null, + activeRelayMask: null, +}; + +async function getState() { + const state = await chrome.storage.session.get(null); + return { ...DEFAULT_STATE, ...state }; +} + +async function initializeSessionStorageAccess() { + try { + if (chrome.storage?.session?.setAccessLevel) { + await chrome.storage.session.setAccessLevel({ + accessLevel: 'TRUSTED_AND_UNTRUSTED_CONTEXTS', + }); + console.log(LOG_PREFIX, 'Enabled storage.session for content scripts'); + } + } catch (err) { + console.warn(LOG_PREFIX, 'Failed to enable storage.session for content scripts:', err?.message || err); + } +} + +async function setState(updates) { + console.log(LOG_PREFIX, 'storage.set:', JSON.stringify(updates).slice(0, 200)); + await chrome.storage.session.set(updates); +} + +function broadcastDataUpdate(payload) { + chrome.runtime.sendMessage({ + type: 'DATA_UPDATED', + payload, + }).catch(() => {}); +} + +async function setEmailState(email) { + await setState({ email }); + broadcastDataUpdate({ email }); +} + +async function setEmailProviderState(emailProvider) { + const nextProvider = normalizeEmailProvider(emailProvider); + await setState({ emailProvider: nextProvider }); + broadcastDataUpdate({ emailProvider: nextProvider }); +} + +async function setPasswordState(password) { + await setState({ password }); + broadcastDataUpdate({ password }); +} + +async function setActiveRelayMaskState(activeRelayMask) { + await setState({ activeRelayMask: activeRelayMask || null }); +} + +async function setActiveCloudflareMailboxState(activeCloudflareMailbox) { + await setState({ activeCloudflareMailbox: activeCloudflareMailbox || null }); +} + +function getCloudflareTempEmailAdminUrl(state = {}) { + return normalizeCloudflareTempEmailAdminUrl(state.cloudflareTempEmailAdminUrl || ''); +} + +async function resetState() { + console.log(LOG_PREFIX, 'Resetting all state'); + // Preserve settings and persistent data across resets + const prev = await chrome.storage.session.get([ + 'seenCodes', + 'seenInbucketMailIds', + 'accounts', + 'tabRegistry', + 'vpsUrl', + 'customPassword', + 'emailProvider', + 'mailProvider', + 'cloudflareTempEmailAdminUrl', + 'inbucketHost', + 'inbucketMailbox', + ]); + await chrome.storage.session.clear(); + await chrome.storage.session.set({ + ...DEFAULT_STATE, + seenCodes: prev.seenCodes || [], + seenInbucketMailIds: prev.seenInbucketMailIds || [], + accounts: prev.accounts || [], + tabRegistry: prev.tabRegistry || {}, + vpsUrl: prev.vpsUrl || '', + customPassword: prev.customPassword || '', + emailProvider: normalizeEmailProvider(prev.emailProvider), + mailProvider: prev.mailProvider || '163', + cloudflareTempEmailAdminUrl: prev.cloudflareTempEmailAdminUrl || '', + inbucketHost: prev.inbucketHost || '', + inbucketMailbox: prev.inbucketMailbox || '', + }); +} + +/** + * Generate a random password: 14 chars, mix of uppercase, lowercase, digits, symbols. + */ +function generatePassword() { + const upper = 'ABCDEFGHJKLMNPQRSTUVWXYZ'; + const lower = 'abcdefghjkmnpqrstuvwxyz'; + const digits = '23456789'; + const symbols = '!@#$%&*?'; + const all = upper + lower + digits + symbols; + + // Ensure at least one of each type + let pw = ''; + pw += upper[Math.floor(Math.random() * upper.length)]; + pw += lower[Math.floor(Math.random() * lower.length)]; + pw += digits[Math.floor(Math.random() * digits.length)]; + pw += symbols[Math.floor(Math.random() * symbols.length)]; + + // Fill remaining 10 chars + for (let i = 0; i < 10; i++) { + pw += all[Math.floor(Math.random() * all.length)]; + } + + // Shuffle + return pw.split('').sort(() => Math.random() - 0.5).join(''); +} + +// ============================================================ +// Tab Registry +// ============================================================ + +async function getTabRegistry() { + const state = await getState(); + return state.tabRegistry || {}; +} + +async function registerTab(source, tabId) { + const registry = await getTabRegistry(); + registry[source] = { tabId, ready: true }; + await setState({ tabRegistry: registry }); + console.log(LOG_PREFIX, `Tab registered: ${source} -> ${tabId}`); +} + +async function isTabAlive(source) { + const registry = await getTabRegistry(); + const entry = registry[source]; + if (!entry) return false; + try { + await chrome.tabs.get(entry.tabId); + return true; + } catch { + // Tab no longer exists — clean up registry + registry[source] = null; + await setState({ tabRegistry: registry }); + return false; + } +} + +async function getTabId(source) { + const registry = await getTabRegistry(); + return registry[source]?.tabId || null; +} + +// ============================================================ +// Command Queue (for content scripts not yet ready) +// ============================================================ + +const pendingCommands = new Map(); // source -> { message, resolve, reject, timer } + +function queueCommand(source, message, timeout = 15000) { + return new Promise((resolve, reject) => { + const timer = setTimeout(() => { + pendingCommands.delete(source); + const err = `Content script on ${source} did not respond in ${timeout / 1000}s. Try refreshing the tab and retry.`; + console.error(LOG_PREFIX, err); + reject(new Error(err)); + }, timeout); + pendingCommands.set(source, { message, resolve, reject, timer }); + console.log(LOG_PREFIX, `Command queued for ${source} (waiting for ready)`); + }); +} + +function flushCommand(source, tabId) { + const pending = pendingCommands.get(source); + if (pending) { + clearTimeout(pending.timer); + pendingCommands.delete(source); + chrome.tabs.sendMessage(tabId, pending.message).then(pending.resolve).catch(pending.reject); + console.log(LOG_PREFIX, `Flushed queued command to ${source} (tab ${tabId})`); + } +} + +function cancelPendingCommands(reason = STOP_ERROR_MESSAGE) { + for (const [source, pending] of pendingCommands.entries()) { + clearTimeout(pending.timer); + pending.reject(new Error(reason)); + pendingCommands.delete(source); + console.log(LOG_PREFIX, `Cancelled queued command for ${source}`); + } +} + +// ============================================================ +// Reuse or create tab +// ============================================================ + +async function reuseOrCreateTab(source, url, options = {}) { + const alive = await isTabAlive(source); + if (alive) { + const tabId = await getTabId(source); + const currentTab = await chrome.tabs.get(tabId); + const sameUrl = currentTab.url === url; + const shouldReloadOnReuse = sameUrl && options.reloadIfSameUrl; + + const registry = await getTabRegistry(); + if (sameUrl) { + await chrome.tabs.update(tabId, { active: true }); + console.log(LOG_PREFIX, `Reused tab ${source} (${tabId}) on same URL`); + + if (shouldReloadOnReuse) { + if (registry[source]) registry[source].ready = false; + await setState({ tabRegistry: registry }); + await chrome.tabs.reload(tabId); + + await new Promise((resolve) => { + const timer = setTimeout(() => { chrome.tabs.onUpdated.removeListener(listener); resolve(); }, 30000); + const listener = (tid, info) => { + if (tid === tabId && info.status === 'complete') { + chrome.tabs.onUpdated.removeListener(listener); + clearTimeout(timer); + resolve(); + } + }; + chrome.tabs.onUpdated.addListener(listener); + }); + } + + // For dynamically injected pages like the VPS panel, re-inject immediately. + if (options.inject) { + if (registry[source]) registry[source].ready = false; + await setState({ tabRegistry: registry }); + if (options.injectSource) { + await chrome.scripting.executeScript({ + target: { tabId }, + func: (injectedSource) => { + window.__MULTIPAGE_SOURCE = injectedSource; + }, + args: [options.injectSource], + }); + } + await chrome.scripting.executeScript({ + target: { tabId }, + files: options.inject, + }); + await new Promise(r => setTimeout(r, 500)); + } + + return tabId; + } + + // Mark as not ready BEFORE navigating — so READY signal from new page is captured correctly + if (registry[source]) registry[source].ready = false; + await setState({ tabRegistry: registry }); + + // Navigate existing tab to new URL + await chrome.tabs.update(tabId, { url, active: true }); + console.log(LOG_PREFIX, `Reused tab ${source} (${tabId}), navigated to ${url.slice(0, 60)}`); + + // Wait for page load complete (with 30s timeout) + await new Promise((resolve) => { + const timer = setTimeout(() => { chrome.tabs.onUpdated.removeListener(listener); resolve(); }, 30000); + const listener = (tid, info) => { + if (tid === tabId && info.status === 'complete') { + chrome.tabs.onUpdated.removeListener(listener); + clearTimeout(timer); + resolve(); + } + }; + chrome.tabs.onUpdated.addListener(listener); + }); + + // If dynamic injection needed (VPS panel), re-inject after navigation + if (options.inject) { + if (options.injectSource) { + await chrome.scripting.executeScript({ + target: { tabId }, + func: (injectedSource) => { + window.__MULTIPAGE_SOURCE = injectedSource; + }, + args: [options.injectSource], + }); + } + await chrome.scripting.executeScript({ + target: { tabId }, + files: options.inject, + }); + } + + // Wait a bit for content script to inject and send READY + await new Promise(r => setTimeout(r, 500)); + + return tabId; + } + + // Create new tab + const tab = await chrome.tabs.create({ url, active: true }); + console.log(LOG_PREFIX, `Created new tab ${source} (${tab.id})`); + + // If dynamic injection needed (VPS panel), inject scripts after load + if (options.inject) { + await new Promise((resolve) => { + const timer = setTimeout(() => { chrome.tabs.onUpdated.removeListener(listener); resolve(); }, 30000); + const listener = (tabId, info) => { + if (tabId === tab.id && info.status === 'complete') { + chrome.tabs.onUpdated.removeListener(listener); + clearTimeout(timer); + resolve(); + } + }; + chrome.tabs.onUpdated.addListener(listener); + }); + if (options.injectSource) { + await chrome.scripting.executeScript({ + target: { tabId: tab.id }, + func: (injectedSource) => { + window.__MULTIPAGE_SOURCE = injectedSource; + }, + args: [options.injectSource], + }); + } + await chrome.scripting.executeScript({ + target: { tabId: tab.id }, + files: options.inject, + }); + } + + return tab.id; +} + +// ============================================================ +// Send command to content script (with readiness check) +// ============================================================ + +async function sendToContentScript(source, message) { + const registry = await getTabRegistry(); + const entry = registry[source]; + + if (!entry || !entry.ready) { + console.log(LOG_PREFIX, `${source} not ready, queuing command`); + return queueCommand(source, message); + } + + // Verify tab is still alive + const alive = await isTabAlive(source); + if (!alive) { + // Tab was closed — queue the command, it will be sent when tab is reopened + console.log(LOG_PREFIX, `${source} tab was closed, queuing command`); + return queueCommand(source, message); + } + + console.log(LOG_PREFIX, `Sending to ${source} (tab ${entry.tabId}):`, message.type); + return chrome.tabs.sendMessage(entry.tabId, message); +} + +// ============================================================ +// Logging +// ============================================================ + +async function addLog(message, level = 'info') { + const state = await getState(); + const logs = state.logs || []; + const entry = { message, level, timestamp: Date.now() }; + logs.push(entry); + // Keep last 500 logs + if (logs.length > 500) logs.splice(0, logs.length - 500); + await setState({ logs }); + // Broadcast to side panel + chrome.runtime.sendMessage({ type: 'LOG_ENTRY', payload: entry }).catch(() => {}); +} + +async function completeStepFromBackground(step, payload = {}, options = {}) { + const { logMessage = null, logLevel = 'info' } = options; + + if (logMessage) { + await addLog(logMessage, logLevel); + } + + await setStepStatus(step, 'completed'); + await addLog(`Step ${step} completed`, 'ok'); + await handleStepData(step, payload); + notifyStepComplete(step, payload); +} + +async function getSignupPageState() { + const tabId = await getTabId('signup-page'); + if (!tabId) { + return { url: '', hasVisibleContinueButton: false, isConsentPage: false }; + } + + const alive = await isTabAlive('signup-page'); + if (!alive) { + return { url: '', hasVisibleContinueButton: false, isConsentPage: false }; + } + + const tab = await chrome.tabs.get(tabId); + const currentUrl = tab?.url || ''; + if (MultiPageOAuthFlow.isConsentUrl(currentUrl)) { + return { url: currentUrl, hasVisibleContinueButton: false, isConsentPage: true }; + } + + try { + const pageState = await sendToContentScript('signup-page', { + type: 'GET_PAGE_STATE', + source: 'background', + payload: {}, + }); + + return { + url: pageState?.url || currentUrl, + hasVisibleContinueButton: Boolean(pageState?.hasVisibleContinueButton), + isConsentPage: Boolean(pageState?.isConsentPage), + }; + } catch (err) { + console.warn(LOG_PREFIX, 'Consent page state check failed:', err?.message || err); + return { + url: currentUrl, + hasVisibleContinueButton: false, + isConsentPage: false, + }; + } +} + +async function isSignupConsentPageReady() { + const pageState = await getSignupPageState(); + return pageState.isConsentPage; +} + +async function waitForConsentPageAfterStep5(timeoutMs = 12000, pollMs = 300) { + const observedStates = []; + const start = Date.now(); + + while (Date.now() - start < timeoutMs) { + throwIfStopped(); + + const pageState = await getSignupPageState(); + observedStates.push(pageState); + + if (MultiPageOAuthFlow.hasAnyConsentPageState(observedStates)) { + return true; + } + + await sleepWithStop(pollMs); + } + + return false; +} + +async function skipStepBecauseConsentReady(step) { + await completeStepFromBackground(step, { skipped: true, reason: 'consent_ready' }, { + logMessage: `Step ${step} skipped: consent page already ready`, + }); +} + +// ============================================================ +// Step Status Management +// ============================================================ + +async function setStepStatus(step, status) { + const state = await getState(); + const statuses = { ...state.stepStatuses }; + statuses[step] = status; + await setState({ stepStatuses: statuses, currentStep: step }); + // Broadcast to side panel + chrome.runtime.sendMessage({ + type: 'STEP_STATUS_CHANGED', + payload: { step, status }, + }).catch(() => {}); +} + +function isStopError(error) { + const message = typeof error === 'string' ? error : error?.message; + return message === STOP_ERROR_MESSAGE; +} + +function clearStopRequest() { + stopRequested = false; +} + +function throwIfStopped() { + if (stopRequested) { + throw new Error(STOP_ERROR_MESSAGE); + } +} + +async function sleepWithStop(ms) { + const start = Date.now(); + while (Date.now() - start < ms) { + throwIfStopped(); + await new Promise(r => setTimeout(r, Math.min(100, ms - (Date.now() - start)))); + } +} + +async function humanStepDelay(min = HUMAN_STEP_DELAY_MIN, max = HUMAN_STEP_DELAY_MAX) { + const duration = Math.floor(Math.random() * (max - min + 1)) + min; + await sleepWithStop(duration); +} + +async function clickWithDebugger(tabId, rect) { + if (!tabId) { + throw new Error('No auth tab found for debugger click.'); + } + if (!rect || !Number.isFinite(rect.centerX) || !Number.isFinite(rect.centerY)) { + throw new Error('Step 8 debugger fallback needs a valid button position.'); + } + + const target = { tabId }; + try { + await chrome.debugger.attach(target, '1.3'); + } catch (err) { + throw new Error( + `Debugger attach failed during step 8 fallback: ${err.message}. ` + + 'If DevTools is open on the auth tab, close it and retry.' + ); + } + + try { + const x = Math.round(rect.centerX); + const y = Math.round(rect.centerY); + + await chrome.debugger.sendCommand(target, 'Page.bringToFront'); + await chrome.debugger.sendCommand(target, 'Input.dispatchMouseEvent', { + type: 'mouseMoved', + x, + y, + button: 'none', + buttons: 0, + clickCount: 0, + }); + await chrome.debugger.sendCommand(target, 'Input.dispatchMouseEvent', { + type: 'mousePressed', + x, + y, + button: 'left', + buttons: 1, + clickCount: 1, + }); + await chrome.debugger.sendCommand(target, 'Input.dispatchMouseEvent', { + type: 'mouseReleased', + x, + y, + button: 'left', + buttons: 0, + clickCount: 1, + }); + } finally { + await chrome.debugger.detach(target).catch(() => {}); + } +} + +async function broadcastStopToContentScripts() { + const registry = await getTabRegistry(); + for (const entry of Object.values(registry)) { + if (!entry?.tabId) continue; + try { + await chrome.tabs.sendMessage(entry.tabId, { + type: 'STOP_FLOW', + source: 'background', + payload: {}, + }); + } catch {} + } +} + +let stopRequested = false; + +// ============================================================ +// Message Handler (central router) +// ============================================================ + +chrome.runtime.onMessage.addListener((message, sender, sendResponse) => { + console.log(LOG_PREFIX, `Received: ${message.type} from ${message.source || 'sidepanel'}`, message); + + handleMessage(message, sender).then(response => { + sendResponse(response); + }).catch(err => { + console.error(LOG_PREFIX, 'Handler error:', err); + sendResponse({ error: err.message }); + }); + + return true; // async response +}); + +async function handleMessage(message, sender) { + switch (message.type) { + case 'CONTENT_SCRIPT_READY': { + const tabId = sender.tab?.id; + if (tabId && message.source) { + await registerTab(message.source, tabId); + flushCommand(message.source, tabId); + await addLog(`Content script ready: ${message.source} (tab ${tabId})`); + } + return { ok: true }; + } + + case 'LOG': { + const { message: msg, level } = message.payload; + await addLog(`[${message.source}] ${msg}`, level); + return { ok: true }; + } + + case 'STEP_COMPLETE': { + if (stopRequested) { + await setStepStatus(message.step, 'stopped'); + notifyStepError(message.step, STOP_ERROR_MESSAGE); + return { ok: true }; + } + await setStepStatus(message.step, 'completed'); + await addLog(`Step ${message.step} completed`, 'ok'); + await handleStepData(message.step, message.payload); + notifyStepComplete(message.step, message.payload); + return { ok: true }; + } + + case 'STEP_ERROR': { + if (isStopError(message.error)) { + await setStepStatus(message.step, 'stopped'); + await addLog(`Step ${message.step} stopped by user`, 'warn'); + notifyStepError(message.step, message.error); + } else { + await setStepStatus(message.step, 'failed'); + await addLog(`Step ${message.step} failed: ${message.error}`, 'error'); + notifyStepError(message.step, message.error); + } + return { ok: true }; + } + + case 'GET_STATE': { + return await getState(); + } + + case 'RESET': { + clearStopRequest(); + await resetState(); + await addLog('Flow reset', 'info'); + return { ok: true }; + } + + case 'EXECUTE_STEP': { + clearStopRequest(); + const step = message.payload.step; + // Save email if provided (from side panel step 3) + if (message.payload.email) { + await setEmailState(message.payload.email); + } + await executeStep(step); + return { ok: true }; + } + + case 'AUTO_RUN': { + clearStopRequest(); + const totalRuns = message.payload?.totalRuns || 1; + autoRunLoop(totalRuns); // fire-and-forget + return { ok: true }; + } + + case 'RESUME_AUTO_RUN': { + clearStopRequest(); + if (message.payload.email) { + await setEmailState(message.payload.email); + const state = await getState(); + if (isRelayFirefoxProvider(state.emailProvider) && !state.activeRelayMask) { + await setActiveRelayMaskState({ email: message.payload.email, label: null, inferred: true }); + } + if (isCloudflareTempEmailProvider(state.emailProvider)) { + await setActiveCloudflareMailboxState({ + email: message.payload.email, + addressId: null, + provenance: 'manual_existing', + acquiredAt: Date.now(), + }); + } + } + resumeAutoRun(); // fire-and-forget + return { ok: true }; + } + + case 'SAVE_SETTING': { + const updates = {}; + if (message.payload.vpsUrl !== undefined) updates.vpsUrl = message.payload.vpsUrl; + if (message.payload.customPassword !== undefined) updates.customPassword = message.payload.customPassword; + if (message.payload.emailProvider !== undefined) { + updates.emailProvider = normalizeEmailProvider(message.payload.emailProvider); + } + if (message.payload.mailProvider !== undefined) updates.mailProvider = message.payload.mailProvider; + if (message.payload.cloudflareTempEmailAdminUrl !== undefined) { + updates.cloudflareTempEmailAdminUrl = String(message.payload.cloudflareTempEmailAdminUrl || '').trim(); + } + if (message.payload.inbucketHost !== undefined) updates.inbucketHost = message.payload.inbucketHost; + if (message.payload.inbucketMailbox !== undefined) updates.inbucketMailbox = message.payload.inbucketMailbox; + await setState(updates); + return { ok: true }; + } + + // Side panel data updates + case 'SAVE_EMAIL': { + await setEmailState(message.payload.email); + return { ok: true, email: message.payload.email }; + } + + case 'FETCH_PROVIDER_EMAIL': { + clearStopRequest(); + const email = await fetchEmailFromProvider(message.payload || {}); + return { ok: true, email }; + } + + case 'FETCH_DUCK_EMAIL': { + clearStopRequest(); + const email = await fetchEmailFromProvider({ + ...(message.payload || {}), + provider: EMAIL_PROVIDER_DUCK, + }); + return { ok: true, email }; + } + + case 'STOP_FLOW': { + await requestStop(); + return { ok: true }; + } + + default: + console.warn(LOG_PREFIX, `Unknown message type: ${message.type}`); + return { error: `Unknown message type: ${message.type}` }; + } +} + +// ============================================================ +// Step Data Handlers +// ============================================================ + +async function handleStepData(step, payload) { + switch (step) { + case 1: + if (payload.oauthUrl) { + await setState({ oauthUrl: payload.oauthUrl }); + broadcastDataUpdate({ oauthUrl: payload.oauthUrl }); + } + break; + case 3: + if (payload.email) await setEmailState(payload.email); + break; + case 4: + if (payload.emailTimestamp) await setState({ lastEmailTimestamp: payload.emailTimestamp }); + break; + case 8: + if (payload.localhostUrl) { + await setState({ localhostUrl: payload.localhostUrl }); + broadcastDataUpdate({ localhostUrl: payload.localhostUrl }); + } + break; + } +} + +// ============================================================ +// Step Completion Waiting +// ============================================================ + +// Map of step -> { resolve, reject } for waiting on step completion +const stepWaiters = new Map(); +let resumeWaiter = null; + +function waitForStepComplete(step, timeoutMs = 120000) { + return new Promise((resolve, reject) => { + throwIfStopped(); + const timer = setTimeout(() => { + stepWaiters.delete(step); + reject(new Error(`Step ${step} timed out after ${timeoutMs / 1000}s`)); + }, timeoutMs); + + stepWaiters.set(step, { + resolve: (data) => { clearTimeout(timer); stepWaiters.delete(step); resolve(data); }, + reject: (err) => { clearTimeout(timer); stepWaiters.delete(step); reject(err); }, + }); + }); +} + +function notifyStepComplete(step, payload) { + const waiter = stepWaiters.get(step); + if (waiter) waiter.resolve(payload); +} + +function notifyStepError(step, error) { + const waiter = stepWaiters.get(step); + if (waiter) waiter.reject(new Error(error)); +} + +async function markRunningStepsStopped() { + const state = await getState(); + const runningSteps = Object.entries(state.stepStatuses || {}) + .filter(([, status]) => status === 'running') + .map(([step]) => Number(step)); + + for (const step of runningSteps) { + await setStepStatus(step, 'stopped'); + } +} + +async function requestStop() { + if (stopRequested) return; + + stopRequested = true; + cancelPendingCommands(); + if (webNavListener) { + chrome.webNavigation.onBeforeNavigate.removeListener(webNavListener); + webNavListener = null; + } + + await addLog('Stop requested. Cancelling current operations...', 'warn'); + await broadcastStopToContentScripts(); + + for (const waiter of stepWaiters.values()) { + waiter.reject(new Error(STOP_ERROR_MESSAGE)); + } + stepWaiters.clear(); + + if (resumeWaiter) { + resumeWaiter.reject(new Error(STOP_ERROR_MESSAGE)); + resumeWaiter = null; + } + + await markRunningStepsStopped(); + autoRunActive = false; + await setState({ autoRunning: false }); + chrome.runtime.sendMessage({ + type: 'AUTO_RUN_STATUS', + payload: { phase: 'stopped', currentRun: autoRunCurrentRun, totalRuns: autoRunTotalRuns }, + }).catch(() => {}); +} + +// ============================================================ +// Step Execution +// ============================================================ + +async function executeStep(step) { + console.log(LOG_PREFIX, `Executing step ${step}`); + throwIfStopped(); + await setStepStatus(step, 'running'); + await addLog(`Step ${step} started`); + await humanStepDelay(); + + const state = await getState(); + + // Set flow start time on first step + if (step === 1 && !state.flowStartTime) { + await setState({ flowStartTime: Date.now() }); + } + + try { + switch (step) { + case 1: await executeStep1(state); break; + case 2: await executeStep2(state); break; + case 3: await executeStep3(state); break; + case 4: await executeStep4(state); break; + case 5: await executeStep5(state); break; + case 6: await executeStep6(state); break; + case 7: await executeStep7(state); break; + case 8: await executeStep8(state); break; + case 9: await executeStep9(state); break; + default: + throw new Error(`Unknown step: ${step}`); + } + } catch (err) { + if (isStopError(err)) { + await setStepStatus(step, 'stopped'); + await addLog(`Step ${step} stopped by user`, 'warn'); + throw err; + } + await setStepStatus(step, 'failed'); + await addLog(`Step ${step} failed: ${err.message}`, 'error'); + throw err; + } +} + +/** + * Execute a step and wait for it to complete before returning. + * @param {number} step + * @param {number} delayAfter - ms to wait after completion (for page transitions) + */ +async function executeStepAndWait(step, delayAfter = 2000) { + throwIfStopped(); + const promise = waitForStepComplete(step, 120000); + await executeStep(step); + await promise; + // Extra delay for page transitions / DOM updates + if (delayAfter > 0) { + await sleepWithStop(delayAfter + Math.floor(Math.random() * 1200)); + } +} + +async function fetchEmailFromProvider(options = {}) { + const state = await getState(); + const provider = normalizeEmailProvider(options.provider || state.emailProvider); + + if (isCloudflareTempEmailProvider(provider)) { + return fetchCloudflareTempEmail(options); + } + + if (isRelayFirefoxProvider(provider)) { + await setActiveCloudflareMailboxState(null); + return fetchRelayMaskEmail(options); + } + + await setActiveCloudflareMailboxState(null); + await setActiveRelayMaskState(null); + return fetchDuckEmail(options); +} + +async function fetchDuckEmail(options = {}) { + throwIfStopped(); + const { generateNew = true } = options; + + await addLog(`Duck Mail: Opening autofill settings (${generateNew ? 'generate new' : 'reuse current'})...`); + await reuseOrCreateTab('duck-mail', DUCK_AUTOFILL_URL); + + const result = await sendToContentScript('duck-mail', { + type: 'FETCH_DUCK_EMAIL', + source: 'background', + payload: { generateNew }, + }); + + if (result?.error) { + throw new Error(result.error); + } + if (!result?.email) { + throw new Error('Duck email not returned.'); + } + + await setEmailState(result.email); + await addLog(`Duck Mail: ${result.generated ? 'Generated' : 'Loaded'} ${result.email}`, 'ok'); + return result.email; +} + +async function fetchRelayMaskEmail(options = {}) { + throwIfStopped(); + const { generateNew = true } = options; + + await setActiveCloudflareMailboxState(null); + await addLog(`Relay: Opening profile page (${generateNew ? 'create new mask' : 'reuse current'})...`); + await reuseOrCreateTab('relay-firefox', RELAY_FIREFOX_PROFILE_URL); + + const result = await sendToContentScript('relay-firefox', { + type: 'CREATE_RELAY_MASK', + source: 'background', + payload: { generateNew }, + }); + + if (result?.error) { + throw new Error(result.error); + } + if (!result?.email) { + throw new Error('Relay mask email not returned.'); + } + + await setEmailState(result.email); + await setActiveRelayMaskState({ + email: result.email, + label: result.label || null, + }); + await addLog(`Relay: Created ${result.email}${result.label ? ` (${result.label})` : ''}`, 'ok'); + return result.email; +} + +async function fetchCloudflareTempEmail(options = {}) { + throwIfStopped(); + const { generateNew = true } = options; + const state = await getState(); + const adminUrl = getCloudflareTempEmailAdminUrl(state); + + await addLog(`Cloudflare Temp Email: Opening admin page (${generateNew ? 'create new mailbox' : 'reuse current'})...`); + await reuseOrCreateTab('cloudflare-temp-email', adminUrl, { + inject: CLOUDFLARE_TEMP_EMAIL_INJECT_FILES, + injectSource: 'cloudflare-temp-email', + reloadIfSameUrl: true, + }); + + const result = await sendToContentScript('cloudflare-temp-email', { + type: 'CREATE_CLOUDFLARE_TEMP_EMAIL', + source: 'background', + payload: { generateNew }, + }); + + if (result?.error) { + throw new Error(result.error); + } + if (!result?.email) { + throw new Error('Cloudflare Temp Email mailbox was not returned.'); + } + + await setActiveRelayMaskState(null); + await setEmailState(result.email); + await setActiveCloudflareMailboxState({ + email: result.email, + addressId: result.addressId ?? null, + provenance: result.provenance || 'created', + acquiredAt: Date.now(), + }); + await addLog(`Cloudflare Temp Email: ${result.generated ? 'Created' : 'Loaded'} ${result.email}`, 'ok'); + return result.email; +} + +async function deleteRelayMask(activeRelayMask) { + throwIfStopped(); + if (!activeRelayMask?.email) { + throw new Error('No Relay mask recorded for cleanup.'); + } + + await addLog(`Relay: Opening profile page to delete ${activeRelayMask.email}...`); + await reuseOrCreateTab('relay-firefox', RELAY_FIREFOX_PROFILE_URL); + + const result = await sendToContentScript('relay-firefox', { + type: 'DELETE_RELAY_MASK', + source: 'background', + payload: { email: activeRelayMask.email }, + }); + + if (result?.error) { + throw new Error(result.error); + } + if (!result?.deleted) { + throw new Error(`Relay mask ${activeRelayMask.email} was not deleted.`); + } + + await setActiveRelayMaskState(null); + await addLog(`Relay: Deleted ${activeRelayMask.email}`, 'ok'); +} + +// ============================================================ +// Auto Run Flow +// ============================================================ + +let autoRunActive = false; +let autoRunCurrentRun = 0; +let autoRunTotalRuns = 1; + +// Outer loop: runs the full flow N times +async function autoRunLoop(totalRuns) { + if (autoRunActive) { + await addLog('Auto run already in progress', 'warn'); + return; + } + + clearStopRequest(); + autoRunActive = true; + autoRunTotalRuns = totalRuns; + await setState({ autoRunning: true }); + + for (let run = 1; run <= totalRuns; run++) { + autoRunCurrentRun = run; + + // Reset everything at the start of each run (keep VPS/mail settings) + const prevState = await getState(); + const keepSettings = { + vpsUrl: prevState.vpsUrl, + emailProvider: normalizeEmailProvider(prevState.emailProvider), + mailProvider: prevState.mailProvider, + inbucketHost: prevState.inbucketHost, + inbucketMailbox: prevState.inbucketMailbox, + autoRunning: true, + }; + await resetState(); + await setState(keepSettings); + // Tell side panel to reset all UI + chrome.runtime.sendMessage({ type: 'AUTO_RUN_RESET' }).catch(() => {}); + await sleepWithStop(500); + + await addLog(`=== Auto Run ${run}/${totalRuns} — Phase 1: Get OAuth link & open signup ===`, 'info'); + const status = (phase) => ({ type: 'AUTO_RUN_STATUS', payload: { phase, currentRun: run, totalRuns } }); + + try { + throwIfStopped(); + chrome.runtime.sendMessage(status('running')).catch(() => {}); + + await executeStepAndWait(1, 2000); + await executeStepAndWait(2, 2000); + + const currentState = await getState(); + const emailProvider = normalizeEmailProvider(currentState.emailProvider); + const providerName = getEmailProviderDisplayName(emailProvider); + let emailReady = false; + try { + const providerEmail = await fetchEmailFromProvider({ provider: emailProvider, generateNew: true }); + await addLog(`=== Run ${run}/${totalRuns} — ${providerName} email ready: ${providerEmail} ===`, 'ok'); + emailReady = true; + } catch (err) { + await addLog(`${providerName} auto-fetch failed: ${err.message}`, 'warn'); + } + + if (!emailReady) { + await addLog(`=== Run ${run}/${totalRuns} PAUSED: Fetch ${providerName} email or paste manually, then continue ===`, 'warn'); + chrome.runtime.sendMessage(status('waiting_email')).catch(() => {}); + + // Wait for RESUME_AUTO_RUN — sets a promise that resumeAutoRun resolves + await waitForResume(); + + const resumedState = await getState(); + if (!resumedState.email) { + await addLog('Cannot resume: no email address.', 'error'); + break; + } + } + + await addLog(`=== Run ${run}/${totalRuns} — Phase 2: Register, verify, login, complete ===`, 'info'); + chrome.runtime.sendMessage(status('running')).catch(() => {}); + + const signupTabId = await getTabId('signup-page'); + if (signupTabId) { + await chrome.tabs.update(signupTabId, { active: true }); + } + + await executeStepAndWait(3, 3000); + await executeStepAndWait(4, 2000); + await executeStepAndWait(5, 3000); + if (await waitForConsentPageAfterStep5()) { + await addLog('Consent page detected after step 5; skipping steps 6 and 7', 'info'); + await skipStepBecauseConsentReady(6); + await skipStepBecauseConsentReady(7); + } else { + await executeStepAndWait(6, 3000); + await executeStepAndWait(7, 2000); + } + await executeStepAndWait(8, 2000); + await executeStepAndWait(9, 1000); + + await addLog(`=== Run ${run}/${totalRuns} COMPLETE! ===`, 'ok'); + + } catch (err) { + if (isStopError(err)) { + await addLog(`Run ${run}/${totalRuns} stopped by user`, 'warn'); + } else { + await addLog(`Run ${run}/${totalRuns} failed: ${err.message}`, 'error'); + } + chrome.runtime.sendMessage(status('stopped')).catch(() => {}); + break; // Stop on error + } + } + + const completedRuns = autoRunCurrentRun; + if (stopRequested) { + await addLog(`=== Stopped after ${Math.max(0, completedRuns - 1)}/${autoRunTotalRuns} runs ===`, 'warn'); + chrome.runtime.sendMessage({ type: 'AUTO_RUN_STATUS', payload: { phase: 'stopped', currentRun: completedRuns, totalRuns: autoRunTotalRuns } }).catch(() => {}); + } else if (completedRuns >= autoRunTotalRuns) { + await addLog(`=== All ${autoRunTotalRuns} runs completed successfully ===`, 'ok'); + chrome.runtime.sendMessage({ type: 'AUTO_RUN_STATUS', payload: { phase: 'complete', currentRun: completedRuns, totalRuns: autoRunTotalRuns } }).catch(() => {}); + } else { + await addLog(`=== Stopped after ${completedRuns}/${autoRunTotalRuns} runs ===`, 'warn'); + chrome.runtime.sendMessage({ type: 'AUTO_RUN_STATUS', payload: { phase: 'stopped', currentRun: completedRuns, totalRuns: autoRunTotalRuns } }).catch(() => {}); + } + autoRunActive = false; + await setState({ autoRunning: false }); + clearStopRequest(); +} + +function waitForResume() { + return new Promise((resolve, reject) => { + throwIfStopped(); + resumeWaiter = { resolve, reject }; + }); +} + +async function resumeAutoRun() { + throwIfStopped(); + const state = await getState(); + if (!state.email) { + await addLog('Cannot resume: no email address. Paste email in Side Panel first.', 'error'); + return; + } + if (resumeWaiter) { + resumeWaiter.resolve(); + resumeWaiter = null; + } +} + +// ============================================================ +// Step 1: Get OAuth Link (via vps-panel.js) +// ============================================================ + +async function executeStep1(state) { + if (!state.vpsUrl) { + throw new Error('No VPS URL configured. Enter VPS address in Side Panel first.'); + } + await addLog(`Step 1: Opening VPS panel...`); + await reuseOrCreateTab('vps-panel', state.vpsUrl, { + inject: ['content/utils.js', 'content/vps-panel.js'], + reloadIfSameUrl: true, + }); + + await sendToContentScript('vps-panel', { + type: 'EXECUTE_STEP', + step: 1, + source: 'background', + payload: {}, + }); +} + +// ============================================================ +// Step 2: Open Signup Page (Background opens tab, signup-page.js clicks Register) +// ============================================================ + +async function executeStep2(state) { + if (!state.oauthUrl) { + throw new Error('No OAuth URL. Complete step 1 first.'); + } + await addLog(`Step 2: Opening auth URL...`); + await reuseOrCreateTab('signup-page', state.oauthUrl); + + await sendToContentScript('signup-page', { + type: 'EXECUTE_STEP', + step: 2, + source: 'background', + payload: {}, + }); +} + +// ============================================================ +// Step 3: Fill Email & Password (via signup-page.js) +// ============================================================ + +async function executeStep3(state) { + const emailProvider = normalizeEmailProvider(state.emailProvider); + let email = state.email; + + if (isRelayFirefoxProvider(emailProvider)) { + if (state.activeRelayMask?.email) { + email = state.activeRelayMask.email; + await setEmailState(email); + await addLog(`Step 3: Reusing Relay mask ${email}`, 'info'); + } else { + email = await fetchRelayMaskEmail({ generateNew: true }); + } + } else if (isCloudflareTempEmailProvider(emailProvider)) { + const activeMailbox = state.activeCloudflareMailbox; + const canReuseCloudflareMailbox = activeMailbox?.email + && activeMailbox.email === state.email + && (activeMailbox.provenance === 'created' || activeMailbox.provenance === 'manual_existing'); + + if (canReuseCloudflareMailbox) { + email = activeMailbox.email; + await setEmailState(email); + await addLog(`Step 3: Reusing Cloudflare Temp Email mailbox ${email}`, 'info'); + } else { + email = await fetchCloudflareTempEmail({ generateNew: true }); + } + } else if (!email) { + throw new Error('No email address. Paste email in Side Panel first.'); + } + + const password = state.customPassword || generatePassword(); + await setPasswordState(password); + + // Save account record + const accounts = state.accounts || []; + accounts.push({ email, password, emailProvider, createdAt: new Date().toISOString() }); + await setState({ accounts }); + + await addLog( + `Step 3: Filling email ${email}, password ${state.customPassword ? 'customized' : 'generated'} (${password.length} chars)` + ); + await sendToContentScript('signup-page', { + type: 'EXECUTE_STEP', + step: 3, + source: 'background', + payload: { email, password }, + }); +} + +// ============================================================ +// Step 4: Get Signup Verification Code (qq-mail.js polls, then fills in signup-page.js) +// ============================================================ + +function getMailConfig(state) { + const provider = state.mailProvider || 'qq'; + if (provider === '163') { + return { source: 'mail-163', url: 'https://mail.163.com/js6/main.jsp?df=mail163_letter#module=mbox.ListModule%7C%7B%22fid%22%3A1%2C%22order%22%3A%22date%22%2C%22desc%22%3Atrue%7D', label: '163 Mail' }; + } + if (provider === 'inbucket') { + const host = normalizeInbucketOrigin(state.inbucketHost); + const mailbox = (state.inbucketMailbox || '').trim(); + if (!host) { + return { error: 'Inbucket host is empty or invalid.' }; + } + if (!mailbox) { + return { error: 'Inbucket mailbox name is empty.' }; + } + return { + source: 'inbucket-mail', + url: `${host}/m/${encodeURIComponent(mailbox)}/`, + label: `Inbucket Mailbox (${mailbox})`, + navigateOnReuse: true, + inject: ['content/utils.js', 'content/inbucket-mail.js'], + injectSource: 'inbucket-mail', + }; + } + return { source: 'qq-mail', url: 'https://wx.mail.qq.com/', label: 'QQ Mail' }; +} + +function normalizeInbucketOrigin(rawValue) { + const value = (rawValue || '').trim(); + if (!value) return ''; + + const candidate = /^[a-zA-Z][a-zA-Z\d+\-.]*:\/\//.test(value) ? value : `https://${value}`; + + try { + const parsed = new URL(candidate); + return parsed.origin; + } catch { + return ''; + } +} + +async function pollCodeFromCloudflareAdmin(step, state, options = {}) { + if (!state.email) { + throw new Error('No email. Complete step 3 first.'); + } + const adminUrl = getCloudflareTempEmailAdminUrl(state); + + await addLog(`Step ${step}: Opening Cloudflare Temp Email admin...`); + await reuseOrCreateTab('cloudflare-temp-email', adminUrl, { + inject: CLOUDFLARE_TEMP_EMAIL_INJECT_FILES, + injectSource: 'cloudflare-temp-email', + reloadIfSameUrl: true, + }); + + const result = await sendToContentScript('cloudflare-temp-email', { + type: 'POLL_EMAIL', + step, + source: 'background', + payload: { + filterAfterTimestamp: options.filterAfterTimestamp || 0, + senderFilters: options.senderFilters || [], + subjectFilters: options.subjectFilters || [], + targetEmail: state.email, + maxAttempts: options.maxAttempts || 20, + intervalMs: options.intervalMs || 3000, + }, + }); + + if (result?.error) { + throw new Error(result.error); + } + if (!result?.code) { + throw new Error(`Cloudflare Temp Email did not return a verification code for step ${step}.`); + } + + return result; +} + +async function executeStep4(state) { + let result = null; + + if (shouldUseEmailSourceForVerification(state.emailProvider)) { + result = await pollCodeFromCloudflareAdmin(4, state, { + filterAfterTimestamp: state.flowStartTime || 0, + senderFilters: ['openai', 'noreply', 'verify', 'auth', 'duckduckgo', 'forward'], + subjectFilters: ['verify', 'verification', 'code', '验证', 'confirm'], + }); + } else { + const mail = getMailConfig(state); + if (mail.error) throw new Error(mail.error); + await addLog(`Step 4: Opening ${mail.label}...`); + + // For mail tabs, only create if not alive — don't navigate (preserves login session) + const alive = await isTabAlive(mail.source); + if (alive) { + if (mail.navigateOnReuse) { + await reuseOrCreateTab(mail.source, mail.url, { + inject: mail.inject, + injectSource: mail.injectSource, + }); + } else { + const tabId = await getTabId(mail.source); + await chrome.tabs.update(tabId, { active: true }); + } + } else { + await reuseOrCreateTab(mail.source, mail.url, { + inject: mail.inject, + injectSource: mail.injectSource, + }); + } + + result = await sendToContentScript(mail.source, { + type: 'POLL_EMAIL', + step: 4, + source: 'background', + payload: { + filterAfterTimestamp: state.flowStartTime || 0, + senderFilters: ['openai', 'noreply', 'verify', 'auth', 'duckduckgo', 'forward'], + subjectFilters: ['verify', 'verification', 'code', '验证', 'confirm'], + targetEmail: state.email, + maxAttempts: 20, + intervalMs: 3000, + }, + }); + + if (result && result.error) { + throw new Error(result.error); + } + } + + if (result && result.code) { + await setState({ lastEmailTimestamp: result.emailTimestamp }); + await addLog(`Step 4: Got verification code: ${result.code}`); + + // Switch to signup tab and fill code + const signupTabId = await getTabId('signup-page'); + if (signupTabId) { + await chrome.tabs.update(signupTabId, { active: true }); + await sendToContentScript('signup-page', { + type: 'FILL_CODE', + step: 4, + source: 'background', + payload: { code: result.code }, + }); + } else { + throw new Error('Signup page tab was closed. Cannot fill verification code.'); + } + } +} + +// ============================================================ +// Step 5: Fill Name & Birthday (via signup-page.js) +// ============================================================ + +async function executeStep5(state) { + const { firstName, lastName } = generateRandomName(); + const { year, month, day } = generateRandomBirthday(); + + await addLog(`Step 5: Generated name: ${firstName} ${lastName}, Birthday: ${year}-${month}-${day}`); + + await sendToContentScript('signup-page', { + type: 'EXECUTE_STEP', + step: 5, + source: 'background', + payload: { firstName, lastName, year, month, day }, + }); +} + +// ============================================================ +// Step 6: Login ChatGPT (Background opens tab, chatgpt.js handles login) +// ============================================================ + +async function executeStep6(state) { + if (await isSignupConsentPageReady()) { + await skipStepBecauseConsentReady(6); + return; + } + + if (!state.oauthUrl) { + throw new Error('No OAuth URL. Complete step 1 first.'); + } + if (!state.email) { + throw new Error('No email. Complete step 3 first.'); + } + + await addLog(`Step 6: Opening OAuth URL for login...`); + // Reuse the signup-page tab — navigate it to the OAuth URL + await reuseOrCreateTab('signup-page', state.oauthUrl); + + // signup-page.js will inject (same auth.openai.com domain) and handle login + await sendToContentScript('signup-page', { + type: 'EXECUTE_STEP', + step: 6, + source: 'background', + payload: { email: state.email, password: state.password }, + }); +} + +// ============================================================ +// Step 7: Get Login Verification Code (qq-mail.js polls, then fills in chatgpt.js) +// ============================================================ + +async function executeStep7(state) { + if (await isSignupConsentPageReady()) { + await skipStepBecauseConsentReady(7); + return; + } + + let result = null; + + if (shouldUseEmailSourceForVerification(state.emailProvider)) { + result = await pollCodeFromCloudflareAdmin(7, state, { + filterAfterTimestamp: state.lastEmailTimestamp || state.flowStartTime || 0, + senderFilters: ['openai', 'noreply', 'verify', 'auth', 'chatgpt', 'duckduckgo', 'forward'], + subjectFilters: ['verify', 'verification', 'code', '验证', 'confirm', 'login'], + }); + } else { + const mail = getMailConfig(state); + if (mail.error) throw new Error(mail.error); + await addLog(`Step 7: Opening ${mail.label}...`); + + const alive = await isTabAlive(mail.source); + if (alive) { + if (mail.navigateOnReuse) { + await reuseOrCreateTab(mail.source, mail.url, { + inject: mail.inject, + injectSource: mail.injectSource, + }); + } else { + const tabId = await getTabId(mail.source); + await chrome.tabs.update(tabId, { active: true }); + } + } else { + await reuseOrCreateTab(mail.source, mail.url, { + inject: mail.inject, + injectSource: mail.injectSource, + }); + } + + result = await sendToContentScript(mail.source, { + type: 'POLL_EMAIL', + step: 7, + source: 'background', + payload: { + filterAfterTimestamp: state.lastEmailTimestamp || state.flowStartTime || 0, + senderFilters: ['openai', 'noreply', 'verify', 'auth', 'chatgpt', 'duckduckgo', 'forward'], + subjectFilters: ['verify', 'verification', 'code', '验证', 'confirm', 'login'], + targetEmail: state.email, + maxAttempts: 20, + intervalMs: 3000, + }, + }); + + if (result && result.error) { + throw new Error(result.error); + } + } + + if (result && result.code) { + await addLog(`Step 7: Got login verification code: ${result.code}`); + + // Switch to signup/auth tab and fill code + const signupTabId = await getTabId('signup-page'); + if (signupTabId) { + await chrome.tabs.update(signupTabId, { active: true }); + await sendToContentScript('signup-page', { + type: 'FILL_CODE', + step: 7, + source: 'background', + payload: { code: result.code }, + }); + } else { + throw new Error('Auth page tab was closed. Cannot fill verification code.'); + } + } +} + +// ============================================================ +// Step 8: Complete OAuth (auto click + localhost listener) +// ============================================================ + +let webNavListener = null; + +async function executeStep8(state) { + if (!state.oauthUrl) { + throw new Error('No OAuth URL. Complete step 1 first.'); + } + + await addLog('Step 8: Setting up localhost redirect listener...'); + + // Register webNavigation listener (scoped to this step) + return new Promise((resolve, reject) => { + let resolved = false; + + const cleanupListener = () => { + if (webNavListener) { + chrome.webNavigation.onBeforeNavigate.removeListener(webNavListener); + webNavListener = null; + } + }; + + const finishStep8WithCallbackUrl = async (url) => { + const matchedUrl = MultiPageOAuthFlow.findLoopbackCallbackUrl([url]); + if (!matchedUrl || resolved) { + return false; + } + + resolved = true; + cleanupListener(); + clearTimeout(timeout); + + try { + await completeStepFromBackground(8, { localhostUrl: matchedUrl }, { + logMessage: `Step 8: Captured callback URL: ${matchedUrl}`, + logLevel: 'ok', + }); + resolve(); + } catch (err) { + reject(err); + } + + return true; + }; + + const timeout = setTimeout(() => { + cleanupListener(); + resolved = true; + reject(new Error('Loopback callback URL not captured after 120s. Step 8 click may have been blocked.')); + }, 120000); + + webNavListener = (details) => { + if (MultiPageOAuthFlow.isLoopbackCallbackUrl(details.url)) { + console.log(LOG_PREFIX, `Captured loopback redirect: ${details.url}`); + void finishStep8WithCallbackUrl(details.url); + } + }; + + chrome.webNavigation.onBeforeNavigate.addListener(webNavListener); + + // After step 7, the auth page shows a consent screen ("使用 ChatGPT 登录到 Codex") + // with a "继续" button. We locate the button in-page, then click it through + // the debugger Input API directly. + (async () => { + try { + let signupTabId = await getTabId('signup-page'); + if (signupTabId) { + await chrome.tabs.update(signupTabId, { active: true }); + await addLog('Step 8: Switched to auth page. Preparing debugger click...'); + } else { + signupTabId = await reuseOrCreateTab('signup-page', state.oauthUrl); + await addLog('Step 8: Auth tab reopened. Preparing debugger click...'); + } + + const clickResult = await sendToContentScript('signup-page', { + type: 'STEP8_FIND_AND_CLICK', + source: 'background', + payload: {}, + }); + + if (clickResult?.error) { + throw new Error(clickResult.error); + } + + if (!resolved) { + await clickWithDebugger(signupTabId, clickResult?.rect); + await addLog('Step 8: Debugger click dispatched, waiting for redirect...'); + + (async () => { + while (!resolved) { + const tab = await chrome.tabs.get(signupTabId).catch(() => null); + const matchedUrl = MultiPageOAuthFlow.findLoopbackCallbackUrl([tab?.url || '']); + if (matchedUrl) { + console.log(LOG_PREFIX, `Detected loopback callback via tab polling: ${matchedUrl}`); + await finishStep8WithCallbackUrl(matchedUrl); + return; + } + await new Promise((resume) => setTimeout(resume, 250)); + } + })().catch((err) => { + if (!resolved) { + clearTimeout(timeout); + cleanupListener(); + reject(err); + } + }); + } + } catch (err) { + clearTimeout(timeout); + cleanupListener(); + reject(err); + } + })(); + }); +} + +// ============================================================ +// Step 9: Cleanup Email Resource +// ============================================================ + +async function executeStep9(state) { + const emailProvider = normalizeEmailProvider(state.emailProvider); + const providerName = getEmailProviderDisplayName(emailProvider); + + if (shouldSkipStep9Cleanup(emailProvider)) { + await completeStepFromBackground(9, { skipped: true, reason: 'no_cleanup_needed' }, { + logMessage: `Step 9 skipped: no cleanup needed for ${providerName}`, + logLevel: 'info', + }); + return; + } + + const targetMask = state.activeRelayMask?.email + ? state.activeRelayMask + : (state.email ? { email: state.email, label: null, inferred: true } : null); + + if (!targetMask?.email) { + throw new Error('No Relay mask recorded for cleanup.'); + } + + await deleteRelayMask(targetMask); + await completeStepFromBackground(9, { deletedMaskEmail: targetMask.email }, { + logMessage: `Step 9: Relay cleanup complete for ${targetMask.email}`, + logLevel: 'ok', + }); +} + +// ============================================================ +// Open Side Panel on extension icon click +// ============================================================ + +chrome.sidePanel.setPanelBehavior({ openPanelOnActionClick: true }); diff --git a/DouYinSparkFlow/webui/static/multiPagePlugins/content/cloudflare-temp-email.js b/DouYinSparkFlow/webui/static/multiPagePlugins/content/cloudflare-temp-email.js new file mode 100644 index 0000000..7537c86 --- /dev/null +++ b/DouYinSparkFlow/webui/static/multiPagePlugins/content/cloudflare-temp-email.js @@ -0,0 +1,531 @@ +// content/cloudflare-temp-email.js — Content script for Cloudflare Temp Email admin page + +const CLOUDFLARE_TEMP_EMAIL_PREFIX = '[MultiPage:cloudflare-temp-email]'; +const isTopFrame = window === window.top; + +const { + combineDistinctTextParts = (parts = []) => parts + .map((part) => String(part || '').replace(/\s+/g, ' ').trim()) + .filter(Boolean) + .filter((part, index, values) => values.indexOf(part) === index) + .join(' '), + extractVerificationCode = () => null, + generateReadableLocalPart = () => `mp${Date.now().toString(36)}${Math.random().toString(36).slice(2, 6)}`.slice(0, 18), + normalizeDomainSuffix = (value) => String(value || '').trim().replace(/^@+/, '').toLowerCase(), + parseCloudflareMailboxCredential = () => null, + pickRandomSuffix = (options = []) => normalizeDomainSuffix(options[0] || ''), + selectVerificationMessage = () => null, +} = globalThis.MultiPageCloudflareTempEmail || {}; + +console.log(CLOUDFLARE_TEMP_EMAIL_PREFIX, 'Content script loaded on', location.href, 'frame:', isTopFrame ? 'top' : 'child'); + +if (!isTopFrame) { + console.log(CLOUDFLARE_TEMP_EMAIL_PREFIX, 'Skipping child frame'); +} else { + chrome.runtime.onMessage.addListener((message, sender, sendResponse) => { + if (message.type !== 'CREATE_CLOUDFLARE_TEMP_EMAIL' && message.type !== 'POLL_EMAIL') { + return; + } + + resetStopState(); + + const handler = message.type === 'CREATE_CLOUDFLARE_TEMP_EMAIL' + ? createCloudflareTempEmail + : pollCloudflareTempEmail; + + handler(message.step, message.payload || {}).then((result) => { + sendResponse(result); + }).catch((err) => { + if (isStopError(err)) { + if (message.step) { + log(`Step ${message.step}: Stopped by user.`, 'warn'); + } else { + log('Cloudflare Temp Email: Stopped by user.', 'warn'); + } + sendResponse({ stopped: true, error: err.message }); + return; + } + + if (message.step) { + reportError(message.step, err.message); + } + sendResponse({ error: err.message }); + }); + + return true; + }); + + function getElementText(el) { + return combineDistinctTextParts([ + el?.innerText, + el?.textContent, + el?.getAttribute?.('aria-label'), + el?.getAttribute?.('title'), + el?.value, + ]); + } + + function normalizeText(value) { + return String(value || '').replace(/\s+/g, ' ').trim(); + } + + function normalizeEmail(value) { + return normalizeText(value).toLowerCase(); + } + + function isVisible(el) { + if (!el) return false; + if (el.hidden) return false; + const style = window.getComputedStyle(el); + if (style.display === 'none' || style.visibility === 'hidden' || style.opacity === '0') { + return false; + } + return Boolean(el.offsetWidth || el.offsetHeight || el.getClientRects().length); + } + + function findVisibleButton(pattern) { + return Array.from(document.querySelectorAll('button')) + .filter(isVisible) + .find((button) => pattern.test(normalizeText(getElementText(button)))); + } + + function findVisibleTab(pattern, occurrence = 'first') { + const tabs = Array.from(document.querySelectorAll('.n-tabs-tab')) + .filter(isVisible) + .filter((tab) => pattern.test(normalizeText(getElementText(tab)))); + + return occurrence === 'last' ? tabs[tabs.length - 1] || null : tabs[0] || null; + } + + async function waitForCondition(predicate, timeout, message) { + const startedAt = Date.now(); + + while (Date.now() - startedAt < timeout) { + throwIfStopped(); + const value = predicate(); + if (value) { + return value; + } + await sleep(150); + } + + throw new Error(message); + } + + async function clickTab(pattern, occurrence = 'first', timeout = 10000) { + await waitForCondition( + () => findVisibleTab(pattern, occurrence), + timeout, + `Timed out waiting for tab ${pattern}` + ); + + const tab = findVisibleTab(pattern, occurrence); + if (!tab) { + throw new Error(`Could not find tab ${pattern}`); + } + + await humanPause(120, 260); + simulateClick(tab); + await sleep(400); + return tab; + } + + function getCreateAddressInput() { + return Array.from(document.querySelectorAll('input[placeholder="请输入"]')).find(isVisible) || null; + } + + function getPrefixSwitch() { + return Array.from(document.querySelectorAll('[role="switch"], .n-switch')).find(isVisible) || null; + } + + function getCreateInputGroup() { + return getCreateAddressInput()?.closest('.n-input-group') || null; + } + + function getCreateDomainSelect() { + const group = getCreateInputGroup(); + + return Array.from(group?.querySelectorAll('.n-base-selection') || []).find(isVisible) + || Array.from(group?.querySelectorAll('.n-select') || []).find(isVisible) + || null; + } + + function getCurrentDomain() { + const groupText = normalizeText(getCreateInputGroup()?.textContent || ''); + const match = groupText.match(/@([a-z0-9.-]+\.[a-z]{2,})/i); + return normalizeDomainSuffix(match ? match[1] : ''); + } + + function getVisibleDomainOptionEntries() { + const seen = new Set(); + const entries = []; + + for (const option of Array.from(document.querySelectorAll('.n-base-select-option, [role="option"]'))) { + if (!isVisible(option)) { + continue; + } + + const value = normalizeDomainSuffix(getElementText(option)); + if (!value || seen.has(value)) { + continue; + } + + seen.add(value); + entries.push({ option, value }); + } + + return entries; + } + + async function ensureCreateAccountPage() { + await clickTab(/^账号$/, 'first'); + await clickTab(/^创建账号$/); + await waitForCondition( + () => getCreateAddressInput(), + 10000, + 'Cloudflare Temp Email create form did not load.' + ); + } + + async function ensureMailPage() { + await clickTab(/^邮件$/, 'first'); + await clickTab(/^邮件$/, 'last'); + await waitForCondition( + () => document.querySelector('input[placeholder="留空查询所有地址"]'), + 10000, + 'Cloudflare Temp Email mail page did not load.' + ); + } + + async function ensurePrefixDisabled() { + const prefixSwitch = getPrefixSwitch(); + if (!prefixSwitch) { + log('Cloudflare Temp Email: Prefix switch not present, assuming prefix is already disabled', 'info'); + return; + } + + if (prefixSwitch.getAttribute('aria-checked') === 'true') { + await humanPause(120, 280); + simulateClick(prefixSwitch); + await waitForCondition( + () => prefixSwitch.getAttribute('aria-checked') === 'false', + 5000, + 'Cloudflare Temp Email prefix switch did not turn off.' + ); + log('Cloudflare Temp Email: Prefix disabled', 'ok'); + } + } + + async function selectRandomDomainSuffix() { + const domainSelect = await waitForCondition( + () => getCreateDomainSelect(), + 5000, + 'Could not find the Cloudflare Temp Email suffix selector.' + ); + + await humanPause(120, 260); + simulateClick(domainSelect); + await sleep(300); + + const optionEntries = await waitForCondition( + () => { + const entries = getVisibleDomainOptionEntries(); + return entries.length > 0 ? entries : null; + }, + 5000, + 'Could not find any available Cloudflare Temp Email suffix options.' + ); + + const suffix = pickRandomSuffix(optionEntries.map((entry) => entry.value)); + const selectedEntry = optionEntries.find((entry) => entry.value === suffix); + + if (!suffix || !selectedEntry?.option) { + throw new Error('Could not choose a Cloudflare Temp Email suffix from the available options.'); + } + + await humanPause(120, 260); + simulateClick(selectedEntry.option); + await waitForCondition( + () => getCurrentDomain() === suffix, + 5000, + `Cloudflare Temp Email suffix did not switch to ${suffix}.` + ); + + log(`Cloudflare Temp Email: Selected suffix ${suffix}`, 'info'); + return suffix; + } + + function generateLocalPart() { + return generateReadableLocalPart(); + } + + function findCredentialDialog() { + return Array.from( + document.querySelectorAll('[role="dialog"], .n-dialog, .n-modal, .n-base-modal, .n-card') + ).find((el) => isVisible(el) && /邮箱地址凭证/.test(getElementText(el))); + } + + function extractCredentialToken(root) { + if (!root) return ''; + + const candidates = [ + getElementText(root), + ...Array.from(root.querySelectorAll('textarea, input, pre, code')).map((el) => el.value || el.textContent || ''), + ]; + + for (const candidate of candidates) { + const match = String(candidate || '').match(/[A-Za-z0-9_-]+\.[A-Za-z0-9_-]+\.[A-Za-z0-9_-]+/); + if (match) { + return match[0]; + } + } + + return ''; + } + + async function waitForCredentialDetails(timeout = 15000) { + return waitForCondition(() => { + const dialog = findCredentialDialog(); + const token = extractCredentialToken(dialog); + const credential = parseCloudflareMailboxCredential(token); + if (!credential?.email) { + return null; + } + return credential; + }, timeout, 'Timed out waiting for Cloudflare Temp Email credential dialog.'); + } + + async function dismissCredentialDialog() { + const dialog = findCredentialDialog(); + if (!dialog) return; + + const closeButton = Array.from(dialog.querySelectorAll('button, .n-base-close')) + .find((el) => isVisible(el) && (/关闭|确定|取消/.test(getElementText(el)) || el.classList?.contains('n-base-close'))); + + if (closeButton) { + simulateClick(closeButton); + await sleep(300); + return; + } + + document.dispatchEvent(new KeyboardEvent('keydown', { key: 'Escape', bubbles: true })); + await sleep(300); + } + + async function createCloudflareTempEmail(step, payload = {}) { + const { generateNew = true } = payload; + + await ensureCreateAccountPage(); + await ensurePrefixDisabled(); + await selectRandomDomainSuffix(); + + const input = getCreateAddressInput(); + if (!input) { + throw new Error('Could not find the Cloudflare Temp Email address input.'); + } + + const createButton = findVisibleButton(/^创建新邮箱$/); + if (!createButton) { + throw new Error('Could not find the "创建新邮箱" button.'); + } + + for (let attempt = 1; attempt <= 3; attempt++) { + const localPart = generateLocalPart(); + fillInput(input, localPart); + await humanPause(120, 260); + simulateClick(createButton); + log(`Cloudflare Temp Email: Creating mailbox attempt ${attempt}`, 'info'); + + try { + const credential = await waitForCredentialDetails(10000); + await dismissCredentialDialog(); + + return { + ...credential, + domain: credential.domain || getCurrentDomain(), + generated: Boolean(generateNew), + }; + } catch (err) { + if (attempt === 3) { + throw err; + } + log(`Cloudflare Temp Email: Mailbox attempt ${attempt} did not complete, retrying`, 'warn'); + await dismissCredentialDialog().catch(() => {}); + await sleep(500); + } + } + + throw new Error('Cloudflare Temp Email mailbox creation did not succeed.'); + } + + function getMessageRows() { + return Array.from(document.querySelectorAll('.n-thing')).filter(isVisible); + } + + function parseMessageRow(row) { + const rowText = row?.innerText || getElementText(row); + const subject = normalizeText( + row.querySelector('.n-thing-header__title')?.textContent + || row.querySelector('h3, h4, h2')?.textContent + || '' + ); + const messageId = rowText.match(/ID:\s*([^\s]+)/i)?.[1] || null; + const timestampText = rowText.match(/\d{4}\/\d{1,2}\/\d{1,2}\s+\d{1,2}:\d{2}:\d{2}/)?.[0] || ''; + const sender = normalizeText(rowText.match(/FROM:\s*([^\n]+)/i)?.[1] || ''); + const matchedEmail = normalizeEmail(rowText.match(/TO:\s*([^\n]+)/i)?.[1] || ''); + + return { + combinedText: normalizeText(rowText), + emailTimestamp: null, + matchedEmail, + messageId, + row, + sender, + subject, + timestampText, + }; + } + + function findMessageDetailRoot() { + const deleteButton = Array.from(document.querySelectorAll('button')) + .find((button) => isVisible(button) && /^删除$/.test(normalizeText(getElementText(button)))); + + let current = deleteButton?.parentElement || null; + while (current && current !== document.body) { + const text = getElementText(current); + if (/FROM:/i.test(text) && /TO:/i.test(text)) { + return current; + } + current = current.parentElement; + } + + return null; + } + + async function openMessageRow(row, subject) { + await humanPause(80, 180); + simulateClick(row); + await waitForCondition(() => { + const detailRoot = findMessageDetailRoot(); + const detailText = normalizeText(getElementText(detailRoot)); + if (!detailText) return null; + if (!subject || detailText.includes(subject)) { + return detailRoot; + } + return null; + }, 4000, `Timed out opening message ${subject || ''}`.trim()); + } + + function buildMessageDetailText() { + return normalizeText(getElementText(findMessageDetailRoot())); + } + + async function collectMessagesForTarget(targetEmail) { + const normalizedTargetEmail = normalizeEmail(targetEmail); + const rows = getMessageRows(); + const messages = []; + + for (const row of rows) { + const message = parseMessageRow(row); + if (!message.matchedEmail || message.matchedEmail !== normalizedTargetEmail) { + continue; + } + + if (!extractVerificationCode(`${message.subject} ${message.combinedText}`)) { + await openMessageRow(row, message.subject); + message.combinedText = `${message.combinedText} ${buildMessageDetailText()}`.trim(); + } + + messages.push(message); + } + + return messages; + } + + async function runMailQuery(targetEmail) { + const queryInput = document.querySelector('input[placeholder="留空查询所有地址"]'); + if (!queryInput) { + throw new Error('Could not find the admin mail query input.'); + } + + const queryButton = findVisibleButton(/^查询$/); + if (!queryButton) { + throw new Error('Could not find the admin mail query button.'); + } + + fillInput(queryInput, targetEmail); + await humanPause(80, 180); + simulateClick(queryButton); + await sleep(800); + } + + async function refreshMailList() { + const refreshButton = findVisibleButton(/^刷新$/); + if (!refreshButton) { + throw new Error('Could not find the admin mail refresh button.'); + } + + simulateClick(refreshButton); + await sleep(1000); + } + + async function pollCloudflareTempEmail(step, payload = {}) { + const { + filterAfterTimestamp = 0, + intervalMs = 3000, + maxAttempts = 20, + senderFilters = [], + subjectFilters = [], + targetEmail = '', + } = payload; + + if (!targetEmail) { + throw new Error('No target email provided for Cloudflare Temp Email polling.'); + } + + await ensureMailPage(); + await runMailQuery(targetEmail); + + log(`Step ${step}: Starting Cloudflare Temp Email poll for ${targetEmail}`, 'info'); + + for (let attempt = 1; attempt <= maxAttempts; attempt++) { + log(`Step ${step}: Polling Cloudflare Temp Email... attempt ${attempt}/${maxAttempts}`, 'info'); + await refreshMailList(); + + const messages = await collectMessagesForTarget(targetEmail); + const match = selectVerificationMessage(messages, { + filterAfterTimestamp, + senderFilters, + subjectFilters, + targetEmail, + }); + + if (match?.code) { + log( + `Step ${step}: Code found: ${match.code} (subject: ${(match.subject || '').slice(0, 60)})`, + 'ok' + ); + return { + ok: true, + code: match.code, + emailTimestamp: match.emailTimestamp, + matchedEmail: match.matchedEmail, + messageId: match.messageId, + subject: match.subject, + }; + } + + if (attempt < maxAttempts) { + await sleep(intervalMs); + } + } + + const newerSuffix = Number(filterAfterTimestamp) > 0 + ? ' newer than the previous verification message' + : ''; + + throw new Error( + `No matching verification email${newerSuffix} was found for ${targetEmail} after ${(maxAttempts * intervalMs / 1000).toFixed(0)}s.` + ); + } +} diff --git a/DouYinSparkFlow/webui/static/multiPagePlugins/content/duck-mail.js b/DouYinSparkFlow/webui/static/multiPagePlugins/content/duck-mail.js new file mode 100644 index 0000000..4acc564 --- /dev/null +++ b/DouYinSparkFlow/webui/static/multiPagePlugins/content/duck-mail.js @@ -0,0 +1,74 @@ +// content/duck-mail.js — Content script for DuckDuckGo Email Protection autofill settings + +console.log('[MultiPage:duck-mail] Content script loaded on', location.href); + +chrome.runtime.onMessage.addListener((message, sender, sendResponse) => { + if (message.type !== 'FETCH_DUCK_EMAIL') return; + + resetStopState(); + fetchDuckEmail(message.payload).then(result => { + sendResponse(result); + }).catch(err => { + if (isStopError(err)) { + log('Duck Mail: Stopped by user.', 'warn'); + sendResponse({ stopped: true, error: err.message }); + return; + } + sendResponse({ error: err.message }); + }); + + return true; +}); + +async function fetchDuckEmail(payload = {}) { + const { generateNew = true } = payload; + + log(`Duck Mail: ${generateNew ? 'Generating' : 'Reading'} private address...`); + + await waitForElement( + 'input.AutofillSettingsPanel__PrivateDuckAddressValue, button.AutofillSettingsPanel__GeneratorButton', + 15000 + ); + + const getAddressInput = () => document.querySelector('input.AutofillSettingsPanel__PrivateDuckAddressValue'); + const getGeneratorButton = () => document.querySelector('button.AutofillSettingsPanel__GeneratorButton') + || Array.from(document.querySelectorAll('button')).find(btn => /generate private duck address/i.test(btn.textContent || '')); + const readEmail = () => { + const value = getAddressInput()?.value?.trim() || ''; + return value.includes('@duck.com') ? value : ''; + }; + + const waitForEmailValue = async (previousValue = '') => { + for (let i = 0; i < 100; i++) { + const nextValue = readEmail(); + if (nextValue && nextValue !== previousValue) { + return nextValue; + } + await sleep(150); + } + throw new Error('Timed out waiting for Duck address to appear.'); + }; + + const currentEmail = readEmail(); + if (currentEmail && !generateNew) { + log(`Duck Mail: Found existing address ${currentEmail}`); + return { email: currentEmail, generated: false }; + } + + await humanPause(500, 1300); + const generatorButton = getGeneratorButton(); + if (!generatorButton) { + if (currentEmail) { + log(`Duck Mail: Reusing existing address ${currentEmail}`, 'warn'); + return { email: currentEmail, generated: false }; + } + throw new Error('Could not find "Generate Private Duck Address" button.'); + } + + generatorButton.click(); + log('Duck Mail: Clicked "Generate Private Duck Address"'); + + const nextEmail = await waitForEmailValue(currentEmail); + log(`Duck Mail: Ready address ${nextEmail}`, 'ok'); + return { email: nextEmail, generated: true }; +} diff --git a/DouYinSparkFlow/webui/static/multiPagePlugins/content/inbucket-mail.js b/DouYinSparkFlow/webui/static/multiPagePlugins/content/inbucket-mail.js new file mode 100644 index 0000000..02fe7b7 --- /dev/null +++ b/DouYinSparkFlow/webui/static/multiPagePlugins/content/inbucket-mail.js @@ -0,0 +1,258 @@ +// content/inbucket-mail.js — Content script for Inbucket polling (steps 4, 7) +// Injected dynamically on the configured Inbucket host +// +// Supported page: +// - /m// + +const INBUCKET_PREFIX = '[MultiPage:inbucket-mail]'; +const isTopFrame = window === window.top; +const SEEN_MAIL_IDS_KEY = 'seenInbucketMailIds'; + +console.log(INBUCKET_PREFIX, 'Content script loaded on', location.href, 'frame:', isTopFrame ? 'top' : 'child'); + +if (!isTopFrame) { + console.log(INBUCKET_PREFIX, 'Skipping child frame'); +} else { + +let seenMailIds = new Set(); + +async function loadSeenMailIds() { + try { + const data = await chrome.storage.session.get(SEEN_MAIL_IDS_KEY); + if (Array.isArray(data[SEEN_MAIL_IDS_KEY])) { + seenMailIds = new Set(data[SEEN_MAIL_IDS_KEY]); + console.log(INBUCKET_PREFIX, `Loaded ${seenMailIds.size} previously seen mail ids`); + } + } catch (err) { + console.warn(INBUCKET_PREFIX, 'Session storage unavailable, using in-memory seen mail ids:', err?.message || err); + } +} + +async function persistSeenMailIds() { + try { + await chrome.storage.session.set({ [SEEN_MAIL_IDS_KEY]: [...seenMailIds] }); + } catch (err) { + console.warn(INBUCKET_PREFIX, 'Could not persist seen mail ids, continuing in-memory only:', err?.message || err); + } +} + +loadSeenMailIds(); + +chrome.runtime.onMessage.addListener((message, sender, sendResponse) => { + if (message.type === 'POLL_EMAIL') { + resetStopState(); + handlePollEmail(message.step, message.payload).then(result => { + sendResponse(result); + }).catch(err => { + if (isStopError(err)) { + log(`Step ${message.step}: Stopped by user.`, 'warn'); + sendResponse({ stopped: true, error: err.message }); + return; + } + reportError(message.step, err.message); + sendResponse({ error: err.message }); + }); + return true; + } +}); + +function normalizeText(value) { + return (value || '').replace(/\s+/g, ' ').trim().toLowerCase(); +} + +function extractVerificationCode(text) { + const matchCn = text.match(/(?:代码为|验证码[^0-9]*?)[\s：:]*(\d{6})/); + if (matchCn) return matchCn[1]; + + const matchEn = text.match(/code[:\s]+is[:\s]+(\d{6})|code[:\s]+(\d{6})/i); + if (matchEn) return matchEn[1] || matchEn[2]; + + const match6 = text.match(/\b(\d{6})\b/); + if (match6) return match6[1]; + + return null; +} + +function rowMatchesFilters(mail, senderFilters, subjectFilters, targetEmail) { + const sender = normalizeText(mail.sender); + const subject = normalizeText(mail.subject); + const mailbox = normalizeText(mail.mailbox); + const combined = normalizeText(mail.combinedText); + const targetLocal = normalizeText((targetEmail || '').split('@')[0]); + + const senderMatch = senderFilters.some(f => sender.includes(f.toLowerCase()) || combined.includes(f.toLowerCase())); + const subjectMatch = subjectFilters.some(f => subject.includes(f.toLowerCase()) || combined.includes(f.toLowerCase())); + const mailboxMatch = Boolean(targetLocal) && mailbox.includes(targetLocal); + const forwardedDuck = /duckduckgo|forward(?:ed)?\s*by/i.test(mail.combinedText); + const code = extractVerificationCode(mail.combinedText); + const keywordMatch = /openai|chatgpt|verify|verification|confirm|login|验证码|代码/.test(combined); + + if (mailboxMatch) return { matched: true, mailboxMatch, code }; + if (senderMatch || subjectMatch) return { matched: true, mailboxMatch: false, code }; + if (code && (forwardedDuck || keywordMatch)) return { matched: true, mailboxMatch: false, code }; + + return { matched: false, mailboxMatch: false, code }; +} + +function findMailboxEntries() { + return document.querySelectorAll('.message-list-entry'); +} + +function getMailboxEntryId(entry, index = 0) { + const explicitId = entry.getAttribute('data-id') || entry.dataset?.id || ''; + if (explicitId) return explicitId; + + const subject = entry.querySelector('.subject')?.textContent?.trim() || ''; + const sender = entry.querySelector('.from')?.textContent?.trim() || ''; + const dateText = entry.querySelector('.date')?.textContent?.trim() || ''; + + return `mailbox:${index}:${normalizeText(subject)}|${normalizeText(sender)}|${normalizeText(dateText)}`; +} + +function parseMailboxEntry(entry, index = 0) { + const subject = entry.querySelector('.subject')?.textContent?.trim() || ''; + const sender = entry.querySelector('.from')?.textContent?.trim() || ''; + const dateText = entry.querySelector('.date')?.textContent?.trim() || ''; + const combinedText = [subject, sender, dateText].filter(Boolean).join(' '); + + return { + entry, + dateText, + sender, + mailbox: '', + subject, + unread: entry.classList.contains('unseen'), + combinedText, + mailId: getMailboxEntryId(entry, index), + }; +} + +function getCurrentMailboxIds() { + const ids = new Set(); + Array.from(findMailboxEntries()).forEach((entry, index) => { + ids.add(getMailboxEntryId(entry, index)); + }); + return ids; +} + +async function refreshMailbox() { + const refreshButton = document.querySelector('button[alt="Refresh Mailbox"]'); + if (!refreshButton) return; + + simulateClick(refreshButton); + await sleep(800); +} + +async function openMailboxEntry(entry) { + simulateClick(entry); + + for (let i = 0; i < 20; i++) { + if (entry.classList.contains('selected') || document.querySelector('.message-header, .message-body, .button-bar')) { + return; + } + await sleep(150); + } +} + +async function deleteCurrentMailboxMessage(step) { + try { + const deleteButton = await waitForElement('.button-bar button.danger', 5000); + simulateClick(deleteButton); + log(`Step ${step}: Deleted mailbox message`, 'ok'); + await sleep(1200); + } catch (err) { + log(`Step ${step}: Failed to delete mailbox message: ${err.message}`, 'warn'); + } +} + +async function handleMailboxPollEmail(step, payload) { + const { + senderFilters = [], + subjectFilters = [], + maxAttempts = 20, + intervalMs = 3000, + } = payload || {}; + + log(`Step ${step}: Starting email poll on Inbucket mailbox page (max ${maxAttempts} attempts)`); + + try { + await waitForElement('.message-list, .message-list-entry', 15000); + log(`Step ${step}: Mailbox page loaded`); + } catch { + throw new Error('Inbucket mailbox page did not load. Make sure /m// is open.'); + } + + const existingMailIds = getCurrentMailboxIds(); + log(`Step ${step}: Snapshotted ${existingMailIds.size} existing mailbox messages`); + + const FALLBACK_AFTER = 3; + + for (let attempt = 1; attempt <= maxAttempts; attempt++) { + log(`Polling Inbucket mailbox... attempt ${attempt}/${maxAttempts}`); + + if (attempt > 1) { + await refreshMailbox(); + } + + const entries = Array.from(findMailboxEntries()).map(parseMailboxEntry); + const useFallback = attempt > FALLBACK_AFTER; + const candidates = []; + + for (const mail of entries) { + if (!mail.unread) continue; + if (seenMailIds.has(mail.mailId)) continue; + if (!useFallback && existingMailIds.has(mail.mailId)) continue; + + const match = rowMatchesFilters(mail, senderFilters, subjectFilters, ''); + if (!match.matched) continue; + + candidates.push({ ...mail, code: match.code }); + } + + for (const mail of candidates) { + const code = mail.code || extractVerificationCode(mail.combinedText); + if (!code) continue; + + await openMailboxEntry(mail.entry); + await deleteCurrentMailboxMessage(step); + + seenMailIds.add(mail.mailId); + await persistSeenMailIds(); + + const source = existingMailIds.has(mail.mailId) ? 'fallback' : 'new'; + log( + `Step ${step}: Code found: ${code} (${source}, sender: ${mail.sender || 'unknown'}, subject: ${(mail.subject || '').slice(0, 60)})`, + 'ok' + ); + + return { + ok: true, + code, + emailTimestamp: Date.now(), + mailId: mail.mailId, + }; + } + + if (attempt === FALLBACK_AFTER + 1) { + log(`Step ${step}: No new mailbox messages yet, falling back to older matching messages`, 'warn'); + } + + if (attempt < maxAttempts) { + await sleep(intervalMs); + } + } + + throw new Error( + `No matching verification email found in Inbucket mailbox after ${(maxAttempts * intervalMs / 1000).toFixed(0)}s. ` + + 'Check the mailbox page manually.' + ); +} + +async function handlePollEmail(step, payload) { + if (!location.pathname.startsWith('/m/')) { + throw new Error('Inbucket now only supports mailbox pages like /m//.'); + } + return handleMailboxPollEmail(step, payload); +} + +} // end of isTopFrame else block diff --git a/DouYinSparkFlow/webui/static/multiPagePlugins/content/mail-163.js b/DouYinSparkFlow/webui/static/multiPagePlugins/content/mail-163.js new file mode 100644 index 0000000..63762b9 --- /dev/null +++ b/DouYinSparkFlow/webui/static/multiPagePlugins/content/mail-163.js @@ -0,0 +1,296 @@ +// content/mail-163.js — Content script for 163 Mail (steps 4, 7) +// Injected on: mail.163.com +// +// DOM structure: +// Mail item: div[sign="letter"] with aria-label="你的 ChatGPT 代码为 479637 发件人 ： OpenAI ..." +// Sender: .nui-user (e.g., "OpenAI") +// Subject: span.da0 (e.g., "你的 ChatGPT 代码为 479637") +// Right-click menu: .nui-menu → .nui-menu-item with text "删除邮件" + +const MAIL163_PREFIX = '[MultiPage:mail-163]'; +const isTopFrame = window === window.top; + +console.log(MAIL163_PREFIX, 'Content script loaded on', location.href, 'frame:', isTopFrame ? 'top' : 'child'); + +// Only operate in the top frame +if (!isTopFrame) { + console.log(MAIL163_PREFIX, 'Skipping child frame'); +} else { + +// Track codes we've already seen — persisted in chrome.storage.session to survive script re-injection +let seenCodes = new Set(); + +async function loadSeenCodes() { + try { + const data = await chrome.storage.session.get('seenCodes'); + if (data.seenCodes && Array.isArray(data.seenCodes)) { + seenCodes = new Set(data.seenCodes); + console.log(MAIL163_PREFIX, `Loaded ${seenCodes.size} previously seen codes`); + } + } catch (err) { + console.warn(MAIL163_PREFIX, 'Session storage unavailable, using in-memory seen codes:', err?.message || err); + } +} + +// Load previously seen codes on startup +loadSeenCodes(); + +async function persistSeenCodes() { + try { + await chrome.storage.session.set({ seenCodes: [...seenCodes] }); + } catch (err) { + console.warn(MAIL163_PREFIX, 'Could not persist seen codes, continuing in-memory only:', err?.message || err); + } +} + +// ============================================================ +// Message Handler (top frame only) +// ============================================================ + +chrome.runtime.onMessage.addListener((message, sender, sendResponse) => { + if (message.type === 'POLL_EMAIL') { + resetStopState(); + handlePollEmail(message.step, message.payload).then(result => { + sendResponse(result); + }).catch(err => { + if (isStopError(err)) { + log(`Step ${message.step}: Stopped by user.`, 'warn'); + sendResponse({ stopped: true, error: err.message }); + return; + } + reportError(message.step, err.message); + sendResponse({ error: err.message }); + }); + return true; + } +}); + +// ============================================================ +// Find mail items +// ============================================================ + +function findMailItems() { + return document.querySelectorAll('div[sign="letter"]'); +} + +function getCurrentMailIds() { + const ids = new Set(); + findMailItems().forEach(item => { + const id = item.getAttribute('id') || ''; + if (id) ids.add(id); + }); + return ids; +} + +// ============================================================ +// Email Polling +// ============================================================ + +async function handlePollEmail(step, payload) { + const { senderFilters, subjectFilters, maxAttempts, intervalMs } = payload; + + log(`Step ${step}: Starting email poll on 163 Mail (max ${maxAttempts} attempts)`); + + // Click inbox in sidebar to ensure we're in inbox view + log(`Step ${step}: Waiting for sidebar...`); + try { + const inboxLink = await waitForElement('.nui-tree-item-text[title="收件箱"]', 5000); + inboxLink.click(); + log(`Step ${step}: Clicked inbox`); + } catch { + log(`Step ${step}: Inbox link not found, proceeding...`, 'warn'); + } + + // Wait for mail list to appear + log(`Step ${step}: Waiting for mail list...`); + let items = []; + for (let i = 0; i < 20; i++) { + items = findMailItems(); + if (items.length > 0) break; + await sleep(500); + } + + if (items.length === 0) { + await refreshInbox(); + await sleep(2000); + items = findMailItems(); + } + + if (items.length === 0) { + throw new Error('163 Mail list did not load. Make sure inbox is open.'); + } + + log(`Step ${step}: Mail list loaded, ${items.length} items`); + + // Snapshot existing mail IDs + const existingMailIds = getCurrentMailIds(); + log(`Step ${step}: Snapshotted ${existingMailIds.size} existing emails`); + + const FALLBACK_AFTER = 3; + + for (let attempt = 1; attempt <= maxAttempts; attempt++) { + log(`Polling 163 Mail... attempt ${attempt}/${maxAttempts}`); + + if (attempt > 1) { + await refreshInbox(); + await sleep(1000); + } + + const allItems = findMailItems(); + const useFallback = attempt > FALLBACK_AFTER; + + for (const item of allItems) { + const id = item.getAttribute('id') || ''; + + if (!useFallback && existingMailIds.has(id)) continue; + + const senderEl = item.querySelector('.nui-user'); + const sender = senderEl ? senderEl.textContent.toLowerCase() : ''; + + const subjectEl = item.querySelector('span.da0'); + const subject = subjectEl ? subjectEl.textContent : ''; + + const ariaLabel = (item.getAttribute('aria-label') || '').toLowerCase(); + + const senderMatch = senderFilters.some(f => sender.includes(f.toLowerCase()) || ariaLabel.includes(f.toLowerCase())); + const subjectMatch = subjectFilters.some(f => subject.toLowerCase().includes(f.toLowerCase()) || ariaLabel.includes(f.toLowerCase())); + + if (senderMatch || subjectMatch) { + const code = extractVerificationCode(subject + ' ' + ariaLabel); + if (code && !seenCodes.has(code)) { + seenCodes.add(code); + persistSeenCodes(); + const source = useFallback && existingMailIds.has(id) ? 'fallback' : 'new'; + log(`Step ${step}: Code found: ${code} (${source}, subject: ${subject.slice(0, 40)})`, 'ok'); + + // Delete this email via right-click menu, WAIT for it to finish before returning + await deleteEmail(item, step); + // Extra wait to ensure deletion is processed + await sleep(1000); + + return { ok: true, code, emailTimestamp: Date.now(), mailId: id }; + } else if (code && seenCodes.has(code)) { + log(`Step ${step}: Skipping already-seen code: ${code}`, 'info'); + } + } + } + + if (attempt === FALLBACK_AFTER + 1) { + log(`Step ${step}: No new emails after ${FALLBACK_AFTER} attempts, falling back to first match`, 'warn'); + } + + if (attempt < maxAttempts) { + await sleep(intervalMs); + } + } + + throw new Error( + `No new matching email found on 163 Mail after ${(maxAttempts * intervalMs / 1000).toFixed(0)}s. ` + + 'Check inbox manually.' + ); +} + +// ============================================================ +// Delete Email via Right-Click Menu +// ============================================================ + +async function deleteEmail(item, step) { + try { + log(`Step ${step}: Deleting email...`); + + // Strategy 1: Click the trash icon inside the mail item + // Each mail item has: + // These icons appear on hover, so we trigger mouseover first + item.dispatchEvent(new MouseEvent('mouseover', { bubbles: true })); + item.dispatchEvent(new MouseEvent('mouseenter', { bubbles: true })); + await sleep(300); + + const trashIcon = item.querySelector('[sign="trash"], .nui-ico-delete, [title="删除邮件"]'); + if (trashIcon) { + trashIcon.click(); + log(`Step ${step}: Clicked trash icon`, 'ok'); + await sleep(1500); + + // Check if item disappeared (confirm deletion) + const stillExists = document.getElementById(item.id); + if (!stillExists || stillExists.style.display === 'none') { + log(`Step ${step}: Email deleted successfully`); + } else { + log(`Step ${step}: Email may not have been deleted, item still visible`, 'warn'); + } + return; + } + + // Strategy 2: Select checkbox then click toolbar delete button + log(`Step ${step}: Trash icon not found, trying checkbox + toolbar delete...`); + const checkbox = item.querySelector('[sign="checkbox"], .nui-chk'); + if (checkbox) { + checkbox.click(); + await sleep(300); + + // Click toolbar delete button + const toolbarBtns = document.querySelectorAll('.nui-btn .nui-btn-text'); + for (const btn of toolbarBtns) { + if (btn.textContent.replace(/\s/g, '').includes('删除')) { + btn.closest('.nui-btn').click(); + log(`Step ${step}: Clicked toolbar delete`, 'ok'); + await sleep(1500); + return; + } + } + } + + log(`Step ${step}: Could not delete email (no delete button found)`, 'warn'); + } catch (err) { + log(`Step ${step}: Failed to delete email: ${err.message}`, 'warn'); + } +} + +// ============================================================ +// Inbox Refresh +// ============================================================ + +async function refreshInbox() { + // Try toolbar "刷 新" button + const toolbarBtns = document.querySelectorAll('.nui-btn .nui-btn-text'); + for (const btn of toolbarBtns) { + if (btn.textContent.replace(/\s/g, '') === '刷新') { + btn.closest('.nui-btn').click(); + console.log(MAIL163_PREFIX, 'Clicked "刷新" button'); + await sleep(800); + return; + } + } + + // Fallback: click sidebar "收 信" + const shouXinBtns = document.querySelectorAll('.ra0'); + for (const btn of shouXinBtns) { + if (btn.textContent.replace(/\s/g, '').includes('收信')) { + btn.click(); + console.log(MAIL163_PREFIX, 'Clicked "收信" button'); + await sleep(800); + return; + } + } + + console.log(MAIL163_PREFIX, 'Could not find refresh button'); +} + +// ============================================================ +// Verification Code Extraction +// ============================================================ + +function extractVerificationCode(text) { + const matchCn = text.match(/(?:代码为|验证码[^0-9]*?)[\s：:]*(\d{6})/); + if (matchCn) return matchCn[1]; + + const matchEn = text.match(/code[:\s]+is[:\s]+(\d{6})|code[:\s]+(\d{6})/i); + if (matchEn) return matchEn[1] || matchEn[2]; + + const match6 = text.match(/\b(\d{6})\b/); + if (match6) return match6[1]; + + return null; +} + +} // end of isTopFrame else block diff --git a/DouYinSparkFlow/webui/static/multiPagePlugins/content/qq-mail.js b/DouYinSparkFlow/webui/static/multiPagePlugins/content/qq-mail.js new file mode 100644 index 0000000..d545198 --- /dev/null +++ b/DouYinSparkFlow/webui/static/multiPagePlugins/content/qq-mail.js @@ -0,0 +1,147 @@ +// content/qq-mail.js — Content script for QQ Mail (steps 4, 7) +// Injected on: mail.qq.com, wx.mail.qq.com +// NOTE: all_frames: true +// +// Strategy for avoiding stale codes: +// 1. On poll start, snapshot all existing mail IDs as "old" +// 2. On each poll cycle, refresh inbox and look for NEW items (not in snapshot) +// 3. Only extract codes from NEW items that match sender/subject filters +// 4. Never fall back to older matching emails + +const QQ_MAIL_PREFIX = '[MultiPage:qq-mail]'; +const isTopFrame = window === window.top; + +console.log(QQ_MAIL_PREFIX, 'Content script loaded on', location.href, 'frame:', isTopFrame ? 'top' : 'child'); + +// ============================================================ +// Message Handler +// ============================================================ + +chrome.runtime.onMessage.addListener((message, sender, sendResponse) => { + if (message.type === 'POLL_EMAIL') { + if (!isTopFrame) { + sendResponse({ ok: false, reason: 'wrong-frame' }); + return; + } + resetStopState(); + handlePollEmail(message.step, message.payload).then(result => { + sendResponse(result); + }).catch(err => { + if (isStopError(err)) { + log(`Step ${message.step}: Stopped by user.`, 'warn'); + sendResponse({ stopped: true, error: err.message }); + return; + } + reportError(message.step, err.message); + sendResponse({ error: err.message }); + }); + return true; // async response + } +}); + +// ============================================================ +// Get all current mail IDs from the list +// ============================================================ + +function getCurrentMailIds() { + const ids = new Set(); + document.querySelectorAll('.mail-list-page-item[data-mailid]').forEach(item => { + ids.add(item.getAttribute('data-mailid')); + }); + return ids; +} + +function collectMailItems() { + return Array.from(document.querySelectorAll('.mail-list-page-item[data-mailid]')).map((item) => ({ + mailId: item.getAttribute('data-mailid') || '', + sender: item.querySelector('.cmp-account-nick')?.textContent || '', + subject: item.querySelector('.mail-subject')?.textContent || '', + digest: item.querySelector('.mail-digest')?.textContent || '', + })); +} + +// ============================================================ +// Email Polling +// ============================================================ + +async function handlePollEmail(step, payload) { + const { senderFilters, subjectFilters, maxAttempts, intervalMs } = payload; + + log(`Step ${step}: Starting email poll (max ${maxAttempts} attempts, every ${intervalMs / 1000}s)`); + + // Wait for mail list to load + try { + await waitForElement('.mail-list-page-item', 10000); + log(`Step ${step}: Mail list loaded`); + } catch { + throw new Error('Mail list did not load. Make sure QQ Mail inbox is open.'); + } + + // Step 1: Snapshot existing mail IDs BEFORE we start waiting for new email + const existingMailIds = getCurrentMailIds(); + log(`Step ${step}: Snapshotted ${existingMailIds.size} existing emails as "old"`); + + for (let attempt = 1; attempt <= maxAttempts; attempt++) { + log(`Polling QQ Mail... attempt ${attempt}/${maxAttempts}`); + + // Refresh inbox (skip on first attempt, list is fresh) + if (attempt > 1) { + await refreshInbox(); + await sleep(800); + } + + const result = MultiPageQQMail.findNewQQVerificationCode(collectMailItems(), { + existingMailIds: [...existingMailIds], + senderFilters, + subjectFilters, + }); + + if (result) { + log(`Step ${step}: Code found: ${result.code} (${result.source}, subject: ${result.subject.slice(0, 40)})`, 'ok'); + return { ok: true, code: result.code, emailTimestamp: Date.now(), mailId: result.mailId }; + } + + if (attempt < maxAttempts) { + await sleep(intervalMs); + } + } + + throw new Error( + `No new matching email found after ${(maxAttempts * intervalMs / 1000).toFixed(0)}s. ` + + 'Check QQ Mail manually. Email may be delayed or in spam folder.' + ); +} + +// ============================================================ +// Inbox Refresh +// ============================================================ + +async function refreshInbox() { + // Try multiple strategies to refresh the mail list + + // Strategy 1: Click any visible refresh button + const refreshBtn = document.querySelector('[class*="refresh"], [title*="刷新"]'); + if (refreshBtn) { + simulateClick(refreshBtn); + console.log(QQ_MAIL_PREFIX, 'Clicked refresh button'); + await sleep(500); + return; + } + + // Strategy 2: Click inbox in sidebar to reload list + const sidebarInbox = document.querySelector('a[href*="inbox"], [class*="folder-item"][class*="inbox"], [title="收件箱"]'); + if (sidebarInbox) { + simulateClick(sidebarInbox); + console.log(QQ_MAIL_PREFIX, 'Clicked sidebar inbox'); + await sleep(500); + return; + } + + // Strategy 3: Click the folder name in toolbar + const folderName = document.querySelector('.toolbar-folder-name'); + if (folderName) { + simulateClick(folderName); + console.log(QQ_MAIL_PREFIX, 'Clicked toolbar folder name'); + await sleep(500); + } +} diff --git a/DouYinSparkFlow/webui/static/multiPagePlugins/content/relay-firefox.js b/DouYinSparkFlow/webui/static/multiPagePlugins/content/relay-firefox.js new file mode 100644 index 0000000..5ce00f8 --- /dev/null +++ b/DouYinSparkFlow/webui/static/multiPagePlugins/content/relay-firefox.js @@ -0,0 +1,265 @@ +// content/relay-firefox.js — Content script for Firefox Relay profile page + +console.log('[MultiPage:relay-firefox] Content script loaded on', location.href); + +const { + getNextRelayMaskLabel = (labels = []) => `t${labels.length + 1}`, +} = globalThis.MultiPageEmailProvider || {}; + +const LABEL_INPUT_SELECTOR = 'input[placeholder="Add account name"], input[aria-label="Edit the label for this mask"]'; + +chrome.runtime.onMessage.addListener((message, sender, sendResponse) => { + if (message.type !== 'CREATE_RELAY_MASK' && message.type !== 'DELETE_RELAY_MASK') return; + + resetStopState(); + + const handler = message.type === 'CREATE_RELAY_MASK' + ? createRelayMask + : deleteRelayMask; + + handler(message.payload || {}).then(result => { + sendResponse(result); + }).catch(err => { + if (isStopError(err)) { + log('Relay: Stopped by user.', 'warn'); + sendResponse({ stopped: true, error: err.message }); + return; + } + sendResponse({ error: err.message }); + }); + + return true; +}); + +function getElementText(el) { + return [ + el?.innerText, + el?.textContent, + el?.getAttribute?.('aria-label'), + el?.getAttribute?.('title'), + el?.getAttribute?.('description'), + ].filter(Boolean).join(' '); +} + +function isVisible(el) { + if (!el) return false; + if (el.hidden) return false; + const style = window.getComputedStyle(el); + if (style.display === 'none' || style.visibility === 'hidden' || style.opacity === '0') { + return false; + } + return Boolean(el.offsetWidth || el.offsetHeight || el.getClientRects().length); +} + +function extractMozmail(text) { + const match = String(text || '').match(/[A-Z0-9._%+-]+@mozmail\.com/i); + return match ? match[0].toLowerCase() : ''; +} + +function getMaskButtons(root = document) { + return Array.from(root.querySelectorAll('button')).filter((button) => extractMozmail(getElementText(button))); +} + +function getMaskEmails(root = document) { + return Array.from(new Set( + getMaskButtons(root) + .map((button) => extractMozmail(getElementText(button))) + .filter(Boolean) + )); +} + +function getVisibleLabelInputs(root = document) { + return Array.from(root.querySelectorAll(LABEL_INPUT_SELECTOR)).filter(isVisible); +} + +function getExistingLabels() { + return Array.from(document.querySelectorAll(LABEL_INPUT_SELECTOR)) + .map((input) => input.value.trim()) + .filter(Boolean); +} + +function findGenerateButton() { + return document.querySelector('button[title="Generate new mask"]') + || Array.from(document.querySelectorAll('button')).find((button) => /generate new mask/i.test(getElementText(button))); +} + +function findDeleteButton(root) { + return Array.from(root.querySelectorAll('button')).find((button) => /^delete$/i.test(getElementText(button).trim())); +} + +function getMaskButtonsIn(root) { + return Array.from(root.querySelectorAll('button')).filter((button) => extractMozmail(getElementText(button))); +} + +function findMaskContainerForButton(button) { + let current = button?.parentElement || null; + + while (current && current !== document.body) { + const maskButtons = getMaskButtonsIn(current); + if (maskButtons.length === 1 && (current.querySelector(LABEL_INPUT_SELECTOR) || findDeleteButton(current))) { + return current; + } + current = current.parentElement; + } + + return button?.closest('li') || button?.parentElement || null; +} + +function findMaskRowByEmail(email) { + const normalizedEmail = String(email || '').toLowerCase(); + const button = getMaskButtons().find((candidate) => extractMozmail(getElementText(candidate)) === normalizedEmail); + if (!button) return null; + return findMaskContainerForButton(button); +} + +async function waitForNewMaskEmail(previousEmails = new Set(), timeout = 15000) { + const startedAt = Date.now(); + + while (Date.now() - startedAt < timeout) { + throwIfStopped(); + const currentEmails = getMaskEmails(); + const nextEmail = currentEmails.find((email) => !previousEmails.has(email)); + if (nextEmail) { + return nextEmail; + } + await sleep(150); + } + + throw new Error('Timed out waiting for a new Relay mask to appear.'); +} + +async function waitForMaskRow(email, timeout = 10000) { + const startedAt = Date.now(); + + while (Date.now() - startedAt < timeout) { + throwIfStopped(); + const row = findMaskRowByEmail(email); + if (row) { + return row; + } + await sleep(150); + } + + throw new Error(`Timed out waiting for Relay mask row: ${email}`); +} + +async function assignRelayLabel(maskRow) { + const labelInput = Array.from(maskRow.querySelectorAll(LABEL_INPUT_SELECTOR)).find(isVisible) + || maskRow.querySelector(LABEL_INPUT_SELECTOR); + + if (!labelInput) { + throw new Error('Could not find Relay label input for the new mask.'); + } + + const currentValue = labelInput.value.trim(); + if (currentValue) { + return currentValue; + } + + const nextLabel = getNextRelayMaskLabel(getExistingLabels()); + + await humanPause(200, 450); + fillInput(labelInput, nextLabel); + labelInput.dispatchEvent(new KeyboardEvent('keydown', { key: 'Enter', bubbles: true })); + labelInput.dispatchEvent(new KeyboardEvent('keyup', { key: 'Enter', bubbles: true })); + labelInput.blur(); + + for (let i = 0; i < 20; i++) { + throwIfStopped(); + const labels = getExistingLabels(); + if (labels.includes(nextLabel) || labelInput.value.trim() === nextLabel) { + log(`Relay: Assigned label ${nextLabel}`, 'ok'); + return nextLabel; + } + await sleep(150); + } + + throw new Error(`Relay label ${nextLabel} was not saved.`); +} + +async function createRelayMask(payload = {}) { + const { generateNew = true } = payload; + + log(`Relay: ${generateNew ? 'Creating' : 'Reading'} mask...`); + await waitForElement(LABEL_INPUT_SELECTOR + ', button[title="Generate new mask"]', 20000); + + const previousEmails = new Set(getMaskEmails()); + if (!generateNew && previousEmails.size > 0) { + const email = Array.from(previousEmails)[0]; + return { email, label: null, generated: false }; + } + + const generatorButton = findGenerateButton(); + if (!generatorButton) { + throw new Error('Could not find "Generate new mask" button on Firefox Relay.'); + } + + await humanPause(500, 1200); + simulateClick(generatorButton); + log('Relay: Clicked "Generate new mask"'); + + const email = await waitForNewMaskEmail(previousEmails); + const maskRow = await waitForMaskRow(email); + const label = await assignRelayLabel(maskRow); + + log(`Relay: Ready mask ${email}`, 'ok'); + return { email, label, generated: true }; +} + +function findVisibleDialogDeleteButton() { + const dialogButtons = Array.from(document.querySelectorAll('[role="dialog"] button, dialog button, [aria-modal="true"] button')); + return dialogButtons.find((button) => isVisible(button) && /delete|confirm|remove/i.test(getElementText(button))); +} + +async function waitForMaskRemoval(email, timeout = 15000) { + const startedAt = Date.now(); + const normalizedEmail = String(email || '').toLowerCase(); + + while (Date.now() - startedAt < timeout) { + throwIfStopped(); + const exists = getMaskEmails().includes(normalizedEmail); + if (!exists) { + return; + } + await sleep(200); + } + + throw new Error(`Timed out waiting for Relay mask deletion: ${email}`); +} + +async function deleteRelayMask(payload = {}) { + const email = String(payload.email || '').trim().toLowerCase(); + if (!email) { + throw new Error('No Relay mask email provided for deletion.'); + } + + log(`Relay: Deleting ${email}...`); + await waitForElement(LABEL_INPUT_SELECTOR + ', button[title="Generate new mask"]', 20000); + + const maskRow = await waitForMaskRow(email); + const detailsButton = Array.from(maskRow.querySelectorAll('button')).find((button) => /show mask details/i.test(getElementText(button))); + if (detailsButton && isVisible(detailsButton)) { + await humanPause(150, 300); + simulateClick(detailsButton); + await sleep(250); + } + + const deleteButton = findDeleteButton(maskRow); + if (!deleteButton) { + throw new Error(`Could not find Delete button for Relay mask ${email}.`); + } + + await humanPause(200, 400); + simulateClick(deleteButton); + + await sleep(300); + const confirmButton = findVisibleDialogDeleteButton(); + if (confirmButton) { + await humanPause(150, 300); + simulateClick(confirmButton); + } + + await waitForMaskRemoval(email); + log(`Relay: Deleted ${email}`, 'ok'); + return { deleted: true, email }; +} diff --git a/DouYinSparkFlow/webui/static/multiPagePlugins/content/signup-page.js b/DouYinSparkFlow/webui/static/multiPagePlugins/content/signup-page.js new file mode 100644 index 0000000..829cecf --- /dev/null +++ b/DouYinSparkFlow/webui/static/multiPagePlugins/content/signup-page.js @@ -0,0 +1,569 @@ +// content/signup-page.js — Content script for OpenAI auth pages (steps 2, 3, 4-receive, 5) +// Injected on: auth0.openai.com, auth.openai.com, accounts.openai.com + +console.log('[MultiPage:signup-page] Content script loaded on', location.href); + +// Listen for commands from Background +chrome.runtime.onMessage.addListener((message, sender, sendResponse) => { + if (message.type === 'GET_PAGE_STATE') { + handleCommand(message).then((result) => { + sendResponse({ ok: true, ...(result || {}) }); + }).catch(err => { + sendResponse({ error: err.message }); + }); + return true; + } + + if (message.type === 'EXECUTE_STEP' || message.type === 'FILL_CODE' || message.type === 'STEP8_FIND_AND_CLICK') { + resetStopState(); + handleCommand(message).then((result) => { + sendResponse({ ok: true, ...(result || {}) }); + }).catch(err => { + if (isStopError(err)) { + log(`Step ${message.step || 8}: Stopped by user.`, 'warn'); + sendResponse({ stopped: true, error: err.message }); + return; + } + + if (message.type === 'STEP8_FIND_AND_CLICK') { + log(`Step 8: ${err.message}`, 'error'); + sendResponse({ error: err.message }); + return; + } + + reportError(message.step, err.message); + sendResponse({ error: err.message }); + }); + return true; + } +}); + +async function handleCommand(message) { + switch (message.type) { + case 'GET_PAGE_STATE': + return getCurrentPageState(); + case 'EXECUTE_STEP': + switch (message.step) { + case 2: return await step2_clickRegister(); + case 3: return await step3_fillEmailPassword(message.payload); + case 5: return await step5_fillNameBirthday(message.payload); + case 6: return await step6_login(message.payload); + case 8: return await step8_findAndClick(); + default: throw new Error(`signup-page.js does not handle step ${message.step}`); + } + case 'FILL_CODE': + // Step 4 = signup code, Step 7 = login code (same handler) + return await fillVerificationCode(message.step, message.payload); + case 'STEP8_FIND_AND_CLICK': + return await step8_findAndClick(); + } +} + +function getCurrentPageState() { + const consentButton = findVisibleConsentButton(); + const hasVisibleContinueButton = Boolean(consentButton); + + return { + url: location.href, + hasVisibleContinueButton, + isConsentPage: MultiPageOAuthFlow.isConsentPageState({ + url: location.href, + hasVisibleContinueButton, + }), + }; +} + +// ============================================================ +// Step 2: Click Register +// ============================================================ + +async function step2_clickRegister() { + log('Step 2: Looking for Register/Sign up button...'); + + let registerBtn = null; + try { + registerBtn = await waitForElementByText( + 'a, button, [role="button"], [role="link"]', + /sign\s*up|register|create\s*account|注册/i, + 10000 + ); + } catch { + // Some pages may have a direct link + try { + registerBtn = await waitForElement('a[href*="signup"], a[href*="register"]', 5000); + } catch { + throw new Error( + 'Could not find Register/Sign up button. ' + + 'Check auth page DOM in DevTools. URL: ' + location.href + ); + } + } + + await humanPause(450, 1200); + reportComplete(2); + simulateClick(registerBtn); + log('Step 2: Clicked Register button'); +} + +// ============================================================ +// Step 3: Fill Email & Password +// ============================================================ + +async function step3_fillEmailPassword(payload) { + const { email } = payload; + if (!email) throw new Error('No email provided. Paste email in Side Panel first.'); + + log(`Step 3: Filling email: ${email}`); + + // Find email input + let emailInput = null; + try { + emailInput = await waitForElement( + 'input[type="email"], input[name="email"], input[name="username"], input[id*="email"], input[placeholder*="email"], input[placeholder*="Email"]', + 10000 + ); + } catch { + throw new Error('Could not find email input field on signup page. URL: ' + location.href); + } + + await humanPause(500, 1400); + fillInput(emailInput, email); + log('Step 3: Email filled'); + + // Check if password field is on the same page + let passwordInput = document.querySelector('input[type="password"]'); + + if (!passwordInput) { + // Need to submit email first to get to password page + log('Step 3: No password field yet, submitting email first...'); + const submitBtn = document.querySelector('button[type="submit"]') + || await waitForElementByText('button', /continue|next|submit|继续|下一步/i, 5000).catch(() => null); + + if (submitBtn) { + await humanPause(400, 1100); + simulateClick(submitBtn); + log('Step 3: Submitted email, waiting for password field...'); + await sleep(2000); + } + + try { + passwordInput = await waitForElement('input[type="password"]', 10000); + } catch { + throw new Error('Could not find password input after submitting email. URL: ' + location.href); + } + } + + if (!payload.password) throw new Error('No password provided. Step 3 requires a generated password.'); + await humanPause(600, 1500); + fillInput(passwordInput, payload.password); + log('Step 3: Password filled'); + + // Report complete BEFORE submit, because submit causes page navigation + // which kills the content script connection + reportComplete(3, { email }); + + // Submit the form (page will navigate away after this) + await sleep(500); + const submitBtn = document.querySelector('button[type="submit"]') + || await waitForElementByText('button', /continue|sign\s*up|submit|注册|创建|create/i, 5000).catch(() => null); + + if (submitBtn) { + await humanPause(500, 1300); + simulateClick(submitBtn); + log('Step 3: Form submitted'); + } +} + +// ============================================================ +// Fill Verification Code (used by step 4 and step 7) +// ============================================================ + +async function fillVerificationCode(step, payload) { + const { code } = payload; + if (!code) throw new Error('No verification code provided.'); + + log(`Step ${step}: Filling verification code: ${code}`); + + // Find code input — could be a single input or multiple separate inputs + let codeInput = null; + try { + codeInput = await waitForElement( + 'input[name="code"], input[name="otp"], input[type="text"][maxlength="6"], input[aria-label*="code"], input[placeholder*="code"], input[placeholder*="Code"], input[inputmode="numeric"]', + 10000 + ); + } catch { + // Check for multiple single-digit inputs (common pattern) + const singleInputs = document.querySelectorAll('input[maxlength="1"]'); + if (singleInputs.length >= 6) { + log(`Step ${step}: Found single-digit code inputs, filling individually...`); + for (let i = 0; i < 6 && i < singleInputs.length; i++) { + fillInput(singleInputs[i], code[i]); + await sleep(100); + } + await sleep(1000); + reportComplete(step); + return; + } + throw new Error('Could not find verification code input. URL: ' + location.href); + } + + fillInput(codeInput, code); + log(`Step ${step}: Code filled`); + + // Report complete BEFORE submit (page may navigate away) + reportComplete(step); + + // Submit + await sleep(500); + const submitBtn = document.querySelector('button[type="submit"]') + || await waitForElementByText('button', /verify|confirm|submit|continue|确认|验证/i, 5000).catch(() => null); + + if (submitBtn) { + await humanPause(450, 1200); + simulateClick(submitBtn); + log(`Step ${step}: Verification submitted`); + } +} + +// ============================================================ +// Step 6: Login with registered account (on OAuth auth page) +// ============================================================ + +async function step6_login(payload) { + const { email, password } = payload; + if (!email) throw new Error('No email provided for login.'); + + log(`Step 6: Logging in with ${email}...`); + + // Wait for email input on the auth page + let emailInput = null; + try { + emailInput = await waitForElement( + 'input[type="email"], input[name="email"], input[name="username"], input[id*="email"], input[placeholder*="email" i], input[placeholder*="Email"]', + 15000 + ); + } catch { + throw new Error('Could not find email input on login page. URL: ' + location.href); + } + + await humanPause(500, 1400); + fillInput(emailInput, email); + log('Step 6: Email filled'); + + // Submit email + await sleep(500); + const submitBtn1 = document.querySelector('button[type="submit"]') + || await waitForElementByText('button', /continue|next|submit|继续|下一步/i, 5000).catch(() => null); + if (submitBtn1) { + await humanPause(400, 1100); + simulateClick(submitBtn1); + log('Step 6: Submitted email'); + } + + const passwordInput = await waitForLoginPasswordField(); + if (passwordInput) { + log('Step 6: Password field found, filling password...'); + await humanPause(550, 1450); + fillInput(passwordInput, password); + + await sleep(500); + const submitBtn2 = document.querySelector('button[type="submit"]') + || await waitForElementByText('button', /continue|log\s*in|submit|sign\s*in|登录|继续/i, 5000).catch(() => null); + // Report complete BEFORE submit in case page navigates + reportComplete(6, { needsOTP: true }); + + if (submitBtn2) { + await humanPause(450, 1200); + simulateClick(submitBtn2); + log('Step 6: Submitted password, may need verification code (step 7)'); + } + return; + } + + // No password field — OTP flow + log('Step 6: No password field. OTP flow or auto-redirect.'); + reportComplete(6, { needsOTP: true }); +} + +async function waitForLoginPasswordField(timeout = 25000) { + const start = Date.now(); + + while (Date.now() - start < timeout) { + throwIfStopped(); + + const passwordInput = findVisiblePasswordInput(); + if (passwordInput) { + return passwordInput; + } + + await sleep(250); + } + + log(`Step 6: Password field did not appear within ${Math.round(timeout / 1000)}s.`, 'warn'); + return null; +} + +function findVisiblePasswordInput() { + const inputs = document.querySelectorAll('input[type="password"]'); + for (const input of inputs) { + if (isElementVisible(input)) { + return input; + } + } + return null; +} + +function isElementVisible(el) { + if (!el) return false; + const style = window.getComputedStyle(el); + if (style.display === 'none' || style.visibility === 'hidden' || style.opacity === '0') { + return false; + } + const rect = el.getBoundingClientRect(); + return rect.width > 0 && rect.height > 0; +} + +// ============================================================ +// Step 8: Find "继续" on OAuth consent page for debugger click +// ============================================================ +// After login + verification, page shows: +// "使用 ChatGPT 登录到 Codex" with a "继续" submit button. +// Background performs the actual click through the debugger Input API. + +async function step8_findAndClick() { + log('Step 8: Looking for OAuth consent "继续" button...'); + + const continueBtn = await findContinueButton(); + await waitForButtonEnabled(continueBtn); + + await humanPause(350, 900); + continueBtn.scrollIntoView({ behavior: 'smooth', block: 'center' }); + continueBtn.focus(); + await sleep(250); + + const rect = getSerializableRect(continueBtn); + log('Step 8: Found "继续" button and prepared debugger click coordinates.'); + return { + rect, + buttonText: (continueBtn.textContent || '').trim(), + url: location.href, + }; +} + +async function findContinueButton() { + const visibleButton = findVisibleConsentButton(); + if (visibleButton) { + return visibleButton; + } + + try { + return await waitForElement( + 'button[type="submit"][data-dd-action-name="Continue"], button[type="submit"]._primary_3rdp0_107', + 10000 + ); + } catch { + try { + return await waitForElementByText('button', /继续|Continue/, 5000); + } catch { + throw new Error('Could not find "继续" button on OAuth consent page. URL: ' + location.href); + } + } +} + +function findVisibleConsentButton() { + const selectorMatches = document.querySelectorAll( + 'button[type="submit"][data-dd-action-name="Continue"], button[type="submit"]._primary_3rdp0_107' + ); + + for (const button of selectorMatches) { + if (isElementVisible(button)) { + return button; + } + } + + const buttons = document.querySelectorAll('button'); + for (const button of buttons) { + if (!isElementVisible(button)) { + continue; + } + + if (/继续|Continue/i.test(button.textContent || '')) { + return button; + } + } + + return null; +} + +async function waitForButtonEnabled(button, timeout = 8000) { + const start = Date.now(); + while (Date.now() - start < timeout) { + throwIfStopped(); + if (isButtonEnabled(button)) return; + await sleep(150); + } + throw new Error('"继续" button stayed disabled for too long. URL: ' + location.href); +} + +function isButtonEnabled(button) { + return Boolean(button) + && !button.disabled + && button.getAttribute('aria-disabled') !== 'true'; +} + +function getSerializableRect(el) { + const rect = el.getBoundingClientRect(); + if (!rect.width || !rect.height) { + throw new Error('"继续" button has no clickable size after scrolling. URL: ' + location.href); + } + + return { + left: rect.left, + top: rect.top, + width: rect.width, + height: rect.height, + centerX: rect.left + (rect.width / 2), + centerY: rect.top + (rect.height / 2), + }; +} + +// ============================================================ +// Step 5: Fill Name & Birthday / Age +// ============================================================ + +async function step5_fillNameBirthday(payload) { + const { firstName, lastName, age, year, month, day } = payload; + if (!firstName || !lastName) throw new Error('No name data provided.'); + + const resolvedAge = age ?? (year ? new Date().getFullYear() - Number(year) : null); + const hasBirthdayData = [year, month, day].every(value => value != null && !Number.isNaN(Number(value))); + if (!hasBirthdayData && (resolvedAge == null || Number.isNaN(Number(resolvedAge)))) { + throw new Error('No birthday or age data provided.'); + } + + const fullName = `${firstName} ${lastName}`; + log(`Step 5: Filling name: ${fullName}`); + + // Actual DOM structure: + // - Full name: + // - Birthday: React Aria DateField or hidden input[name="birthday"] + // - Age: + + // --- Full Name (single field, not first+last) --- + let nameInput = null; + try { + nameInput = await waitForElement( + 'input[name="name"], input[placeholder*="全名"], input[autocomplete="name"]', + 10000 + ); + } catch { + throw new Error('Could not find name input. URL: ' + location.href); + } + await humanPause(500, 1300); + fillInput(nameInput, fullName); + log(`Step 5: Name filled: ${fullName}`); + + let birthdayMode = false; + let ageInput = null; + + for (let i = 0; i < 100; i++) { + const yearSpinner = document.querySelector('[role="spinbutton"][data-type="year"]'); + const monthSpinner = document.querySelector('[role="spinbutton"][data-type="month"]'); + const daySpinner = document.querySelector('[role="spinbutton"][data-type="day"]'); + const hiddenBirthday = document.querySelector('input[name="birthday"]'); + ageInput = document.querySelector('input[name="age"]'); + + // Some pages include a hidden birthday input even though the real UI is "age". + // In that case we must prioritize filling age to satisfy required validation. + if (ageInput) break; + + if ((yearSpinner && monthSpinner && daySpinner) || hiddenBirthday) { + birthdayMode = true; + break; + } + await sleep(100); + } + + if (birthdayMode) { + if (!hasBirthdayData) { + throw new Error('Birthday field detected, but no birthday data provided.'); + } + + const yearSpinner = document.querySelector('[role="spinbutton"][data-type="year"]'); + const monthSpinner = document.querySelector('[role="spinbutton"][data-type="month"]'); + const daySpinner = document.querySelector('[role="spinbutton"][data-type="day"]'); + + if (yearSpinner && monthSpinner && daySpinner) { + log('Step 5: Birthday fields detected, filling birthday...'); + + async function setSpinButton(el, value) { + el.focus(); + await sleep(100); + document.execCommand('selectAll', false, null); + await sleep(50); + + const valueStr = String(value); + for (const char of valueStr) { + el.dispatchEvent(new KeyboardEvent('keydown', { key: char, code: `Digit${char}`, bubbles: true })); + el.dispatchEvent(new KeyboardEvent('keypress', { key: char, code: `Digit${char}`, bubbles: true })); + el.dispatchEvent(new InputEvent('beforeinput', { inputType: 'insertText', data: char, bubbles: true })); + el.dispatchEvent(new InputEvent('input', { inputType: 'insertText', data: char, bubbles: true })); + await sleep(50); + } + + el.dispatchEvent(new KeyboardEvent('keyup', { key: 'Tab', code: 'Tab', bubbles: true })); + el.blur(); + await sleep(100); + } + + await humanPause(450, 1100); + await setSpinButton(yearSpinner, year); + await humanPause(250, 650); + await setSpinButton(monthSpinner, String(month).padStart(2, '0')); + await humanPause(250, 650); + await setSpinButton(daySpinner, String(day).padStart(2, '0')); + log(`Step 5: Birthday filled: ${year}-${String(month).padStart(2, '0')}-${String(day).padStart(2, '0')}`); + } + + const hiddenBirthday = document.querySelector('input[name="birthday"]'); + if (hiddenBirthday) { + const dateStr = `${year}-${String(month).padStart(2, '0')}-${String(day).padStart(2, '0')}`; + hiddenBirthday.value = dateStr; + hiddenBirthday.dispatchEvent(new Event('change', { bubbles: true })); + log(`Step 5: Hidden birthday input set: ${dateStr}`); + } + } else if (ageInput) { + if (resolvedAge == null || Number.isNaN(Number(resolvedAge))) { + throw new Error('Age field detected, but no age data provided.'); + } + await humanPause(500, 1300); + fillInput(ageInput, String(resolvedAge)); + log(`Step 5: Age filled: ${resolvedAge}`); + + // Some age-mode pages still submit a hidden birthday field. + // Keep it aligned with generated data so backend validation won't reject. + const hiddenBirthday = document.querySelector('input[name="birthday"]'); + if (hiddenBirthday && hasBirthdayData) { + const dateStr = `${year}-${String(month).padStart(2, '0')}-${String(day).padStart(2, '0')}`; + hiddenBirthday.value = dateStr; + hiddenBirthday.dispatchEvent(new Event('change', { bubbles: true })); + log(`Step 5: Hidden birthday input set (age mode): ${dateStr}`); + } + } else { + throw new Error('Could not find birthday or age input. URL: ' + location.href); + } + + // Click "完成帐户创建" button + await sleep(500); + const completeBtn = document.querySelector('button[type="submit"]') + || await waitForElementByText('button', /完成|create|continue|finish|done|agree/i, 5000).catch(() => null); + + // Report complete BEFORE submit (page navigates to add-phone after this) + reportComplete(5); + + if (completeBtn) { + await humanPause(500, 1300); + simulateClick(completeBtn); + log('Step 5: Clicked "完成帐户创建"'); + } +} diff --git a/DouYinSparkFlow/webui/static/multiPagePlugins/content/utils.js b/DouYinSparkFlow/webui/static/multiPagePlugins/content/utils.js new file mode 100644 index 0000000..bf8824b --- /dev/null +++ b/DouYinSparkFlow/webui/static/multiPagePlugins/content/utils.js @@ -0,0 +1,337 @@ +// content/utils.js — Shared utilities for all content scripts + +const SCRIPT_SOURCE = (() => { + if (window.__MULTIPAGE_SOURCE) return window.__MULTIPAGE_SOURCE; + const url = location.href; + if (url.includes('auth0.openai.com') || url.includes('auth.openai.com') || url.includes('accounts.openai.com')) return 'signup-page'; + if (url.includes('mail.qq.com')) return 'qq-mail'; + if (url.includes('mail.163.com')) return 'mail-163'; + if (url.includes('duckduckgo.com/email/settings/autofill')) return 'duck-mail'; + if (url.includes('relay.firefox.com/accounts/profile')) return 'relay-firefox'; + if (url.includes('mail.cloudflare.com/admin')) return 'cloudflare-temp-email'; + if (url.includes('chatgpt.com')) return 'chatgpt'; + // VPS panel — detected dynamically since URL is configurable + return 'vps-panel'; +})(); + +const LOG_PREFIX = `[MultiPage:${SCRIPT_SOURCE}]`; +const STOP_ERROR_MESSAGE = 'Flow stopped by user.'; +let flowStopped = false; + +chrome.runtime.onMessage.addListener((message) => { + if (message.type === 'STOP_FLOW') { + flowStopped = true; + console.warn(LOG_PREFIX, STOP_ERROR_MESSAGE); + } +}); + +function resetStopState() { + flowStopped = false; +} + +function isStopError(error) { + const message = typeof error === 'string' ? error : error?.message; + return message === STOP_ERROR_MESSAGE; +} + +function throwIfStopped() { + if (flowStopped) { + throw new Error(STOP_ERROR_MESSAGE); + } +} + +/** + * Wait for a DOM element to appear. + * @param {string} selector - CSS selector + * @param {number} timeout - Max wait time in ms (default 10000) + * @returns {Promise} + */ +function waitForElement(selector, timeout = 10000) { + return new Promise((resolve, reject) => { + throwIfStopped(); + + const existing = document.querySelector(selector); + if (existing) { + console.log(LOG_PREFIX, `Found immediately: ${selector}`); + log(`Found element: ${selector}`); + resolve(existing); + return; + } + + console.log(LOG_PREFIX, `Waiting for: ${selector} (timeout: ${timeout}ms)`); + log(`Waiting for selector: ${selector}...`); + + let settled = false; + let stopTimer = null; + const cleanup = () => { + if (settled) return; + settled = true; + observer.disconnect(); + clearTimeout(timer); + clearTimeout(stopTimer); + }; + + const observer = new MutationObserver(() => { + if (flowStopped) { + cleanup(); + reject(new Error(STOP_ERROR_MESSAGE)); + return; + } + const el = document.querySelector(selector); + if (el) { + cleanup(); + console.log(LOG_PREFIX, `Found after wait: ${selector}`); + log(`Found element: ${selector}`); + resolve(el); + } + }); + + observer.observe(document.body || document.documentElement, { + childList: true, + subtree: true, + }); + + const timer = setTimeout(() => { + cleanup(); + const msg = `Timeout waiting for ${selector} after ${timeout}ms on ${location.href}`; + console.error(LOG_PREFIX, msg); + reject(new Error(msg)); + }, timeout); + + const pollStop = () => { + if (settled) return; + if (flowStopped) { + cleanup(); + reject(new Error(STOP_ERROR_MESSAGE)); + return; + } + stopTimer = setTimeout(pollStop, 100); + }; + pollStop(); + }); +} + +/** + * Wait for an element matching a text pattern among multiple candidates. + * @param {string} containerSelector - Selector for candidate elements + * @param {RegExp} textPattern - Regex to match against textContent + * @param {number} timeout - Max wait time in ms + * @returns {Promise} + */ +function waitForElementByText(containerSelector, textPattern, timeout = 10000) { + return new Promise((resolve, reject) => { + throwIfStopped(); + + function search() { + const candidates = document.querySelectorAll(containerSelector); + for (const el of candidates) { + if (textPattern.test(el.textContent)) { + return el; + } + } + return null; + } + + const existing = search(); + if (existing) { + console.log(LOG_PREFIX, `Found by text immediately: ${containerSelector} matching ${textPattern}`); + log(`Found element by text: ${textPattern}`); + resolve(existing); + return; + } + + console.log(LOG_PREFIX, `Waiting for text match: ${containerSelector} / ${textPattern}`); + log(`Waiting for element with text: ${textPattern}...`); + + let settled = false; + let stopTimer = null; + const cleanup = () => { + if (settled) return; + settled = true; + observer.disconnect(); + clearTimeout(timer); + clearTimeout(stopTimer); + }; + + const observer = new MutationObserver(() => { + if (flowStopped) { + cleanup(); + reject(new Error(STOP_ERROR_MESSAGE)); + return; + } + const el = search(); + if (el) { + cleanup(); + console.log(LOG_PREFIX, `Found by text after wait: ${textPattern}`); + log(`Found element by text: ${textPattern}`); + resolve(el); + } + }); + + observer.observe(document.body || document.documentElement, { + childList: true, + subtree: true, + }); + + const timer = setTimeout(() => { + cleanup(); + const msg = `Timeout waiting for text "${textPattern}" in "${containerSelector}" after ${timeout}ms on ${location.href}`; + console.error(LOG_PREFIX, msg); + reject(new Error(msg)); + }, timeout); + + const pollStop = () => { + if (settled) return; + if (flowStopped) { + cleanup(); + reject(new Error(STOP_ERROR_MESSAGE)); + return; + } + stopTimer = setTimeout(pollStop, 100); + }; + pollStop(); + }); +} + +/** + * React-compatible form filling. + * Sets value via native setter and dispatches input + change events. + * @param {HTMLInputElement} el + * @param {string} value + */ +function fillInput(el, value) { + throwIfStopped(); + const nativeInputValueSetter = Object.getOwnPropertyDescriptor( + window.HTMLInputElement.prototype, + 'value' + ).set; + nativeInputValueSetter.call(el, value); + el.dispatchEvent(new Event('input', { bubbles: true })); + el.dispatchEvent(new Event('change', { bubbles: true })); + console.log(LOG_PREFIX, `Filled input ${el.name || el.id || el.type} with: ${value}`); + log(`Filled input [${el.name || el.id || el.type || 'unknown'}]`); +} + +/** + * Fill a select element by setting its value and triggering change. + * @param {HTMLSelectElement} el + * @param {string} value + */ +function fillSelect(el, value) { + throwIfStopped(); + el.value = value; + el.dispatchEvent(new Event('change', { bubbles: true })); + console.log(LOG_PREFIX, `Selected value ${value} in ${el.name || el.id}`); + log(`Selected [${el.name || el.id || 'unknown'}] = ${value}`); +} + +/** + * Send a log message to Side Panel via Background. + * @param {string} message + * @param {string} level - 'info' | 'ok' | 'warn' | 'error' + */ +function log(message, level = 'info') { + chrome.runtime.sendMessage({ + type: 'LOG', + source: SCRIPT_SOURCE, + step: null, + payload: { message, level, timestamp: Date.now() }, + error: null, + }); +} + +/** + * Report that this content script is loaded and ready. + */ +function reportReady() { + console.log(LOG_PREFIX, 'Content script ready'); + chrome.runtime.sendMessage({ + type: 'CONTENT_SCRIPT_READY', + source: SCRIPT_SOURCE, + step: null, + payload: {}, + error: null, + }); +} + +/** + * Report step completion. + * @param {number} step + * @param {Object} data - Step output data + */ +function reportComplete(step, data = {}) { + console.log(LOG_PREFIX, `Step ${step} completed`, data); + log(`Step ${step} completed successfully`, 'ok'); + chrome.runtime.sendMessage({ + type: 'STEP_COMPLETE', + source: SCRIPT_SOURCE, + step, + payload: data, + error: null, + }); +} + +/** + * Report step error. + * @param {number} step + * @param {string} errorMessage + */ +function reportError(step, errorMessage) { + console.error(LOG_PREFIX, `Step ${step} failed: ${errorMessage}`); + log(`Step ${step} failed: ${errorMessage}`, 'error'); + chrome.runtime.sendMessage({ + type: 'STEP_ERROR', + source: SCRIPT_SOURCE, + step, + payload: {}, + error: errorMessage, + }); +} + +/** + * Simulate a click with proper event dispatching. + * @param {Element} el + */ +function simulateClick(el) { + throwIfStopped(); + el.dispatchEvent(new MouseEvent('click', { bubbles: true, cancelable: true })); + console.log(LOG_PREFIX, `Clicked: ${el.tagName} ${el.textContent?.slice(0, 30) || ''}`); + log(`Clicked [${el.tagName}] "${el.textContent?.trim().slice(0, 30) || ''}"`); +} + +/** + * Wait a specified number of milliseconds. + * @param {number} ms + * @returns {Promise} + */ +function sleep(ms) { + return new Promise((resolve, reject) => { + const start = Date.now(); + + function tick() { + if (flowStopped) { + reject(new Error(STOP_ERROR_MESSAGE)); + return; + } + if (Date.now() - start >= ms) { + resolve(); + return; + } + setTimeout(tick, Math.min(100, Math.max(25, ms - (Date.now() - start)))); + } + + tick(); + }); +} + +async function humanPause(min = 250, max = 850) { + const duration = Math.floor(Math.random() * (max - min + 1)) + min; + await sleep(duration); +} + +// Auto-report ready on load +// Skip ready signal from child iframes of mail pages to avoid overwriting the top frame's registration +const _isMailChildFrame = (SCRIPT_SOURCE === 'qq-mail' || SCRIPT_SOURCE === 'mail-163' || SCRIPT_SOURCE === 'inbucket-mail') && window !== window.top; +if (!_isMailChildFrame) { + reportReady(); +} diff --git a/DouYinSparkFlow/webui/static/multiPagePlugins/content/vps-panel.js b/DouYinSparkFlow/webui/static/multiPagePlugins/content/vps-panel.js new file mode 100644 index 0000000..a5f34a9 --- /dev/null +++ b/DouYinSparkFlow/webui/static/multiPagePlugins/content/vps-panel.js @@ -0,0 +1,183 @@ +// content/vps-panel.js — Content script for VPS panel (steps 1, 9) +// Injected on: VPS panel (user-configured URL) +// +// Actual DOM structure (after login click): +//

+//
+// Codex OAuth +// +//
+//
+//
+//
授权链接:
+//
https://auth.openai.com/...
+//
+// +// +//
+//
+//
+// +// +//
+//
+//
+ +console.log('[MultiPage:vps-panel] Content script loaded on', location.href); + +// Listen for commands from Background +chrome.runtime.onMessage.addListener((message, sender, sendResponse) => { + if (message.type === 'EXECUTE_STEP') { + resetStopState(); + handleStep(message.step, message.payload).then(() => { + sendResponse({ ok: true }); + }).catch(err => { + if (isStopError(err)) { + log(`Step ${message.step}: Stopped by user.`, 'warn'); + sendResponse({ stopped: true, error: err.message }); + return; + } + reportError(message.step, err.message); + sendResponse({ error: err.message }); + }); + return true; + } +}); + +async function handleStep(step, payload) { + switch (step) { + case 1: return await step1_getOAuthLink(); + case 9: return await step9_vpsVerify(payload); + default: + throw new Error(`vps-panel.js does not handle step ${step}`); + } +} + +// ============================================================ +// Step 1: Get OAuth Link +// ============================================================ + +async function step1_getOAuthLink() { + log('Step 1: Waiting for VPS panel to load (auto-login may take a moment)...'); + + // The page may start at #/login and auto-redirect to #/oauth. + // Wait for the Codex OAuth card to appear (up to 30s for auto-login + redirect). + let loginBtn = null; + try { + // Wait for any card-header containing "Codex" to appear + const header = await waitForElementByText('.card-header', /codex/i, 30000); + loginBtn = header.querySelector('button.btn.btn-primary, button.btn'); + log('Step 1: Found Codex OAuth card'); + } catch { + throw new Error( + 'Codex OAuth card did not appear after 30s. Page may still be loading or not logged in. ' + + 'Current URL: ' + location.href + ); + } + + if (!loginBtn) { + throw new Error('Found Codex OAuth card but no login button inside it. URL: ' + location.href); + } + + // Check if button is disabled (already clicked / loading) + if (loginBtn.disabled) { + log('Step 1: Login button is disabled (already loading), waiting for auth URL...'); + } else { + await humanPause(500, 1400); + simulateClick(loginBtn); + log('Step 1: Clicked login button, waiting for auth URL...'); + } + + // Wait for the auth URL to appear in the specific div + let authUrlEl = null; + try { + authUrlEl = await waitForElement('[class*="authUrlValue"]', 15000); + } catch { + throw new Error( + 'Auth URL did not appear after clicking login. ' + + 'Check if VPS panel is logged in and Codex service is running. URL: ' + location.href + ); + } + + const oauthUrl = (authUrlEl.textContent || '').trim(); + if (!oauthUrl || !oauthUrl.startsWith('http')) { + throw new Error(`Invalid OAuth URL found: "${oauthUrl.slice(0, 50)}". Expected URL starting with http.`); + } + + log(`Step 1: OAuth URL obtained: ${oauthUrl.slice(0, 80)}...`, 'ok'); + reportComplete(1, { oauthUrl }); +} + +// ============================================================ +// Step 9: VPS Verify — paste localhost URL and submit +// ============================================================ + +async function step9_vpsVerify(payload) { + // Get localhostUrl from payload (passed directly by background) or fallback to state + let localhostUrl = payload?.localhostUrl; + if (!localhostUrl) { + log('Step 9: localhostUrl not in payload, fetching from state...'); + const state = await chrome.runtime.sendMessage({ type: 'GET_STATE' }); + localhostUrl = state.localhostUrl; + } + if (!localhostUrl) { + throw new Error('No localhost URL found. Complete step 8 first.'); + } + log(`Step 9: Got localhostUrl: ${localhostUrl.slice(0, 60)}...`); + + log('Step 9: Looking for callback URL input...'); + + // Find the callback URL input + // Actual DOM: + let urlInput = null; + try { + urlInput = await waitForElement('[class*="callbackSection"] input.input', 10000); + } catch { + try { + urlInput = await waitForElement('input[placeholder*="localhost"]', 5000); + } catch { + throw new Error('Could not find callback URL input on VPS panel. URL: ' + location.href); + } + } + + await humanPause(600, 1500); + fillInput(urlInput, localhostUrl); + log(`Step 9: Filled callback URL: ${localhostUrl.slice(0, 80)}...`); + + // Find and click "提交回调 URL" button + let submitBtn = null; + try { + submitBtn = await waitForElementByText( + '[class*="callbackActions"] button, [class*="callbackSection"] button', + /提交/, + 5000 + ); + } catch { + try { + submitBtn = await waitForElementByText('button.btn', /提交回调/, 5000); + } catch { + throw new Error('Could not find "提交回调 URL" button. URL: ' + location.href); + } + } + + await humanPause(450, 1200); + simulateClick(submitBtn); + log('Step 9: Clicked "提交回调 URL", waiting for authentication result...'); + + // Wait for "认证成功！" status badge to appear + try { + await waitForElementByText('.status-badge, [class*="status"]', /认证成功/, 30000); + log('Step 9: Authentication successful!', 'ok'); + } catch { + // Check if there's an error message instead + const statusEl = document.querySelector('.status-badge, [class*="status"]'); + const statusText = statusEl ? statusEl.textContent : 'unknown'; + if (/成功|success/i.test(statusText)) { + log('Step 9: Authentication successful!', 'ok'); + } else { + log(`Step 9: Status after submit: "${statusText}". May still be processing.`, 'warn'); + } + } + + reportComplete(9); +} diff --git a/DouYinSparkFlow/webui/static/multiPagePlugins/data/names.js b/DouYinSparkFlow/webui/static/multiPagePlugins/data/names.js new file mode 100644 index 0000000..12e1567 --- /dev/null +++ b/DouYinSparkFlow/webui/static/multiPagePlugins/data/names.js @@ -0,0 +1,38 @@ +// data/names.js — English name lists for random generation + +const FIRST_NAMES = [ + 'James', 'John', 'Robert', 'Michael', 'William', 'David', 'Richard', 'Joseph', 'Thomas', 'Christopher', + 'Mary', 'Patricia', 'Jennifer', 'Linda', 'Barbara', 'Elizabeth', 'Susan', 'Jessica', 'Sarah', 'Karen', + 'Daniel', 'Matthew', 'Anthony', 'Mark', 'Donald', 'Steven', 'Andrew', 'Paul', 'Joshua', 'Kenneth', + 'Emma', 'Olivia', 'Ava', 'Isabella', 'Sophia', 'Mia', 'Charlotte', 'Amelia', 'Harper', 'Evelyn', +]; + +const LAST_NAMES = [ + 'Smith', 'Johnson', 'Williams', 'Brown', 'Jones', 'Garcia', 'Miller', 'Davis', 'Rodriguez', 'Martinez', + 'Hernandez', 'Lopez', 'Gonzalez', 'Wilson', 'Anderson', 'Thomas', 'Taylor', 'Moore', 'Jackson', 'Martin', + 'Lee', 'Perez', 'Thompson', 'White', 'Harris', 'Sanchez', 'Clark', 'Ramirez', 'Lewis', 'Robinson', +]; + +/** + * Generate a random full name. + * @returns {{ firstName: string, lastName: string }} + */ +function generateRandomName() { + const firstName = FIRST_NAMES[Math.floor(Math.random() * FIRST_NAMES.length)]; + const lastName = LAST_NAMES[Math.floor(Math.random() * LAST_NAMES.length)]; + return { firstName, lastName }; +} + +/** + * Generate a random birthday (age 19-25). + * @returns {{ year: number, month: number, day: number }} + */ +function generateRandomBirthday() { + const currentYear = new Date().getFullYear(); + const age = 19 + Math.floor(Math.random() * 7); // 19 to 25 + const year = currentYear - age; + const month = 1 + Math.floor(Math.random() * 12); // 1 to 12 + const maxDay = new Date(year, month, 0).getDate(); // days in that month + const day = 1 + Math.floor(Math.random() * maxDay); + return { year, month, day }; +} diff --git a/DouYinSparkFlow/webui/static/multiPagePlugins/icons/icon128.png b/DouYinSparkFlow/webui/static/multiPagePlugins/icons/icon128.png new file mode 100644 index 0000000000000000000000000000000000000000..cfe63a09aebdb807926dba1925e5f422d1c8e910 GIT binary patch literal 2800 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 literal 0 HcmV?d00001 diff --git a/DouYinSparkFlow/webui/static/multiPagePlugins/manifest.json b/DouYinSparkFlow/webui/static/multiPagePlugins/manifest.json new file mode 100644 index 0000000..ccdace8 --- /dev/null +++ b/DouYinSparkFlow/webui/static/multiPagePlugins/manifest.json @@ -0,0 +1,78 @@ +{ + "manifest_version": 3, + "name": "Multi-Page Automation", + "version": "1.1.0", + "description": "Automates multi-step OAuth registration workflow", + "permissions": [ + "sidePanel", + "tabs", + "webNavigation", + "debugger", + "storage", + "scripting", + "activeTab" + ], + "host_permissions": [ + "" + ], + "background": { + "service_worker": "background.js" + }, + "side_panel": { + "default_path": "sidepanel/sidepanel.html" + }, + "content_scripts": [ + { + "matches": [ + "https://auth0.openai.com/*", + "https://auth.openai.com/*", + "https://accounts.openai.com/*" + ], + "js": ["content/utils.js", "shared/oauth-flow.js", "content/signup-page.js"], + "run_at": "document_idle" + }, + { + "matches": [ + "https://mail.qq.com/*", + "https://wx.mail.qq.com/*" + ], + "js": ["content/utils.js", "shared/qq-mail.js", "content/qq-mail.js"], + "all_frames": true, + "run_at": "document_idle" + }, + { + "matches": [ + "https://mail.163.com/*" + ], + "js": ["content/utils.js", "content/mail-163.js"], + "all_frames": true, + "run_at": "document_idle" + }, + { + "matches": [ + "https://duckduckgo.com/email/settings/autofill*" + ], + "js": ["content/utils.js", "content/duck-mail.js"], + "run_at": "document_idle" + }, + { + "matches": [ + "https://relay.firefox.com/accounts/profile/*" + ], + "js": ["content/utils.js", "shared/email-provider.js", "content/relay-firefox.js"], + "run_at": "document_idle" + } + ], + "action": { + "default_icon": { + "16": "icons/icon16.png", + "48": "icons/icon48.png", + "128": "icons/icon128.png" + } + }, + "icons": { + "16": "icons/icon16.png", + "48": "icons/icon48.png", + "128": "icons/icon128.png" + } +} diff --git a/DouYinSparkFlow/webui/static/multiPagePlugins/shared/cloudflare-temp-email.js b/DouYinSparkFlow/webui/static/multiPagePlugins/shared/cloudflare-temp-email.js new file mode 100644 index 0000000..f2333c4 --- /dev/null +++ b/DouYinSparkFlow/webui/static/multiPagePlugins/shared/cloudflare-temp-email.js @@ -0,0 +1,389 @@ +(function attachCloudflareTempEmailHelpers(globalScope) { + const PRIMARY_LOCAL_PART_WORD_BANKS = [ + [ + 'anew', 'brisk', 'candid', 'fervent', 'gentle', + 'humble', 'jovial', 'kindly', 'lucid', 'mellow', + 'nimble', 'open', 'polished', 'quick', 'rosy', + 'steady', 'tidy', 'upbeat', 'vantage', 'thunderous', + ], + [ + 'angled', 'bordered', 'crisp', 'eager', 'frozen', + 'golden', 'dotted', 'hushed', 'jagged', 'layered', + 'mellowed', 'narrow', 'opal', 'primal', 'quiet', + 'rippled', 'sunlit', 'trimmed', 'velvet', 'thumping', + ], + [ + 'anchor', 'beacon', 'cinder', 'drifter', 'ember', + 'meadow', 'nickel', 'orbit', 'prairie', 'quartz', + 'rivet', 'latch', 'signal', 'thicket', 'uplift', + 'voyager', 'willow', 'yonder', 'zephyr', 'wilderness', + ], + ]; + const EXTENDED_LOCAL_PART_WORD_BANKS = [ + ['aurora', 'breezy', 'copper', 'drizzle', 'whimsy', 'glimmer', 'sapphire', 'harbor', 'inkwell', 'juniper'], + ['almond', 'bronzed', 'cobbled', 'dappled', 'marbled', 'northern', 'moonlit', 'orchard', 'plaited', 'radiant'], + ['acorn', 'bramble', 'citadel', 'daybreak', 'solstice', 'harvest', 'treeline', 'updraft', 'wildfire', 'yearling'], + ]; + const MID_EXTENDED_LOCAL_PART_WORD_BANKS = [ + [ + 'citrine', 'dapper', 'elmwood', 'feather', 'gossamer', + 'halcyon', 'ivory', 'kestrel', 'lively', 'mistral', + ], + [ + 'lantern', 'mosaic', 'notched', 'oaken', 'pearled', + 'quilted', 'rusted', 'silken', 'tapered', 'umber', + ], + [ + 'meridian', 'northstar', 'overlook', 'peninsula', 'quickstep', + 'ridgeline', 'starling', 'turnpike', 'undertow', 'vale', + ], + ]; + const TOP_EXTENDED_LOCAL_PART_WORD_BANKS = [ + ['whimsy', 'afterglow', 'birdsong', 'clearwater', 'dreamscape', 'everbright', 'firecrest', 'hinterland', 'isleward', 'keystone'], + ['marbled', 'auric', 'blossomed', 'celestial', 'dawnlit', 'embered', 'frosted', 'gilded', 'heartland', 'ironbound'], + ['solstice', 'airstream', 'brightside', 'crestfall', 'dovetail', 'elmshade', 'fieldstone', 'goldleaf', 'highwater', 'ivytrail'], + ]; + const HIGH_EXTENDED_LOCAL_PART_WORD_BANKS = [ + [ + 'adrift', 'bellwether', 'cedar', 'daystar', 'emberglow', + 'fjord', 'glasswing', 'horizon', 'islander', 'jetstream', + 'kingsley', 'longview', 'moonrise', 'northbound', 'oakleaf', + 'pinelight', 'quasar', 'runestone', 'seaborne', 'trailhead', + ], + [ + 'bronzed', 'cobbled', 'drifted', 'etched', 'fernlike', + 'granulated', 'honeyed', 'indigo', 'jadeite', 'kindled', + 'lacquered', 'measured', 'navy', 'opaline', 'painted', + 'quenched', 'reeded', 'sanded', 'tempered', 'uplifted', + ], + [ + 'cosmos', 'drumbeat', 'everglade', 'fjordline', 'grove', + 'headland', 'icefield', 'journey', 'knoll', 'lagoon', + 'moorland', 'narrows', 'outpost', 'passage', 'quarry', + 'riverbend', 'shoal', 'tideline', 'upland', 'vista', + ], + ]; + const APEX_EXTENDED_LOCAL_PART_WORD_BANKS = [ + [ + 'atlas', 'bluebird', 'crestline', 'dewdrop', 'eastwind', + 'flare', 'glen', 'harvestmoon', 'iris', 'joyride', + 'kindred', 'larkspur', 'midway', 'nightfall', 'overture', + 'prairiesky', 'quill', 'rosewood', 'sunflare', 'turnstone', + 'uplight', 'violet', 'wildwood', 'xylia', 'yearbright', + 'zenway', 'amberline', 'brightshore', 'cloudrest', 'dawnsong', + ], + [ + 'bronze', 'coppered', 'dawnwashed', 'everspun', 'firelit', + 'glazed', 'harbored', 'ivied', 'jade', 'keelmarked', + 'leafed', 'misted', 'nacre', 'oakmoss', 'pearlstone', + 'quartzite', 'rainsoft', 'sunwashed', 'timbered', 'umbered', + 'velour', 'windcut', 'xanthic', 'yellowed', 'zestful', + 'ashen', 'brightened', 'coasted', 'deepwater', 'emberlit', + ], + [ + 'cosmos', 'daybreak', 'evercrest', 'fieldpath', 'groveside', + 'hilltop', 'inlet', 'junction', 'keyway', 'lakeside', + 'moonpath', 'nest', 'oakridge', 'portside', 'quayside', + 'riverside', 'stonepath', 'trailway', 'uplook', 'valecrest', + 'woodline', 'xylogrove', 'yardarm', 'zenithal', 'aircrest', + 'bayshore', 'crossing', 'driftway', 'elmtrail', 'foreside', + ], + ]; + const BASE_EXTENDED_WORD_RANGE_START = 0.91; + const MID_EXTENDED_WORD_RANGE_START = 0.95; + const TOP_EXTENDED_WORD_RANGE_START = 0.97; + const HIGH_EXTENDED_WORD_RANGE_START = 0.985; + const APEX_EXTENDED_WORD_RANGE_START = 0.993; + + function normalizeWhitespace(value) { + return String(value || '').replace(/\s+/g, ' ').trim(); + } + + function combineDistinctTextParts(parts = []) { + const seen = new Set(); + const normalizedParts = []; + + for (const part of parts) { + const value = normalizeWhitespace(part); + if (!value || seen.has(value)) { + continue; + } + seen.add(value); + normalizedParts.push(value); + } + + return normalizedParts.join(' '); + } + + function normalizeText(value) { + return normalizeWhitespace(value).toLowerCase(); + } + + function normalizeEmail(value) { + return normalizeText(value); + } + + function normalizeDomainSuffix(value) { + const match = normalizeText(value).match(/@?([a-z0-9.-]+\.[a-z]{2,})/i); + return match ? match[1].toLowerCase() : ''; + } + + function toFiniteNumber(value) { + const numeric = typeof value === 'number' ? value : Number(value); + return Number.isFinite(numeric) ? numeric : null; + } + + function parseAdminTimestamp(value) { + const match = normalizeWhitespace(value).match( + /^(\d{4})\/(\d{1,2})\/(\d{1,2})\s+(\d{1,2}):(\d{2})(?::(\d{2}))?$/ + ); + if (!match) return null; + + const [, year, month, day, hour, minute, second = '0'] = match; + const timestamp = new Date( + Number(year), + Number(month) - 1, + Number(day), + Number(hour), + Number(minute), + Number(second) + ).getTime(); + + return Number.isFinite(timestamp) ? timestamp : null; + } + + function extractVerificationCode(text) { + const content = String(text || ''); + + const matchCn = content.match(/(?:代码为|验证码[^0-9]*?)[\s：:]*(\d{6})/); + if (matchCn) return matchCn[1]; + + const matchEn = content.match(/code[:\s]+is[:\s]+(\d{6})|code[:\s]+(\d{6})/i); + if (matchEn) return matchEn[1] || matchEn[2]; + + const match6 = content.match(/\b(\d{6})\b/); + if (match6) return match6[1]; + + return null; + } + + function decodeBase64Url(segment) { + const base64 = String(segment || '') + .replace(/-/g, '+') + .replace(/_/g, '/'); + const padding = base64.length % 4 === 0 ? '' : '='.repeat(4 - (base64.length % 4)); + const padded = base64 + padding; + + if (typeof Buffer !== 'undefined') { + return Buffer.from(padded, 'base64').toString('utf8'); + } + + if (typeof atob === 'function') { + return atob(padded); + } + + throw new Error('No base64 decoder available.'); + } + + function decodeJwtPayload(token) { + const parts = String(token || '').split('.'); + if (parts.length < 2) return null; + + try { + return JSON.parse(decodeBase64Url(parts[1])); + } catch { + return null; + } + } + + function parseCloudflareMailboxCredential(token) { + const jwtMatch = String(token || '').match(/[A-Za-z0-9_-]+\.[A-Za-z0-9_-]+\.[A-Za-z0-9_-]+/); + if (!jwtMatch) return null; + + const payload = decodeJwtPayload(jwtMatch[0]); + const email = normalizeEmail(payload?.address || payload?.email || ''); + if (!email || !email.includes('@')) { + return null; + } + + const [localPart, ...domainParts] = email.split('@'); + const domain = domainParts.join('@'); + + return { + addressId: toFiniteNumber(payload?.address_id), + domain, + email, + localPart, + provenance: 'created', + }; + } + + function pickWord(words, randomFn) { + const randomValue = Math.max(0, Math.min(0.999999999999, Number(randomFn()))); + return words[Math.floor(randomValue * words.length)] || words[0]; + } + + function pickReadableWord(bankIndex, randomFn) { + const randomValue = Math.max(0, Math.min(0.999999999999, Number(randomFn()))); + const primaryWords = PRIMARY_LOCAL_PART_WORD_BANKS[bankIndex] || []; + const extendedWords = EXTENDED_LOCAL_PART_WORD_BANKS[bankIndex] || []; + const midExtendedWords = MID_EXTENDED_LOCAL_PART_WORD_BANKS[bankIndex] || []; + const topExtendedWords = TOP_EXTENDED_LOCAL_PART_WORD_BANKS[bankIndex] || []; + const highExtendedWords = HIGH_EXTENDED_LOCAL_PART_WORD_BANKS[bankIndex] || []; + const apexExtendedWords = APEX_EXTENDED_LOCAL_PART_WORD_BANKS[bankIndex] || []; + + if (apexExtendedWords.length > 0 && randomValue >= APEX_EXTENDED_WORD_RANGE_START) { + const apexExtendedSpan = 1 - APEX_EXTENDED_WORD_RANGE_START; + const apexExtendedValue = Math.min(0.999999999999, (randomValue - APEX_EXTENDED_WORD_RANGE_START) / apexExtendedSpan); + return pickWord(apexExtendedWords, () => apexExtendedValue); + } + + if (highExtendedWords.length > 0 && randomValue >= HIGH_EXTENDED_WORD_RANGE_START) { + const highExtendedSpan = APEX_EXTENDED_WORD_RANGE_START - HIGH_EXTENDED_WORD_RANGE_START; + const highExtendedValue = Math.min(0.999999999999, (randomValue - HIGH_EXTENDED_WORD_RANGE_START) / highExtendedSpan); + return pickWord(highExtendedWords, () => highExtendedValue); + } + + if (topExtendedWords.length > 0 && randomValue >= TOP_EXTENDED_WORD_RANGE_START) { + const topExtendedSpan = HIGH_EXTENDED_WORD_RANGE_START - TOP_EXTENDED_WORD_RANGE_START; + const topExtendedValue = Math.min(0.999999999999, (randomValue - TOP_EXTENDED_WORD_RANGE_START) / topExtendedSpan); + return pickWord(topExtendedWords, () => topExtendedValue); + } + + if (midExtendedWords.length > 0 && randomValue >= MID_EXTENDED_WORD_RANGE_START) { + const midExtendedSpan = TOP_EXTENDED_WORD_RANGE_START - MID_EXTENDED_WORD_RANGE_START; + const midExtendedValue = Math.min(0.999999999999, (randomValue - MID_EXTENDED_WORD_RANGE_START) / midExtendedSpan); + return pickWord(midExtendedWords, () => midExtendedValue); + } + + if (extendedWords.length > 0 && randomValue >= BASE_EXTENDED_WORD_RANGE_START) { + const extendedSpan = MID_EXTENDED_WORD_RANGE_START - BASE_EXTENDED_WORD_RANGE_START; + const extendedValue = Math.min(0.999999999999, (randomValue - BASE_EXTENDED_WORD_RANGE_START) / extendedSpan); + return pickWord(extendedWords, () => extendedValue); + } + + return pickWord(primaryWords, () => randomValue); + } + + function generateReadableLocalPart(randomFn = Math.random, maxLength = 24) { + for (let attempt = 1; attempt <= 20; attempt++) { + const value = PRIMARY_LOCAL_PART_WORD_BANKS + .map((_, bankIndex) => pickReadableWord(bankIndex, randomFn)) + .join('-'); + + if (value.length <= maxLength) { + return value; + } + } + + return 'anew-dotted-latch'; + } + + function pickRandomSuffix(options = [], randomFn = Math.random) { + const seen = new Set(); + const suffixes = []; + + for (const option of options) { + const suffix = normalizeDomainSuffix(option); + if (!suffix || seen.has(suffix)) { + continue; + } + seen.add(suffix); + suffixes.push(suffix); + } + + if (suffixes.length === 0) { + return ''; + } + + return pickWord(suffixes, randomFn); + } + + function compareMessageIds(left, right) { + const leftNumber = toFiniteNumber(left); + const rightNumber = toFiniteNumber(right); + + if (leftNumber !== null && rightNumber !== null) { + return rightNumber - leftNumber; + } + + return String(right || '').localeCompare(String(left || '')); + } + + function selectVerificationMessage(messages = [], options = {}) { + const targetEmail = normalizeEmail(options.targetEmail || ''); + const senderFilters = (options.senderFilters || []).map(normalizeText); + const subjectFilters = (options.subjectFilters || []).map(normalizeText); + const filterAfterTimestamp = toFiniteNumber(options.filterAfterTimestamp) || 0; + const candidates = []; + + for (const message of messages) { + const matchedEmail = normalizeEmail(message?.matchedEmail || message?.toEmail || ''); + if (targetEmail && matchedEmail && matchedEmail !== targetEmail) { + continue; + } + if (targetEmail && !matchedEmail) { + continue; + } + + const subject = normalizeWhitespace(message?.subject || ''); + const combinedText = normalizeWhitespace(message?.combinedText || ''); + const sender = normalizeText(message?.sender || ''); + const searchText = normalizeText(`${subject} ${combinedText}`); + const code = extractVerificationCode(`${subject} ${combinedText}`); + if (!code) { + continue; + } + + const senderMatch = senderFilters.length === 0 + || senderFilters.some((filter) => sender.includes(filter) || searchText.includes(filter)); + const subjectMatch = subjectFilters.length === 0 + || subjectFilters.some((filter) => normalizeText(subject).includes(filter) || searchText.includes(filter)); + + if (!senderMatch && !subjectMatch) { + continue; + } + + const emailTimestamp = toFiniteNumber(message?.emailTimestamp) + || parseAdminTimestamp(message?.timestampText || ''); + + if (filterAfterTimestamp > 0 && (!emailTimestamp || emailTimestamp <= filterAfterTimestamp)) { + continue; + } + + candidates.push({ + code, + emailTimestamp: emailTimestamp || 0, + matchedEmail, + messageId: message?.messageId ?? null, + subject: subject || null, + }); + } + + candidates.sort((left, right) => { + if (left.emailTimestamp !== right.emailTimestamp) { + return right.emailTimestamp - left.emailTimestamp; + } + return compareMessageIds(left.messageId, right.messageId); + }); + + return candidates[0] || null; + } + + const api = { + combineDistinctTextParts, + extractVerificationCode, + generateReadableLocalPart, + normalizeDomainSuffix, + parseAdminTimestamp, + parseCloudflareMailboxCredential, + pickRandomSuffix, + selectVerificationMessage, + }; + + globalScope.MultiPageCloudflareTempEmail = api; + + if (typeof module !== 'undefined' && module.exports) { + module.exports = api; + } +})(typeof globalThis !== 'undefined' ? globalThis : this); diff --git a/DouYinSparkFlow/webui/static/multiPagePlugins/shared/email-provider.js b/DouYinSparkFlow/webui/static/multiPagePlugins/shared/email-provider.js new file mode 100644 index 0000000..1261947 --- /dev/null +++ b/DouYinSparkFlow/webui/static/multiPagePlugins/shared/email-provider.js @@ -0,0 +1,99 @@ +(function attachEmailProviderHelpers(globalScope) { + const DEFAULT_CLOUDFLARE_TEMP_EMAIL_ADMIN_URL = 'https://mail.cloudflare.com/admin'; + const EMAIL_PROVIDER_DUCK = 'duckduckgo'; + const EMAIL_PROVIDER_RELAY_FIREFOX = 'relay_firefox'; + const EMAIL_PROVIDER_CLOUDFLARE_TEMP_EMAIL = 'cloudflare_temp_email'; + + function normalizeEmailProvider(value) { + if (value === EMAIL_PROVIDER_RELAY_FIREFOX) { + return EMAIL_PROVIDER_RELAY_FIREFOX; + } + if (value === EMAIL_PROVIDER_CLOUDFLARE_TEMP_EMAIL) { + return EMAIL_PROVIDER_CLOUDFLARE_TEMP_EMAIL; + } + return EMAIL_PROVIDER_DUCK; + } + + function isRelayFirefoxProvider(value) { + return normalizeEmailProvider(value) === EMAIL_PROVIDER_RELAY_FIREFOX; + } + + function isCloudflareTempEmailProvider(value) { + return normalizeEmailProvider(value) === EMAIL_PROVIDER_CLOUDFLARE_TEMP_EMAIL; + } + + function getEmailProviderDisplayName(value) { + if (isRelayFirefoxProvider(value)) { + return 'Firefox Relay'; + } + if (isCloudflareTempEmailProvider(value)) { + return 'Cloudflare Temp Email'; + } + return 'DuckDuckGo'; + } + + function shouldUseEmailSourceForVerification(value) { + return isCloudflareTempEmailProvider(value); + } + + function shouldSkipStep9Cleanup(value) { + return !isRelayFirefoxProvider(value); + } + + function normalizeCloudflareTempEmailAdminUrl(value) { + const raw = String(value || '').trim(); + if (!raw) { + return DEFAULT_CLOUDFLARE_TEMP_EMAIL_ADMIN_URL; + } + + const candidate = /^[a-z][a-z0-9+.-]*:\/\//i.test(raw) ? raw : `https://${raw}`; + + try { + const parsed = new URL(candidate); + parsed.pathname = parsed.pathname.replace(/\/+$/, '') || '/'; + return parsed.toString(); + } catch { + return DEFAULT_CLOUDFLARE_TEMP_EMAIL_ADMIN_URL; + } + } + + function getNextRelayMaskLabel(labels = []) { + const used = new Set(); + + for (const rawLabel of labels) { + const match = String(rawLabel || '').trim().match(/^t(\d+)$/i); + if (!match) continue; + const nextValue = Number(match[1]); + if (Number.isInteger(nextValue) && nextValue > 0) { + used.add(nextValue); + } + } + + let candidate = 1; + while (used.has(candidate)) { + candidate += 1; + } + return `t${candidate}`; + } + + const api = { + DEFAULT_CLOUDFLARE_TEMP_EMAIL_ADMIN_URL, + EMAIL_PROVIDER_CLOUDFLARE_TEMP_EMAIL, + EMAIL_PROVIDER_DUCK, + EMAIL_PROVIDER_RELAY_FIREFOX, + getEmailProviderDisplayName, + getNextRelayMaskLabel, + isCloudflareTempEmailProvider, + isRelayFirefoxProvider, + normalizeCloudflareTempEmailAdminUrl, + normalizeEmailProvider, + shouldUseEmailSourceForVerification, + shouldSkipStep9Cleanup, + }; + + globalScope.MultiPageEmailProvider = api; + + if (typeof module !== 'undefined' && module.exports) { + module.exports = api; + } +})(typeof globalThis !== 'undefined' ? globalThis : this); diff --git a/DouYinSparkFlow/webui/static/multiPagePlugins/shared/oauth-flow.js b/DouYinSparkFlow/webui/static/multiPagePlugins/shared/oauth-flow.js new file mode 100644 index 0000000..1a76680 --- /dev/null +++ b/DouYinSparkFlow/webui/static/multiPagePlugins/shared/oauth-flow.js @@ -0,0 +1,85 @@ +(function attachOAuthFlowHelpers(globalScope) { + const EXACT_CONSENT_PATH = '/sign-in-with-chatgpt/codex/consent'; + const SIGN_IN_WITH_CHATGPT_PATH_SEGMENT = '/sign-in-with-chatgpt/'; + + function parseUrl(input) { + if (!input || typeof input !== 'string') { + return null; + } + + try { + return new URL(input); + } catch { + return null; + } + } + + function isConsentUrl(url) { + const parsed = parseUrl(url); + if (!parsed) { + return false; + } + + return parsed.pathname === EXACT_CONSENT_PATH; + } + + function isConsentPageState(state = {}) { + const { hasVisibleContinueButton = false, url = '' } = state; + if (isConsentUrl(url)) { + return true; + } + + const parsed = parseUrl(url); + if (!parsed) { + return false; + } + + return parsed.pathname.includes(SIGN_IN_WITH_CHATGPT_PATH_SEGMENT) && Boolean(hasVisibleContinueButton); + } + + function hasAnyConsentPageState(states = []) { + return states.some((state) => isConsentPageState(state)); + } + + function isLoopbackCallbackUrl(url) { + const parsed = parseUrl(url); + if (!parsed) { + return false; + } + + if (parsed.protocol !== 'http:' && parsed.protocol !== 'https:') { + return false; + } + + return parsed.hostname === 'localhost' + || parsed.hostname === '127.0.0.1' + || parsed.hostname === '::1' + || parsed.hostname === '[::1]'; + } + + function findLoopbackCallbackUrl(candidates = []) { + for (const candidate of candidates) { + if (isLoopbackCallbackUrl(candidate)) { + return candidate; + } + } + + return null; + } + + const api = { + EXACT_CONSENT_PATH, + SIGN_IN_WITH_CHATGPT_PATH_SEGMENT, + findLoopbackCallbackUrl, + hasAnyConsentPageState, + isConsentPageState, + isConsentUrl, + isLoopbackCallbackUrl, + }; + + globalScope.MultiPageOAuthFlow = api; + + if (typeof module !== 'undefined' && module.exports) { + module.exports = api; + } +})(typeof globalThis !== 'undefined' ? globalThis : this); diff --git a/DouYinSparkFlow/webui/static/multiPagePlugins/shared/qq-mail.js b/DouYinSparkFlow/webui/static/multiPagePlugins/shared/qq-mail.js new file mode 100644 index 0000000..33661bb --- /dev/null +++ b/DouYinSparkFlow/webui/static/multiPagePlugins/shared/qq-mail.js @@ -0,0 +1,67 @@ +(function attachQQMailHelpers(globalScope) { + function normalizeText(value) { + return (value || '').toLowerCase(); + } + + function extractVerificationCode(text) { + const matchCn = text.match(/(?:代码为|验证码[^0-9]*?)[\s：:]*(\d{6})/); + if (matchCn) return matchCn[1]; + + const matchEn = text.match(/code[:\s]+is[:\s]+(\d{6})|code[:\s]+(\d{6})/i); + if (matchEn) return matchEn[1] || matchEn[2]; + + const match6 = text.match(/\b(\d{6})\b/); + if (match6) return match6[1]; + + return null; + } + + function findNewQQVerificationCode(messages = [], options = {}) { + const existingMailIds = new Set(options.existingMailIds || []); + const senderFilters = options.senderFilters || []; + const subjectFilters = options.subjectFilters || []; + + for (const message of messages) { + const mailId = message.mailId || ''; + if (!mailId || existingMailIds.has(mailId)) { + continue; + } + + const sender = normalizeText(message.sender); + const subject = normalizeText(message.subject); + const digest = message.digest || ''; + + const senderMatch = senderFilters.some((filter) => sender.includes(normalizeText(filter))); + const subjectMatch = subjectFilters.some((filter) => subject.includes(normalizeText(filter))); + + if (!senderMatch && !subjectMatch) { + continue; + } + + const code = extractVerificationCode(`${message.subject || ''} ${digest}`); + if (!code) { + continue; + } + + return { + code, + mailId, + source: 'new', + subject: message.subject || '', + }; + } + + return null; + } + + const api = { + extractVerificationCode, + findNewQQVerificationCode, + }; + + globalScope.MultiPageQQMail = api; + + if (typeof module !== 'undefined' && module.exports) { + module.exports = api; + } +})(typeof globalThis !== 'undefined' ? globalThis : this); diff --git a/DouYinSparkFlow/webui/static/multiPagePlugins/sidepanel/sidepanel.css b/DouYinSparkFlow/webui/static/multiPagePlugins/sidepanel/sidepanel.css new file mode 100644 index 0000000..5c16ca1 --- /dev/null +++ b/DouYinSparkFlow/webui/static/multiPagePlugins/sidepanel/sidepanel.css @@ -0,0 +1,669 @@ +/* ============================================================ + MultiPage Automation — Side Panel + Design: Swiss Modernism + Developer Tool + Font: Inter (UI) + JetBrains Mono (code) + Themes: Light (default) + Dark (toggle) + ============================================================ */ + +/* ---- Light Theme (default) ---- */ +:root { + --bg-base: #ffffff; + --bg-surface: #f7f8fa; + --bg-elevated: #eef0f4; + --bg-hover: #e4e7ec; + --bg-active: #dce0e8; + + --border: #d8dce3; + --border-subtle: #e8ecf1; + + --text-primary: #1a1d24; + --text-secondary: #5c6370; + --text-muted: #9ca3af; + + --blue: #2563eb; + --blue-soft: rgba(37, 99, 235, 0.08); + --blue-glow: rgba(37, 99, 235, 0.12); + --green: #16a34a; + --green-soft: rgba(22, 163, 74, 0.08); + --orange: #ea580c; + --orange-soft: rgba(234, 88, 12, 0.08); + --red: #dc2626; + --red-soft: rgba(220, 38, 38, 0.08); + --cyan: #0891b2; + --purple: #7c3aed; + + --shadow-sm: 0 1px 2px rgba(0,0,0,0.04); + --shadow-md: 0 2px 6px rgba(0,0,0,0.06); + + --radius-sm: 6px; + --radius-md: 8px; + --transition: 150ms ease; +} + +/* ---- Dark Theme ---- */ +[data-theme="dark"] { + --bg-base: #0f1117; + --bg-surface: #181a21; + --bg-elevated: #21242d; + --bg-hover: #2a2e38; + --bg-active: #323844; + + --border: #2a2e38; + --border-subtle: #21242d; + + --text-primary: #e4e6eb; + --text-secondary: #8b919e; + --text-muted: #565c6a; + + --blue: #3b82f6; + --blue-soft: rgba(59, 130, 246, 0.12); + --blue-glow: rgba(59, 130, 246, 0.18); + --green: #22c55e; + --green-soft: rgba(34, 197, 94, 0.12); + --orange: #f97316; + --orange-soft: rgba(249, 115, 22, 0.12); + --red: #ef4444; + --red-soft: rgba(239, 68, 68, 0.12); + --cyan: #06b6d4; + --purple: #a78bfa; + + --shadow-sm: 0 1px 2px rgba(0,0,0,0.2); + --shadow-md: 0 2px 8px rgba(0,0,0,0.3); +} + +* { margin: 0; padding: 0; box-sizing: border-box; } + +body { + font-family: 'Inter', -apple-system, BlinkMacSystemFont, sans-serif; + font-size: 14px; + color: var(--text-primary); + background: var(--bg-base); + padding: 12px; + width: 100%; + min-height: 100vh; + -webkit-font-smoothing: antialiased; + transition: background var(--transition), color var(--transition); +} + +/* ============================================================ + Header + ============================================================ */ + +header { + display: flex; + justify-content: space-between; + align-items: center; + margin-bottom: 14px; + padding-bottom: 12px; + border-bottom: 1px solid var(--border-subtle); +} + +.header-left { + display: flex; + align-items: center; + gap: 8px; +} + +.header-left svg { color: var(--blue); } + +.header-left h1 { + font-size: 16px; + font-weight: 700; + letter-spacing: -0.02em; + color: var(--text-primary); +} + +.header-btns { + display: flex; + align-items: center; + gap: 4px; +} + +/* ============================================================ + Theme Toggle + ============================================================ */ + +.theme-toggle { + width: 30px; + height: 30px; + border: none; + background: transparent; + color: var(--text-muted); + border-radius: var(--radius-sm); + cursor: pointer; + display: flex; + align-items: center; + justify-content: center; + transition: all var(--transition); +} +.theme-toggle:hover { background: var(--bg-hover); color: var(--text-primary); } +.theme-toggle .icon-moon { display: block; } +.theme-toggle .icon-sun { display: none; } +[data-theme="dark"] .theme-toggle .icon-moon { display: none; } +[data-theme="dark"] .theme-toggle .icon-sun { display: block; } + +/* ============================================================ + Buttons + ============================================================ */ + +.btn { + display: inline-flex; + align-items: center; + gap: 6px; + padding: 7px 14px; + font-family: inherit; + font-size: 13px; + font-weight: 600; + border: 1px solid transparent; + border-radius: var(--radius-sm); + cursor: pointer; + transition: all var(--transition); + white-space: nowrap; +} + +.btn-primary { + background: var(--blue); + color: #fff; +} +.btn-primary:hover { opacity: 0.9; box-shadow: 0 2px 8px var(--blue-glow); } + +.btn-success { + background: var(--green); + color: #fff; +} +.btn-success:hover { opacity: 0.9; box-shadow: 0 2px 8px var(--green-soft); } + +.btn-danger { + background: var(--red); + color: #fff; +} +.btn-danger:hover { opacity: 0.9; box-shadow: 0 2px 8px var(--red-soft); } + +.run-group { + display: flex; + align-items: center; + gap: 4px; +} + +.run-count-input { + width: 42px; + padding: 6px 4px; + text-align: center; + background: var(--bg-base); + border: 1px solid var(--border); + border-radius: var(--radius-sm); + color: var(--text-primary); + font-family: 'JetBrains Mono', monospace; + font-size: 13px; + font-weight: 600; + outline: none; +} +.run-count-input:focus { border-color: var(--blue); } +.run-count-input::-webkit-inner-spin-button { opacity: 0.5; } +.btn-success:disabled, .btn-primary:disabled, .btn-danger:disabled { background: var(--bg-elevated); color: var(--text-muted); cursor: not-allowed; box-shadow: none; } +.run-count-input:disabled { opacity: 0.5; cursor: not-allowed; } + +.btn-ghost { + background: transparent; + color: var(--text-secondary); + padding: 6px; + border-radius: var(--radius-sm); +} +.btn-ghost:hover { background: var(--bg-hover); color: var(--text-primary); } + +.btn-outline { + background: transparent; + border: 1px solid var(--border); + color: var(--text-secondary); +} +.btn-outline:hover { border-color: var(--blue); color: var(--blue); background: var(--blue-soft); } + +.btn-sm { padding: 5px 12px; font-size: 12px; } +.btn-xs { padding: 4px 10px; font-size: 11px; } + +/* ============================================================ + Data Card + ============================================================ */ + +#data-section { margin-bottom: 14px; } + +.data-card { + background: var(--bg-surface); + border: 1px solid var(--border); + border-radius: var(--radius-md); + padding: 12px 14px; + display: flex; + flex-direction: column; + gap: 9px; + box-shadow: var(--shadow-sm); +} + +.data-row { + display: flex; + align-items: center; + gap: 8px; +} + +.data-inline { + display: flex; + align-items: center; + gap: 8px; + flex: 1; + min-width: 0; +} + +.data-label { + width: 56px; + font-size: 11px; + font-weight: 700; + color: var(--text-muted); + text-transform: uppercase; + letter-spacing: 0.06em; + flex-shrink: 0; +} + +.data-value { + font-size: 13px; + color: var(--text-muted); + min-width: 0; +} + +.data-value.has-value { color: var(--text-primary); } + +.mono { + font-family: 'JetBrains Mono', 'Consolas', monospace; + font-size: 12px; +} + +.truncate { + overflow: hidden; + text-overflow: ellipsis; + white-space: nowrap; +} + +.data-input { + flex: 1; + padding: 7px 10px; + background: var(--bg-base); + border: 1px solid var(--border); + border-radius: var(--radius-sm); + color: var(--text-primary); + font-family: 'JetBrains Mono', monospace; + font-size: 13px; + outline: none; + transition: border-color var(--transition), box-shadow var(--transition); + min-width: 0; +} +.data-input::placeholder { color: var(--text-muted); } +.data-input:focus { border-color: var(--blue); box-shadow: 0 0 0 3px var(--blue-soft); } + +#btn-fetch-email { + padding-inline: 10px; +} + +#btn-toggle-password { + min-width: 58px; + padding-inline: 10px; +} + +.data-select { + flex: 1; + padding: 7px 10px; + background: var(--bg-base); + border: 1px solid var(--border); + border-radius: var(--radius-sm); + color: var(--text-primary); + font-family: inherit; + font-size: 13px; + outline: none; + cursor: pointer; + transition: border-color var(--transition); + min-width: 0; +} +.data-select:focus { border-color: var(--blue); box-shadow: 0 0 0 3px var(--blue-soft); } +[data-theme="dark"] .data-select { color-scheme: dark; } + +/* Status Bar */ +.status-bar { + display: flex; + align-items: center; + gap: 8px; + margin-top: 8px; + padding: 8px 12px; + background: var(--bg-surface); + border: 1px solid var(--border); + border-radius: var(--radius-sm); + font-size: 13px; + font-weight: 500; + color: var(--text-secondary); + box-shadow: var(--shadow-sm); +} + +.status-dot { + width: 8px; + height: 8px; + border-radius: 50%; + background: var(--text-muted); + flex-shrink: 0; + transition: background var(--transition); +} + +.status-bar.running .status-dot { + background: var(--orange); + animation: pulse 1.5s ease-in-out infinite; +} +.status-bar.running { color: var(--orange); } + +.status-bar.completed .status-dot { background: var(--green); } +.status-bar.completed { color: var(--green); } + +.status-bar.failed .status-dot { background: var(--red); } +.status-bar.failed { color: var(--red); } + +.status-bar.stopped .status-dot { background: var(--cyan); } +.status-bar.stopped { color: var(--cyan); } + +@keyframes pulse { + 0%, 100% { opacity: 1; transform: scale(1); } + 50% { opacity: 0.4; transform: scale(0.85); } +} + +/* Auto Continue Bar */ +.auto-continue-bar { + margin-top: 8px; + padding: 8px 10px; + background: var(--orange-soft); + border: 1px solid rgba(234, 88, 12, 0.2); + border-radius: var(--radius-sm); + display: flex; + align-items: center; + gap: 8px; +} +.auto-continue-bar svg { color: var(--orange); flex-shrink: 0; } +.auto-hint { font-size: 13px; color: var(--orange); flex: 1; font-weight: 500; } + +/* ============================================================ + Steps Section + ============================================================ */ + +#steps-section { margin-bottom: 14px; } + +.steps-header { + display: flex; + justify-content: space-between; + align-items: center; + margin-bottom: 8px; +} + +.section-label { + font-size: 11px; + font-weight: 700; + color: var(--text-muted); + text-transform: uppercase; + letter-spacing: 0.08em; +} + +.steps-progress { + font-family: 'JetBrains Mono', monospace; + font-size: 11px; + font-weight: 600; + color: var(--text-muted); + background: var(--bg-surface); + padding: 2px 8px; + border-radius: 10px; + border: 1px solid var(--border); +} + +.steps-list { + display: flex; + flex-direction: column; + gap: 5px; +} + +.step-row { + display: flex; + align-items: center; + gap: 8px; + padding: 1px 0; + transition: opacity var(--transition); +} + +/* Step Number Indicator */ +.step-indicator { + width: 26px; + height: 26px; + border-radius: 50%; + background: var(--bg-surface); + border: 1.5px solid var(--border); + display: flex; + align-items: center; + justify-content: center; + flex-shrink: 0; + transition: all var(--transition); +} + +.step-num { + font-size: 11px; + font-weight: 700; + color: var(--text-muted); + transition: color var(--transition); +} + +.step-row.running .step-indicator { border-color: var(--orange); background: var(--orange-soft); } +.step-row.running .step-num { color: var(--orange); } +.step-row.running .step-indicator { animation: pulse 1.5s ease-in-out infinite; } + +.step-row.completed .step-indicator { border-color: var(--green); background: var(--green-soft); } +.step-row.completed .step-num { color: var(--green); } + +.step-row.failed .step-indicator { border-color: var(--red); background: var(--red-soft); } +.step-row.failed .step-num { color: var(--red); } + +.step-row.stopped .step-indicator { border-color: var(--cyan); background: rgba(8, 145, 178, 0.08); } +.step-row.stopped .step-num { color: var(--cyan); } + +/* Step Button */ +.step-btn { + flex: 1; + padding: 8px 12px; + font-family: inherit; + font-size: 13px; + font-weight: 500; + color: var(--text-primary); + background: var(--bg-surface); + border: 1px solid var(--border); + border-radius: var(--radius-sm); + cursor: pointer; + text-align: left; + transition: all var(--transition); + box-shadow: var(--shadow-sm); +} +.step-btn:hover:not(:disabled) { background: var(--bg-hover); border-color: var(--blue); } +.step-btn:disabled { color: var(--text-muted); background: var(--bg-base); border-color: var(--border-subtle); cursor: not-allowed; opacity: 0.45; box-shadow: none; } + +.step-row.running .step-btn { border-color: var(--orange); color: var(--orange); } +.step-row.completed .step-btn { border-color: var(--border-subtle); color: var(--text-secondary); opacity: 0.7; } +.step-row.failed .step-btn { border-color: var(--red); color: var(--red); } +.step-row.stopped .step-btn { border-color: var(--cyan); color: var(--cyan); } + +.step-status { + width: 20px; + text-align: center; + font-size: 14px; + font-weight: 700; + flex-shrink: 0; +} +.step-row.completed .step-status { color: var(--green); } +.step-row.failed .step-status { color: var(--red); } +.step-row.stopped .step-status { color: var(--cyan); } + +/* ============================================================ + Log / Console Section + ============================================================ */ + +.log-header { + display: flex; + justify-content: space-between; + align-items: center; + margin-bottom: 6px; +} + +#log-area { + background: var(--bg-surface); + border: 1px solid var(--border); + border-radius: var(--radius-md); + padding: 10px 12px; + height: 220px; + overflow-y: auto; + font-family: 'JetBrains Mono', 'Consolas', monospace; + font-size: 12px; + line-height: 1.7; + color: var(--text-secondary); + box-shadow: var(--shadow-sm); +} + +#log-area::-webkit-scrollbar { width: 5px; } +#log-area::-webkit-scrollbar-track { background: transparent; } +#log-area::-webkit-scrollbar-thumb { background: var(--bg-elevated); border-radius: 4px; } +#log-area::-webkit-scrollbar-thumb:hover { background: var(--text-muted); } + +.log-line { padding: 2.5px 0; } +.log-line + .log-line { border-top: 1px solid var(--border-subtle); } + +.log-time { color: var(--text-muted); } + +.log-level { font-weight: 700; margin: 0 2px; } +.log-level-info { color: var(--blue); } +.log-level-ok { color: var(--green); } +.log-level-warn { color: var(--orange); } +.log-level-error { color: var(--red); } + +.log-step-tag { + display: inline-block; + padding: 1px 5px; + border-radius: 3px; + font-weight: 700; + font-size: 11px; + margin-right: 3px; +} +.log-step-tag.step-1 { color: var(--cyan); background: rgba(8, 145, 178, 0.08); } +.log-step-tag.step-2 { color: var(--purple); background: rgba(124, 58, 237, 0.08); } +.log-step-tag.step-3 { color: #b45309; background: rgba(180, 83, 9, 0.06); } +[data-theme="dark"] .log-step-tag.step-3 { color: #fbbf24; background: rgba(251, 191, 36, 0.1); } +.log-step-tag.step-4 { color: var(--orange); background: var(--orange-soft); } +.log-step-tag.step-5 { color: var(--green); background: var(--green-soft); } +.log-step-tag.step-6 { color: var(--cyan); background: rgba(8, 145, 178, 0.08); } +.log-step-tag.step-7 { color: var(--orange); background: var(--orange-soft); } +.log-step-tag.step-8 { color: var(--purple); background: rgba(124, 58, 237, 0.08); } +.log-step-tag.step-9 { color: var(--green); background: var(--green-soft); } + +.log-msg { color: var(--text-secondary); } +.log-line.log-ok .log-msg { color: var(--green); font-weight: 500; } +.log-line.log-error .log-msg { color: var(--red); font-weight: 500; } +.log-line.log-warn .log-msg { color: var(--orange); } + +/* ============================================================ + Animations + ============================================================ */ + +@keyframes fadeIn { + from { opacity: 0; transform: translateY(3px); } + to { opacity: 1; transform: translateY(0); } +} + +.log-line { animation: fadeIn 120ms ease-out; } + +/* ============================================================ + Toast Notifications + ============================================================ */ + +#toast-container { + position: fixed; + top: 12px; + left: 12px; + right: 12px; + z-index: 1000; + display: flex; + flex-direction: column; + gap: 6px; + pointer-events: none; +} + +.toast { + display: flex; + align-items: center; + gap: 8px; + padding: 10px 14px; + border-radius: var(--radius-md); + font-size: 13px; + font-weight: 500; + box-shadow: var(--shadow-md), 0 4px 12px rgba(0,0,0,0.1); + pointer-events: auto; + animation: toastIn 250ms ease-out; + border: 1px solid; +} + +.toast.toast-exit { + animation: toastOut 200ms ease-in forwards; +} + +.toast-error { + background: var(--red-soft); + border-color: var(--red); + color: var(--red); +} + +.toast-warn { + background: var(--orange-soft); + border-color: var(--orange); + color: var(--orange); +} + +.toast-success { + background: var(--green-soft); + border-color: var(--green); + color: var(--green); +} + +.toast-info { + background: var(--blue-soft); + border-color: var(--blue); + color: var(--blue); +} + +.toast svg { + flex-shrink: 0; +} + +.toast-msg { + flex: 1; +} + +.toast-close { + background: none; + border: none; + color: inherit; + opacity: 0.6; + cursor: pointer; + padding: 2px; + font-size: 16px; + line-height: 1; +} +.toast-close:hover { opacity: 1; } + +@keyframes toastIn { + from { opacity: 0; transform: translateY(-10px) scale(0.96); } + to { opacity: 1; transform: translateY(0) scale(1); } +} + +@keyframes toastOut { + from { opacity: 1; transform: translateY(0) scale(1); } + to { opacity: 0; transform: translateY(-10px) scale(0.96); } +} + +@media (prefers-reduced-motion: reduce) { + *, *::before, *::after { + animation-duration: 0.01ms !important; + transition-duration: 0.01ms !important; + } +} diff --git a/DouYinSparkFlow/webui/static/multiPagePlugins/sidepanel/sidepanel.html b/DouYinSparkFlow/webui/static/multiPagePlugins/sidepanel/sidepanel.html new file mode 100644 index 0000000..d88810a --- /dev/null +++ b/DouYinSparkFlow/webui/static/multiPagePlugins/sidepanel/sidepanel.html @@ -0,0 +1,179 @@ + + + + + + Multi-Page Automation + + + + + + +
+
+ + + +

MultiPage

+
+
+
+ + + +
+ + +
+
+ +
+
+
+ VPS + +
+
+ Mail + +
+
+ Source + +
+ + + +
+ Email +
+ + +
+
+
+ Password +
+ + +
+
+
+ OAuth + Waiting... +
+
+ Callback + Waiting... +
+
+
+
+ Ready +
+ +
+ +
+
+ Workflow + 0 / 9 +
+
+
+
1
+ + +
+
+
2
+ + +
+
+
3
+ + +
+
+
4
+ + +
+
+
5
+ + +
+
+
6
+ + +
+
+
7
+ + +
+
+
8
+ + +
+
+
9
+ + +
+
+
+ +
+
+ Console + +
+
+
+ +
+ + + + diff --git a/DouYinSparkFlow/webui/static/multiPagePlugins/sidepanel/sidepanel.js b/DouYinSparkFlow/webui/static/multiPagePlugins/sidepanel/sidepanel.js new file mode 100644 index 0000000..49a0037 --- /dev/null +++ b/DouYinSparkFlow/webui/static/multiPagePlugins/sidepanel/sidepanel.js @@ -0,0 +1,636 @@ +// sidepanel/sidepanel.js — Side Panel logic + +const STATUS_ICONS = { + pending: '', + running: '', + completed: '\u2713', // ✓ + failed: '\u2717', // ✗ + stopped: '\u25A0', // ■ +}; + +const logArea = document.getElementById('log-area'); +const displayOauthUrl = document.getElementById('display-oauth-url'); +const displayLocalhostUrl = document.getElementById('display-localhost-url'); +const displayStatus = document.getElementById('display-status'); +const statusBar = document.getElementById('status-bar'); +const inputEmail = document.getElementById('input-email'); +const inputPassword = document.getElementById('input-password'); +const btnFetchEmail = document.getElementById('btn-fetch-email'); +const autoHint = document.getElementById('auto-hint'); +const btnTogglePassword = document.getElementById('btn-toggle-password'); +const btnStop = document.getElementById('btn-stop'); +const btnReset = document.getElementById('btn-reset'); +const stepsProgress = document.getElementById('steps-progress'); +const btnAutoRun = document.getElementById('btn-auto-run'); +const btnAutoContinue = document.getElementById('btn-auto-continue'); +const autoContinueBar = document.getElementById('auto-continue-bar'); +const btnClearLog = document.getElementById('btn-clear-log'); +const inputVpsUrl = document.getElementById('input-vps-url'); +const selectMailProvider = document.getElementById('select-mail-provider'); +const selectEmailProvider = document.getElementById('select-email-provider'); +const rowCloudflareTempEmailUrl = document.getElementById('row-cloudflare-temp-email-url'); +const inputCloudflareTempEmailUrl = document.getElementById('input-cloudflare-temp-email-url'); +const rowInbucketHost = document.getElementById('row-inbucket-host'); +const inputInbucketHost = document.getElementById('input-inbucket-host'); +const rowInbucketMailbox = document.getElementById('row-inbucket-mailbox'); +const inputInbucketMailbox = document.getElementById('input-inbucket-mailbox'); +const inputRunCount = document.getElementById('input-run-count'); + +const { + DEFAULT_CLOUDFLARE_TEMP_EMAIL_ADMIN_URL = 'https://mail.cloudflare.com/admin', + EMAIL_PROVIDER_CLOUDFLARE_TEMP_EMAIL = 'cloudflare_temp_email', + EMAIL_PROVIDER_DUCK = 'duckduckgo', + EMAIL_PROVIDER_RELAY_FIREFOX = 'relay_firefox', + getEmailProviderDisplayName = (value) => value === 'relay_firefox' + ? 'Firefox Relay' + : value === 'cloudflare_temp_email' + ? 'Cloudflare Temp Email' + : 'DuckDuckGo', + normalizeCloudflareTempEmailAdminUrl = (value) => value || DEFAULT_CLOUDFLARE_TEMP_EMAIL_ADMIN_URL, + normalizeEmailProvider = (value) => { + if (value === 'relay_firefox') return 'relay_firefox'; + if (value === 'cloudflare_temp_email') return 'cloudflare_temp_email'; + return 'duckduckgo'; + }, +} = globalThis.MultiPageEmailProvider || {}; + +// ============================================================ +// Toast Notifications +// ============================================================ + +const toastContainer = document.getElementById('toast-container'); + +const TOAST_ICONS = { + error: '', + warn: '', + success: '', + info: '', +}; + +function showToast(message, type = 'error', duration = 4000) { + const toast = document.createElement('div'); + toast.className = `toast toast-${type}`; + toast.innerHTML = `${TOAST_ICONS[type] || ''}${escapeHtml(message)}`; + + toast.querySelector('.toast-close').addEventListener('click', () => dismissToast(toast)); + toastContainer.appendChild(toast); + + if (duration > 0) { + setTimeout(() => dismissToast(toast), duration); + } +} + +function dismissToast(toast) { + if (!toast.parentNode) return; + toast.classList.add('toast-exit'); + toast.addEventListener('animationend', () => toast.remove()); +} + +// ============================================================ +// State Restore on load +// ============================================================ + +async function restoreState() { + try { + const state = await chrome.runtime.sendMessage({ type: 'GET_STATE', source: 'sidepanel' }); + + if (state.oauthUrl) { + displayOauthUrl.textContent = state.oauthUrl; + displayOauthUrl.classList.add('has-value'); + } + if (state.localhostUrl) { + displayLocalhostUrl.textContent = state.localhostUrl; + displayLocalhostUrl.classList.add('has-value'); + } + if (state.email) { + inputEmail.value = state.email; + } + syncPasswordField(state); + if (state.vpsUrl) { + inputVpsUrl.value = state.vpsUrl; + } + if (state.mailProvider) { + selectMailProvider.value = state.mailProvider; + } + if (state.emailProvider) { + selectEmailProvider.value = normalizeEmailProvider(state.emailProvider); + } + if (state.cloudflareTempEmailAdminUrl) { + inputCloudflareTempEmailUrl.value = state.cloudflareTempEmailAdminUrl; + } + if (state.inbucketHost) { + inputInbucketHost.value = state.inbucketHost; + } + if (state.inbucketMailbox) { + inputInbucketMailbox.value = state.inbucketMailbox; + } + + if (state.stepStatuses) { + for (const [step, status] of Object.entries(state.stepStatuses)) { + updateStepUI(Number(step), status); + } + } + + if (state.logs) { + for (const entry of state.logs) { + appendLog(entry); + } + } + + updateStatusDisplay(state); + updateProgressCounter(); + updateMailProviderUI(); + updateAutoContinueHint(); + } catch (err) { + console.error('Failed to restore state:', err); + } +} + +function syncPasswordField(state) { + inputPassword.value = state.customPassword || state.password || ''; +} + +function updateMailProviderUI() { + const useInbucket = selectMailProvider.value === 'inbucket'; + const useCloudflareTempEmail = getSelectedEmailProvider() === EMAIL_PROVIDER_CLOUDFLARE_TEMP_EMAIL; + + inputCloudflareTempEmailUrl.placeholder = DEFAULT_CLOUDFLARE_TEMP_EMAIL_ADMIN_URL; + rowCloudflareTempEmailUrl.style.display = useCloudflareTempEmail ? '' : 'none'; + rowInbucketHost.style.display = useInbucket ? '' : 'none'; + rowInbucketMailbox.style.display = useInbucket ? '' : 'none'; +} + +function getSelectedEmailProvider() { + return normalizeEmailProvider(selectEmailProvider.value); +} + +function getEmailProviderName(provider = getSelectedEmailProvider()) { + return getEmailProviderDisplayName(provider); +} + +function updateAutoContinueHint() { + const provider = getSelectedEmailProvider(); + if (!autoHint) return; + if (provider === EMAIL_PROVIDER_RELAY_FIREFOX) { + autoHint.textContent = 'Use Auto to create a Relay mask, or paste manually, then continue'; + return; + } + if (provider === EMAIL_PROVIDER_CLOUDFLARE_TEMP_EMAIL) { + const configuredUrl = normalizeCloudflareTempEmailAdminUrl(inputCloudflareTempEmailUrl.value.trim()); + autoHint.textContent = `Use Auto to create a Cloudflare Temp Email mailbox from ${configuredUrl}, or paste an existing admin mailbox, then continue`; + return; + } + autoHint.textContent = 'Use Auto to fetch Duck email, or paste manually, then continue'; +} + +// ============================================================ +// UI Updates +// ============================================================ + +function updateStepUI(step, status) { + const statusEl = document.querySelector(`.step-status[data-step="${step}"]`); + const row = document.querySelector(`.step-row[data-step="${step}"]`); + + if (statusEl) statusEl.textContent = STATUS_ICONS[status] || ''; + if (row) { + row.className = `step-row ${status}`; + } + + updateButtonStates(); + updateProgressCounter(); +} + +function updateProgressCounter() { + let completed = 0; + document.querySelectorAll('.step-row').forEach(row => { + if (row.classList.contains('completed')) completed++; + }); + stepsProgress.textContent = `${completed} / 9`; +} + +function updateButtonStates() { + const statuses = {}; + document.querySelectorAll('.step-row').forEach(row => { + const step = Number(row.dataset.step); + if (row.classList.contains('completed')) statuses[step] = 'completed'; + else if (row.classList.contains('running')) statuses[step] = 'running'; + else if (row.classList.contains('failed')) statuses[step] = 'failed'; + else if (row.classList.contains('stopped')) statuses[step] = 'stopped'; + else statuses[step] = 'pending'; + }); + + const anyRunning = Object.values(statuses).some(s => s === 'running'); + + for (let step = 1; step <= 9; step++) { + const btn = document.querySelector(`.step-btn[data-step="${step}"]`); + if (!btn) continue; + + if (anyRunning) { + btn.disabled = true; + } else if (step === 1) { + btn.disabled = false; + } else { + const prevStatus = statuses[step - 1]; + const currentStatus = statuses[step]; + btn.disabled = !(prevStatus === 'completed' || currentStatus === 'failed' || currentStatus === 'completed' || currentStatus === 'stopped'); + } + } + + updateStopButtonState(anyRunning || autoContinueBar.style.display !== 'none'); +} + +function updateStopButtonState(active) { + btnStop.disabled = !active; +} + +function updateStatusDisplay(state) { + if (!state || !state.stepStatuses) return; + + statusBar.className = 'status-bar'; + + const running = Object.entries(state.stepStatuses).find(([, s]) => s === 'running'); + if (running) { + displayStatus.textContent = `Step ${running[0]} running...`; + statusBar.classList.add('running'); + return; + } + + const failed = Object.entries(state.stepStatuses).find(([, s]) => s === 'failed'); + if (failed) { + displayStatus.textContent = `Step ${failed[0]} failed`; + statusBar.classList.add('failed'); + return; + } + + const stopped = Object.entries(state.stepStatuses).find(([, s]) => s === 'stopped'); + if (stopped) { + displayStatus.textContent = `Step ${stopped[0]} stopped`; + statusBar.classList.add('stopped'); + return; + } + + const lastCompleted = Object.entries(state.stepStatuses) + .filter(([, s]) => s === 'completed') + .map(([k]) => Number(k)) + .sort((a, b) => b - a)[0]; + + if (lastCompleted === 9) { + displayStatus.textContent = 'All steps completed!'; + statusBar.classList.add('completed'); + } else if (lastCompleted) { + displayStatus.textContent = `Step ${lastCompleted} done`; + } else { + displayStatus.textContent = 'Ready'; + } +} + +function appendLog(entry) { + const time = new Date(entry.timestamp).toLocaleTimeString('en-US', { hour12: false }); + const levelLabel = entry.level.toUpperCase(); + const line = document.createElement('div'); + line.className = `log-line log-${entry.level}`; + + const stepMatch = entry.message.match(/Step (\d)/); + const stepNum = stepMatch ? stepMatch[1] : null; + + let html = `${time} `; + html += `${levelLabel} `; + if (stepNum) { + html += `S${stepNum}`; + } + html += `${escapeHtml(entry.message)}`; + + line.innerHTML = html; + logArea.appendChild(line); + logArea.scrollTop = logArea.scrollHeight; +} + +function escapeHtml(text) { + const div = document.createElement('div'); + div.textContent = text; + return div.innerHTML; +} + +async function fetchSelectedEmail() { + const defaultLabel = 'Auto'; + const provider = getSelectedEmailProvider(); + btnFetchEmail.disabled = true; + btnFetchEmail.textContent = '...'; + + try { + const response = await chrome.runtime.sendMessage({ + type: 'FETCH_PROVIDER_EMAIL', + source: 'sidepanel', + payload: { provider, generateNew: true }, + }); + + if (response?.error) { + throw new Error(response.error); + } + if (!response?.email) { + throw new Error('Provider email was not returned.'); + } + + inputEmail.value = response.email; + showToast(`Fetched ${response.email}`, 'success', 2500); + return response.email; + } catch (err) { + showToast(`Auto fetch failed: ${err.message}`, 'error'); + throw err; + } finally { + btnFetchEmail.disabled = false; + btnFetchEmail.textContent = defaultLabel; + } +} + +function syncPasswordToggleLabel() { + btnTogglePassword.textContent = inputPassword.type === 'password' ? 'Show' : 'Hide'; +} + +// ============================================================ +// Button Handlers +// ============================================================ + +document.querySelectorAll('.step-btn').forEach(btn => { + btn.addEventListener('click', async () => { + const step = Number(btn.dataset.step); + if (step === 3) { + const provider = getSelectedEmailProvider(); + const email = inputEmail.value.trim(); + if (provider === EMAIL_PROVIDER_DUCK && !email) { + showToast('Please paste email address or use Auto first', 'warn'); + return; + } + const payload = provider === EMAIL_PROVIDER_DUCK ? { step, email } : { step }; + await chrome.runtime.sendMessage({ type: 'EXECUTE_STEP', source: 'sidepanel', payload }); + } else { + await chrome.runtime.sendMessage({ type: 'EXECUTE_STEP', source: 'sidepanel', payload: { step } }); + } + }); +}); + +btnFetchEmail.addEventListener('click', async () => { + await fetchSelectedEmail().catch(() => {}); +}); + +btnTogglePassword.addEventListener('click', () => { + inputPassword.type = inputPassword.type === 'password' ? 'text' : 'password'; + syncPasswordToggleLabel(); +}); + +btnStop.addEventListener('click', async () => { + btnStop.disabled = true; + await chrome.runtime.sendMessage({ type: 'STOP_FLOW', source: 'sidepanel', payload: {} }); + showToast('Stopping current flow...', 'warn', 2000); +}); + +// Auto Run +btnAutoRun.addEventListener('click', async () => { + const totalRuns = parseInt(inputRunCount.value) || 1; + btnAutoRun.disabled = true; + inputRunCount.disabled = true; + btnAutoRun.innerHTML = ' Running...'; + await chrome.runtime.sendMessage({ type: 'AUTO_RUN', source: 'sidepanel', payload: { totalRuns } }); +}); + +btnAutoContinue.addEventListener('click', async () => { + const provider = getSelectedEmailProvider(); + const email = inputEmail.value.trim(); + if (!email) { + showToast(`Please fetch or paste ${getEmailProviderName(provider)} email first!`, 'warn'); + return; + } + autoContinueBar.style.display = 'none'; + await chrome.runtime.sendMessage({ type: 'RESUME_AUTO_RUN', source: 'sidepanel', payload: { email } }); +}); + +// Reset +btnReset.addEventListener('click', async () => { + if (confirm('Reset all steps and data?')) { + await chrome.runtime.sendMessage({ type: 'RESET', source: 'sidepanel' }); + displayOauthUrl.textContent = 'Waiting...'; + displayOauthUrl.classList.remove('has-value'); + displayLocalhostUrl.textContent = 'Waiting...'; + displayLocalhostUrl.classList.remove('has-value'); + inputEmail.value = ''; + displayStatus.textContent = 'Ready'; + statusBar.className = 'status-bar'; + logArea.innerHTML = ''; + document.querySelectorAll('.step-row').forEach(row => row.className = 'step-row'); + document.querySelectorAll('.step-status').forEach(el => el.textContent = ''); + btnAutoRun.disabled = false; + inputRunCount.disabled = false; + btnAutoRun.innerHTML = ' Auto'; + autoContinueBar.style.display = 'none'; + updateStopButtonState(false); + updateButtonStates(); + updateProgressCounter(); + } +}); + +// Clear log +btnClearLog.addEventListener('click', () => { + logArea.innerHTML = ''; +}); + +// Save settings on change +inputEmail.addEventListener('change', async () => { + const email = inputEmail.value.trim(); + if (email) { + await chrome.runtime.sendMessage({ type: 'SAVE_EMAIL', source: 'sidepanel', payload: { email } }); + } +}); + +inputVpsUrl.addEventListener('change', async () => { + const vpsUrl = inputVpsUrl.value.trim(); + if (vpsUrl) { + await chrome.runtime.sendMessage({ type: 'SAVE_SETTING', source: 'sidepanel', payload: { vpsUrl } }); + } +}); + +inputPassword.addEventListener('change', async () => { + await chrome.runtime.sendMessage({ + type: 'SAVE_SETTING', + source: 'sidepanel', + payload: { customPassword: inputPassword.value }, + }); +}); + +selectMailProvider.addEventListener('change', async () => { + updateMailProviderUI(); + await chrome.runtime.sendMessage({ + type: 'SAVE_SETTING', source: 'sidepanel', + payload: { mailProvider: selectMailProvider.value }, + }); +}); + +selectEmailProvider.addEventListener('change', async () => { + updateMailProviderUI(); + updateAutoContinueHint(); + await chrome.runtime.sendMessage({ + type: 'SAVE_SETTING', + source: 'sidepanel', + payload: { emailProvider: getSelectedEmailProvider() }, + }); +}); + +inputCloudflareTempEmailUrl.addEventListener('change', async () => { + updateAutoContinueHint(); + await chrome.runtime.sendMessage({ + type: 'SAVE_SETTING', + source: 'sidepanel', + payload: { cloudflareTempEmailAdminUrl: inputCloudflareTempEmailUrl.value.trim() }, + }); +}); + +inputInbucketMailbox.addEventListener('change', async () => { + await chrome.runtime.sendMessage({ + type: 'SAVE_SETTING', + source: 'sidepanel', + payload: { inbucketMailbox: inputInbucketMailbox.value.trim() }, + }); +}); + +inputInbucketHost.addEventListener('change', async () => { + await chrome.runtime.sendMessage({ + type: 'SAVE_SETTING', + source: 'sidepanel', + payload: { inbucketHost: inputInbucketHost.value.trim() }, + }); +}); + +// ============================================================ +// Listen for Background broadcasts +// ============================================================ + +chrome.runtime.onMessage.addListener((message) => { + switch (message.type) { + case 'LOG_ENTRY': + appendLog(message.payload); + if (message.payload.level === 'error') { + showToast(message.payload.message, 'error'); + } + break; + + case 'STEP_STATUS_CHANGED': { + const { step, status } = message.payload; + updateStepUI(step, status); + chrome.runtime.sendMessage({ type: 'GET_STATE', source: 'sidepanel' }).then(updateStatusDisplay); + if (status === 'completed') { + chrome.runtime.sendMessage({ type: 'GET_STATE', source: 'sidepanel' }).then(state => { + syncPasswordField(state); + if (state.oauthUrl) { + displayOauthUrl.textContent = state.oauthUrl; + displayOauthUrl.classList.add('has-value'); + } + if (state.localhostUrl) { + displayLocalhostUrl.textContent = state.localhostUrl; + displayLocalhostUrl.classList.add('has-value'); + } + }); + } + break; + } + + case 'AUTO_RUN_RESET': { + // Full UI reset for next run + displayOauthUrl.textContent = 'Waiting...'; + displayOauthUrl.classList.remove('has-value'); + displayLocalhostUrl.textContent = 'Waiting...'; + displayLocalhostUrl.classList.remove('has-value'); + inputEmail.value = ''; + displayStatus.textContent = 'Ready'; + statusBar.className = 'status-bar'; + logArea.innerHTML = ''; + document.querySelectorAll('.step-row').forEach(row => row.className = 'step-row'); + document.querySelectorAll('.step-status').forEach(el => el.textContent = ''); + updateStopButtonState(false); + updateProgressCounter(); + break; + } + + case 'DATA_UPDATED': { + if (message.payload.email) { + inputEmail.value = message.payload.email; + } + if (message.payload.password !== undefined) { + inputPassword.value = message.payload.password || ''; + } + if (message.payload.oauthUrl) { + displayOauthUrl.textContent = message.payload.oauthUrl; + displayOauthUrl.classList.add('has-value'); + } + if (message.payload.localhostUrl) { + displayLocalhostUrl.textContent = message.payload.localhostUrl; + displayLocalhostUrl.classList.add('has-value'); + } + break; + } + + case 'AUTO_RUN_STATUS': { + const { phase, currentRun, totalRuns } = message.payload; + const runLabel = totalRuns > 1 ? ` (${currentRun}/${totalRuns})` : ''; + switch (phase) { + case 'waiting_email': + autoContinueBar.style.display = 'flex'; + btnAutoRun.innerHTML = `Paused${runLabel}`; + updateStopButtonState(true); + break; + case 'running': + btnAutoRun.innerHTML = `Running${runLabel}`; + updateStopButtonState(true); + break; + case 'complete': + btnAutoRun.disabled = false; + inputRunCount.disabled = false; + btnAutoRun.innerHTML = ' Auto'; + autoContinueBar.style.display = 'none'; + updateStopButtonState(false); + break; + case 'stopped': + btnAutoRun.disabled = false; + inputRunCount.disabled = false; + btnAutoRun.innerHTML = ' Auto'; + autoContinueBar.style.display = 'none'; + updateStopButtonState(false); + break; + } + break; + } + } +}); + +// ============================================================ +// Theme Toggle +// ============================================================ + +const btnTheme = document.getElementById('btn-theme'); + +function setTheme(theme) { + document.documentElement.setAttribute('data-theme', theme); + localStorage.setItem('multipage-theme', theme); +} + +function initTheme() { + const saved = localStorage.getItem('multipage-theme'); + if (saved) { + setTheme(saved); + } else if (window.matchMedia('(prefers-color-scheme: dark)').matches) { + setTheme('dark'); + } +} + +btnTheme.addEventListener('click', () => { + const current = document.documentElement.getAttribute('data-theme'); + setTheme(current === 'dark' ? 'light' : 'dark'); +}); + +// ============================================================ +// Init +// ============================================================ + +initTheme(); +restoreState().then(() => { + syncPasswordToggleLabel(); + updateButtonStates(); +}); diff --git a/DouYinSparkFlow/webui/static/multiPagePlugins/tests/cloudflare-temp-email.test.js b/DouYinSparkFlow/webui/static/multiPagePlugins/tests/cloudflare-temp-email.test.js new file mode 100644 index 0000000..f0c74d8 --- /dev/null +++ b/DouYinSparkFlow/webui/static/multiPagePlugins/tests/cloudflare-temp-email.test.js @@ -0,0 +1,221 @@ +const test = require('node:test'); +const assert = require('node:assert/strict'); + +const { + combineDistinctTextParts, + extractVerificationCode, + generateReadableLocalPart, + parseAdminTimestamp, + parseCloudflareMailboxCredential, + pickRandomSuffix, + selectVerificationMessage, +} = require('../shared/cloudflare-temp-email.js'); + +function createJwt(payload) { + const header = Buffer.from(JSON.stringify({ alg: 'HS256', typ: 'JWT' })).toString('base64url'); + const body = Buffer.from(JSON.stringify(payload)).toString('base64url'); + return `${header}.${body}.signature`; +} + +test('parseCloudflareMailboxCredential decodes email and address id from JWT token', () => { + const token = createJwt({ + address: 'newmask@co.example.test', + address_id: 42, + }); + + assert.deepEqual(parseCloudflareMailboxCredential(token), { + addressId: 42, + domain: 'co.example.test', + email: 'newmask@co.example.test', + localPart: 'newmask', + provenance: 'created', + }); +}); + +test('parseAdminTimestamp parses admin timestamps into epoch milliseconds', () => { + const value = parseAdminTimestamp('2026/4/7 10:33:07'); + assert.equal(Number.isFinite(value), true); + assert.equal(new Date(value).getFullYear(), 2026); +}); + +test('extractVerificationCode reads six-digit codes from mixed-language subjects', () => { + assert.equal(extractVerificationCode('Your ChatGPT code is 377680'), '377680'); + assert.equal(extractVerificationCode('你的 ChatGPT 代码为 479637，请勿泄露。'), '479637'); +}); + +test('combineDistinctTextParts collapses duplicated text fragments from DOM sources', () => { + const value = combineDistinctTextParts([ + '账号', + '账号', + ' 账号 ', + '', + null, + ]); + + assert.equal(value, '账号'); +}); + +test('combineDistinctTextParts keeps distinct fragments in order', () => { + const value = combineDistinctTextParts([ + '邮箱地址凭证', + 'token-value', + 'token-value', + '关闭', + ]); + + assert.equal(value, '邮箱地址凭证 token-value 关闭'); +}); + +test('generateReadableLocalPart creates three lowercase hyphenated words', () => { + const value = generateReadableLocalPart(() => 0); + + assert.match(value, /^[a-z]+-[a-z]+-[a-z]+$/); + assert.equal(value.split('-').length, 3); +}); + +test('generateReadableLocalPart is deterministic for a fixed random sequence', () => { + const sequence = [0.02, 0.31, 0.58]; + let index = 0; + const value = generateReadableLocalPart(() => sequence[index++]); + + assert.equal(value, 'anew-dotted-latch'); +}); + +test('generateReadableLocalPart retries until the generated local part fits the max length', () => { + const sequence = [ + 0.98, 0.98, 0.98, + 0.02, 0.31, 0.58, + ]; + let index = 0; + const value = generateReadableLocalPart(() => sequence[index++], 20); + + assert.equal(value.length <= 20, true); + assert.equal(value, 'anew-dotted-latch'); +}); + +test('generateReadableLocalPart can use newly added higher-range words', () => { + const sequence = [0.9, 0.9, 0.9]; + let index = 0; + const value = generateReadableLocalPart(() => sequence[index++]); + + assert.equal(value, 'vantage-velvet-zephyr'); +}); + +test('generateReadableLocalPart can use extended top-range words', () => { + const sequence = [0.97, 0.97, 0.97]; + let index = 0; + const value = generateReadableLocalPart(() => sequence[index++]); + + assert.equal(value, 'whimsy-marbled-solstice'); +}); + +test('generateReadableLocalPart can use extended mid-range words', () => { + const sequence = [0.962, 0.962, 0.962]; + let index = 0; + const value = generateReadableLocalPart(() => sequence[index++]); + + assert.equal(value, 'ivory-rusted-starling'); +}); + +test('generateReadableLocalPart can use extended apex-range words', () => { + const sequence = [0.993, 0.993, 0.993]; + let index = 0; + const value = generateReadableLocalPart(() => sequence[index++]); + + assert.equal(value, 'atlas-bronze-cosmos'); +}); + +test('pickRandomSuffix selects a deterministic suffix from the available options', () => { + const value = pickRandomSuffix([ + 'co.example.test', + 'de.example.test', + 'ice.example.test', + 'work.example.test', + ], () => 0.74); + + assert.equal(value, 'ice.example.test'); +}); + +test('pickRandomSuffix ignores empty and duplicate suffix values', () => { + const value = pickRandomSuffix([ + ' co.example.test ', + '', + null, + 'de.example.test', + '@ICE.example.test', + 'de.example.test', + ], () => 0.9); + + assert.equal(value, 'ice.example.test'); +}); + +test('selectVerificationMessage ignores messages for other recipients', () => { + const result = selectVerificationMessage([ + { + combinedText: 'Your ChatGPT code is 123456', + emailTimestamp: parseAdminTimestamp('2026/4/7 10:33:07'), + matchedEmail: 'someone-else@co.example.test', + messageId: '11', + subject: 'Your ChatGPT code is 123456', + }, + ], { + filterAfterTimestamp: 0, + senderFilters: ['openai'], + subjectFilters: ['code'], + targetEmail: 'target@co.example.test', + }); + + assert.equal(result, null); +}); + +test('selectVerificationMessage requires a strictly newer timestamp than filterAfterTimestamp', () => { + const ts = parseAdminTimestamp('2026/4/7 10:33:07'); + const result = selectVerificationMessage([ + { + combinedText: 'Enter this temporary verification code to continue: 377680', + emailTimestamp: ts, + matchedEmail: 'target@co.example.test', + messageId: '11', + subject: 'Your ChatGPT code is 377680', + }, + ], { + filterAfterTimestamp: ts, + senderFilters: ['openai'], + subjectFilters: ['code'], + targetEmail: 'target@co.example.test', + }); + + assert.equal(result, null); +}); + +test('selectVerificationMessage picks the newest matching message after the threshold', () => { + const result = selectVerificationMessage([ + { + combinedText: '旧验证码 111111', + emailTimestamp: parseAdminTimestamp('2026/4/7 10:30:00'), + matchedEmail: 'target@co.example.test', + messageId: '8', + subject: 'Your ChatGPT code is 111111', + }, + { + combinedText: 'Enter this temporary verification code to continue: 377680', + emailTimestamp: parseAdminTimestamp('2026/4/7 10:33:07'), + matchedEmail: 'target@co.example.test', + messageId: '11', + subject: 'Your ChatGPT code is 377680', + }, + ], { + filterAfterTimestamp: parseAdminTimestamp('2026/4/7 10:31:00'), + senderFilters: ['openai'], + subjectFilters: ['code'], + targetEmail: 'target@co.example.test', + }); + + assert.deepEqual(result, { + code: '377680', + emailTimestamp: parseAdminTimestamp('2026/4/7 10:33:07'), + matchedEmail: 'target@co.example.test', + messageId: '11', + subject: 'Your ChatGPT code is 377680', + }); +}); diff --git a/DouYinSparkFlow/webui/static/multiPagePlugins/tests/email-provider.test.js b/DouYinSparkFlow/webui/static/multiPagePlugins/tests/email-provider.test.js new file mode 100644 index 0000000..d78a82e --- /dev/null +++ b/DouYinSparkFlow/webui/static/multiPagePlugins/tests/email-provider.test.js @@ -0,0 +1,106 @@ +const test = require('node:test'); +const assert = require('node:assert/strict'); + +const { + DEFAULT_CLOUDFLARE_TEMP_EMAIL_ADMIN_URL, + EMAIL_PROVIDER_DUCK, + EMAIL_PROVIDER_CLOUDFLARE_TEMP_EMAIL, + EMAIL_PROVIDER_RELAY_FIREFOX, + getEmailProviderDisplayName, + getNextRelayMaskLabel, + isCloudflareTempEmailProvider, + normalizeCloudflareTempEmailAdminUrl, + normalizeEmailProvider, + shouldUseEmailSourceForVerification, + shouldSkipStep9Cleanup, +} = require('../shared/email-provider.js'); + +test('normalizeEmailProvider keeps relay_firefox as-is', () => { + assert.equal(normalizeEmailProvider('relay_firefox'), EMAIL_PROVIDER_RELAY_FIREFOX); +}); + +test('normalizeEmailProvider keeps cloudflare_temp_email as-is', () => { + assert.equal( + normalizeEmailProvider('cloudflare_temp_email'), + EMAIL_PROVIDER_CLOUDFLARE_TEMP_EMAIL + ); +}); + +test('normalizeEmailProvider falls back to duckduckgo for unknown values', () => { + assert.equal(normalizeEmailProvider('something-else'), EMAIL_PROVIDER_DUCK); +}); + +test('isCloudflareTempEmailProvider identifies cloudflare_temp_email', () => { + assert.equal(isCloudflareTempEmailProvider('cloudflare_temp_email'), true); +}); + +test('isCloudflareTempEmailProvider rejects relay_firefox', () => { + assert.equal(isCloudflareTempEmailProvider('relay_firefox'), false); +}); + +test('getEmailProviderDisplayName returns Cloudflare Temp Email label', () => { + assert.equal( + getEmailProviderDisplayName('cloudflare_temp_email'), + 'Cloudflare Temp Email' + ); +}); + +test('DEFAULT_CLOUDFLARE_TEMP_EMAIL_ADMIN_URL uses the public open-source-safe admin URL', () => { + assert.equal( + DEFAULT_CLOUDFLARE_TEMP_EMAIL_ADMIN_URL, + 'https://mail.cloudflare.com/admin' + ); +}); + +test('normalizeCloudflareTempEmailAdminUrl falls back to the default URL for empty values', () => { + assert.equal( + normalizeCloudflareTempEmailAdminUrl(''), + DEFAULT_CLOUDFLARE_TEMP_EMAIL_ADMIN_URL + ); +}); + +test('normalizeCloudflareTempEmailAdminUrl trims whitespace and prepends https when protocol is missing', () => { + assert.equal( + normalizeCloudflareTempEmailAdminUrl(' custom.example.com/admin '), + 'https://custom.example.com/admin' + ); +}); + +test('normalizeCloudflareTempEmailAdminUrl normalizes the default admin URL path', () => { + assert.equal( + normalizeCloudflareTempEmailAdminUrl('https://mail.cloudflare.com/admin/'), + DEFAULT_CLOUDFLARE_TEMP_EMAIL_ADMIN_URL + ); +}); + +test('getNextRelayMaskLabel returns t1 when there are no existing labels', () => { + assert.equal(getNextRelayMaskLabel([]), 't1'); +}); + +test('getNextRelayMaskLabel fills the first numeric gap', () => { + assert.equal(getNextRelayMaskLabel(['t1', 'hello', 't3']), 't2'); +}); + +test('shouldSkipStep9Cleanup returns false for relay_firefox', () => { + assert.equal(shouldSkipStep9Cleanup('relay_firefox'), false); +}); + +test('shouldUseEmailSourceForVerification returns true for cloudflare_temp_email', () => { + assert.equal(shouldUseEmailSourceForVerification('cloudflare_temp_email'), true); +}); + +test('shouldUseEmailSourceForVerification returns false for relay_firefox', () => { + assert.equal(shouldUseEmailSourceForVerification('relay_firefox'), false); +}); + +test('shouldUseEmailSourceForVerification returns false for duckduckgo', () => { + assert.equal(shouldUseEmailSourceForVerification('duckduckgo'), false); +}); + +test('shouldSkipStep9Cleanup returns true for duckduckgo', () => { + assert.equal(shouldSkipStep9Cleanup('duckduckgo'), true); +}); + +test('shouldSkipStep9Cleanup returns true for cloudflare_temp_email', () => { + assert.equal(shouldSkipStep9Cleanup('cloudflare_temp_email'), true); +}); diff --git a/DouYinSparkFlow/webui/static/multiPagePlugins/tests/oauth-consent.test.js b/DouYinSparkFlow/webui/static/multiPagePlugins/tests/oauth-consent.test.js new file mode 100644 index 0000000..cca22e7 --- /dev/null +++ b/DouYinSparkFlow/webui/static/multiPagePlugins/tests/oauth-consent.test.js @@ -0,0 +1,102 @@ +const test = require('node:test'); +const assert = require('node:assert/strict'); + +const { + hasAnyConsentPageState, + findLoopbackCallbackUrl, + isConsentUrl, + isConsentPageState, + isLoopbackCallbackUrl, +} = require('../shared/oauth-flow.js'); + +test('isConsentUrl matches the exact known consent URL', () => { + assert.equal( + isConsentUrl('https://auth.openai.com/sign-in-with-chatgpt/codex/consent'), + true + ); +}); + +test('isConsentUrl rejects unrelated auth routes', () => { + assert.equal( + isConsentUrl('https://auth.openai.com/u/signup/identifier'), + false + ); +}); + +test('isConsentPageState accepts sign-in-with-chatgpt routes when a continue button is visible', () => { + assert.equal( + isConsentPageState({ + url: 'https://auth.openai.com/sign-in-with-chatgpt/codex/consent?state=abc', + hasVisibleContinueButton: true, + }), + true + ); +}); + +test('isConsentPageState rejects sign-in-with-chatgpt routes without a visible continue button when URL is not exact', () => { + assert.equal( + isConsentPageState({ + url: 'https://auth.openai.com/sign-in-with-chatgpt/codex/checkpoint', + hasVisibleContinueButton: false, + }), + false + ); +}); + +test('hasAnyConsentPageState returns true when consent appears after an initial non-consent state', () => { + assert.equal( + hasAnyConsentPageState([ + { + url: 'https://auth.openai.com/u/signup/profile', + hasVisibleContinueButton: false, + }, + { + url: 'https://auth.openai.com/sign-in-with-chatgpt/codex/consent?state=abc', + hasVisibleContinueButton: true, + }, + ]), + true + ); +}); + +test('isLoopbackCallbackUrl accepts localhost callback URLs', () => { + assert.equal( + isLoopbackCallbackUrl('http://localhost:1455/auth/callback?code=abc&state=123'), + true + ); +}); + +test('isLoopbackCallbackUrl accepts 127.0.0.1 callback URLs', () => { + assert.equal( + isLoopbackCallbackUrl('http://127.0.0.1:8317/codex/callback?code=abc&state=123'), + true + ); +}); + +test('isLoopbackCallbackUrl rejects non-loopback callback URLs', () => { + assert.equal( + isLoopbackCallbackUrl('https://example.com/callback?code=abc&state=123'), + false + ); +}); + +test('findLoopbackCallbackUrl returns the first loopback callback URL from candidates', () => { + assert.equal( + findLoopbackCallbackUrl([ + 'https://auth.openai.com/sign-in-with-chatgpt/codex/consent', + 'http://127.0.0.1:8317/codex/callback?code=abc&state=123', + 'http://localhost:1455/auth/callback?code=def&state=456', + ]), + 'http://127.0.0.1:8317/codex/callback?code=abc&state=123' + ); +}); + +test('findLoopbackCallbackUrl returns null when no loopback callback URL exists', () => { + assert.equal( + findLoopbackCallbackUrl([ + 'https://auth.openai.com/sign-in-with-chatgpt/codex/consent', + 'https://example.com/callback?code=abc&state=123', + ]), + null + ); +}); diff --git a/DouYinSparkFlow/webui/static/multiPagePlugins/tests/qq-mail.test.js b/DouYinSparkFlow/webui/static/multiPagePlugins/tests/qq-mail.test.js new file mode 100644 index 0000000..4425ebe --- /dev/null +++ b/DouYinSparkFlow/webui/static/multiPagePlugins/tests/qq-mail.test.js @@ -0,0 +1,59 @@ +const test = require('node:test'); +const assert = require('node:assert/strict'); + +const { + extractVerificationCode, + findNewQQVerificationCode, +} = require('../shared/qq-mail.js'); + +test('extractVerificationCode reads 6-digit codes from QQ mail text', () => { + assert.equal( + extractVerificationCode('你的 ChatGPT 代码为 479637，请勿泄露。'), + '479637' + ); +}); + +test('findNewQQVerificationCode rejects matching emails that already existed before polling', () => { + const result = findNewQQVerificationCode([ + { + mailId: 'old-1', + sender: 'OpenAI', + subject: '你的 ChatGPT 代码为 479637', + digest: '用于验证你的邮箱地址', + }, + ], { + existingMailIds: ['old-1'], + senderFilters: ['openai', 'verify'], + subjectFilters: ['code', '验证'], + }); + + assert.equal(result, null); +}); + +test('findNewQQVerificationCode accepts the first new matching email', () => { + const result = findNewQQVerificationCode([ + { + mailId: 'old-1', + sender: 'OpenAI', + subject: '你的 ChatGPT 代码为 111111', + digest: '旧邮件', + }, + { + mailId: 'new-1', + sender: 'OpenAI', + subject: '你的 ChatGPT 代码为 222222', + digest: '新邮件', + }, + ], { + existingMailIds: ['old-1'], + senderFilters: ['openai', 'verify'], + subjectFilters: ['code', '验证'], + }); + + assert.deepEqual(result, { + code: '222222', + mailId: 'new-1', + source: 'new', + subject: '你的 ChatGPT 代码为 222222', + }); +}); diff --git a/DouYinSparkFlow/webui/static/styles.css b/DouYinSparkFlow/webui/static/styles.css new file mode 100644 index 0000000..e55466a --- /dev/null +++ b/DouYinSparkFlow/webui/static/styles.css @@ -0,0 +1,527 @@ +:root { + --bg: #f4f1ea; + --panel: #fffdfa; + --panel-strong: #f7efe2; + --ink: #1f1d1a; + --muted: #665f55; + --line: #d9cdbd; + --accent: #b84c2a; + --accent-deep: #8f3215; + --danger: #8f1d2c; + --warning: #8f5d00; + --success: #236c43; + --shadow: 0 16px 40px rgba(63, 42, 17, 0.12); +} + +* { + box-sizing: border-box; +} + +body { + margin: 0; + min-height: 100vh; + font-family: "Segoe UI", "PingFang SC", "Hiragino Sans GB", sans-serif; + color: var(--ink); + background: + radial-gradient(circle at top left, rgba(184, 76, 42, 0.16), transparent 26%), + radial-gradient(circle at top right, rgba(35, 108, 67, 0.12), transparent 24%), + linear-gradient(180deg, #f9f4eb 0%, var(--bg) 100%); +} + +.topbar { + display: flex; + align-items: flex-end; + justify-content: space-between; + gap: 24px; + padding: 32px 36px 18px; +} + +.eyebrow { + margin: 0 0 4px; + font-size: 12px; + letter-spacing: 0.14em; + text-transform: uppercase; + color: var(--muted); +} + +h1, h2 { + margin: 0; +} + +h1 { + font-size: clamp(28px, 4vw, 42px); +} + +h2 { + font-size: 22px; + margin-bottom: 10px; +} + +.page-shell { + padding: 0 36px 36px; +} + +.grid { + display: grid; + gap: 20px; + margin-bottom: 20px; +} + +.grid.two-up { + grid-template-columns: repeat(auto-fit, minmax(320px, 1fr)); +} + +.panel { + background: rgba(255, 253, 250, 0.92); + border: 1px solid rgba(217, 205, 189, 0.8); + border-radius: 22px; + box-shadow: var(--shadow); + padding: 22px; + backdrop-filter: blur(10px); +} + +.panel.narrow { + max-width: 520px; + margin: 8vh auto 0; +} + +.panel-header { + display: flex; + align-items: flex-start; + justify-content: space-between; + gap: 16px; + margin-bottom: 16px; +} + +.muted { + color: var(--muted); +} + +.compact { + margin-top: 6px; +} + +.banner { + margin: 0 36px 18px; + padding: 14px 18px; + border-radius: 14px; + border: 1px solid transparent; +} + +.banner.warning { + background: rgba(255, 233, 194, 0.82); + border-color: rgba(143, 93, 0, 0.25); +} + +.banner.success { + background: rgba(202, 239, 218, 0.88); + border-color: rgba(35, 108, 67, 0.24); +} + +.banner.error { + background: rgba(250, 212, 219, 0.9); + border-color: rgba(143, 29, 44, 0.22); +} + +.banner.info { + background: rgba(213, 230, 247, 0.88); + border-color: rgba(32, 87, 127, 0.2); +} + +.stack-form { + display: grid; + gap: 14px; +} + +label { + display: grid; + gap: 8px; + font-size: 14px; +} + +label span { + font-weight: 600; +} + +input, +textarea, +button { + font: inherit; +} + +input, +textarea { + width: 100%; + border: 1px solid var(--line); + border-radius: 12px; + background: #fff; + color: var(--ink); + padding: 12px 14px; +} + +textarea { + resize: vertical; +} + +button, +.link-button { + display: inline-flex; + align-items: center; + justify-content: center; + gap: 8px; + min-height: 44px; + border: 0; + border-radius: 999px; + padding: 0 18px; + background: linear-gradient(135deg, var(--accent) 0%, var(--accent-deep) 100%); + color: #fff; + cursor: pointer; + text-decoration: none; + transition: transform 120ms ease, box-shadow 120ms ease; + box-shadow: 0 10px 24px rgba(184, 76, 42, 0.2); +} + +button:hover, +.link-button:hover { + transform: translateY(-1px); +} + +.ghost-button { + background: rgba(255, 255, 255, 0.65); + color: var(--ink); + border: 1px solid var(--line); + box-shadow: none; +} + +.danger-button { + background: linear-gradient(135deg, #b53749 0%, var(--danger) 100%); + box-shadow: 0 10px 24px rgba(143, 29, 44, 0.18); +} + +.stats { + display: grid; + grid-template-columns: repeat(auto-fit, minmax(120px, 1fr)); + gap: 12px; +} + +.stats article { + background: var(--panel-strong); + border-radius: 16px; + padding: 14px; + border: 1px solid rgba(217, 205, 189, 0.8); +} + +.stat-label { + display: block; + font-size: 12px; + color: var(--muted); + margin-bottom: 8px; +} + +.account-list { + display: grid; + grid-template-columns: repeat(auto-fit, minmax(280px, 1fr)); + gap: 16px; +} + +.account-card { + border: 1px solid rgba(217, 205, 189, 0.8); + border-radius: 18px; + padding: 16px; + background: rgba(255, 255, 255, 0.78); + display: grid; + gap: 14px; +} + +.inline-meta, +.button-row, +.button-grid { + display: flex; + flex-wrap: wrap; + gap: 10px; +} + +.button-grid { + margin-bottom: 16px; +} + +.pill { + display: inline-flex; + align-items: center; + min-height: 30px; + padding: 0 12px; + border-radius: 999px; + background: rgba(184, 76, 42, 0.1); + color: var(--accent-deep); + font-size: 13px; +} + +.pill.soft { + background: rgba(31, 29, 26, 0.08); + color: var(--muted); +} + +.table-shell { + overflow-x: auto; +} + +table { + width: 100%; + border-collapse: collapse; +} + +th, +td { + text-align: left; + padding: 10px 12px; + border-bottom: 1px solid rgba(217, 205, 189, 0.7); +} + +th { + color: var(--muted); + font-size: 13px; +} + +.code-block { + margin: 0; + padding: 14px; + border-radius: 16px; + background: #171411; + color: #f8f4ee; + overflow: auto; + font-family: "Cascadia Code", "SFMono-Regular", Consolas, monospace; + font-size: 13px; + line-height: 1.55; +} + +.code-block.tall { + min-height: 320px; + max-height: 520px; +} + +.empty-state { + display: grid; + place-items: center; + min-height: 160px; + border: 1px dashed var(--line); + border-radius: 16px; + color: var(--muted); + background: rgba(255, 255, 255, 0.46); +} + +.qr-preview { + display: block; + width: 100%; + max-width: 760px; + border-radius: 20px; + border: 4px solid #fff; + box-shadow: 0 12px 36px rgba(63, 42, 17, 0.18); + margin: 0 auto 18px; + cursor: pointer; + transition: all 0.3s cubic-bezier(0.4, 0, 0.2, 1); +} + +.qr-preview:hover { + transform: scale(1.02); + box-shadow: 0 18px 48px rgba(63, 42, 17, 0.24); +} + +.qr-preview.expanded { + max-width: 900px; +} + +body.modal-open { + overflow: hidden; +} + +.image-modal[hidden] { + display: none; +} + +.image-modal { + position: fixed; + inset: 0; + z-index: 1000; + display: grid; + place-items: center; +} + +.image-modal-backdrop { + position: absolute; + inset: 0; + background: rgba(17, 12, 8, 0.72); + backdrop-filter: blur(6px); +} + +.image-modal-dialog { + position: relative; + z-index: 1; + width: min(96vw, 1080px); + max-height: 92vh; + display: grid; + gap: 16px; + padding: 20px; + border-radius: 24px; + background: rgba(255, 253, 250, 0.98); + box-shadow: 0 24px 60px rgba(17, 12, 8, 0.3); +} + +.image-modal-header { + display: flex; + align-items: center; + justify-content: space-between; + gap: 12px; +} + +.image-modal-preview { + width: 100%; + max-height: calc(92vh - 92px); + object-fit: contain; + border-radius: 18px; + border: 1px solid rgba(217, 205, 189, 0.9); + background: #fff; +} + +.friend-picker { + display: grid; + gap: 12px; +} + +.friend-picker-toolbar { + display: flex; + align-items: flex-start; + justify-content: space-between; + gap: 12px; +} + +.friend-picker-title { + display: inline-block; + font-weight: 600; + margin-bottom: 4px; +} + +.friend-search { + display: grid; + gap: 8px; +} + +.friend-picker-list { + display: flex; + flex-wrap: wrap; + align-items: flex-start; + align-content: flex-start; + gap: 8px; + max-height: 280px; + overflow: auto; + padding: 12px; + border: 1px solid rgba(217, 205, 189, 0.9); + border-radius: 16px; + background: rgba(255, 255, 255, 0.8); +} + +.friend-picker-current-targets { + padding: 10px 12px; + border-radius: 12px; + background: rgba(247, 239, 226, 0.65); + line-height: 1.5; +} + +.friend-option { + position: relative; + display: inline-flex; + align-items: center; + justify-content: center; + gap: 0; + min-height: 40px; + max-width: 100%; + padding: 8px 14px; + border-radius: 999px; + border: 1px solid rgba(217, 205, 189, 0.95); + background: rgba(255, 255, 255, 0.92); + cursor: pointer; + transition: border-color 120ms ease, background-color 120ms ease, box-shadow 120ms ease; +} + +.friend-option span { + font-weight: 600; + line-height: 1.2; + word-break: break-word; + white-space: nowrap; +} + +.friend-option input { + position: absolute; + opacity: 0; + pointer-events: none; + inset: 0; +} + +.friend-option:hover { + border-color: rgba(143, 50, 21, 0.35); + box-shadow: 0 8px 18px rgba(63, 42, 17, 0.08); +} + +.friend-option.selected { + border-color: #2f6fed; + background: #2f6fed; + box-shadow: 0 10px 20px rgba(47, 111, 237, 0.22); +} + +.friend-option.selected span { + color: #fff; +} + +.friend-picker-empty { + display: grid; + place-items: center; + min-height: 120px; + border: 1px dashed var(--line); + border-radius: 14px; + color: var(--muted); + background: rgba(255, 255, 255, 0.4); + text-align: center; + padding: 16px; +} + +.check-row { + grid-template-columns: auto 1fr; + align-items: center; +} + +.check-row input { + width: auto; +} + +.ops-meta { + margin-top: 16px; + color: var(--muted); + font-size: 14px; +} + +@media (max-width: 720px) { + .topbar, + .page-shell { + padding-left: 18px; + padding-right: 18px; + } + + .banner { + margin-left: 18px; + margin-right: 18px; + } + + .panel-header { + flex-direction: column; + } + + .button-grid, + .button-row, + .inline-meta { + flex-direction: column; + } + + button, + .link-button { + width: 100%; + } +} diff --git a/DouYinSparkFlow/webui/templates/base.html b/DouYinSparkFlow/webui/templates/base.html new file mode 100644 index 0000000..b58e20c --- /dev/null +++ b/DouYinSparkFlow/webui/templates/base.html @@ -0,0 +1,1039 @@ + + + + + + {% block title %}抖音多账号续火花控制台{% endblock %} + + + + + + {% block scripts %}{% endblock %} + + diff --git a/DouYinSparkFlow/webui/templates/dashboard.html b/DouYinSparkFlow/webui/templates/dashboard.html new file mode 100644 index 0000000..37a9229 --- /dev/null +++ b/DouYinSparkFlow/webui/templates/dashboard.html @@ -0,0 +1,731 @@ +{% extends "base.html" %} + +{% block title %}抖音多账号续火花控制台{% endblock %} +{% block page_title %}抖音多账号续火花控制台{% endblock %} + +{% block content %} +{% set enabled_accounts = accounts | selectattr("enabled", "equalto", true) | list %} +{% set proxy_rows = ops.containers | selectattr("Names", "equalto", "mihomo") | list %} +
+
+
+
+
+
+ 账号总数 + 已启用 {{ enabled_accounts|length }} / 总数 {{ accounts|length }} + {{ accounts|length }} +
+
👥
+
+
+
+ 今日发送计划时间 + 下一次执行：{{ ops.daily_schedule or "未配置" }} + {{ ops.daily_schedule or "未配置" }} +
+
🕒
+
+
+
+ 代理容器状态 + 容器在线 / 离线 +
+ {{ proxy_rows|length }} / {{ ops.containers|length }} + + {% if ops.image_present %}镜像已构建{% else %}镜像待构建{% endif %} + +
+
+
▣
+
+ +
+
+ +
+
+
+

交互式登录浏览器（推荐）

+

在网页里直接操作服务器浏览器完成扫码、短信验证和登录，不再依赖远程截图轮询。

+
+
+ + + + +
+ +
+
+
+

账号管理（{{ accounts|length }}）

+

多账号、目标好友、启停状态、交互式登录同步都在这里集中管理。

+
+
+ + {% if accounts %} + + {% else %} +
还没有账号。先通过交互式登录浏览器登录并保存账号。
+ {% endif %} +
+ +
+
+

容器状态

+
+ + + + + + + + + + {% for row in ops.containers %} + + + + + + {% else %} + + {% endfor %} + +
NameStatusImage
{{ row.Names }} + + {{ row.Status }} + + {{ row.Image }}
当前没有可见容器状态。
+
+
+ +
+

Cron / 调度（服务端 crontab）

+ 
{{ ops.crontab or "当前没有 crontab 任务。" }}
+
+ +
+

日志预览（最近 100 行）

+ 
{{ ops.log_tail or "暂无日志" }}
+
+
+
+ + +
+ +
+
+
+

面板与服务器设置

+

服务器参数、交互式登录桌面 API 地址、日志路径等基础设置。

+
+
+
+ +
+ + + + + + + + + + +
+
+ +
+
+
+{% endblock %} + +{% block scripts %} + +{% endblock %} diff --git a/DouYinSparkFlow/webui/templates/login.html b/DouYinSparkFlow/webui/templates/login.html new file mode 100644 index 0000000..df6f8eb --- /dev/null +++ b/DouYinSparkFlow/webui/templates/login.html @@ -0,0 +1,117 @@ + + + + + + 登录 | 抖音多账号续火花控制台 + + + +
+

控制台登录

+

用于管理抖音多账号、目标好友、自动续火花任务与运维配置。

+ + {% if flash %} +
{{ flash.message }}
+ {% endif %} + + {% if not bootstrapped %} +
+ + + + +
+ {% else %} +
+ + + +
+ {% endif %} +
+ + diff --git a/DouYinSparkFlow/webui/templates/logs.html b/DouYinSparkFlow/webui/templates/logs.html new file mode 100644 index 0000000..e55199b --- /dev/null +++ b/DouYinSparkFlow/webui/templates/logs.html @@ -0,0 +1,17 @@ +{% extends "base.html" %} + +{% block title %}运行日志 | 抖音多账号续火花控制台{% endblock %} +{% block page_title %}运行日志{% endblock %} + +{% block content %} +
+
+
+

详细日志

+

展示最近的任务输出，便于检查登录同步、发送过程和容器状态。

+
+ 返回控制台 +
+ 
{{ log_tail or "暂无日志" }}
+
+{% endblock %} diff --git a/README.md b/README.md index 8d6b86d..0ee93d2 100644 --- a/README.md +++ b/README.md @@ -1 +1,41 @@ -# douyin-sparkflow \ No newline at end of file +# douyin-sparkflow + +这个仓库是一个围绕 `DouYinSparkFlow/` 组织的部署仓库，用于保存核心应用源码、代理配置和容器编排文件，方便在本地或服务器上统一维护。当前整理目标是“私有内用、可放入 GitHub、避免提交运行态和敏感数据”。 + +## 仓库结构 + +- `DouYinSparkFlow/`: 核心应用源码，包含 Web UI、任务调度、账号登录与消息发送逻辑。 +- `proxy/`: 代理容器配置目录，当前包含 `mihomo` 配置文件。 +- `docker-compose.yml`: 统一的容器编排入口。 +- `refresh_proxy.sh`: 代理刷新脚本。 + +## 运行方式概览 + +- 支持本地运行核心应用，也支持通过 `docker-compose.yml` 在服务器上部署。 +- Web 管理入口、交互式登录桌面和定时任务都由仓库内现有脚本与配置驱动。 +- 定时发送、账号状态和消息模板属于运行时行为，不在本仓库中直接携带账号数据。 + +## 配置与敏感文件 + +以下内容不会进入当前 Git 仓库，需要在实际部署环境中自行补齐： + +- `.env` +- `state/` +- `logs/` +- `DouYinSparkFlow/usersData.json` +- `DouYinSparkFlow/webui_settings.json` +- `DouYinSparkFlow/.im_sdk_cache/` + +如果需要复现运行环境，建议在目标机器上重新生成这些文件，而不是从仓库恢复。 + +## 使用边界 + +- 本仓库按内部项目资料整理，主要用于源码管理、部署维护和环境迁移。 +- 使用者需要自行评估平台规则、账号风险和运行后果。 +- 不建议把真实账号数据、浏览器登录态、日志或运行缓存提交到仓库。 + +## 许可证 + +核心应用当前采用 MIT 协议，许可证文件位于 [DouYinSparkFlow/LICENSE](DouYinSparkFlow/LICENSE)。 + +如需查看源码级说明，请优先阅读 [DouYinSparkFlow/README.md](DouYinSparkFlow/README.md)。 diff --git a/docker-compose.yml b/docker-compose.yml new file mode 100644 index 0000000..7eb922e --- /dev/null +++ b/docker-compose.yml @@ -0,0 +1,84 @@ +services: + proxy: + image: metacubex/mihomo:latest + container_name: mihomo + restart: unless-stopped + logging: + driver: json-file + options: + max-size: "20m" + max-file: "3" + ports: + - "7890:7890" + - "9090:9090" + volumes: + - ./proxy/config.yaml:/root/.config/mihomo/config.yaml + + web: + build: + context: ./DouYinSparkFlow + dockerfile: Dockerfile.server + network: host + args: + HTTP_PROXY: http://127.0.0.1:7890 + HTTPS_PROXY: http://127.0.0.1:7890 + ALL_PROXY: socks5://127.0.0.1:7890 + image: douyin-sparkflow:local + container_name: douyin-web + restart: unless-stopped + depends_on: + - proxy + - login-desktop + environment: + TZ: Asia/Shanghai + HTTP_PROXY: http://proxy:7890 + HTTPS_PROXY: http://proxy:7890 + ALL_PROXY: socks5://proxy:7890 + NO_PROXY: localhost,127.0.0.1,login-desktop,douyin.com,amemv.com,snssdk.com,bytedance.com,pstatp.com,volccdn.com,bytescm.com,byted.net,douyinstatic.com,bytecdn.cn,byteimg.com,bytegoofy.com,toutiaostatic.com + ports: + - "8787:8787" + command: python main.py --web --host 0.0.0.0 --port 8787 + volumes: + - ./DouYinSparkFlow:/app + - ./DouYinSparkFlow/logs:/app/logs + - /var/run/docker.sock:/var/run/docker.sock + - /opt/douyin-sparkflow:/opt/douyin-sparkflow + - /var/spool/cron/root:/var/spool/cron/crontabs/root + + login-desktop: + image: douyin-sparkflow:local + container_name: login-desktop + restart: unless-stopped + depends_on: + - proxy + environment: + TZ: Asia/Shanghai + DISPLAY: :99 + HTTP_PROXY: http://proxy:7890 + HTTPS_PROXY: http://proxy:7890 + ALL_PROXY: socks5://proxy:7890 + NO_PROXY: localhost,127.0.0.1,login-desktop,douyin.com,amemv.com,snssdk.com,bytedance.com,pstatp.com,volccdn.com,bytescm.com,byted.net,douyinstatic.com,bytecdn.cn,byteimg.com,bytegoofy.com,toutiaostatic.com + ports: + - "8788:6080" + command: bash /app/scripts/start_login_desktop.sh + volumes: + - ./DouYinSparkFlow:/app + - ./DouYinSparkFlow/logs:/app/logs + - ./state/login-profile:/data/login-profile + + task: + image: douyin-sparkflow:local + container_name: douyin-task + depends_on: + - proxy + environment: + TZ: Asia/Shanghai + HTTP_PROXY: http://proxy:7890 + HTTPS_PROXY: http://proxy:7890 + ALL_PROXY: socks5://proxy:7890 + NO_PROXY: localhost,127.0.0.1,douyin.com,amemv.com,snssdk.com,bytedance.com,pstatp.com,volccdn.com,bytescm.com,byted.net,douyinstatic.com,bytecdn.cn,byteimg.com,bytegoofy.com,toutiaostatic.com + command: python main.py --doTask + volumes: + - ./DouYinSparkFlow:/app + - ./DouYinSparkFlow/logs:/app/logs + restart: "no" diff --git a/refresh_proxy.sh b/refresh_proxy.sh new file mode 100644 index 0000000..d600b80 --- /dev/null +++ b/refresh_proxy.sh @@ -0,0 +1,9 @@ +#!/usr/bin/env bash +set -euo pipefail +APP_ROOT=/opt/douyin-sparkflow +SUB_URL='https://liangxin.xyz/api/v1/liangxin?OwO=6981c5a8452d44e8521c78f9f7bf1eea' +curl -fsSL -A 'clash-verge/1.7.7' "$SUB_URL" -o "$APP_ROOT/proxy/config.yaml" +if grep -q '^allow-lan:' "$APP_ROOT/proxy/config.yaml"; then sed -i 's/^allow-lan:.*/allow-lan: true/' "$APP_ROOT/proxy/config.yaml"; else echo 'allow-lan: true' >> "$APP_ROOT/proxy/config.yaml"; fi +if grep -q '^bind-address:' "$APP_ROOT/proxy/config.yaml"; then sed -i "s#^bind-address:.*#bind-address: '*'#" "$APP_ROOT/proxy/config.yaml"; else echo "bind-address: '*'" >> "$APP_ROOT/proxy/config.yaml"; fi +if grep -q '^external-controller:' "$APP_ROOT/proxy/config.yaml"; then sed -i "s#^external-controller:.*#external-controller: '0.0.0.0:9090'#" "$APP_ROOT/proxy/config.yaml"; else echo "external-controller: '0.0.0.0:9090'" >> "$APP_ROOT/proxy/config.yaml"; fi +docker compose -f "$APP_ROOT/docker-compose.yml" restart proxy
+ + +
+
+
+
+
{% block page_title %}抖音多账号续火花控制台{% endblock %}
+
多账号管理、登录同步、自动续火花、运维控制
+
+
+
+
系统时间：
+ 服务运行中 +
+
{{ (current_user or "A")[:1]|upper }}
+ {{ current_user or "admin" }} +
+
+
+ +
+ {% if flash %} +
{{ flash.message }}
+ {% endif %} + + {% block content %}{% endblock %} +
+
+

FEe+OV5qZ2m^TYsQ=ZeRqyMS1y zCzpSZfb~*7LM+cy3s=25!vwV)rYFXq6#Z-EIG&rP(EQ6cp>INjI+zOZf>o`AS=I70 zV#s9(hgfIUq~q8XZPxY_9;Fd$ol0DyfrqTkvgHW6La2^Sr4R2C+A;=f(t|}rn{W2K zruGn2PiHynMapI(;ep;8UvXd?fa|V*Ap&MGENhF9XJP9`Q@02X1$n8%6m-0_Fm-g; zp{%OQJKn2$tBj^D`OdEYRg6VQ%tJ{gWo|rBjn2sjKw`f{F^|UgVY^Bc{52%J)g7RD zPii(Nm}+;*kraq`5l3efskZlk-2L(1?ys*aT^Q z8@d78wr!7Ou-+H@U`HDyWAgoU7d^pZmn=o-ZNU2MnZ-l- z=y{WcPjS8{CRDBzHQNh%_4R@^V(=PGIr*D0!UG?bAjPkQ1P~SURn98k^eXbFIoB>! zKDof_FJhBEX^Bp#O0w(R^C+*fO}TyB^zK%o;g6#0httXpp7D?j{$w96>f%i4A>5lv z^26dcDPHf@A<&(R zd3MQBJlKMF4N48buR8X}4&jO>ah{^xb>OBD4C>$Cf8*eih;c3{K*1^ADN8&gz_eAP$Up6l zR@T-rw59{l5RO}BYDWm_wR3do1Au5zLip6j-I0aLC5mZJh8l$6FiVMj66UQ3k6X}+ zj+J)Z%lZ}77rVM}RjC}@UlKwR!fM(IyU@O6y#B}({0 zQG~UW7c(XdQk!&=Qgxk>@s6)hne^Xow!8kiab@3E#p zk+kNywXsHlnu4Fe+(;fKCcn*E2Dj;V2cZi(j-_Ss;KqyWZ%w;dc=TTUFhg|a9Rv{O zgOKHWS}t`873uaI=zD&7&BBFXWN8L!fA_*-w%LsXEm65ni1B`ashge~o|_N(?8OfC z`v@9M-@8ItzzbOO!#;lw{?76$>l(}0%|JJoGnXEuM%u$GdnaXVv4jYE{p|E06s%XuUk#Xif6SZ-2GN$ckjyR8^v2g%mnJ>6`y|Kry@Jo zGJkSQp(`Kq=#ql4>EUSBOn4nHz63$IfKZ5-vhDWk+!B>z-yS?37&MVqd)<6`XpF z1{c#lQphe7GTIbKA2|)9U6EtzIza96)QFWaoOb??DxXyX(lu=qEX}i%t3@7^bg;i6 zdGMbtai39uOH3&yt_)&e1@28uYz=9)I^XD@wpX?WzQ+!JW`wp(((|{y@69aTv2A9q z25n4gmW`S*$yFM3bLJGQ;Fi3)azy9Vwy)r>^D>J)yn(VQd>_Q**GWzW__v26aHO3@ zx=Hq9|Is5bG=x~v{83gZVDS9f09mD_C=4I3Y~v82$7#Ybg_vz5B84GPKWn8RU=Ki2 zQVO?E=vFLQWO$+p--$ZU>MeFuDiohpW}Qe?GfcDH_eUJ@{ZvHlBTt{H{F5QOrLZ zrnm9{ZdAvK;FfK?j#FCex5P2}JSE2_F|@f;+ev{W#@YP%NXOQP*`e<@#ik@Kf&W&J zrW}+YUlqUJOW0qi#6i)&@sFOCycmM+K7a76tX1tobS_{c8^521GIH3JWo{Vv;l3>~OV0*i8RW96b&Y5_n!gvcI<#P}#~xHgWy@(dCxq${vxAC5o3^ zsSNl)7wjf|hWtUbUQ@WZgJcP@2y;If?A%y31uo;ESqMQiKk_erw~V!SXcJlK=YbCc z5SKk7ho&ZjuYbU%LF=dgrSTA_<0?1|q0QgBBHK+FL}aalxRbaB10d0UlqrX-zQsUZZd!J%Rh#&)f8YB^Lw(-|jLny;EC?MNsMf@8Mp)FJ0f2TO(|d84US%GZO=&Q!#++9;+m=es@k9CX^>t-NuG;RTIv zE-$@AomhTJV6!1T&r5;xupkyKDV|iWV_FtVs5MgfC(U08*Oxh{#K>u-KFowzMBFh& z<~AcRs3F1%jV_Kk4b^L0S4a_g3qMY6dsq)r;luX?#@n6az$H@V#vE9bzVQV{B@Rs=`$nZ z_&U!n<2H2!Z<^~!Imf0Hhu8O*f-N+C%*ccqCN`HaldC-;nbHBL!+m5^Y@HFXbAK9G zqc+KnaHxgioH|l#YgJNlQ353LLYD{DmcH;I-mR*Bi#ZdT2NY;C0tQqWeNqy8@$W9= z*TAn41#dKhlv6P8uowvMP`?#(Q&Qr<4NvNab;4z^Cizn}PM>fwQFkr^%mUAn1lbN@ zrz#y*SeRI63)!}?L_*b|gWik6-ACVO3G&O@tIWq!X`UaJtsNU3Atmyv8b8iX*#HQY1W&Q>kXLDrF=dXW2dQ zDLi?#X+{pnXXfxUWgb*ntaM%dR>2YUqMDryT$bWD6&Pg5QVd2SI}Nmg@7&?#Fynw3 z#`vejsa7hDy4ojHDIq}$CMGRv4HkvH_g#Kt??4k^-Ak5O}Pt{~|`c%KD!_N9~( z44V<9m)3|aDNcM;{KZFoD$$Km9s)BducRhdSXbkFe}e9V^m&$JD<@(7w`|Au9i=_V zl45yH@3ZOGN~M~>qp1U^Zs}_1wiH}tEKJ^&OH5@DKzUpJKC50b9YFA8ClG?LW zx^**EASxVnAG;;G1Z|fVX?a;GMI-*SCoVpVhUEKKQjt5D^73+RfEJfKWk(3( z?tbBj<>hF_>ZcCS3U(gi%0sCGujwQZ@tu;Rxy63v=M63P=AWekaDusOI>J1hEFZP? z9wZzlk+8_wF+;PETkneTS}ts))x*igl3I`nZj>y$3N>;%vF@r?`_FTfa#k=0qhDa$P0Jd?$ypegY zVM^2}CUxFk=oWuTuv|w2LSnDR9x~RT$QtEVoUl;@Kolxp{nX#PYdK=4U%d;>zqvzs zGo<~EHH!mqf60<41(duUnN2&(fhE#Ni|5VrcAkHZ`LMd-w3+(do(-7rp$hho7q*`x z+#OjDickJHeF~!$Mp=#lF0yDh<{jrLXstmM`anC{JHq$#4iTV(Q}rRD89#Ww7^a=4 z%@a1yNY_4(d^SRkAsv9Mz(N{2TET3RLX$OlU_3Gl>+)wyBJ60QOU(tOe?%i>(b+t$ z!)d=wAte zdO*8ko0z$bJ8I;jnOLD?f!^3?-y3g%SNpkustQjYQD;ODz1qxO`HPq{8iLr%3HX;7 z`reMw@8&4wNNWnv+#*^LodJ+N1J`n%8y6db`v(jBl@lBo6}e4e{(&wH2MO;(dY`vNx54~=qmryF9=dG2(y z)+nh&aV*_cdM~!IPISfo<#9;}#|7SEO7ye^9=yoyKq=rNa7PMbrd0PT!04Lb zJ^sSL*~C5ZXTIHyByBSb;DV_kM1H)p`@=zM9@ltlxOirbjD`WKlFYzwa?lBb(ca0z zoTg05PgF-9;jeSjoxW-}Ew&=0;i>=j-evtmiT_m)% zb6yRrzPm*mp-h+@RT-?Qr@>b|Tr?fYOwq?lX2AQv?pH~6kR`;sH=4onFLm}A`zYbNs^adH4e9cqyg)y++|ql>UgB_i=aHl$)^+fN(@oF# z5Qo@;MXf4wD6&5pCw+cipW5A`Vt?~KB(p8G6{vsv7wlen!IjHpoSGJuM3(b%5Du>z zJg)-ZH=Y^)N|1+B$6YEGE|6t7&T;Bxp*r62VdD{&4Jb@0qLaaBpswODTZLk&6~@x# z$7(JqH}^x^_}X;}FmhhM%ewZ(a+AZ`BsigfUG2$JlLd;y#tY*PPL<6w9X(n$eSgEu zMPc8|xZ-Pfn5R+LO8(r1s0qjedlXYc^IAeTbAP)Y%bgb7#!b$7lCj>HRSt$$dHyr2 zs)+DAkJqTE(kriGiKPfgM_Ywwr|XV|KNow&eg&Obuqi;m4LbU5%DWYg_d%!+&N21S zXi#EI)SJA(mP2$(;8yHZjO=Os9$(PzM6_}^%vH~5u&2N(%}pJ5Buvji?Oo>gVv1Vj!xXYyWn~QCdi>l1BcDg?FGR#+?|PQNrgfI zlO%<@J-4KxY`9l!Lry!`+RMzvp+QVs18rdt+gG`kKxxK4hKFBkOfv21!wQoy6XbT4 z8AsSVR);LO3%Jq?)nNDGtfTL0bYO*?XiEgUb~#}%OI@G%TquV}0bha>Qb?{AN3I~} zZ6xR2`@{Z;2T4mz=kjT|4i?oWfneN(Skge{|EhiIzABilf?&at3+v2k$S>C@;>@Yjq0c zbl*~itg{#-osrZ`DxJxtj#iA?3Jk2kRB;ueMN~qHv0GbgyLjaGM-7VpM4HAmc@?LjLt^tE0aB_5WUqg$9HdDWfhR}VrQ zPr?XrPcgQL!=iHJN@k6*)X_xwS@_3>J?F$J9{ZR?gio@Dwi82A1c~x(IhRdZTpM~WCGnjo3%ud zo1@0EWJyY#Th1KTU4I{}BqNv>UUyP%O8RL(Pqh=~Pjmg2u-ShzQk^N+)!qCd#{(#9 zO4L1t!^`7-h7N+WM_Zkv?Z?eS@0aC8-e@G9?V`4J+c;seaE8!{uwWO z0OKD!KP0u8kR(7Ki?m`NX;?k05JDID1v09o3-5Ks>ji5E48Zh?fry zW+YA~$e$jFpYvL}< zBlaH+H)!ti6hGh2j|Z7}QKCV->=bW5$0e9E~<+^L!JN8g9@lV$9^UoFAP zL&g<#5|v1e`w*R~DeDJUBvoKN=XvwD2Je&yY8XA1xWl!eh&>s{(E5)}$$(Y&1^`q* z>KMJ_0IDYj09L&Ks-Sg@{waV}VxioI0F@r-z3buY(E2<%XA?grUpVhk0M#9Ih93yD zz6#tA*OR;19kdR&9Ell7{r5DqzR8ay(2vgJ#_-mEQ0@fupDO-G`v+1<$oj*rzy+;a zR!sO2`;QjaXYT3^u*{|wt&ak(D(t$nS;Gn1Ra@s@xgnq;axG!SW?lirJ`h%49xY>H zUEzVAi3v^tGJuSNP^iR1W8z%ljh;Pzsw`T{$hqW!o{dS*nKD-%EoQ+5y7*MzV?iKqw29mIi*fxN-T}bLC>^dy}WiB}|3id4c1ni~c`4 zAI$fqE5w<2t=yh+*kN9;eE5q$;@4(H?1(M;M69bB;7QpECs zAW4Pg!chsK#-r^*3BE#tpIE#(#%l=NfG`H>IK9GOdTD0(M9N~01SZ+V1;ycr@i2#i zXe5&?@&n=Q@1KAN!Wd-Z>}$u#eH;4}?)x zndgUldY9gbLFQT1J^WqbWRgw(k%U42)|s=z+8+La-U}Q4RPjIBj6aab)gNw|Cpwv? zl*o_Re>5J@!nL_Q;hj#Ouk$H7H9a))3VRh6xA1LIkbEI9N*x?V=44-Vj|=WrTb*|z zTbID)+|)hxtkQVhg?=FP-F@C=-spJaFY?1- zjJ%5;=y;g)yvcX@(Qqc-rwM>w=y>1W8}{9O2SPvH_hb6$KHkOe?)!$29|$cC{BUvO z$}{is#m420y zJoGO4t|%v!F-Ms`qsdeTztIO0O9Srnnw0;E{m{-B(5GTy<=&q5KcaGBoj1yoO!J=x7!hhF8{-&@ zp{DLs5T-WXtRN66oiWobr?p1RKzTvGB$9NdUrX#&1FkCC{yMj%@j?Te;FALheBa_MKX}pqF9`vEPa!Z^lAN3((h$qk;-8 z>163aS?s8qiq}R1oGV12Eshvkg69m~FgtlvMiFI!n<7ecOZ4stPLw)*u7QL({1>xY zf>$Dm;Hj|#>J9)I0dIt&^nfwr01~E0o;i(CW=dqm^uGqmk9%7zl)&|UYYAmHS>~NG z*(HPUvjYIYQn33^;$Z4av+@F6`e0a-Ax8$_Vwlf#TBwJ!Er^>AyYI=ncJ)1CxPi8+ zTBxOQ7_Tn|Whe$N(Fiw;nKQ5ApqqkP=S2pt`wIkK+^@pl6ZQ!te~#~f+r9Bjn*dys z_8Hh`7ng%@QbS7m4O#k;lhNPk0Ry(!oiE@`{?@0$(kte!N{cAOdfv6xyLTbArt zT!?bFCDAGzbIVhzBR?L(Oxa#KqtUf82%~o4om3l3M@L*q7fCG$dIs2FOz)o+(cnT# z$*$DoDguH=RG*iEibK3<5UIGv#8B=eW?Dr_Hr$20@tI<>OVA|p{01P` zY~K-6qe0yWegh)YtS1V~pNjy-3o>f>I7INmtyM_Yl(lx?f75R9x-q~hbPhBAOvbDm zj)oER0>=6z=oi8Z-PL|6MevRf0Id8D4Csv^pS3`iDT(_+3ouCj;=SLS)23D|St!{S z%1zRWWC*ahsmuyy{FNN}D5ZW{RWVESdAhUf`G=>Xhv8fkfYM_p_SkOGC4u(p2f-`E zWFFk@KlvNjgENj?8?yZ~&u-f$(v|_;8Xu$hxl6b9aj1HC&@^`>F=y$nI!V_MsVNHh zA>v!8jkxoc#HmVmzWcKXt9^3O<;4{OI$yEXFnfHd`Jhym=v1 zKOdIE`$+LVW{|kNE0n~R7}219??}q%K~_cVgYIC8sD%!-H6*O?ZB6T@3a+JJP0%Dn z)itt;*`c2@%&vXXU<}3%kCQsd7@}o?!9*&RL_$&0_R8b^LGji)#~*1}{Y8(zym&BC z8#K=<++U$rKufj`O|c&|-`QIqq?44nw=eHXdmmgY%r&SiP%0|Yzp=p?RIyblAvi2| zl*+tGU>B>42>!aXQ`6n&t&fH#)lL3vUa(pQ7((!T<}9_W;qO|NYegp#2t*Agjf=v$ zt0>pJs69s}{U$JUgSGhXIb?Uwee++C$CF3TEgbX8f1N@qpfhL{83Xagb~7E*D8{Xl zJ~Zz(AuN|M_}Xopk($YyNtuQdAz2-`j2w;TGzGt0=r#fu~s(q-vB^-8&At6}1M8Q`= z|Mp}M=PKNdfmyePz2q&Sb9US*P{6$WSmiz-j&Z?r!U|GPcHzxA&!#+C2#3>F8up}qc~E|58MFR{YS4LH;t*3u{qE=N^YMqT`$6wR3zRK)SGUp}d7nLM zyt*6-v*htHzu;?lI(H>4?W?2T7tG1rpyOh;XpI>Y*L_<`@<^y>I3-#A$!?f~~63B-5q4fU6v43|s-YXcWI+NcT z#1Y}_K{N!>g1}_uOXZU1U;6{W+-0JfWJ{xQ%MOT7v#jc9Fqc4^<3JvmkeZey(m+4y zTuK?wE!LZfRwN_fLRiEG4Zv|S4&QkC*zr#x=q}c*89;4o2%gcaM6F-D!E<=Un>gX>H0BXUlea}xBh|6B=>KYF@lLjs{@du#%Td94hWWqk zb9rvp&;9-E$AbU>p#Janv9mRDadb4XHS+jwrxaxwyN&O5`lkkeWdOVDdCI~c3NutU z(X3QAArBrcO(tkPmh`)AyB5zx!zLS8hz!`FKTeGIeyquj#@y_8PAdZ!z0CGZjOuaVg$uZbU|f!=7Mm}|FxSo$4}DRLbS*INMZgdz(UrrIAR@7rLN z;H+qfJ3y|*(2?2_maNF9=xzd2%3>0q`jq&1{Afyt*5!#zB#m z>YS<2_vJWSH8ac4N;Y`K_?tfL8x8D`FW1yOHKmJMt1Pm3LA1#QWCN0Y%rN-|K`#6Q zduP;n?&12|ev`}Q0uz3F*9uDJ&56Kf|DIEXL9EwIX(W=v`R6P4axy$YIiRQ?aV04O+3-TjnCaE`uK0SMPvim0*eVkB_^8w@|VH=nq?M=?+NeU{vfzPl@I#c&(#BV2K+Hy zC&o7{TI!3qef&Ou_{AZQw?@Cmnb2=%!}wqRW^Ca6 zeK@M4i;=U7qsdS1>y)~d-3BYN?{h8wVwhw|LDfJGw6pm#vsGyIlqXhXue^CgL_*4Opb*O1f|)<22Ef8mocqOJF%Pmv-%IH}qf^t$rqKX-i^7%4~azCf&Wn=;q zoqlY;>C4R|fua?Q9;?1@B{&Tvw32qs8HlD{s&d+4Q4>`%(qnX*AWE*k8|1cNh^7WH z#h-Fa0sr1U$>CX4lvARVO{Yrne92{sdrZUlDuM+For>WCi(cE_RUaOnUwU|1*hz{g z!vUR7PsHYa4dH6b%ck8uJ8GyC<=o%%2YG`h8=$r6^3|KHx-iGgk0PUwT|f_Ci4_*$ zFs$6{>?K(~whGs%V|d~Q2ayr?QAIkt^FyhimpkIdnz1Bb1!$AGDc+E?D%IiPxo$KD z$#+LHnp-joW}x9|GltL1xc)3!t%>Lpbh0Q~^1C@`N8v;|1jWP9uc-nK1ZmFTL(9Mp zIGA_uLU4fx=fq3mL0CJ8dZ?uw+kJ z*%*T4KG5-klYXCz9QLMW?v7WShyMLc^o=tzuSt`mo&( z;fnNGS1y?s>}1@u%NTROk-mj#89wc6dqzI=85eBYwRd6LRZDsI(n`B0DlUs? zcAtxuG1{knOr)X$x?yKjqAtXKW#}OUW-EApw{~ZtM}_w@pS9a&4biY)#C|s*_Hh2~ zHo&!CEeeVj_^k#Qw##eJeLl#C43A6BGwsT~4Su{1y~``gB4@Av2B%tgT{fb$rYY3a zwb(l<{O$0Squ~Hy>d-?Qd=>JJ-UBlRN3_xY?TKt|;j_#$!$c$UT8CPct1&AAQQG7W zY`Tv~pzoNBx6+@!K?@we7o4@*ah6`}H~ULrNL0J|aw73r91bZ3*c=D2 z6PTW;=4oOD$kdwj-3CWl-hERX+r(;HPgtv7e_1v{D~k0kX)lH`IvhYcLfRCX2>7jtbh3=;IShO|hR^4pKm<2f0OSR1L=sEk#zvR%9OiIF@Ap{su%;;0j^ z&vkTQM~HU^A@Qfg_4)-dKX4XZj34GCnw&%-Unsm~wlhtUl^3K7?H##8z2PclY7T`%J*+Cd{L&uK_Yok^tfyy6{jAbY68>C( zzKfmI23xGJAo1TTTU0V_a>qOUS`SgZ_dFpPQ{(Vw?v#$}b6!vgJ`i1FVz-~Q>9_0o zWQU1l5r5Uq0DYfwBkRsa1TrL9jI=Frn;2N8yG<7Gu)AQ(6N-L1uVXo^K#!Aup-^W_ zdo7Jf?a&W$zy%_VXZE#|4j$cUrD_)nY;0>-Hpq9+6hc_-g>%5g9QI|NkK;|9 z=UEu)P=LX|ZswRc)DQYi$2G_lnl#V?4E`wg5KoHn99=SzgT(Y_`K0h3UWUQUo6B=} z_3IH?3gn#3QBI;p!g>QxLD5d?6A;(fm54mHnn=>e89FmcivZywy_^}o3pZ0w@K(i5 z9e2SJE_6ZxYAeja>4hto)v++XB|*fW?mDp6E&V*8^8}gAl?|5OM9uo zTx}{@_6!Q&);+x%zzuLZv|I@mc$&yO$y`T^GewkVkS$mUIh@ znB~JsCB5*K`57I=oH~%bV+WG_wum7ld;;NkST>LQHwzQ~IrLkhh1>t;qq~d>L$v8b zZ5G85_c(@|$hQa+IDT46Q>bwC@lsT~>Gc?xBJ!C%W#Xt}8}s<6T_iCpp>11L+!8}J zE{_|xVS>{w+R4g%dv4^lukbwfa_b+*t0Q}=rixnC41WK>P{Ci%LepOSbj~-pUBAE=MmG7fiO#VCgck@CnX~_ z<{_80->Ux#%j0%V)=H?KUt-4DKpLx~y6L=>rg#f52ORWRR!ZzWQ~ORloU$tE=px%` zYt9wFEIXd)m190%|7gNJT#Yn)={aZWjnjO5-c+oR_|ZIp=lH&N;#D+LSiU`$yno2E zTESdi8Q8UZcx_(T^{~q4cGo}wb8vAjgriQ?TSf%ZAfx;nkFTR^H(ZG-5b3sc`)3%h z-2J&Ral+T-^GNu$V^gCy0GbyW?NXfAs9O<21Lz zE2ACv?bhQp=;NKj?yvtWTgNV3tIz!N$6CM{YBOvq@mxukdo0;Tyu)2$J(f;B+RLC~o?JL?6^%t^$(A+HE;1d3bQD9jQLZbx!}1qkP-v9F zvvqL7{*)r#Xw-@=Q4wG6!zsz^#|g-;8#Yv*GlCtn;>+RZzLyhmFAoboRxX(+rAz@- zUBanZ`p!CS0FX*rKaFh^_?<}5 zNxwhlUjQsBNZJQr3RZv+nY?2}d-87jN83EvXo0O-kNZFfZdO(P(IeNWYu_)Xq|7jY zT|luf3oXp~#kHFPtkkkHn`R-=V;rL!1n~B6UYXgxC(JD3+{OXjwwndU*EhBYThLBl zGR3EYVmDU}EB#9bsDhQxxhVulq?VPgjGq;Zr| zw8ruZw3#jiHDL%U!=@xvk)c-KR*|N+pmM^1Tuusdl>cd1IZiSG2sNSbdRF}Gc4OCa z4sOeU2b;4cR61sTrz_Yov5gNX_|F2<;gYQzy1nV=qdZ)S7RBd@ysKC-kIRtW(&Br4 z#TK3HkGEPLkD@$# zQAV&z<<_33^UGec>xGMd1 zR1d2PJ(kRpJ{(#tGD}hWiLur%D<-MqMV_9IsVu)*o&cnbjK&RP96mV0P)nwa^{#Au zdfs+2A)teVx-FM!#3$DiZ-0Z&p7vn!r=@oAa{a<-X3wlEc|j(o5@aIJe`-cfDQv{W z6rv$Qf>4>w8Cb-$9iN%%Z(yQ_VvNU3XXQ9ByD>K4oXGJ_`&eW>Y769a7JDm5b)QEC zUuR*PPdjO$U$D2BnX!%%qd#l3NJbf$RZ$De2cGY}6tD&SawA{MtQEjW!EfW|2c=?N zby`6M#f(JsebQllHNBhKUuzkxy&q`b4EmMVojk-0CWVqI;PdEpTn0~!kcjOHa(>ZV zmK+grs@*gYgGHRK00JG$uM42WjcEk?6gKhXp{m1Xqo&JzrBt`w8(q*Y2M2>{r)u`g zb`(Sb8(t(B5SC|^czpQkFIF*3LVt64T%t653-sdP)NVZ7uEaVjV9J6&Yc4S!p|2tP zbWlb^!)}79#Q#IsH$_<%ZONu>+qPY4+qP}nwr$&$wry0}wpID^w#Mx{`gMQI&wXMp zoO9-0D`G}c77zAvC)mCoBBZUKUjL!*X!nZ3*| z=KKlLsKTdV4W?}|+gKO>B#`yIw^1~MVtbrLU-pp$9Caq1NadeAD{^yzXDvI;e6%K) zm>3XK4lMbTm0z9wFIPb4HLCe1h_vdN3Mv{_x1Z7D!Pko!31TXLQuG;FB9kEyVb+gA ziO--A7MMV;D+zx|eIDQua;L^J*Y**+o_&=@GUt8ell3c}dc_5fK9CgQCW&#huIRe- zLFI)td9ZopYAELt(M5CTj;bO=-fQ{3nI8#oI@{{9nquJ(ZQ*?Tr35oQ?T zptB}VhU*iCZ`}+j73fOVfRsMq&Znp0$yG; zRE|p2=%mQUkR=r_7NZGg7E~ijeakmMfj+)aeJ}a~5fB=sAA0DxcY@enYWSA!vKjj1 z$+Grhw|Hjv&T?3Jyp;~fb|deE2CctE`n&cIaIM$vynt?9Ul6FUFU|Qjh!MYh|JqYa zK>vHNB*2U%fcZG5QjUNtvk)IcwljT~#wi=CZ=}hD>kD*U{Ngsw@cE2`U9M49RM&;AX87@P|*>>ojfB$O1fU1cX?gqdda@T0=Mv%e>pqCbmXF3l;D3QQWH1xqJWPuEl zs)r9qA>9})Sqnp{Aw_8dsd}=s6$u84ZARzEkU2}xJ=#(om9!B2E>H>I?KkcyAsx@p z$6NHS=+Je83X}vz-%&p(r^DX*qS2yjGPAS{CVZs?ZsPA{%j*oMVy0qo5Q-}3s8!Eu z;co0l49p%L*Poja#OgMYa$;%KjOUMAn9S*6?DFXr~J z*_3K`ys>+O^8>(wWXj8;F7f8F%YmD6R*5dlx9;ReD(Rxa=Zf#(Og^Fgj z45Fqm+5F?V^AYkV>7s1Oco+lOs1rAX(kvGNyUu|CIvVZeN!zAcOL1lyj%$5Dm1{R@ zxp``Izq)TXP|2qj1XiyTaaMC`--WnyauH(`^M(^#d)eQ;vfqP&i;!mAEe9wNhJ91u zw^?XHHDLN(KLh>5mM;fb6(;B*9@B~Xn29hBhY>Ec(mXFBw8Y&5w6J7-0Bc%JSV)!J zrpf(pk*CUIzFb8DNG<*gAFck5*-^d{RWn7!Y(waR`Zs!?@wU+t9(UGiqaLrJCqI8~ ze3ye7w4yZ=;UY|CWNByhgLI^F&k=os*?|7%e%Tgcusj?7VuxNY$cN(cxbL~Gv7~b^!G4KI*R#i^|&P58kMu(RfJJP9*KZ2UX6f!WX)J2 z)YW*1R8eO-AySP)gnM3PY;%K4l zv@kKhoz^n6#|l;$UzX%E|Bflm3*e0}d9>zq$(I|q*(+}pZKqdFUXB*x=l1#z8~3U` zycQL`%Waj7b9ikXYr+r`_eY#s6)y)Kd1k~vyzEAJW=C|^Yw{53=fo$w+{jR%z*D2F z%m;p_BJw}10sLI?xf$J1_{5#`x2DsZ{sD{Pv~12^Z$VJwI(ZWHR?-ue;gUpH7DKyG zMk@^s$$Ykf*VeOesJ>ZipVp3WwPV)l!2x38B##`PX1J80Lc6Z=W7L)&kTawxznyf+ zlN^gIJW%Yq2c-59XcivPM!~f6XlJJzaOVAhPqV82YdW#&Ezz;N>1puy(Rc-mUG|7~ zUotF%pRk^bX2?)k%zQEWD*q!>@Ru?e^am{sQe#95BM#E3GvkgF3mTLc$^l3+wr~D; zIvs2_jy9_-7Z*|~6F|+4@wvNsND7__-)VZ5Oyp#|c2L@6WY)xA)9^AIWcTJ%HkZ{A zzrH$!Jhq5DTf4wmOB#w^=94N`_=xiDPOCd?H7EB_*Jkk7^>*pTJD%rj&s-TB!!n)l zme&~^P(oj0Q{{^=BCLW3l2WW+qW?zeZi6L zs168&?5o6I(sX=G{2sNbMLc14<=+pVizT=!C6|mB2r8#4ka!rD3lbovt`=h7OomVN z$@Th;c_1xZnL_8KDH1uCRSkjftr%X{`T z6^-RsvbDwsukySTf13`eBUgZ}pL26{aYbx6&0KL7b-EN8 zMzZhNd;*?wrlnvZKt;oGt}`H$5AAIjZ?INovKq0UB+PhyrS&!uhl%zfM(bUQQG8TE zPA5DZE>3BYPOm9HK2wz?&%0C|?&2C{cQ|i}@M2zmIEzY%?QE=9pV% z6c<4*-c*Sm(IX}-62G(u8P-Q=!m)|@)JW_3>w?ce_Yn|5QlJX`zyb$8q!ymd`0MEa zcaABCRe$|?uddxrc_xS~W!aA|xl}>_ow#2_IMJ5&ba!NQqaF<&maX%~a+L4c65KmR zWX)yiquBr&z+46(ABf7#=ZS;Zh|_{IFg_{|{SjSWx|p+3z>bW>pddvD_s(NA5qVr7 zR05bD3U~vZct@MFX}Ko&V+4vtQ5-cJXRm0^;QTx{b=#>4V;Lb!(<6!Ph`!1!>lYMJ zHbY-+H}TX7gHZsVsV$l8Ep+9WtAjg6@~3bR;;0gn_tfKu8Q(w_d0k_-rxxNRsg{1% zg>DK%scT9@sZox0cFJa!)Ne|zG!jgx%jW5v|O-9w1!u6vAhq0_?gJn}X zsg%);EByBh$1s)2&Z?5??Yt_l$I@~fS|8IMS&#&SuMg;A@$3zE)riU59|ycOruO_}oAF#;aT zP;4?lr==AafYh|H`G4PH1?4UjA_200>-RvqkWz~${=$^jC(9dUJ1|vL9eE8e`}GSi zn`3{>fSZ-S)kFu?#}jA8#tFJHV-N~T_8hCadpkOcd=Lr_UXH%QQ4gJe03^)u-kGVx zr6dbHJ>u#$T&A0WcKN#z2rI9@{Z2Vh#nQ={laB7Lx@vATH|&sZSx+M$S&AJI!n|Ml zXbYWAoLNd@n<@1CvL{kP8#f`GKtawIBYc?ClZy(}RH$=$t~T&HdEQ~|V2_Vsa_I^V zxx!%NBv2Fix?}xvanGha6TW6|-iuK*Gk9x{JW~dHx+sRtFL>N|-O4Ga|EkHnM*kUT z<0H#ZZ=lOdw4z&pdp%E=~<59jSQB#)#dU=nlCpihS;@V%2{rW zyO7qorFZpu*`JR_kEUfPc(Th9T}x6KF8yTqz2epLC3igXM1!QDDufD5*Z7FJ=n;KW->59=cFnlPMNWnwtaWXQ`YI`5Y7Q}*w=yU8utVycm zxqU!!lri%0`=8B<=q8{C8PF)S5mhXl+)zWuWpXnp6}xFaURrxpSDM5f6``IS)>|L3Q6SPx zngf^92a6fTwr(o6r=>hj-Z3RRn_|HQ4{>?>j+Zl!1Iny4um^Rm#ulWm6TdMnwS+b} zzJ`UT`%T@UR^FcMnKeNB(D*;?`3LotEdRc$bqkO7Z=?6&?U5lSP&E2@%n+mTo?2J= z#j4aGyGtFgROSc$X(AzU`Vk=_hi>DRPy;gUhgc2?eF{&F%%Z1-?aE9OP_S~12bwRL zUx`$+pr#c%R~634DUG`8qrLSRV2i*^1*o@k!4l(kgE}*ymQRzGE->g4zh2BR=g$v6CD>Baw7G=_WKj$@cA+e@wD$uW0V{_%3~%A7NCC) zO_=g}T4=d8)QF@d;4;Xn3NLpK@ogK~9cjM9f9fM!bef=V<>92X9kub40^D%}Yy#7B z9M=d)eFs$I(TGm&O3>UNHGzd>#hJ$=U2>+ueGD7Gt7>zmOn+$-9g|g^m&hrWt8zlv|oY z%+VP6C?-Ns#O_0>ULbVnau&V5iw<^F+djQxH3;Cf;Y=DBRO?U3(?mp5HpOq93CW)5 zrlGr8G&?rpJ)?4}gi_ONv@wn79@=aA3qwrbXw!0&%chhdgyYIX%ZCf#9QBQzQ98gY z={tdLcOi|D(U@P69hvqAheu!?ZL>F#=xn`XQ>YdngMyg+pmh#pNUetV&j)U zc>b14h)M!Ek`ck}dKBVNf^R9QD>Wyg^C5MC4>KOZY%luO7knz`pi(9-7C7C47Xah; z{z$-Ok`k^y*7zYTd{IAA+>5}g7-5e%mZ{lr<)U~rIsInv`aa3+X$gBfUKiQVK~Ug=`TuuN=>`K8~%O2U*k1@1p2haUvO}}PT}Gqr z;J4|Iz*kJYrn7=8L7PKM$XIa>zpr4#>g8-JdA)=8iAP;8$i~ENRfYvN$GF@Kcui!{~Cl zWdM%dsYTqO!6oAhER|BYg?E&C9+aAI(c0tN!-WbazPwzs+vkjHC>}DG%u;&^^~nC@ ztlAv@ctm|uwBz1i6Kpo??0V}T{ab_-Q$9kVLThsl!oHG>iSF&q9)QQl6^CZrkT&V! zC(geyn9xKkMQ7M8|Bfc@d=8I&tFwyf|23|T8Q}}j=RI!@u3}C!u;k4x(zm5~T(!ty zMIVEjTtsPLc4#Gj)DN_<-;37;E$cfJR!7O2W@*ix9l_#wwFVP7+syy-IwW#k_s5h* zoSd6eBrkUK>_}Kh>KsOnyIq^N%(p9=_cPey9;iZjq+Kgtg{@Ltm~{fBE@nq@yGU!! z$dz}ZLz<&(?mQbZvp(+F`87j2Lyhx|(T7OK#F}VeETelQC497yDPTh0 z;!ZR8BllPN_N&YY5vlFaxnt=ZvAV^XxK>f)@Vdl2t0BKtC1*>jMXjpPvu+Ad=1tQe z-YiE})BuZm_rL*R8&n*C2ExSMg%-$8`GbAu<$3!0@>q!Q8CWk4J*oOV%+lK9Td|i< zF6u4Sd?OOTG1t)AOBqzmn7Fbg(C1EnXt84vx%yA5=+%Bqbj!7y5`FE8G!PPSbX_%_P98;#cZSIEh1K8@*zByeqq-#+97$5 z^bB7N(q5?hh9s_PC|4@oJmiR0lT8PGyc!Q|E3oA}4vFHBEuofelHw*tx=?x(V+ok* zLdM{3P59)`^f=u==s0?c?K|pvUp0lC{e0ETBr*4=3rJ;~hw? z3C&%8$y5P_`jetepnFC|D!{UK+p5YH=Bfp5S+i$frPu4R-9yf9U!~$t%gV*o7~Ca| zc6Ctm)c4IEuyJ0Jz;9G~UDUz22jfeuvmvabElk|5J+nf$v)kC}z^g%^La%y~2~izg z5v1Z&G$aD3yDFR)*EsCS^R|bMEgh8@4?SkGtB)|XDzI$nvxTaBv4}!#=TXqJGCePz zyY2G}FRH5-+pDUsGG`IO#ll$oGXvcPe!vbtkB0|2$v0r_ChS@WB~ZIto#>F#sH93p zPcNkk$d6Y>>GaV!MlU@9Cc*b7yd54K2FqF=^FE&-1FR6%AD2cXTefAJ7ETo2EHp!7 zX=#c##X9qC0IlFN-TEU4kmv2H(@4C>z8_UmX6ifIG32&;l3XJ>9Z#?v1&Tpkj{L3) z_w|{P-6Tt))5_w4&o3wB^-HJ&qIH}y3z)lL8|XjDhSS2r~|5%_5Qn<-h91ae#tcC5!F zG}CoHr~FoeKnM2iczn)&(#ElCTDnu{YQo&Hyd53la&9IBNK;kxLKtFD?2nsd$ z!?cTSNfE9Q=X|1j-?0mYk4QcmIyjbw>DQ7~wWU<2J>ZQeTb)HJ ztF&`@5M;o~z3InqrEY{DJJS^7>CDpVybiU;E~`NrGo`OG*l093RrdpO5Bz@NJFi8{$F_(YEwo|6lqo_DIY6|4O0gp~8&F8Xf|hqn{o}P; zNUiQ!UNO3%P;0@9p*{hSFLPN*)LW3$<0Gk?D`{AY8`YcQ=t_q~?r<_`YoGxIpyGgS z6VYjiVeP6eLB*R?ecOSuO#3R)2n$re8uAfoR5$82LbXjJNsx+*ZTWWypfm%cECG** zR*>Ak-k)+sr#ynr;P0v|%H_c8My*f#ewiFeUT97-qDBm|I6sMND;fCK3+PE7WI%M8E)Q z&c=|^fvhX*fSwI<1~ERF803-k^tqm-fI|*$pM807I?&7fqjkYI9C;*FxR8L|D+V{y zOC!&259ne*AbjG5R)G*BxRpk=E4%qTQGlJ2NX$xpoXr1%Iy7gQC&xd zw$&i-zXc!}t!r;P*D`wrw!p6<#02Cm4{wAOq+f3mJ9b{Eqpsg_>X4hQuBU2l}Bq%s!`yNT~{J zYw-m5N=JZdf%y4O3x84mRdbZ(G}l9#L00onIXc&A*yAoEtjRr&FQ?YGK>F5xzys2b zRI|2%wt;R?BP3VZUn`y;)y8G;w?`-`S|}7i`}#Pnwt%)bLVFfYBvYx|i2auTLPYkq zwy1i+rF+#7j1m-|v?K?dzHWfkb^fU&B@=)>-XCyHO0j_!?aDroM;BOh#D3I$xTp|1 zj4dXeFUl=P_>(Q0#m3H}$B6jcb+Ve789lWMy!#W&l|iV&8SWUY=6Byc3LL!}AG_U^ zNB^*j&zhHCRHOab!<-xNlHlPY;TH~k=eqI?1mhACoXm&wv zYLOj1?>tHz7Sts4HZr&FT%LtfADhBQO}8S7#m79YZJwsBNWG}d;_TI%q=B`)kqz27 z6_SLMOOo*In-mmNc!zLpZOm@wA8WQi+SCjH3iSbxK~%afH{^OpB6Mz8iyPmc&Xu!9 z=S<=prz*bcLD(otxFKN4mzN%dmTm1d0>?lm{u*Ucc3jM+nbG^q_oxK}Bw@}b5J}0Z zJ6W$4H8^3^Xn|tvoFs!gExB>jsGZrxbZGiMz6Zxs$+;AVJp`yY)s{urLI4!2(1K-Kv6V z!bhe#wF);D34>z{cX;+CmC6V@=ir|)`omm`T))52$~If?*+@XP&XJoIl2`Sa*H&~D zR8I5HT3B15Lu4&t5qwP%nxuvV)%06^jtW%KRS_`dLiR;*ucp!o?OhCP`TIpDG^ccX zF0mRpYpy-|jq2Ca8bN_UpxrIJpGzciRWp3u0jA-}{BQB|9@kd}?N>12X!cNP0M3Hl z!-ec$)t@{FqHI4DzbFk}KCO#ny_7RVJP}*Lu~svQGwVg%=XSyp6-0 zLJ9YBU4*OX>C6MwpY$=5eXHIheo6fBV*niOgm2Msxs+*BIZI8UH|Og!E+MhNE)ig( zL>3u}{^9`NIoo)H2iXv@S0BbRtN0`sz#ic5G(OFNbpwX(lixvkZ_+S%@dxm86E>cP}6`gB{)gbJOyXy7bl{aLR+|Lhns6PQm(Rw97Kay zMo7QSf6Y7GtLqr#+1dDrtzZw@_-PhxQG@IF$W@bib_aFy-Cz`A07XB;Wzz`=OJ`K_ z?GeQY>AAfuo`&bSuMNx}hqfpU#{$Jq*MA(3@>N4j8-*HK7>zQoDJBS-+-%q@CO`!%&{tf!yYi8hx-rBhzhAqnv!}gzPlqT** zCied@X45k_ur;>+_v$%CdEPdQ0mbJ>KgJVqD5BF61{on?6Vfb=C>+poo^;e_awlqI z$~{?G@y!by3mwgdORxX2={3u_nkE?uuB=dEF__v1tq`aj{)@=*s;){PaxYgdK% z@dgNM8pQ3D_LIkd;diqssg0Z=WysJeoNES!uYWFh^dcThm5ylXm~3)f@Jb7Zpad0R zM8H`P5p9vfA);#~^}&G79-g^=BUp_==*J1q&QRGFrS@}Inc#Ow#Yizo*hgZ?_=>He z^Lu9KQ(&m@SlFc0J?pylViw0_ZS5*!M3Q&P4mLgW{onn4;`QQ-<>_DTIwcoX-YI0c zCkjtv(8_`#&zkH*79?I1lUT)eCc)%?F)*b$Qt|TL@^BXCgpSvNuYSlVJpl!kC3XW0 znrmO6q7l0Y&g!a!bTiL2GW9ssK|S&x;&b5RxWIn?kz@+5Lo|&yxq;IRkK1l%-!zg% z0n1VK%RQIqau{E78FU&9Oq*O%zU^7RjCxJjH-gZ~iY`XvCERuQ=_Q67__8je^@zhH?!Bh1mjUI&c3CJ(1zAJyLPeg ztZ_)j?4G(Tt3LdTOW)zX&sF!&Hn2ec@4DFk+6w=8fjUy(u-y-H>2M@fm^IW45Xo4)UOGG$_R43h)h zLuRRkdYOrG5eY3KyUs>58>uXE*rf<+)*L+s`l$gdMM(5u6XLhS^M^=&~=zRghL0y$2!g1QJkc<-}mx38ad+iz@SNorr0EiFu19+frPN+)n(ag8h)Y1}D$8sH;_I-j%13*7s z*OXo!Z}9uO%6NS3WN_bsUP4Uo<2>*82`->SI3qT2ZWpBwoi+GgQCL}J*SyveyYbQk zvk23?xbAn~*rd&|ei5+du0js?V$R3@^9<}6AfGj6Jk*U^z^RuR_u@U7EPjgPxg={xwC7Qn0Fi`6|w)Tx8DemOzPzYscgj8s$|q(hc!}&G~3*9J@ zoF9kB=W9T)a#W0OwA{Yf;72S7N7J~k%wzCWTKthn&Yzc~;r0Ta8VPo1Tn+}n+s}B% zk!qpZH2wRx4_AEuRT(Voa@C%g7tf#A+uf5b%%!^G>k+hR0J zIUcluq`oE-uot`8OveWI+3#&O2NN}!8PwtURZ*aD*S#VzMti;PBA|WUZWGk|FXEh3 z71}tOALRtwPayu2g2LL)%*@2`=eK@xigt{iN?~kVPHuKe>SP~?Q85a|+JMOOtb&wR zpAojCd1yazC{UVIhVEZ zCN@7o_&;a#BW`wbHZeB0bNb)&p{AswrIU~uAEW;tvk6292ZGNB(raV;$>kF1f5=5A z>I?AySP?fTvwyTd`2Vj6HNEVt@_)<)1ib6Z+sy@Uq(wMf%>!GaLj$bV(IIp$p@tP*7Zz&_bU9cJ=1pV?IP}Ph=}- zgK?u&F}vv8nWDp&ic~yYv4Pq|te0^#Gdua!Tkyt%SV4qe5)MyRk&fIV>CQvC*~J&D z_Uk?pyi#nNG%_k(6g<>cu%r<3MI9$RzNB$2Ap4ZVu*kb#9@qwpu_Qf>DI;9H(Qz;i ze>*$pgx&^G^b&p85YlWyGE<$RQXPURVt1FH?#y{&L19FUFl&xRu_(CIc?Jc7rF^Uo z4nn(pBt_W*zNOawK1DP>0vDWfj%@!TpdP$X=1^A5ZAqcohoUg$NU|*4xSlIVQl~4rR?zj zGrAm8C6yf_JX?e?0z^bB>=b%ZC=@tMA1ElwS+>YrL=cf#keT#&Ht8VNCVZ&XV zj1jfZhyT!)%xMZyD|3~W zZkSuN^Foh(Mm6G^4O^S@ttZ|{+$4l&qBLibRPE_Yidj}sN{*OUKj%^F$5}5+W7cY1 z^Syv%?gmoQWsi*n5M6{xkI@8-9X0NNnI{#*5)pbR5rXb5uWN%Qy0hN$g695!?h|md zCKLs@*3IM!8dlD-kHoWi^`7D@6=ggNj>pR6zz1~chk??l0p!(6!!w|L^tR2{Hs{4@ zn~-p;3hbWn0Jxu37bKHzR1ZT2gh`e}lYz+F^?_@e%Qx&_NDhk@XEZxSC5>63!1xFO zvNh7=7iU1=`% z2)Ur%Lm%&ZS7Chae8)h6TsG&VOOhvJ@FnFs6f_tn7)8niQ~w64UinrK2YoH;EJMjO zz=!X9=4U1Ey;wFR9a})@8!u-CCERr#p~+6I)-J+uZ~hfC$*}E_oJL9*T)ok;#tJ9Q z08JzVwVuc4`E-3aID4aak%E4l;{y#hYex*Q!7*H4P^2Gu*T5`jDJ&#bsWNmJ&3F{A zF+nDD(i(uj5<5L)o!NhjtPc}V#r~`z)4FNZw_EeK$@e--tm#n8F;=8)!cM4%fG4=A za=dU2K}R5LVTnj9oF{x%I3^=%ZB^+N?*hEhiG#bdcD74|4T#!>F3sww!H_Z-1$m8o3vU62rmcW(YiUW0to%u5x zSz9nV#pjw24C%TcdL}5mX7xAUO1C%6pxD3vA~M%I9H`;=wN&nmthG($o+A6yi<)C>jzJ=Fzf`vGHZ0fHeG9l44wn~Nhm)1!EfmpO!t0w5|N zO;K=&!{$iKynj1;d(nc;u{fh;)7}YnD=qC5G#wUX!U}|H=Q$LEz_bJj$jmOna2qQk$rbv(GhO)r}W(aKy&MakYL=;U@wa47) z=Aby2Z6iWs%3Vb1+w;fyMXg850z=4K<96W^5K5)GAsV8-7GIIbX_ChbkVCe7uK?Is zFK!>#1@6Xg$`rH4Fsr}3WEDgw96wEH4pTZUQjY(uy%9GS4C=#xhp`0q$q{HC*y=ER zy~F>;4Zvp=XMJ&2X;s7>P9ptK$TpD5Q(q6V3O&sp z-w8Py=>Hu_t!N2_WNefpJ{%08`n%`v`+<1$*RayfxYEtoXxv~AqhK$>iV*QyOEs0r zE@pOWR!Oul!NHt?!}tBbdbyRVP1Pel3K`XLNq6XuDUaKnIDm$GK9|Z$at_tBA<%ZU zB1|2q%tHj6@+3G5jBF~J-aefibiuYohZ*(A?$H zt>FFwW&<^kwnhMiR*$78(4;yKcmfCj9ET1GPb5xs5r%|!KcOUedcs&Q7*I1O=rmI# zcdhL=huKM~vqu8!ok*$nRZVpi`KuM ztHA(1CbjVL5yyeY09sU!uf+2I1vG*#B2A!5RS3c4x^vK!JlHUUjRWSvgJ?ftV1ua3 z(kW_jH|obT$I*$!ggI8rNfl}IUV zTZeA%1O|cKU$WuxbUhuB(RzoB1PvIjEMGuthke4DqaYjT6)om|g_RIF3t+1J{x7Z8 zBydwF3Sj^MNPk{F{<*c&e-_98)t2H2+sf{s?d~6(lgA*~wHe#@Y5qvlq^;b#ESGwZ z$4C|i^N2=|s?~&KQFAhg#a=!oxZabBe2M5m#17Ki2ivTHq7RG} z&rDPQ_CCrSnl2K_hOr2EPY7Q2@1BlVNA^x_p6r;V0h58Tn%`uIE4|+WLvcJ2PYduI z&q4!_Nse!TVVLt#Q51I)ZTiL;^K+|Kv&z-zEO3b;ScX{iY#hbBXpmYU8kZ8+V%-Ik zR_WEM!AI5SdRRnT?;L1LP0r4<{IBroNmlJI5I%(@k2XGZV^IW*VKMFzXyic9`%ih-t=?!`us*ix{IVd{u@L>vOUjD=u? zbRlR^+kolTQ_EcN1tNb9~V?xQteO0hX+56kMJ zndoAGdIHU1YB56>jFya0#K}0_-7pGC*TNDuN%aTE{q}uxu5}WVFbPwKm68`&^aN65 zbRG*Hq7V}r)UTP>V7SXo_s&fL=hICmBr!A2S(;w?=F^D1$hRoNW`wNon2ozZ)hyt( zH`YbYR)Q!PXUklfM67bS%VIEF@{3^P$Ez2~G<+{6+b-o4@QZ<}9>vP>NoWQHYbm!L z{rI$bqP|4$+!Gn$y+w~F#4y`a^+nXPz)K$GYQ2wwMCYIL&=+FJLzIG0y|_G3!}@yt zhfI*bomnYXLdnR%p9|EO^5N;^2n(F%=t+D-OPB{GyAUQFL)u=?StA0C%D4g<- z<)iZeRrlp$u-sa5L_2_B&CEWD)!!h`y(JEDeVNiU=bk^z0?Lp4=D$zY1vskqF2%#K zF{Y>P3sB9G>ysdeU2nKN;-2m6pxuC?6139G6+sMTc6lk~-NP$7w}3{;=0nT_{~c^o zzFKN1w=ovTpz4$_Si=iFL9rAN_>e-~TFlb^nFu<7$56ziugO9>=oG8pL!lpRv2eCq4c9^J}NK2RDA_=opl*B{=%H+>;6fy*& ztjYZ9Sbd{J%4A+GA3px=J)@jM)u`Yd=3E*Y0L^Z?y6FH}qcjq`6Av>&^lK--qXn;^ z#MJJY%DxF=F-W!Jz3p4aTfjZZl~Bn?g;HV2V}!Fm<@=rM-(i5FCO5O2k(=34b6Vkv zva+)KF}w?Ao5cF%idlOCS=jV1XBxTQaZTa9h^03S$!mwFJNG1a_l%6`BZ*MFB}oWO zNi%96&lS>TUGu;@?TKH4?Q)jIJ#<=Zp#6j4$?l;DPw>S2K0)C|b~!A@Z*0afMi8%B za|BOxvH1u2SdLVw@Pvg%oBM|s1t^kT*$9xCO3HfN+u1(;`e%Gsq%h7f5~pJ(pEx7w z0!$=5Rsg#WXNpGUbffWj1GL6HjOf3PuKsp!@&RMjq3b0Trb3FF3k{rEQENW!c zKSta@pTA%LXOy`msq?Q?0XBI?0*fN%Hd_ehhiZf;{=iMl7QG~mg)o|!iXulUqD7m!sM?+Q?aJf4mI^ENj zL4G1a&Rng$nX6(mmhvaWisAeKZ!UeBI%{C%#wRS$R6 zKp4V%x`HIHmn6dun$nsL^=FpH+}ojzx@;Q_0nLcZp?rOFCQ;H2-qyL&L2DSk-3LSh z;KKvNBUq4ubDR|dnZ~swD}}?4oh9TRItB+1YAA6WoqmdAEB*qmPyXkMs~(ua{#Aoj z1`Q>~ElLz>-rO6f5ONf)2~bXD_U7lX!(Bt#Z(JO;Wd#>NEA1(JIi;yc;ZDkk-)-x~ z-B{FjoWki(LF0w%hm}*hZ;jDfPPM=naFSetCqFLN8$daa)@bhDaev_4_$YsQe+o~% z3B2kQ))Q&)`}Y2vpM7YGPj*?`PKv?NQDj2gq~yNpwDKr^f#h98Ty1^da0V=c1Y_U6=_9{COVjigr%!BFE7 zh~(ko+wkQQe~g{d{=C1ZWL()KgGR1syrSH6ctRc(Q_>h8Y_io!ZciYC(XU@$3oio?_p|WD#6_N3!Dl0SM zUcZHKsm}lW9L)$PQIqcyYPnh*DpW7qu!QMAP+RMsGLEIPFE`6W7P7Rogwi%&^as~6 zwi+>`{-e^%={??#dBTek#U`NU+V1+$1}iq+6%3?5BHmd$@IYclmZ7ik%H)oU>S%j; zQBHz`yk<;H+`oR{UhdbMBvYIf?$R}+1rwNRYJ6-vPOWDd@MvX-?n1Tf<2ELb=r1p~DWUOOw<%z?^EKaX!(kXtY5p&EPJm$DUM-)8@hql$0W6!&U&^|*g zU6r>F$+j+-RjwS`=}ol1=R%q*k2D(VW|Y&rEu%(UGlikR1r_qhW}S}`XG>xdM6KSR za0T{)<;iMt=U9;k8A}~FJ!E&WVS$`}OH0rbf=Zr_l&F9$gba&?kl(qU3%OfTu9Yka zkP1C8XbGv2jxvhoo2?L)Xe*fPvdi8P*g?EhkoBG-Vn*kIvL~sc;}qPjwm<|Sj<*E2 zt+h{Ag77l?Zg<~zu{>YP1F;t}$v&9ZWaDeDaI98sbM;_8q9Qi2h1*Z%&-qo0x>H+H zNrO_(sK%}i<#f(iR}LN-O}){()@hv!U%-;@Ggtf^vnM2y5TZ64ikRIVgW5mn!P%Bp z{F{np@x`he)oW2~ozC6?mSkZ~BN6B87NyKE&3e75aaF;tlRHkpE)96r3tP!8i}Mxk zDbsbFjjF89Dvyvk7fN=clvS%oB&#Q1V3zEx-p5?miJeR4qdyaQN?WQ++P121b4o%* z%NIub%>*Y_DO%VssI4t_N6S=(;I4=+HFl;r`ba%^5YGHr=+qhgNRMgPA&KQSd`9Z- z=iTzNDemtW=cj;n2s20LBI{Zz0wNXNh_ZkAA}nJc*cNaEPO3bKUMkg)vLYVSwHJ2Y zJPZS~K;SSYTGV)((BD{apOS_evV+HqryZKz6|PO-xZcdC{|rsRfMgAgG>3L#3COtV zPpoR>aEqSfBiqCg+SA0Vc%(`#sIRn>7$_WVZEcZ5cd=B?%VhjgA@M*)24Ny+bMn3L zMa-MxgXVrpg_4#rxxa>z_xoOCMWnOzhqhmqn~iKLm1mD!ex8;}ZpNGdUO9HHx5W2- z@9tTHIrBYJU?5k$GY`szWV#GopH-Cs^a1Y8K|Wr&5xI+L+SLg~ISZ2_Pd}0>Vm}N+ zYO8zg1hH{R$^*98HUzYMFfp5{prtBTpelnTP|MMxQf65Q)=lXs3VxF8?Suf#~F?O?-5~MlEb-UB0lJw&2DF6I1;iOgbUjKpbI zjH&Wgiq)XYX8_OqQ!qv0F`>o9C5Do0`Su&g4Lw;F$1H69iv|qW#INogHT6k%udn^2 zrzL@_XU>um+>veQpmRECBX@8;wF|W_Gqt3IoW=ffy1-!le3)yKb=?(QcBlTkIT01a z=RJ!ov|tQ32y{&O6EFDf)#;XwPwn?+#ENUCFMqo4@3~@+j`R}Sb+ZO-p}!toCN3D6 zrMywn>F_&cGd7r&{(LIP^9onHU+?GqTF&Y^v>mnUiQb-k7oX_=X$j(dpgu7`0sx56 z1OWK;|Fc8!KTx$xY#qCU;oGg=K$AColB#v>1$014`||AJ{;f53E*mHTd~*wvMzMHG ziLD`)j~y<&_iiao*INF7V0hMME~ZW{E8;#_fKn`giCoS~wnNqm|euR;FzA9-vGe6Z-De6rx&Ahv0RT z^s2A_)QpyGetc;u;DDg_*svD7)u1ee`hBb0{b{KR`S76fTodgP8ttNWCEP*vQj)nL ziLGY}!D&u3G9%evZc>QAOwUZ!ack3169Erba?{T&2y1<+yMnJiU3`%pYGGIYG*PJ< z(owPzJ~xQy_WxQrS9E5wToxRv04j0*1^mkzAuW{y&Qz=aru-Wx&Rnl)Xd06S&{`Q< zw;kw76v9RjTx)Ba&%iY@Q}VE3AjH<6^-B*p)yrI{u$!mz>udjk^85Yu@%gnCz4UuD z;n{5GDD~##gUq*=*URhm`0-IAt6-u8n%u|7<0|kD0%f#y3XJ#zX+qwa3mwhW3f_m= z=}8x@O`pf`j6olLJ3zmi=80C_Sd>-p;vV)?&382@31Y}5u@S6Rhz;;yE737<2EqxK9!QgiaD7b4toSY?#kl|Qwgw~#O6n_Ht?m(DPp7xvZE9m><;qSE$HdIGPOjefU<+OQOFOztm}QCmP7)7H3n#~` zy7Ez|7|l9bsEIS91~EMITNB;8WYInGXJ#m`&<}dxk)GrS>iK~zolUvbIy#5D2z-`? zl&m(jPGO(vzED*TC@};u${N{1bM-0tQ!7MMBI@nS5ZZ16JO*$WAniA=X#@q;x$b5p ztB*DhrsA?y$GL4p&ee+6oXb$P_)qq<_x|(z0Fh{XF|KIx_dHsa_gW(^>rhI=Yb$H0 zucJL@RU9u5V`oJMn8(C`~6g+UAkL}W%p4;VMq8%BP9wbCxJ>p9q6LgAE6`m?f z<;o!)Q!7fe4cP_~^!qpv_4GITFXXZ0i=IA2A#H`_cVPO%*#kaYl-1(Ql5%}YjRJ8g zqqosBeRVU6j6!L7T+u{iWHr*QFh_XgZgi0uMc(A3cPA!9}Q0rT6v z(J3+Gf3Ac9$3Gb@;b;@J*rvi1yP~s#xLi(%dP8Py8h8JTgS~!U59< z2LQ!!wT~Ii0aCnj+6zpmSY52_GZeg#e9Y>a8D1xA6wAudj$ zaQxP5t7}U+iZ@mrS`?sYmDqY9e-hbgMFvhWa32xvtSTM|cuJV<{4|;?BY5J4C=C?* zQ>NGqmQtMPkB>?hE{LZ5#%i;N9!y^2p!H{Yo?xc9Sc|=va0{bRA!<%Db(Pr|Z#)LB z^@40@T4-|+NWhov0z*0;8Oz=Z(?y5K8r9tAmDu z40${r_nxtNSJ8RJ0SONDh<0dZ2rf%uL=YXS1s>e-6AlPD^|Qe-JhUpdV8H*AR5YyO zy*_ftl$WA56Sb-2?JYB83=e0)uuDJ#Bbs6yoc-DY z0$B#5O+4CefCR;8?lH;D9*9&@c$WW|Q@|XQu2RqRricR(Hm|6*PQCP<&J6SoEMd|C^A+o{xnE&|IsiW|}( zgg{hU9?yX*wZ&X^T_~5eN1+Xmi4VA7eIAA#kCf>e5MJx-0Z)`0H8F3D>^5WaL-?c+ zInBNMeOycXW5ka&f9#EtONxtBJo~<(aV7O6DQ*ghe$x&1mu{MV3)cLKK&UB89Bu`9Svow;qf*eq+F6H0v}(on8je&RR?OXG}ifEf?^5m~(ghK{8iyi9O)-O$EO zbNo_-kW`E-k`#`ZEgsmS6Fq>jah|39}JI^Jk1)ag2l8dWf%KF!N;#QOPeSvsfB&K z+_L?KkNDjj1}EhNVqZdv&O(+fr?q`kr4n;w@R+k_X;y3`vZfnFwWa;c0*l>i(iaKk zbXISVSz8|ZdDIk&Pp)HIOk7QP^GEh|q9K0id%oUcMjx%RB~Na{ z;T{sNwyT>OW7h`w?VkD(`oK#RcrjAZFl;W z5@1$aP(c>A-oa7KrJp0k>w1ig=YbBfB47d8?vZBzsG0B%!ukW}!l)$D&>qBpzzULj z=3@D?Da2!3e<`~DDpT`wjHBDG>CKrv!!3f|5+<7=T6Z+l)mbQ6QmO&Yb=-Ply4d2L z>9+U9Nel>TkGrHw^8w+RC3-?`%J(u<6W|%K#rB}a+CIg;x*7Q77{DA6sVo_oj0;V7 zDcGr-mQe(SN3(6um_F4HxpYzXnKibSHYn_2$+#6rmVoiXMCY^0m9cT=?nXD`3oZU~ z{+@4K(_!B!p-pp;0u9O;z?{l1rI(6@H$zBGgVr0HN+&U!QBz9)6MON;-gd6^@s}n} z`qYawPsBdX23MvTw%XaBiHGof@Axhn-tZ!>rUB!Ki$>@v*1y*P07lx4TysQ7qBcM? zw-FE;+7m(dHGb%YZ-1I7k78~(uoF>rFzF*{893A2lg1R>5-sqZhgCpJ-vucil!$_I zs3t|;^`N#U@u#UMi0aWdmMz*DHA_-@#inzTMy0ad}TqEDsRNTU~(Aw#m2WuWUm}JGb3+Q1K2#HpR}O@)@aCTp(jWZ}1#D zGvx_+FQT3E0@CyP!6c^ap@!?CVA&5Kc4UId@jkot;drP3t;qXm0m(6u(*@r4Wnf4n zb=+S9&b)|)>*{6cPV&I5V$(j5yFW%?)ZT%;RHq^5TV$WsBvQGMa_uW0B{Wjmoddmt z-&2UOE|??+pjzhq(75j9GcFseu@z_tZKkU50|v;UX^xC`*wh7#{!w(hq55 zz4;6;gyQjtS?ZP@QcOL4ja}y}oP<%&QUr3dy6Tj$BvN2-_T@G4CKP^$ay!K6<1^@Q z0JxF5~%ogY7L1HQ>bpjFiFgQybY-Et4(UITy#bF4!X@*2DXwQT zZn!(flTeXuUodWI-QE7G!ts|K*W%Kb1HYHN9QXw=uO%K|nKnmBn*Yx_67Gd~2L+q2 zsRQ;*!JJo?*N~}_W65H7&jU!6C4EB|LnZK5C5Fy%8q6w~{kVIz;6kv1sAfiW=I19d zZ4__FTF;uC;(Xg_I_u-=_EAtO9SqJW2@1)+>sGI;Jw_@I(P5bWzhB8mGE?KavK$l~%xX4>LKEWT?NmocT#^Q2e@ z#Ro>(X6a$JP2DEcFK$gRnsX(iufo_LKj;9z(|7mz`_hU}C`+Lep$&T(uu!JpwM8fH z@!hlgA_Z;b%j$d?sh77XuoBzprs&wJc}^u4rkqEwL)9MU_uVD&t|)5}a^Z1T7>ijO z;IC~EVlR3_9KB=65^|vBYQG6+L$5jjOhT+uGa4Gv5F!K^&5O0Dw7qnH+;`uj^i#C+ zk-qtr;kxtAm>GM{fYFz&X&~M|kgx8040-t^II@>N4+LZC1`or{8_c8^YqqCSV%yEW zerznGM{+=zZ?o}ZHF6dP5$BHuv4_V?F}Leeq?IoYsQA{84}|lIv3v(wHR+IQ+LPi{ z=yr05+OSv597+e;9Bx-LVCLhPZz~Bnd3~yJ0?47fom}=z9Ilm|xaxbzwH`2GC^|*p zD|r^%1{tEyNw@U?i#3b-c)9xFJ7FG-caQ-Nxws~}!McaO@AP{{1)A?DmE2HUts~0u-k3gh+{3u3_%ZI$L_IjK@WFH-{(3jTUIMtz))5T zIUa4sqzuCivX!zGQZqC>q|K^hXuM!{Z%&y5ZB6*a0cgkVDDlpa5nXJ@HE6<0&9Z|U zogH)HIu@?u3NBACI%pL_*K7J8Ch*MkX1?%^pjG%_BKkUn|E6^Z#QF9N3Y?xc5)rXK9MNNKS;;qb(%Q9fAW^QwJEef34b~cNi8Yc4 zFu{?67`M?#JO}9de_a#~)^EUVx*ndTyp_Oyf;&+Tffu6qE~pU%R^p2We)^5q`x z)9^jBr&EG$do!XczwkX}8O4;^fXbh7WKkj2#Q3E#NxUVUO^o#^y7Q-Ly398e;rAdG z7_vISQTOU)zkO85Cm_drWZC#L2lxZp7dT)ybmP{*!>ON#(UX%-C@io-4kQ`&F@AziiMP9h@1#Yc-Y|t8XG+*+j1LHY4`<;bd1;)M#AmUc=2r3rBXFGZqhHN4W;04{C1S_^yyR^9Pv> z?nU;MH`u>f!EYa$r4Zj0Zr?MWCv7%b7{)`jm}%TXz!Z5g2uy`K@I%Rr35*$j?pLGUqw1Snm(?->H$2U4GhQ|E;D#Y7bq{dY<6*om~! zM8WcjP!D!hDyQUw5f#{#)`&-+PXe@ehq{^CF$Zpy>$V)p17?Qr(Ej|?JT%x;+oC5a zXFeg7Td7*CP(s^Ss^;@Iya%BvBf5l_ay<%%uc-*3;t}|_{Y0Y)<%RsjgYc$hJe9rx z%g0H`u_ke!7b3hmVM=lM?eN^(p-@dQuMma?inOmY$j+)(4f;qlkAcT+L~i|xACHgk zpIz{rTS}H%j(PNB-mkotGw8JIww}IR-P)B7-qxg57CEZ^!|1;ub(Tn)N!Fwy8T94; zfK&c+a|-8|&(Q8kD1t|FEC-G0;VhYi3k#v4hT0evwoq-db}y3kNUG8)gc#NFFef8( zE7}>!W+FK?t5xLbIt(5ZO66*WTu0|xJl-Hfv7$s?4vY|}?CH1a=tq{7gfTce?wy@& zFYNqV1J^4ew7jmfx6o)@gwp8Nw2le`(xPM%WnX+1j@7UmRymS2EfouPOVGs=vg;E8 zGb;2V=&8Qn^qLF%t0Y()KVHrb+KG9+Q%K861^_Y8U{R}={CkJ zwlXUDvbze9P%UxYuFysvZMfOh=a63C#~)J|l_`){_=P`^-rGL+PD%bbM$?rUu^U9kHdJz6LXXwcL$y!)r)PB%)la96d91wHhi zL<_jq(tho}JoVV+mfFXu?H&hIl+!+Ileq%O>C!g9%nof9D-#$gb8S8+SjCRQ(!%V3 zZpplxo!aumYb9L0%h@rO83AbTR9j6DES~0z=f5S2IhvB=?vS&E7}|Lntq>gozPubW z&^O)D=PjOTDe0$WdNeMSaA)%03MSlmDS>29;scPJjL8tFsq>THEE>=ye@Az{y{wh* zS)`zAI_;m_^r2v-=-hb?Yfa6`fZfhalLb$vkNbbUkn|Ju^eZLPrItr;z3vobsI8G; z@9Ttgj^N^wU|#`- zgY|&B)c1zJ!nfw!5xG+hX>a-xW$no&D%Vaq>hkF`n(+zp!aMMA;qY+r;ACewbw^<4 z!b_j>x=2g!!G<%sGj?2aC%MZ9v>Q2lo!*>WYAP$4@%LB#`Y<#PG@y+fOFzEn2-iN^ zf|pbF>e@QcWT1^AyrczZFaG=9fV2>hNdR+9Z^s{Jl*o)SWa8{)k828nVZ7j&9x1`F zLE!JuutoCXHj#bzbBPwg-Ayw$`yu7Y8S`cydUry*Pa1adpIJj48gP^dJwr0dz*B;F zt_n{VZzrR0lLJ4>E<2hExuT3sFR#^yNRtt!V91e4iF5tA?rY18TYEioh81xy+YX_T z-d2j}$2)-lCUM}wR-u2P9(_#YN|P+? z2hfofn@Fg-@P#?##^!#ObOGFD=-fjcWd&)Gm4B`aRNQaC3aoYA2&zWUgWIAz)PvTV zE6gj5UM-USHnO|$JEqk2D|(_!1a0Q+*ZjwN_{yJG(3BLD-{VZa8p;_GF(u8@n;~%& z@|;3v+J7j*T7CO-f-5#aF0!n?Zr$@A6|-YTdYbb{W==#jqxT81&Y=h)#un-s3t(j0 z9ZwH2_{!^?89?Ad&%s!#qVPVa$GUddxwLhdMzgkopX!WG%ye}%-0F2J_bBxb;e=d7 zZl+n+C2$zy7AO(z?_@79t(PJZ{ruW@&~s?HL|b)Fzg$_=-#cm%K648Os$C#Q?x7~( zq^8^XN5D_!iWwG51#JAZG&a#KdP8X$MjO?7%Ll9+45>ZBLRfgO19VcnLu{or(Jem% zvey@1xitI7#B6 zFTt`}H0F7(u(n?`8|=*&oQ@q}*akF|Kx5qP8|{DL;9_v=4@xF|;d21%*x0h|&`_%I z!)hA9PxaC<0dj`WDT`2y$oL0Hk;@ixWUTFG9 zlW2X6k)CnY0Kq;8v;%zPlgR6ttBofE+Gi6>iiVNp>&G6M?)~@i(#kSSP1UKd;>gcInE;I?EDjYThL#HEHWUvd_xc3oI~TDYn=FG3pBv&HUHq2)11k#o zA0ztk0_{FDcCju^yDxu%c`LQ%bUZFrf9rHSe*1q?Nm{Nbb@~boE!LE}@-&~9>&RWc z)y~$$MSW-{c`EjEs8;+swOz3r`M4D+j)F-WNVGU2Gw3Hir9!VHxu8FC8g+RraO08> z7!*YZboSh-7#`?4<)1$w+l*pqBHa7-T)Iv%MB)v+K@5(=_x|%)fbc(UkUb&@Jb@R8 z0kQurah3=DcUOWN#2PUy`Y$t3aqIF(F|8}afWojY2R!mX|41mX~LQ5X_Io-O_)><^6K7zLqyiLAn1++L6Hd?~mc< zcHL+O{criKf^y#;7i+(V-yV0+AwS!J&X(;e+LB2HUE8V7ywra`Q?;0shCZRJJ*nij z_`EC%Z3@a?H?Z2m4@%YPD5KiNcOy~xF&Zp;Q+Ur+dVqHYikoeyn)atkeT?*XJ<>(U z0Iz|(v{2^^dW2({tuK2S9=tx*J>>rdobC&~Fw^5X`??NSSj~4UedHr!#l*YIx3Pnp z$^$n8O&2H5)#q`j^wG~-Ciob-fQDQLDyB-c>0?`!QV(f=m6AueMMo_Gbs60uY(s2V zZ)2+&S3Kktky77@o_>?(=sE9n(_VF2qUY`%IgRiNb|q+n&es7NLRt@*rTy;+;!@BY zU9c13f24_=1cY@HIx;EqR2#y7ROk&OOTzYtLFGX`kx=NP(J92!Se4 z7A{{O9Eq8~gkAKa3Xpjl~XP`zSE0DsT(r&)I&)dqe*Q4^I}! zDZ4BK_a?q`_nN7LQ?UBzGiPp~?Zk4IM_D&l;zitTI!gb56cTLtN9j{+a$qC`X?z<5EqRv>2qJPnxGh^7EN1`+Ynd)WViU9jH)sB74E z=4lxFi)%P+xWQ!^>my}&XZH}g8*YQy3qZlc8F~gweQqqBHdSHPv)T8uI2` zMl<(g5mIHcvKKLbojaIcAe~sKqF|u&!Pt!$03KVoEk)ZRJ`qlkti~?Id$b2I+qFhc zd8c%m$Bi~iASlQC9$DLp59DxV{A~xkpi62F?_iMi+MGD`DX`<$_4v4WE^|S{svz@u zpLrjrS4#oU_bP8t`F6*t7c&uecZXqF;8T&*>1QSp(u zlh1_=gi5|fWWKObYrj&~S_=8)S{SyXs_ zWX8<4(M?LnP>#eHKnXyDNR}wxy~N*cRF-iWgQ1L?dfV^{l6IsN;*0yq7bEp063}zu zjP1(PZ|3V}BJnembf*%UKDoX!zgyI_wCLTsHdRM?k>9=N0_EKnu;v7H1_L|H9L2Df zc+hoy&QqC0ENLgraNt4Oa=I#Z#3iy%bXA5u?JzQW^U?Tb;HmP?g!S~+$ZX_^WV1Z> z%Nw1d^1EJd#^Spw427A?e$WaV;YqwX%os!>n<54sX$^b2ti>Ys6sZ!4Fg+!2e;DK? z4}))l=PvzX5Vk}HpUS!Ur7)EUwX=%rus?<0HyCf36_FjU>yX%KUc2q#E9lMVyfS*8 z2ibhJYqN_+)^Uo_(H-|0*HTc2h@tDvDn!Z{K;Qgqr0{@m4H_y8xk7+W^bw*TN{9Ch zL1YDY9ZrPf_jC|jclZ6Dju%C;GHE*q000@=|ICE{ucd{5uPE5q9k3#OUFiv&_N)dR zm^y)D>nDM>bYd}w=_as_p^DVaI+CoL7Pdw@>(Wm7UH>i+R!Gou4QScWf9Nk6O($T% zo}LsMjuemTQa;Q{P9IHiY$Cr;y0OkiQfTf9a#X3rg~l&G*E5S#x(g+Nd{4Wf@Sq}O zA=!b3%smM~@)%B_Xg}<&@jw%JcL7r=l$;He7=mJ$fX?}Q%^c@Jm*Tmcxudy5i@Wu?Z~q7 zMzGi%BU(sqpqK!y+VF5zzw20~!j+DNkyoO)0A7NS)`4oqK<8qjQekQEhf1fkw=#o# z#twAFMTO$#9g}Um!6$+`t2LB?F_~T(DU=YI5{63VRO-%{!RE?8v^w#tks~q)*P%^6 zetcrY!vv76d1!O9E7y|a#v{e-gJ-mo`GmO6^3LCCJ8dz>6i{<&p+FiWk%q8*99Gys zA+igl0wZp8@fh(VNISciCpXarF=+4iJL(K3*Syr;fF@bH7fbb&cy-(1I-x+L>@>~; zZl)RJrM^M*A={nij`k@<^ATI6wy^d@a{me3R%bLFvOZ zyo3^WUiMm1^hRqr*?nEZh7?Jg6X1Wiktn1F2o36JpAGj^K&-roael>IpHYn}UbDg+ z(D1F$PZKO#4!)dRpr(ar3T#f?dD*}ve4PBG6Kji7!e(v>CiLQRXVjUGwljihbY-T0SWT3W0MItb8 zOj?@TR5Hpgn{qbLU*=QCz#EN}xQlNkOj!nLqEDkb0JT(Mv&Bz)I<#mZ3AWSJLgv1Z zTS9pI^Lt686|(mL@-uaZ^OiAE<1?$t*RZ#p4U2!Z@?N9k7#Mr2B6JT;xpfhRL3+Kd zF;9A4@Y2n#*#qOJlIr^((rv~2ziep$Qd4GX-pI-pl^4h~s5-8p&4#$6ikDc;>S=p5vH`nzoorqsE>g#hI)E*@RIf)=T z59fCYX@Xi@8+B-}8PNpPpI-Y`lU2T@pxqTXvy~A5I<{%_V%8M@A=Wj8?3ZK9HGOWqLiXQ}4)wV7Puv#1y zU$SMei%gxET@fqu=E4C+(|IKJx5KR8;o?TP$SwN9vyOK(6ZM?$o3{>-UB42qSKeZH zPDfk;SORBKvY5XJe)B@R+>( z<62e^hd@9?5C-|zn>8bhFo+&EAwA#O3Lw(UWb4kMAYoG{)-%k@8L;K-`+b*~ZlQkr%pDR7o9l@N7w-D{8s4B`e$WMSj(*$- z_dpcP)_C`yLsxiAG~J2$LWt2>q!*A4_b0Q8`&&e5uHV?-lL+w_^`Id1NNCChqvE&m zT|j$un0Np}Kw+S85ClkkBz|Ilae#jdAe+21hV95;=GlM*GX*0lwKjJi_Z6aa`hb}9 zVHAi#1|DDaCu0{3`KUh#fiZ0h#;Vuw;K2!qD}NqQDYk5t3? zthT0Ul}qzL{#;NOuyXi1@mWP+9s~I!pe+E4~V*GyzBQrffd$K?MVt-ygD7Sz5JDNDSm^l3xSmghZP^ctn zsAXtqDgFn9a{~bhX+J$PAtggQHaVjtPA!VA@NYg$lcGHn1O1`opq(Z{FgzpJu<#Q6 z|JkQGpTB^h`6>Fn2L=Fu@*mSX+5ha%nEcoMRFX{820cRP^%rW8mqedK&CqW_a!8rZ zOb{}!RT>iVCw7H;5;aV^%y~RLiLX9e^^6c)DwtSZkDR$v91^7lfQ}^XEPwQ3We_Ka z+pfv8jI{B12%(UUB*8*kKFvGq15uEYFei6#!7qKk5byP!okxP8*XrLhol_m~7?XA( z)=tAixO!!B9cXq#Lurm7WB#tiTX5$>+rPSqLaOMmo+wrfqwd9Z2;nEq_bab8q2Tq9 zs3BElwa7_SjD;kJWI>~(%?WcA+S$PlMafqan^^WCOW&#EEM!dIAxITkQ+ z-)!j5O4Xa&5ilOB4NBr7ne7uhVURYYH9V}@vS*XVa#%!V#tzmvJ`)X1D$^<|6UBI- z@e_jP=Z$`WMjPA##-a=A(^gG?yj#2PKN+|Xi`awvKLS+T~N(1G?yx-JA%2s z;K&oGNG|r#S4S$wW$=Lb3#viEOOs{Iq)@X>hma$s?~m4!XLdc0WN&1?i7&|NC~^{rJ*t&3>pkmp*!K8*K?E zUc8{G9_C|e2~13G(>aeE>rPwQ&Tg(;+0ta)ZYSlj zdE{EMR9E{#hVlG>dA=dm?bA_|lH;9A%oDjL`zO@p34aMGCYqFM=S>o5L?@c4 z6VH{qCsmI)vsKSd>`Zz*T~!Vz%rj~$9-b}ZbwuwrC{k|Do~u0Ji}>J#BN*2hH2~)X zjb+p_i^m_JzHo(W)lk0(c-7p_tzD{-9&$u(vTClt_Th=&IwYft#-VS|I*seaY0=9+ zlF?sF##Qf5Cag6hdVR+wUsp1XV@SgB>{e7#Y7;_U9(g}UNOfeC9;J?7>NKd{@UE8c zYW389JKR)#ODn%qQdAmemwVPG5^AI@m(Cey(5*;2$p zm#rK_THwE0QX#FR(VJqOX!fojk1}Z({YsaeFBpwd?9wf&q}EYMtfFR1UEEVQs#GP1 zGEuQESt=2iQfW{9tJ0vM4E#9KDZ(go@@iP(sbD6zLZOTiOhqH6Ocey?E2*j?1$SD> z8MHfEly#ChWSu}ux3G4|n7buY^P8_hV)XZ$$)|0JWTl=C4brvOSr$r>Ip91m;PeYp z0Jh+*2$Z#kOu`anZ9=3cHgeMIK52Fujl&C6Z2(q?Ep{wU(n7??toY|UGl_yV{ejnu z@7vWQ)rFG6108vx$)jIhqnR?%xmG(EQu*`2&cej=>w}SI2styRKMehwW5!^fl$mE+ ze_6<$t=a9vag#W~hH=NJK*}QmQVY@UbZZ2CCnMeSTt{s1lkQLo&UWc_g^Vh zr~vM z%4@puY_FyvRLLJip19R_e#BGKDe5^jE6hY_F)vM;K^vzj%p9}ZC|IEw&foKmD z0J8E(?%Q7u%7C%lyN)6*h#a$a%v5puWhjN2&X2&!RbEkWQY9>2$`@|Prp6ua8_M~} zVnDtlqmmjmbAMXe6j=vN57<;qnP7pca-WoxEbctbO+{4klVyndJNk}lQN(sWFtkF3 zp^`t)wvaL|!5l23uk7}dMxM@=37hIg?M(*qZ{fxvTw@s~b%Nh^1f{Z*dY8gFlQwxg z#Tp4r8rYmMCujiMd6dOCvZ#xZM4cCxdsGH!>S(O7 zDn!PbizN%*6=^1zY{XN@H!>MrxckXPi3pey=b32YRSw4?XRwlf0Q7|W`}+)?0_Lo#?9eBCJv{VV6Gyj*j*O3JC=H`=wzAbt z^V#2cJSaB-vaX5!`uQZ}lB!I0GRi=yxV&ySB*8q9Q}jGc(cz)(;G-NJ|BY zlfo=G57Iut4>yTrDL^*aIYE>+jku{(?SE#i8&F{lgCH=VTzxs_H;~JZq|R9%8IR{O zKRV`o9?2{r*Wn$x@)f|vx{;z6y6LR##eH3EDFyNbMDL4;eI(Pk6{@_5uh>`!fBbYG zQcn4;ZSY4I^b>4K-k^!R)xM%;>SN;L;0Z^_yPyuP&P0=1n$(w11MWa7M7gnE^>1kK zZ!Q*B{H~GWwuzHQPwkT}=ZyC0*R|4Ecui>dl?P=qi(qf8giNL-iWxE>ig(p)M3a5n z(VUstmE!zSa5j8x+K9x%(Zc8cpeXJOUUx7t` zt~07jhn9^Q`@a>=9g3cb<<7Df1N0fG&Dt7usLX(8442f4`ZjfFt_my~)Qgz(=`Q!n zx-&UWC8C;siSPw3yQG&?mT3ni0Dpp~*sCTh_(B_rE+bSKN!(JV7tjV#1<3pG|@^9f!O(ScQyorfuCyLD)% zpekcbd#MP1(dhoWr^Re+7QwMuvdqPa1Y`U6aCXy9Niak<9_cACY^R{M8;6D&zk6m& zfQ+eyJ7#efkzffHHXGR?)*)21KRu&&#%JS8T%_kR{XO~7B(QP@L4{hRktF?!^HxvYCW zPB4d7v5Xm6p%vhrgBYGYVk{ZD&$pk+6hoFMJN3sP8Xw;Jxm~P8&t*7rehS0{bX#wz*MMz0=ANw7xSj$Ui|CX}b62&7o zXAUZ+208#xY0#xmgrzaUscEQUnSrIcdLdVtvR4hz(NqnTc4I9P>EPx8On@3bh<@}I z!vqbaPa$Iq*e13j4SrH<05ASR0WDjHD(^GLiYxpz{7RUa5QA!GN6340jC3zl?0tB& z0vD6)vUr%sxQfbPt2~xUlvXO0Md5j?cdFH^g?j5DA12g&_VGRS`}Oi@g3#rO2O@=7 zBW|^%IKC!Cs}JIlg4-as*qHvn`z+tDaLUqv7TD%np~q@!-wCbirgXXF5AhUPL8if0 zk>#Hn6^kQ{L#5IAsQOz5T#xGehF+4HhMxtq-xzf%1Z;mq`&$|smOPaNrsZ;5iL+FD zjT+SDc>**A;%U-(y?V3WnPy`}I5Uovo;#_U4F~`HRoKHnN<^N}>r0L~nX^*=C^TUO z?%YSCp{4|ku1?N&@h>g-spR*_APKrY&mv9tCHY2KSPn|;qN`#>Q>c3DJI5@YdaI|` z#lO)SSniJP*JreL%9`&A5t!GIY;L+gMlYdeW{cH)cdKD-6`@+nEm!S4h8YA2H@T=AL5!u?& zY}0#h=2)Haz+W%zwGAnc?Xa5mSHueMBQh%5j%=xCM@p7oWz7W~u0h~`r+^Y1i zjYo94!F1_+OY5&2v)kGl*vwILcN@%>s+-dfgF}pbFdx_@eBkOM1X-T^$*GKDGo1U?F z;ddE$4R}{d^Br|yvs}V(HD%6($Og$+9++F7N0tv)Y18kF|MbGH=cwUiy|^K7+@Com z_w|^UCLGmEZG>8|alR>=PUu>)Svs39Gz@hVi@9o1-9kXP38J8!noEYD!yh zVzf7p`#x1L688QbyjErV;;1b@Ozqvvh@fg_w~;g}JPmq~kty(S<%uhCS{w{!qpWGO z)l2Ubir2KNqcvyCCs4_>%M&9Bt)Yv?+N(Xx=MtkL>i{|UDinw0n_Wf$0dE5}_OZ=~ z0=6>=Aq;P*J`0~>q>LE;3-QL6E;4}~DMf3bFY3&Vu@8{8m-jn=NG%5&&q`bxGbQ!WC_LsD5?gF8I4?~8n~;K9CuTGAQcjTIjJIi5a1LWExK*jg z<_KG?zjs)W-i5um*C=>w*eI8LHcUD=Vh0CVb1KhVi`aP32!jprfsLyR>44ggb$GXB{Z7ki-$8ak`Pb={kzgEFWf z@XjRUXGVQ#SPZ^N5%)(SOF6-`5}0qJQlfBSEnXlt-SosKF80+`i;IMf3>ttx1@OjqQhW+K-ESbX5{>;V_ZS zM7%BZbFB+wVyoS1p!qUh!8&;?zj>{*K532!StLj!-W*QNjes&ga?=K4+_gdNDC%Q* z!kjgzu^W_}aebqk5j-l&j?aMP_hNRCaM+*vu~|5U3+}Acdn6_IEP0km@SQ~X&pSo1 zeATa_mn-E=ug+KccYCLMBS#}kI};dmq-QhB@kJA5HKZEDb%^*QG>&<+dX?&AYwFhk zF-jKxOdBevVs7x^xV)ocMKBXVH(U0B8;5eo$gn;cjS6?#8Z%#_EzX9;%2Me^^?? zr)g#smcUn}?g#D}C*!L#m6g5FQG z4%Z;Cj`3@bYU_GOu@IqO8Rcz?Fu;3~wE6b9_nCf8^9FmZpiKgDeNL-FKogP|=`c8O z=sye1wSL0P5A+Wzy-F!lT3Ma-RwtWhb76ZKbV_&04k(o|i}x zNT)0a!yQd8G9TnEt%Ds*+OJC#MZ9`uOaf6n%29)Pu$4fv;>~`vXJ$k^xy{%=CGpZU z)M1H>bt55+jZ8PtDfuC@QZ7eLF0 zuhfDtwnivmoxG{n^dcSrahoP!5AWPy#?FJxTe1l_qD75q2~+nPmI~=T!lL0IcU_3g zxI4$q&$-<*P5N63r?%hS$>CVFwPn?)NlgJ?5w~O)%{A?zIG97#7&PInk|$GfxDP^)*g6K5m?bq#K06Rq_r7>^}eur-Z9 z$3ca)R?{{;S%~T#=|6l_>^{#1IB0%d<(Rkw{Lb)~WK-l&G>u=OL9R6sqGMi{P=?)* z1?7P%*NWb!*%gA#eR4EHQAv@-N7onh*fvW`1OgPcF&NT+pea#aaMo0&tV-dLmUk(* zH(58EX?T&LYgf4+#ir7~8PSg6Ym(hC5*Qq+qZkuXwT^j8R!h;)pi<0y{$s4CN?A~% z&0=bqagexHUuR-D)e|MzCRJeHeQYR?QY0T#bxy{>dDp1OL!u~eqP&$iTI8i@Mld=Q zHQnb7$a-8;#r=neIrN+(7ct!M(Lnf;!-9#|LdM#t8=G0fi6*?$j^@~#wCs{l0Qf4d zD7Z%yU<5qwFUZ|iRkl2@B6FM z-#6{0t8V4O6yHsrb}Qn#3Oru)Yg+8oioG}M9opB_ig`_yYv)J5bB|;XjAeIIUauIx zUS~|%Hv5`8@viA(I+TY{ZYF^ak^Xs3&Rk&fjyxqiSW_!0ADQHCY{{bC4dk9c%~ex2 z#6XHZW{gijnuVn#<^<|`MtX&Yu?pBY=woPiKa}auR0w0!pUBOlrIzp|KVRntGJZl3 zYe)Yg2Y*jLK24=z5QH}|Uus%maWBeTQ5@gu_B;MbLHOvBng#+!L}daZa@dPWA}85UIP^GJEZ z{ZweD#0ifB&+ctXm*3rrhM>=;c>{yD)mxBRPQm;yuj;A6oJoAYZ3 zC%c02m-qB90xfo?VEYs_Z1Bh1Lzz}tV;si6%eQ`#trA?3jo3ngnRViXZ}atEv&>@) zg8X7wd9jrvEEt6}MMX#p=9_#6*$eO!XapRTC$KHBIiH!tea5|(|3f()#^>#Ni+m)B zN`pHFc%L6AYI8bm=p5i-RcElmS9$<}mD_m4_S1aqf@coN6&}A2*=8;F;vm~)^ZNXP zx-=S?=^brKc|P$?N%BzG!+YkuWNliB=ESSsy&3QI#J#ks`H~HpCn{{{D*H6Q6(ic| zF;Rn5rJ)G|w`Jr9$8aH60|<{;gHY0AhPjW*NOC9R&xvMmYKr~_`lVYD5xzqucSlF0 zjeYD$A&*o|L6eBgpV5?#YQF%Ykaw?+j2 z%uXD*kjxPQY8ihK!{NdKSha#@Bo+$C=IkBjC-L)-BrYdt-iAkQHt7%YE1710fKThb zGh}|5s2op6?N055pbZYE`8XM@U3CsLTv#0ch%;i0k6@|QE{vni({>d4S@W;tNCM(w z$x+bEyO5z@UKWY&oDrX!hm=+dz7!ML4uz-;szcUsq`SXvPU-oQcB(TbWzmmN$~=*9 zYQsxN@lwM2{4!GYUVSBm%wO9H=z-cUJ+I_JyXCCC?0wW%R~wZ4ys?-aB0%7Bx;mez z?@Um=WDXY@OFuF#*}61dlqXdQQZt$b$|m345*;h;uAhf9HTW;_?I_kw>^k zYZdq>_1XnBewDXC&FNo2GCObLP!zfg^rGR{vdmb$y!4h#0)t3GzsI_rlG|kPh~17c zSu%GBO@>YbQv?>0YAgoH{tI8$-sl?&QxdGWv3qzEAx|4b$~?}$f-~w>pTQ-qG~F#% zewE)^%zBE;%65WWaT~JA=N^{a5IT#UPJU04tH0F*2kGUKo+eB`FT{r)9v{O$2ln7- zFI8OTFLLkGtQ_*rxT(lg4fuH!9k=jA>`~Zf`_|`v;${_YsF3b;qA}dRpm$hYrH2Le zN&U`H=7~$24Hhw6O$nRUbZg1U_E6e0D@Yj1yYn9Dit{H2)J_C1qlpm*SF4}H-+IXr zMW$61d~m_+5j`y;%kgovY=p?|SUulnJbQ~!s8yK$hOspk_!G!PHe@F#z7u+v69!Wh zyon#(tS-GuGfh(Su#uOz`H-jWL`vS%l5Hw!i?l$lq^g&l?}-T%KHA|kc{D^b3Hjca zlE1U-okGmX-FHbk%iTRX*u~xnG~DPJ9J<%Xa&`xCl+x_742brV6GiG!s@sR4 zC5L?lGg*nDT&sI*_iz?dKlI^I*8290j-nB9DO?#gR1(4DmY@QAhHCG=Y@GXCfS?Q` zj7qplC;8>~{jgwl=@1H6$H+NqVyt7>2BInuTSPuWFdEUt$g*^HQ?j|6B1uhO5U93r z)RDqdyU%l%P{HMm6yh^P5Nqk$azK#HMowq`3?#^uX*ayTKElmx73Mpp5IP6IbtazWeNWGsci=kI{|n>76L zwG%BZZt1GJ|h{E*@;;dlhc7yRsenzcRCyS*} zV8RY*wu=WUB85#28lYPH{=}YQ-+Z#w{fdI0`;)6gRo!UrJ#^DL|8R_z z)*2SD(Vw)lV@o?-vym=v3-YM4E>}n1g2%`Oe5>k=K`%Jk;Yx(!2wR}SSkP*o=_P|K zS>|vQ&N0=G&HRFf=$dPnY%gQ;O$i^?;(R8NKyH`8V51V_!k46sGNnyc)To;0JmlPS zK;6cWtz|qoy)}GyE1T|y$=?ldtg%;xH`a9ZJ4ElNkr|}A8RzI?MdV{OOj(>a8mGht zr%TzVh8%EHeVtJa>aY}up%D&T?~K`=j|^BVIByQA0kmx*mhZTY_lN6mouC6V1HZX& zEXrvCGMAE_N?2%D1J(xbB&SbSjHn&Jqmsifa~F1grd5>9Kxt#BTdDpj*jZ&(7bpu* zwrFr*n^+uIw-EmjZV5l;TxC^4%S!G8`w4kZo%Q6X%ztgBAh=fU7BQ_I&3ppQj(2FAHx_SV+72(zz=Q4X zb2S)WSFrQ9uzo5k$%;&^2{!g!&6aCLTpel6=*O0jVHg?j1|lPtSPUCyPS$yUFaKwgdcAt*zFFa3fz?}g9o4{B1sc4ThYZG`%+H-h^9B2m90nC(uI7yx6c0jcx;$mtyODjR`x` z%Kmh67lj&ylEG-|55APvw{Zp=-Oy#=Tpv>gO0&B<4yqL9*!7b~KlLMKvF{*@cFU7ziME}}Z_wjd=4NX}^UpuGZ z`dGVV&GeNYZ{Re0o1L!LeCeL|8}*#{V!&@*YI@6AN@tn4x`(=MHy6UKpKxA@VKL1q z=X>2nqKwrC`#;=*;vU|XjOFTfUHpqglSkv@Lg}tA=$}&QmKL<;>rjIej*yi<95%I{ ziiaeRODA+MVVlt^hdM!|T>7}GJ3a&CJNk`x-he{BSLn06E+t>oMp_0t|Z`-fB>8wVrZy#(R(-z{%Nt@U( zQESwAbY?JF0#`a=PHDY)UeC~}_)~f>ZKj!dUs7ijZo^nkMFFPhmR4+|(bzX|g74OW zz7%HS@^m`}E6Kool{l_0&gfIeyIx^ zvnT=e_A$>r?^%pt*ebq*zCS#H0auJUPpSad{A0t)3l9oeI;0&p8>G@Q^m(V{iU+GB zO+mGs$TG&9Csksik&fs2(0XJQWVkh_HhoE{nz4M|tos^C)wTANu$bm@8`@`51>`7$ zYQ)Ew6TGF|1JPRPWGtJ2Ie}Ks4A6w2$bRaM+!GpVy}zJTAlmhU^;eZF8a!M%1xV5K z(wcO5zLSU|21@1Y2v_XTjA1I;(sBOt0C0>cSxuYfB1iggC-5`00qivT!IF+Q(yKgP z$o&DwV%#Cf&g)Cz9N@z&sI_et4*r-+eMN@Sacw)s^hM69OFhGhN&{B3a7^nHu`w6Gi%08&#F&x9O1;oIJqaAuja=x`Ozt6_HIM&A-(d5B8+F$wPM_>j*Vah#I^90oS_CX$<9&>ia?MvwhcQ(ozI z)7%T_&}>+o;o3TguOPbwgw@i_lQz!=yGF3$`VLB{E2P#xbjk(FIwvAlgh0AF3gV7l z(dXM|?V3wq?5fda#aHGs^E(4d zae@s}`ftG#T$iEr{mS-D17G2SP`IPTlhrm8koBT5Qg|$8zrT_%I5sC(CRzR}`K6He zheih?3*HSG_`xksl6u2+1=^1`9VhsnjfB8aD2_e1U(?Y(oQ-qKoVf6pQ?__IS_s|9 zsD$z~l8RWE9p3wE1o{n&wTe*3(#;lJ5yY7oXVXfPMx^t-XMooFeYHxPb-eC+-+h4u zM6y+;G)AfsJY7SsWRHVLo~ahYr^3_%XEScb1U3l$rQzpnY)J|z;+454;r2ec~;sJxuc$kG`N9}Iz-fRK=gt%bkAZi3w z?7|A{kY&R?@Fk*!qqo$1&#oqTp}QhL6V1Rw#I9Vs3wt6WSG1KU(&^0~=4~D>8Jcx?GPESK`(ZU?M2;g56j%)e{J$!7dyH)qSuUJoy5EE5|wx^XTDnr z2>o;w;L>+YI(cW!&wO>Gr_*?FPdRI;b3$3>Yp*ksYR6Wa2J*o|TqZ@i6&Ue*l$8nx%vhm%D*BBIW^dMA z!N}>YMp^LA8uTHYhrN2#(WI6RFf~^`9gOTImqHB7l5V7;LJ7Dyjp4EoN&7cYenIq3 zATE6*9%z5X!5!G_qMnFmKrjohv=_{Atc6HSNx8`-h1Ueht@Eo8HzuCXke;I-k^_Tj zwSOrTm3k0o!QWWZ8hUuE;-1JKfwRE7;*q{N$|NrMCT)ZCK4}J0u%v)DBr_{y!F~*A zI12L$=x_^*fWji%2Vp!)Q^{Af0kUYDQcrFKJP-Uxi0|;$2qOZ!u}W#>C=w`Q1de_$ zD?vq53$d!!g}24y(+y>z?h*BY*rF3 z7%9Qnm}3o18BM|41>=iP_xw$Kq(^9$f{!+?Zp>I$DtR;mO(L*FELpvCdIicP)gfU_ zZ$;GZSn-f-7J+B{aKP1HUuug%G=Cct0ecm5S8Zkp2&^!5-|ijV2SKt>D>svvjqGG$ z>Tn7|Hi{DOoS1o5McbdY#DolS!Sdjr8N_lSbm9~)hljbORH&-{0U|(}4;0=~YgWHT zZDf$nL4rSFR%B=IP1UAfMC`cX6GiNJ-+7!$dMLiI7Nu!4+~rvmeMq4;F^)re8WSDg zkX42$ZBmWYQrc__1wwo^1dsn$h_C%c*5|E{NX4lQNuWQ6h&!GQ4%KS~FXUvwKBHWB zu)#ns1MQfzMqh4YchFBb2k7Jgp2%;5(YYsP;s*jPAVKSlMUxp2o zrYBlJ>`+uostuiYI2$^+_=b0i#ui+8g-i4K{?~c!ZF3lq6Zbv{MI9+jKPr6TY(}6Y z#NtT)20YOh0$s--N>1tz}m{ADD z`ybz(Ar8fp5c9zI`o% z*Uo}aeChoT1ffX%td7~w$U`?_D7pX&xp3{2MCb8h0jx@uh=t*>s4->+#w+|Ol&1yv z;zg*32v`_fopr@`)Hwx5;@lxxNSUMW!3e7a3BNkG57{sYpZtzOkEm)Z)vYR77&@^d zfMUYrS^;I$T&~tX=R4LLYS>KEXOsn_$x4q&e_BSlYqa0zsx~;rsGWRWyV&Qt5_(-5 znPSvVvugwov)%8i=AvZOZkZx&(tfrbssD|8pd2RLHS*%t|Hfd_m*M@V(^eAzgWe;X zcPTPu-`n`VCTxapQXRJOm~YN~zc03b9R1@#$%N?}aiZ65S&fcKKlZPkO#9*718n>P z=C=@x>ej_FWpQwlU&00~Cbj*PzHqO)5H}(TO(aWjFC)rB3BR77R0&7c4-92KnBXM% z06k2YFYAw!;p6U>$@Ne955kUw{@cnh@ zH^%5kxjV*pXCKF=$&WKXPDLh+lu*{>Ao>qklXoWlVe{N<(_8 zd$bLI(EMx1(p^re@^-)9UfAu^b9xEsktO{wUt6dkO7(ECP?0Php87pc9wvrLG*zr9 zT)>N}XfAC~XsB9RR0t!H1m7o*nLJvp7+j$K)g=CshoMQ*D}j;V`9Xl#C;v4by^^o- z=#_kr=L44zB~Ik%uG~I{90L=Xp&x2|7$Yu|0ea`Fy;IYCpgl- zj{foRHJ)!oX^39Q*LYN^{XUitJt$JLL9qmW=$YfLML$)X|Jv?>SFaR5G?Z(FzIM$H{LS1 z(_voUFWy8aOa7sYg}_w}kn{PnQ{^3K$m=#tAK0nSX#=42RM_w)(ZB~iLP z_Qpx(@_P=HRXqB5tzC6oKX@ulh#U5a22Of#lF|90MAt-b_4gzu_h|`bfXRN}mKxX; zqib?c-D2O?N@!0VOs3HlO@IkJ%tim!cbr~*$LZB~oPOiJ<21nJD^9;LnA~M}|LL@S z1H|C=$c9^n$^44b|C+EFzDaf14r0DJzvA>?NB?;EiqmhziQd(BoN|x-YX@_E*fl-lc~H3G^L5EG8*du@ z3Sn4P8d$Eu0Y1_Z7kaHCgt5lX`F1 z^8SYt9O++2|9JSC@!yEj5WAYM8Lvt6uN|v-8NMss`!U?ErlE8l5}jIB7Yh9q@-u+$ zZ5?1(z7z{z!WvMPluvN61dmuZ3j`<`41-t~6Yv!Uq1vZxzvD2&lRxy@G)yxrvPPiI zH{uM+)i;(%oIysp4)mgMc!JO1c%>4e`Q=z9{H5%VR%%yW~1at;ZU4jC?&d%ud0I&AyUc6h@rJcv-oRxzrKDhk7SlmUnCAZ zK>YN}AWhCKXPf$=_)8>Euq9RdJO$T67R=TDSB68o`<5Ofh}+i^fwkv!qmr%zC-hnY zQeKAv;|O$N#H-EWJ*XLcUzXekf#Yh>Yw4bpiz3>Fu>|xEakE=YFpo1YfAIVQ`Ar^- z#s50d@1RN$tkA8NpR87S(hK3wX};S#JfMc_<8HW2|Hfrv#KC7Smfn0kY~=97GFZJy zV$O^q;oE(Cyd>HSnp9cIrGUig^BvRj^6GCY)?SR1poRaV{?OWC!qW;00Pvdx0N{U0 zTmSoaed$~4SQxo|C)%i4*{rc5d}qZs;~S$#GwQw?67;2!2?PKhkJZWu5ircI91tbY ziIFmde?0z;n{P{K!9z0q9h93~ynEdeGSntAELlcccbXLIK$c8hKB;^HyqIw1LAT}rlOKfUjH~4Uyr0O|x5W_c=D@tjp$d(- zUbK~5h34ww_Pkw>bDn1LB=1|3bWQ%b&eF%FQO`Zt_3ogs+=2G7?Omo8*o~q47m06X;O0k#SBq zx4}}kvie3i3?o@S6TBs7mrF0*x^9qod`3`dX{{C zn&VajF|BdX488F(`|3rGgn2OM*~wes-1QKjyGd*GF?g_?dz8jX5gs=VXv5y!Wzws- z`KFPKm|LN{${&@up^X{B@spjw48;Xx>N%ONiL8@W=>%3OpB1O`VZ9181=NV4`#!tO zkGhJFj!{h!ti+8yc>Q+LhZMu)Rlw6>TwA_Ob|$!q+OUR=~GwukwDc4m?3M*FIW{igx!KjHm9FlRoH6 zR#lGifWQw*P&vsL@z-tW1{86n!??j%{LgYIGE9+Ah!Qa{>zkl>*_f>vnFd<{K5FtP zCmkvlMH+)?^<(hV7Gq)EcRe`>oru~g3>g$ zw%D?Y9QBliRPpKvhdJqSRe9t%1Tx^{QV;t<2jG#w4LuDn5Fh**d`ZGl$AiYAsB zY^BVFHhkZ%>+DJ*Y+12j{is@0D(9xtO7RwWL929paG^NTmHk=mm%F5@m*NHc{b>&5 z&7Q{Z-+aL;)o-<`@;+CKD&&Nsu^t;{nqeDe01-@YAxrGh?9TFyaCUJ!LU$WOUTCrd zUi7AqYmUI+30QfSPDlILXp`=Kc-P+q8az+&%IsUduN{&JWNWbz`Hr?q~88 zlK828Z&UH&<<3j=`d;behmUA6i6 z;>Bj3snr!C{~Bxg==Kie z9oMCFBHTS0&h0eUB)9kX29){+;0hA81(u~^WJNpZQL$NOL`1Qfyt=ISCz%JTb@w!W zgY(?Bp1n#$Q}Rafz?hOxcKy^Ltk79#Vgs zKa$Ac+dop6TSD5G_SQ`8rxvsm`0_{oZ-TLXHO0K<*BvtI>+?SafBwDX>+3lfeO>SW zlQk?VK|?1-Gdw>=FFFA{)ACGN!Z84q+5-A4L<-eYGEyLvN}41cHc$c;HbCL26Dv+f zSGkwoudj$nO$SN<@W(Jn2wJq3or9Q#jfIzu`wMXKP z@;Wo0ULil_iAYzX638Y3V1XBhY}vEYpW_b3k|;=1ul8+f~1wiB#ev{11TN?WL*3RJirCN@Qr1%VoPHeiJ`} zwSx#iRGge{q7GDmGpX0s;zhggz)&SuO3<;z&8|j&&T%UySQF|<{2g!7Wh}ICBNhMf zDP@iUcW8|8x79kr{cmtFv3TWTTy#m7d;d-+@sl6OWp7TC|&s(EZzp*q&&%M>qDM zzLckX?lY0bARBC=ta?$G9TVXRM8LNTT?Gal0Y_lg7((sJLYX2KCGU|L9R6( zCm@2ZkD5|t!H~O=4s;|uXjmvQeE+xcQoX1eYhyGX_01s@%SVg-wJXNL=*~c^zL7wR z7pX+O4o1DDURa*4YgnF&?gqA;aTAtRm|gv8ngQFxgMA!&LuOgMToXHF9VKDz zFYBkXKzai4hQn6vHO6gJcI5cGv;zy#&Tz#toHvfOt$7D+WhA_rL=MfnuQc`&FpAb+ zHj9J|?)C}d51kB6it(yCmfsE*bv+gUgJHQ~N#^uk29N=hs!G|2;Vi+g9lx2yGwcKEIiuj)DZ#0lgudt!KFx zp_gnFFH72wmmHy%s}5#1P*T51ik{ub*TqDvt3}xl91k4!+sf6%1|sfAQc5w*zAAMo z2K}=-ZcmoQx%4wDDG&CC<0U~v98vU4r5%jQi4e{!4%UdDfJ0tDrt%*m7GoK+OqX$K zNvX{F0Sr{Ksm}!r%Oy@v4m+tMkfnM1Xh$3+#CjyXt!v0&+N$XG-|5~3uMiz7u=Kp- zu|N8KV8?Wg9Tc@VkvT3{`ZR*?H_K$i+y>qj>CX^yw3o;FOUKfkHPBE=<8M5%+JXF% z+Qst~_uZ%U*zPjoOMVQQM;J3M+G3wG>PpvXz1}RxgS{>(Yqs zcVqUfgwQ27{V1~QN)_7yA_V>j_Mg!wi#wv$qg4~gsqxJj!GaaCuGQmd8(0=uc^*b^Ae5D_i4@6_SU3dI|i&k|t@>!6w~7td7eZ+&_`XD=?dwjQ@! zQg$sha_7oqxMh`EY_M8I7%4tFiv+Z<7vJT{k_neW$MOnWxnXTZo-isGG#`wj5uRVo zWlY)bZTm3i&KiiJR&j3v(D<|Puw|qCA={|`bsEV&GuT_IjUuibUbmnhR1Rb?fG;jEV=5S^PR`$`7S>55wq0n?@$Hm3` zGG@P9mMJGDko59{yq_6U_<*i^7oU9N4iXOXv+SWkTB$m6c+H=B2N_2{b0r}U;!?u{ zgfq=q9epuf&@&(T<|c~|e<1+dQTy91HA9P>7%f3+x=VpBXFZt+}#;8fr`tY&K1<7m1G}IU(Y|`#6uY# z1PAZ$6?k?0>2So2wn8n_soWb)<*mf`(NaJ}GF zU-W9~dj>aD9StVCO)0i_fKA}RGXC)G1zxE0IoZG+287%S%%8qy!Bcs;+cti@4m>J& zk&phxHvT)r5AWn#`l(Wn%x)GBZ0NokE9P3oOMlhhm?EhV=0`KW@ApjNtKu+<0SFHbcU1g)^zHy^i^k zQe0!d`I1sRu6lYYm}PFr??33&NbpZP)=^o#aYt0>)IT@T8mHb zKX$HzekDx$WzU{|i5Z`fG7zt{mNZ`VTeC8}R=?=kxjS>D9;-Sl-@nVGOdO443hYb^ z4jwq!Udf5m0f#e0q%;2KH6`l2l-dtIZOwK!>#o6!h@|1`O(O>6RBT)4)=IQZrpoa- zYRiuMZgjO8IqM%CEC8z4@$}@kPMN~ZofM-+>vCa^TBGJ%>Gq_SO%Au$l%5vHot60_ zXX1*;aLXtKZ%Mm>U+-D_!br@$U=;Sr>Z6qfpTy6 z{h`&(sKXEbJOX(q+fg93N0q-|o`U8V9p^U;ub(^4$5crUu-URxNMx!*%D*Y@+gdtz zKHiK70uk+IP1oFGiYwA6Bvb^Ih@e3>8z>FZ9Z?TsJd}w0kvXMW%b1O9_>2QkhgroA z7{qpDFfih5=ztKWHzY}IS*ISRIB6t)rpFZPt_m~Wxs?Ql0!*N3OICI+gX%bdOx~dW&&TSbHb+B0tcgZ3u1^AS7IZy@# z&}%+_$MZ+NO{~XVD9>kqjZhc4SS=CaLZCULzAznEXGl-Cvzstc5!g6Q#o~;alVuK8 zzPe1W3N>rvwEKJX#|!-vw@ zhXzhWc9cej*EiCao18NFA8Dl?kXHC~TG))S>aj!CA2}Ciev3UYdMrQOV*b8X=B0zn z&Ps;2rwywi6D)~Ru)wTBBeTngo5O2vhI~Z)cX&wBv_LVe??x3UEru9X%ot4g2 zC8DlT%tN{(of(8y;ziEP*7XWU1&{Vyq06xn)&0~c?~!JAl36MRQcG|PTFr=~$v1sS zTS~J?jU}I`!ky9u)rhn&PgVN{+~@@D=jThJx)lXL3_=}J z$Qbyg7175Cc`}qfPA+W_i9b8(;?!sZV6{mJ7S12R--nqde8TN$-G4l5=nrPgc+3Gt z9XA1fabDxoPQ?)li~)mau1TVZa_kB40LzbKZ^sd;E(h;Htxb43sAUn`_TG%n-miVv zv(x@+HH6PF&@_qwVO38P#9C7IH$%sFh|qp~pZuwGzl=BRr`fP}goRvhs3gUfRuEp( zf#vp}{U4%al1c%?OyO0`3MkL)YOpI~9AbT7M`5|t_S3&nNL>J;5u5~Gc~6CUb!N@C zC-vmal0Z!1Y)B0F-RHgbQa|-^O{tsWrkud=M<=`Wu-~ifmaCNzsRziXEzi#};nsk! ztOKuNl<_)IK|Ng`k|?%7U-+S7?LLIZ_?+2+7 zP-TL!Y7e=!=DV>zfs~mPKwEKlHO+AW-AE{dB?7v6+zf^98SH+cR!qNg72>lYpg_)2 z-MT5EIY27tdV^(lK)T9j+5hCt@2~$E)_y~$%(C^!e$#e75vXC%Hq=zJQl3*IRaN%a zF#z?%`MnK3{9@Z44s|$XPf+3-SC~5NC#ir6^onP+bdV}QCHGxR;@}Z;ex-}dQkqdz zDvDwJfPI)A6;Ni*mK@gMp|vBE7)mK=EYC#FW~0q4m81ox;U)rwp0}+`6T(m;d=Twl z$A{@dk++jPVDzpcap28YbMaD$dH4JBAq5V~dBd>6Z-AR8xPQp-XL6D~{~qft&MxWxDBYp+9sV?Sx@ z3FN|Yfc#R^rvzRdAbuC+u0q6Z5>YfN*L9GS7Svz-$qADCT}U66BmFbXGY3>JOr`9X z2+Q(znn~;l8SgPbSFM`pS6Yr(Bpn4y#4q?3lI|dn)L|zq>N%GDW`LkFBDMp7Et9}i zZNXnpKtw?$hWHZNKE?4V$%_Wtr>ak!Xq}PaL8Rp;nfrOwntOqJ`bDxJHsSNrE2HZ7 zCRF}Z@*aT2N)r|}VS|GzHkwz?vT}Y-=dN{$4M<(X5&YSZBJTXk4nZ7jm zf`Hrh&)yO&x~}_}4!WFpdszc?+QtR69Dm@AcPJ z2!dToSvGUK*EQ{40_GFp8R1w$Jt7DG7Ej7(0%QLE(#$cZL&O{FA7Z?&k@TcN#{Z}J zW%(h`{W|p9Xt5{y{O7u*8)GB99TR2+!+R7qPRZa!NlifE2D|$$ z?kktluC}XYO#xnHdM@)RZW>{CI)IJe2I6{50C_AnN&>zRiioOJ~iA1SA0(zJdP#mE&ZsJi8g%kV;<@mPA z5m7v=*(SN_HK~?RJ5kqU#@gy{_ljBhx!&eHEUqUfz411BNd)(0f^ymI{YX+6>;AfO z4PUjZsKQ7Ee<|Ur8!=n9IpEg#bSW?d-oidu9okm#l9yLx`fyG(rKF@h4r|!D0Ni%j zN4!Bc`wUIvopr4=$?IVzi+(ezK_9pPfcd zso#6ToiGh=|?`A+yN_%282_wf|h)f~~NNxAs`!&rQHyvrIWer<8 zPb%*{VKi9uyA6cPhZz~muDTw$BkX7lC6*t+&+MF~m_P%Pk=sl)V;x|US2)`^1V7A zKDz3OVqjz8FjuqbY<}(@)*}6$Cq`9bcroTWO|0s`t{9eRz1uJ{;E(_(`~aq$=X~Rp zZ5^=}F9Fi+eFP-4T8}Y|&{Yf!;A6ltu*518D<IU?)OtI)K831J?Vj09a$=;g&cEJj>lWsao0?r5|3 z8pzjCeDCPCDp+aZSfQV*n=zdbKVV>8k9nx)rzazAJ_TL~{)g|?uIF9~Qt~3wpP>&pcsJ5Vy^PO#&N|b2~CH~5FF>-!oT+PVs zbFuLeL@rT7I4EJRqLk+HH+bDe1>fOcRYH=$U+RuG(*n?VNXoF#Y=hixgxX~|TaT)c zMQKnca24Mi!}uM$Fhn@fxAbG?C3z-2Et0I<%aOxU=Vo)-be|FMHb zBZFdkb3?uCwsv=m<6{2n^>s%3Xym(rqEmr(m&aR`3di)2+%?GE-?77vVly8!0ZgPQ zT%epd>@#|U#RWjS$F&0tF7yrTkcJ|>iFa7Hp{%yc%`P8%tVn>Fvy&gKuLZmhnQjpu zG5|ZCr1}?KdK+DKJ3G=g#8HqGs4JJ5J*w^286>}ughvDuQQtZ_`u%deC=a&g(O#!N zu(s8!0hsc5-$Y>w=OWzI+_6DOF8|IvGZ=6f(=-u{F&LPUPB0kEbQuiVkE`BY<`~j= zvK`HqNWkih8-1x1vIQq@Y+Qj6jcmwF^q3ly&acmfU{5b~)!+RUYdq<2CR#UObe0?> zBKs(bXBfouo7q*7;03}e8gSa8z`A9^wo3<3F7j?mjvnQBa*E<2^yIt+>%j~sM^dF{ zQ=m@FrMrXG4&8z=`tC19nP%kT0$Mke+JQ@T-az?vE>DqSfBLUh+`LCqE2fP4dF2?c zoVF1+D)>d3&|bTqL*!H?Lt*Ok1Vab)!><@#Q-`z0FyN1+2>go_CW1bxWv&pPhG`6c z&jF7|w(?=xJ-ikfupd9j%#bsVS&@>t=qI~@uOTYKUk0QA-Z!%m>{dI|SQq|s6l@}B zE?GlvEsz;_K4^D$GR?G>bG^01y3xn_dmsLvO=H*rtbFsY4dYxW008o@*W$){4vt?N zpY;FVqnoXfwT_vgj)9G}wUL3Nj+4FR*K^#2@}|w|4+QTi9lIS!vSg{%%-G-a(aJwp zS4;C`lu#ob04)ZM8x=-BUNSNQ-*Ph+L(CBU_v}4gHZv~knDUyo;J9)Y2^zVqa5OK| zr^81mM&HIF)rOpj7P%BZT*?#@8=Zw&WcVx!V!3o1t)33N)_$P5SqF0UQybR^K5Ju5 zjVL!K)Wsd)3_kTU7&=Bi8`U(o6qjqc1n@c3UmSUAaJy_AP43h7@9nF!3lrA0)#yFo$v3Rk*A zI;1-Uqy%XRX{5VT1qDSKq&p-ezQg+-qW9r{ShJ3c#s1BnIWu#{J$q(<#W)7P_-u*; zqvzL3d5X|YOtzL#kIu}%yBA04(}@S?pDBSa{ec(>(fw6F-Xo;i&QF>t@RfMTY?7Ur zJDhUI)PA(say7KX2w}}EeU=^`ZtBykPfwmnDVe7oO6U2^4AekgQ={nw(tlmmwk(xD z-TYxe*0`UpdV49OsmjAoM*;8KT*ZS&{YPoBo-UH_&I|ao5a1{{BHgSVR>Px*?@KYV z?ZqY2;HfBsBTyog**JvjliIQ7ozSA%LgOV2F%q`a1~=^SE;w_ZavGv&YJ;t0KibpW zTJhF?AvJMP#m%kHCu&sb`i|?)+wXT!?Y*`gy6jiFD7jSldXQ5;Dp=5X;nOsVCS<~Z z!6y4zGL7~w`8a_`Cgb}m1{%S3Sg;0~%2xdidVR3ACHP#x1=6kLZ0bzNAWv5YHhAAy zbTKET19m@%UQ-T(;YZ(*(gx$*#TCfwgtb|p0J^y3N;kcP@q;0&?6lpI2Q)t;8$^0b{?*0_IXS>xw^ zIXwrnj~8(n&APRCSaPyN{twDRr`c{lnIk#Nkb*D0Qcv8SOF6O+ZXI>J<2R^nv`w+E z+UF?zEPn3a=VNguJ~JIP(zfuOH~wd0^C^#7Dnd_I^G0=0UVW89eW0DXOm4(ant?aB zYs(N-P8V^@(8*%s22U3uSg5^Xk=p*D zuA{}EIBSO1UU_1p8y*lbwjAg;+JR=CAS$m*YBbEu?CKb-;P&dCf|eyk(n&di9FCF% za^95U&n2p9a_JGi+qx?WB;aw)4%L3KJV}8V!n%n!l%G_)N1u?LA^d4+`R+c$mJSS4 zIv5a$_@?0s+zo1ZdGV}gq#{Zi2UftLLnu`tK_(*OGX6vjE^@2VH<7(|UhMsS9;Q(1 z6GNV90imguk68jQP-*zmsZrBnYlzm1c2Y+aKp#eYXhO;!=k{zupwix3;FMfcp0A&2%%5j8P z*;)cc{d21-R55pC2U&Y$S$YTLHG2kFd)S#(xBCYA<+xFNgYyXP&=MFSF)`j*_)bV~ z4+B*ir`{{0%UX&3r!)sgBTF-gwIlGJ{!+ay|~qlfuQpgpJ@dKYWj1PNbgr9P7n>u7YFaEhg2 zmV4HT8nv4vH~@2aH(#vE%cy+2ld3!)r=N#fo+!EJPO)Pojbay>Suk=yS1xi;ZrR#- z%&P#4hCLTkpS7P;Pu0C_`l4Jl>8xoPW1Z<<1#I>@VVbzBqv_h_-es$cc~K))E3lMC z?uq_=SF(Ypkk)3(mG^A*k=}<>w$dYetG!4X%h5R(7f;77t4Jv~ zK0rcU#p=^u{1f+<@cm|k=By>*CjN_+-F8ghG`{|Ki}PX~eIAV^cseY&JV#*TLy2-28aMGiz$p3pj=X^|sd+*q2_O5F1tEz8Bv@ob1qbi?9L< z$^E&9?!&9=u@`$c^ZvATa8>g5w8A@o5q~Q1el(NkhiBUMzI*FPM|ep!a(`T~aOX3R zcCQ)YmuR1xUvRw~J@qea?wyfPz#8k#VJW$$i7vZ=TaWRbv^^?H?!isI0&^ zB_Flv>BE9zb%MQm0mT}$bu#9=)S=@~`u)kxOK#!F58>sJk~xL6->aKo9EPbG7_HU8 zjPrgdaHsV+aML7%lAMY5$s}uZa5Q0d^ty99b?kS$^Ol?+di|&neWtv&p<;I7HnemF z{b&b-82UBcSoW$~yJT_h{CC^^{%IE;2eXs#l1}N%$Hb=LZjkC0Ll%N1_iv4&sc9pf2v`i8l^C1CAksrU<+Gb(X5`KM#@X9IdPL?~@wjzK)^c?%0$ z#_>yL+3}*$WaQB$`2!^9G8kWndLoKy(%eObcAX?P~?HqWeGwT>iThi z_hdg#gfoIQGp|H>8bM@FPh={!Y4Y2rX?sa3?PuHa<>-T70s%)uiA23ukCu&4kMyOA zZ_{ZuEtDpe!xeNLI(r@MQj9bbVi~7t?`#TjJ6RQAADE)kOO$T#MvU_m>cD%J4rYfZ zkJh!^(qC?~aEmCmXW?kqWf-1?sg)VFFo?ZSMefDb8P;kNtoAxh~gFdccXGeTwSKGOO18tN=}Eq+qIT{oWj(kc&iQ<8>?rN1ku* zC?Wz$Y7o>_9@aNbiVn376F9HYZu7&=Sn3{-ns1mRE-rHLo)a&JMZUY;Ln$JwXW3&E;SKwlhh9nmK>13wf=t!dul;BSfa{$Uj8yuv^G z#Yw8pZ@JWm7dLIzO;}N6Je_2=+={JyhdiT2`RoF*SuuI)?YghyJvrT^Q7se z9$mFx!qbB15_*DqjIHf1(SR{F4l6(Bp1BEX z+i)yDba}${#Q(8h1loq}7u;FB;$EH-5q5@$A+~;BYp7}~#=;4rBbRza#FYzFm-n`L zigXsb$0@!PA^C57jjA(BXf+O*fy2PZeaImJ)3Fj_^*r-V*9J(aQjde<}D{}4C9!Yvqz{0782JtnwMAIR8(^1ZAvt;8qcLzc^846j!n6)yc zS_Lfgob2)tW3a;vjMTK`l|3sE<18LDhv#4;57fz$p3>XQGNuf;Ne_ zUrZzhfoRTPSqx3v@5$&I>iK5G4Pi2_6Lw^Z2c@)|um1p>GFnLV zc{VPhh?*fymfvy|*ht>0n^9pOr6OstY$S2^JAco&OeFLS5f)+Iwu>SHur!|qA zKYBp$_;iHhKJNQjXHHd`jJvMk6ym9C3g}!QP1j`6GhQ>(+{lmGh_A$n12^{`p`3zqHV`mueq1y>Vk9SDTEVb?C{XdC$% z!48*_FLO)#zhU6urLPNW8xuS8sv!Qlc<~*9otDCaq;VySb}@$p|7(h{9Q}(A&KG*O z{H;2w)VpPvw-R9u29|lZLYX_o%mjC&t<_Pb^ioE^8!8OGs>bMcBT& zPcbaO0S^cIsh76w>sz>Ox2^cOX*=lXV_HTU{AN53)AJaHjil#^IM&!Iij*dX>}Ldfqqk?52?a{CZm9T^$t1zaq?VwgxjScOZ}W#r z<;Run<3og*F;In?tmYwoLgwy@=NMYAiN)sAjz^WFPS{?bBO2_a3%KlkppG#3zV|#D z1=I}8%X5y$>#u233GqtWD!oQp4^0KJSG@6O`;C0wC;PlX?_AD|)Ikm33HPNZ!$RlX ziMDeQ&p6736`RFcX_K9i%7Vgo@h>iL7OU& z=>AjpEW$g6b?qhm`9s-U;{GLv)#o1MWjjNA1CMG0-^x^Sd3c_28K0}oMF`JA2JU(; zv1j|Bz8nu+4D|B5z!5h!p>4#*^rACIQ#4%K*-f`;wp4F1a{5e>nJy@8{ zl#jaiV1V}?gI7w3Axi$Uxo?*GZxIW|Bqk@{xRmk+yvYeat*FrSae@^yucoR>P&kMC zbFH;>SV<3T_JXFM*0#?ePaJHFEFd=q-%wU$9#S4sV*M3<14&sC1tE-)mVm|%FAjfq z7Zta5ICyj`_Hk-z`pcKe;pRB894k)|UeYFHXA&V|`zFCbt$pc@K47;2?sMgsAP^;> z%D>hNRt`2!&UjDvu>@ib3lr!^2j=t&vkdAgF>o#PVM~`hAsnA$wN6$BeW30pbL*GuT+?2^`UWKIU=!9s*cDszhyRO^pgm%?E&(oJ>Ls%7GN*g z`?%*-`AvDWgH0E=Bu`o-d_1JCNw*vpyJ*$*uE%Hc8oHu4akqyA0x$_24Ig^xdxPN* zwaO@B!p;5iLtK>2p6>Ou&pBhH+ad+lHPpR#N1TsDq3mE_vMd;-zvXqsXr--6~Fqn$3PaQ1u1~4Ss#Dt#vX%KbX3iqki1iJrz1v;)`(8-zy{zRGFJVdt5VQ^=LZe(O6j~QQ?Ab zOTi@9n5#7?{1k(P$DpqIbAP|uB>ny(rF(tw(l~hHNLx7WG+r}Ps$*tqQ?#GMr+wNT zl)Kd+2-3t>Z}VmN96NO9ndsmi*(0~fe6M?PZalP{ZOJ$S_l1t`w^)*W%ZSQqhyrfg z{ej8#uCvZE*)Pp#$Qc{L}*!JwP?)HD_9=! ze|oi0IL!)c7n|jJU0=ycYU!uzowXX;VFc=y^^}D2cTjFML)jR}WcV ztC1nn-mWT@FitWQ3d?{t#Wx*=Nt&cu3|u0U@r9o|6;;!UebBx|{)Pc1`X0_V*x3z8NMKIs$4 zRKtTk`)v40qp^3%6c0J<@nKpMBcb%(3ExlE^j+6hI0Vp(Z7RviZ&7v@^UD`6vA3D%`912ji4KC(8u%BM)KzkiB#vT8g+@lndAk~vFd5e{=Gx}EzBxP& z3l?RVqO*3^FUevmp>~aGEt@~95a8cOL_rY#&eP%U*3-RF&xC4R9$!#(H~rm?oLo)p zR_%(A`Sv&$Ge%ONQB%RYw|?JlMF;U7h1CkXNO}y=rA-ibt+hEMGOR|w{*c6KTg^}y z7c(R=UhcBQ+i0C8$p;FUnf^q4B<=x{q8lHAad#^&p)FN|7{3k1Q=FG5MJuZ1n3x`V z*E`PD^bGqfw+qu-aNCdw*>offX@$XbHa30QpjAwbvkSo~1b(ejZpKiI139A{LxaSr`x16%psU zR~l*pOWad2Q(+e-tT7X9D%|k>$nD^s$o6bxYE`bqyFjcxh6E6J0aQ}ykA!bj#ozNXlIBlNu01h!3yr1je&afoO}^rNxBxa`vE$$d zV|(u~<7GN~J1?Bg&Dy`l{qX~fzF<{=yRcSdrcg(ble~6WcH`xuvZ9B>p@+WKu`7a) z_Zgy!Jj^XTSUg~@11x($R5A+l?=6+6K%i`M5QrN1%~i_wz5LhT*F%bu8ln=S8lup= z6rAy19Y9hW$bcQ~SIYK{1WNfkPg6!xQUMy)o$n&c2_OW4%=`-lDCdb| zHL$fYvj*0YjxLVS+-Udst&m$FkPsX+H~oKdEzOJ|mx0;X6=cOFmDDAnxim!*MbBVB zpa%f=GN9a5%J#LT`=#&i$0(rz;+$Cwz;Qwl@YhfPB4Bgv-wFc&E3lchfdOEgg$5WF zE3bF}(Y|8zK>q~&y4JwzcYu+Nl`Z(vd<-oQTeq(H7%)0F071hDuY`eTwl6W?wE|#U zTc9ZbgEtVS?gog@qc)#>pm~>pz;>5r@~f2Xn+L=VzN*C&u#ts{y^WK#@eK$V`z)$` zKrRz#O^hpf;F;~~XLpSNtl&4uuCLm(2>``M!~g$oz?FEmZNN_e9-xc;P5lKn zq`CM5P%mzvUVrLRnfDvO#Ry`1+2ssO!Pdr>H=`EjJU1Evj2STe{_J|q`8S|$(k9^{ zYZMF69y~zC{?#s*@2sTc8ewT;Vgj+hq34kF?ti$PtAODG^^#CZuf?s*jDadV1KUIX z*9$+g-F_edaFl^e0_3X%%qKUqjBIXfV8@&b)|)vCH*-wf%q~xjLBDD8Nc^9wfD#Ts zrnyoEcxL-*mEBmk%hP8L_7Gz;dtmGT24J5FfxIFBumUpGAHda{fxuvMaD*6}+Bn>V z(+fL;xw)RsFV%5Ml24M5e6{lfRcbr_6LZr z;##3A5a1#KI8R)Dv;N!kX1=}B%P1g_B_jxGV*Ypo$=Jr|CW!3qguYBP;PV1B(x0>1 zX48Mw`Rm-lx6iT!#sPssfRFs;G03Zw?c3e|U(Da8jj4V8Q5s;w5%&bTbL#_Ep{uXN zKau4Po;q0@{q1W59h3fAo7zn%&P{D{`R7;f8qnrf%J$Vf{7wAd5VFuC0y>23m3X#q z&~MVe1(bybKnH=n1|S?=7Y}@0euadECP2seye2?^mc436;6wZG{xq~a^tBJy@(C<3 zzvO@U^ZbwA4t*oSHK~*J2GaHY2+%4)pR>IN)!e-S^zW%#XbSY%*lUU$_YIVPPs&15 zpwFgUQ?LYYp!_^T=}?ZC literal 0 HcmV?d00001 diff --git a/DouYinSparkFlow/vendor/webdeps/h11-0.16.0-py3-none-any.whl b/DouYinSparkFlow/vendor/webdeps/h11-0.16.0-py3-none-any.whl new file mode 100644 index 0000000000000000000000000000000000000000..f12b3ce76d7e422f27eb873b155506de68239ef3 GIT binary patch literal 37515 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