diff --git a/.dockerignore b/.dockerignore index f665fad68f15b17e795c77bf2c27aa30261097ba..e53ed27b6111f781d1839e42d638d2bcf46e1d16 100644 --- a/.dockerignore +++ b/.dockerignore @@ -1,28 +1,28 @@ -auths/ -data/ -storage/ -*.tmp -.git/ -.github/ -.gitignore -docs/ -scripts/__pycache__/ -# 根目录已提交/未提交的二进制产物不进构建上下文(与 .gitignore 对齐) -/login -/credit -/wb2api -/wb2api-launcher -/wb2api-sync -/signin_bin -/wb2api.exe -/wb2api-launcher.exe -/wb2api-sync.exe -/login.exe -/credit.exe -# 真实配置不进镜像;镜像内模板是 config.default.json -config.json -PLAN.md -SPEC.md -LOOP.md -README.md -README.upstream.md +auths/ +data/ +storage/ +*.tmp +.git/ +.github/ +.gitignore +docs/ +scripts/__pycache__/ +# 根目录已提交/未提交的二进制产物不进构建上下文(与 .gitignore 对齐) +/login +/credit +/wb2api +/wb2api-launcher +/wb2api-sync +/signin_bin +/wb2api.exe +/wb2api-launcher.exe +/wb2api-sync.exe +/login.exe +/credit.exe +# 真实配置不进镜像;镜像内模板是 config.default.json +config.json +PLAN.md +SPEC.md +LOOP.md +README.md +README.upstream.md diff --git a/.gitattributes b/.gitattributes new file mode 100644 index 0000000000000000000000000000000000000000..9a54a2782978b3e8d8b6fd7a30d5ff3f53f6b6ce --- /dev/null +++ b/.gitattributes @@ -0,0 +1,12 @@ +# Go 源码与脚本一律 LF。 +# +# 起因:internal/panel 的前端测试用 node 跑 app.js 里的真实函数,靠 +# src.indexOf('\n}\n') 定位代码块边界。Windows 上 core.autocrlf=true 会把检出 +# 写成 CRLF,这些匹配全部落空,本地必红而 Linux CI 常绿 +# (TestAppJSEventsView / TestAppJSStoreRemarksReportsFailure)。 +# 属性一旦写死,检出与规范化就与各人的 autocrlf 设置无关。 +*.js text eol=lf + +# 本文件自身也钉成 LF:否则 core.autocrlf=true 的机器下次检出会把它写成 CRLF, +# 提交时反复刷出 "LF will be replaced by CRLF" 警告(规则本身不受影响,只是噪音)。 +.gitattributes text eol=lf diff --git a/.github/workflows/go-binaries.yml b/.github/workflows/go-binaries.yml deleted file mode 100644 index 8b0e543fea8cb60c116bc84e0b252d40689a6bd5..0000000000000000000000000000000000000000 --- a/.github/workflows/go-binaries.yml +++ /dev/null @@ -1,156 +0,0 @@ -name: go-binaries - -# 可运行二进制构建/发布: -# - PR / push main → 测试 + 五平台编译验证(产物仅存 artifact,不发布) -# - push v* tag → 同上 + 打包上传到 GitHub Release(zip/tar.gz + checksums) -# 固化的发布纪律(曾两次人祸,见仓库 HANDOFF):-s -w 剥离、二进制版本串 == 源码 -# appVersion、tag 版本 == 源码版本(-ci 后缀的测试 tag 豁免,用于演练发布线)。 -on: - push: - branches: [main] - tags: ["v*"] - pull_request: - paths: - - "go.mod" - - "go.sum" - - "cmd/**" - - "internal/**" - - "config.example.json" - - ".github/workflows/go-binaries.yml" - workflow_dispatch: - -concurrency: - group: ${{ github.workflow }}-${{ github.ref }} - cancel-in-progress: ${{ github.event_name == 'pull_request' }} - -permissions: - contents: read - -jobs: - test: - runs-on: ubuntu-latest - steps: - - uses: actions/checkout@v4 - - uses: actions/setup-go@v5 - with: - go-version-file: go.mod - # ubuntu runner 自带 node → panel 包的 JS 运行时冒烟测试(TestAppJSTopLevelSmoke)会真实执行 - - run: go test ./... - - build: - needs: test - runs-on: ubuntu-latest - strategy: - fail-fast: false - matrix: - include: - - { goos: windows, goarch: amd64, ext: .zip } - - { goos: linux, goarch: amd64, ext: .tar.gz } - - { goos: linux, goarch: arm64, ext: .tar.gz } - - { goos: darwin, goarch: amd64, ext: .tar.gz } - - { goos: darwin, goarch: arm64, ext: .tar.gz } - steps: - - uses: actions/checkout@v4 - - uses: actions/setup-go@v5 - with: - go-version-file: go.mod - - - name: 取源码版本号 - id: ver - run: echo "v=$(grep -oP 'appVersion = "\K[^"]+' cmd/server/main.go)" >> "$GITHUB_OUTPUT" - - - name: 构建(剥离符号,对齐本地发布口径) - env: - GOOS: ${{ matrix.goos }} - GOARCH: ${{ matrix.goarch }} - CGO_ENABLED: 0 - run: go build -ldflags "-s -w" -o "wb2api${{ matrix.goos == 'windows' && '.exe' || '' }}" ./cmd/server - - # 启动器单独构建:它是**独立程序**,作用是把新版的 wb2api 二进制换进去就能升级, - # 启动器本身不用动。所以刻意不参与上面的版本串断言(它有自己独立的版本号)。 - - name: 构建启动器(独立,不参与网关版本串断言) - env: - GOOS: ${{ matrix.goos }} - GOARCH: ${{ matrix.goarch }} - CGO_ENABLED: 0 - run: | - LEXT="${{ matrix.goos == 'windows' && '.exe' || '' }}" - go build -ldflags "-s -w" -o "wb2api-launcher${LEXT}" ./cmd/launcher - ls -la "wb2api-launcher${LEXT}" - - # 版本串断言:二进制必须含源码 appVersion(防交叉编译矩阵里编错树/漏 ldflags) - - name: 断言二进制版本串 - run: | - BIN="wb2api${{ matrix.goos == 'windows' && '.exe' || '' }}" - if ! grep -qa "${{ steps.ver.outputs.v }}" "$BIN"; then - echo "::error::binary missing version string ${{ steps.ver.outputs.v }}" - exit 1 - fi - echo "version assert OK: ${{ steps.ver.outputs.v }}" - - - name: 打包(windows=zip 三件套,其余=tar.gz) - run: | - V="${{ steps.ver.outputs.v }}" - V="${V%-panel}" # 文件名不带 -panel 后缀(wb2api-panel-v1.2.3-... 既有惯例) - case "${{ matrix.goos }}" in - windows) - NAME="wb2api-panel-v${V}-windows-amd64.zip" - zip -q "$NAME" wb2api.exe wb2api-launcher.exe config.example.json README.md - ;; - *) - NAME="wb2api-panel-v${V}-${{ matrix.goos }}-${{ matrix.goarch }}.tar.gz" - tar czf "$NAME" wb2api wb2api-launcher config.example.json README.md - ;; - esac - echo "name=$NAME" >> "$GITHUB_ENV" - - - uses: actions/upload-artifact@v4 - with: - name: ${{ env.name }} - path: ${{ env.name }} - retention-days: 7 - - # 仅 tag 触发:校验 tag == 源码版本(-ci 演练 tag 豁免)→ 汇总资产 → 建 Release - publish: - needs: build - if: startsWith(github.ref, 'refs/tags/v') - runs-on: ubuntu-latest - permissions: - contents: write - steps: - - uses: actions/checkout@v4 - with: - fetch-depth: 0 # 取历史 tag 算 compare 链接 - - name: tag 与源码版本一致性断言 - run: | - SRC=$(grep -oP 'appVersion = "\K[^"]+' cmd/server/main.go) - SRC="${SRC%-panel}" # appVersion 带 -panel 后缀,比对前剥掉 - TAG="${GITHUB_REF_NAME#v}" - if [[ "$GITHUB_REF_NAME" != *-ci ]]; then - if [[ "$TAG" != "$SRC" ]]; then - echo "::error::tag $GITHUB_REF_NAME 与源码 appVersion=$SRC 不一致(先提交版本号再打 tag)" - exit 1 - fi - else - echo "演练 tag(-ci 后缀)跳过一致性断言:tag=$TAG src=$SRC" - fi - - uses: actions/download-artifact@v4 - with: - path: dist - merge-multiple: true - - name: checksums - run: cd dist && sha256sum *.zip *.tar.gz > checksums.txt && ls -la - - name: 上一版 tag(compare 链接用) - id: prev - run: | - PREV=$(git describe --tags --abbrev=0 "${GITHUB_REF_NAME}^" 2>/dev/null || true) - echo "prev=${PREV}" >> "$GITHUB_OUTPUT" - - uses: softprops/action-gh-release@v2 - with: - name: ${{ github.ref_name }}-panel - prerelease: ${{ contains(github.ref_name, '-') }} - body: | - CI 自动构建发布(五平台二进制 + checksums)。 - - 完整变更:https://github.com/${{ github.repository }}/compare/${{ steps.prev.outputs.prev }}...${{ github.ref_name }} - files: dist/* diff --git a/.github/workflows/space-keepalive.yml b/.github/workflows/space-keepalive.yml deleted file mode 100644 index b943ef19eda4ba14817726870b3fc028c4b1e34d..0000000000000000000000000000000000000000 --- a/.github/workflows/space-keepalive.yml +++ /dev/null @@ -1,78 +0,0 @@ -name: hf-space-keepalive - -# 作用:定时给 Hugging Face Space 打一次 /healthz,阻止它因「48 小时无 HTTP 流量」被暂停。 -# 为什么需要它:Space 一被暂停,它里面的定时任务(签到 / 活跃 / 保活)就全部停摆, -# 而唤醒要等 30~60 秒冷启动。 -# -# 为什么用 GitHub Actions 而不是 Cloudflare Cron: -# Cloudflare 免费版**每个账号只有 5 个 cron 触发器**。如果那 5 个已经被别的 Worker 占了, -# 再给本 Worker 加 cron 会直接报 `code: 10072`(本仓库实测踩过)。GH Actions 没有这个限制。 -# -# 为什么 6 小时一次就够:HF 的判定阈值是 **48 小时**,所以哪怕 GitHub 的定时任务 -# 延迟几十分钟(高峰期常见)也毫无影响。刻意避开整点(:17)以减少排队。 -# -# ⚠️⚠️ 必须打 Space 的**直连域名**(*.hf.space),**不要**改成公网入口 -# cli.3216gemini.dpdns.org —— 实测那个入口的 `/healthz` 是 **Cloudflare 自己 -# 应答的 `ok`**(响应带 cf-ray,但既没有网关的 `x-service`,也没有 HF 的 -# `link: …/spaces/a3216/gcli2api` 头),请求根本没到 Space。拿它做保活 -# 等于白 ping:返回 200 看着很健康,Space 却照样被暂停。 -# (该入口只在 `/healthz` 上做了短路,`/status`、`/panel/*` 等仍是透传到 Space 的。) -# -# ⚠️ 两个 GitHub 侧的限制,知道一下就好: -# 1. 定时工作流只在**默认分支**上生效(所以这个文件要合进 main)。 -# 2. 仓库连续 60 天没有任何提交/活动,GitHub 会自动停用定时工作流并给你发邮件; -# 到时在 Actions 页面点一下 "Enable workflow" 即可(或随便提交一次)。 - -on: - schedule: - - cron: "17 */6 * * *" - workflow_dispatch: # 也支持手动跑一次(Actions 页面 → Run workflow) - -permissions: {} - -concurrency: - group: hf-space-keepalive - cancel-in-progress: false - -jobs: - ping: - runs-on: ubuntu-latest - timeout-minutes: 10 - steps: - - name: 唤醒 / 保活 HF Space - run: | - set -uo pipefail - - # 直连 Space 的域名(*.hf.space)。**不要**改成 cli.3216gemini.dpdns.org: - # 那个入口的 /healthz 由 Cloudflare 自己回 "ok",请求到不了 Space, - # 拿它保活是无效的(详见文件头注释)。 - # 想顺带把公网入口也探一遍,可以加进来 —— 但它只证明边缘在,不证明 Space 醒着。 - URLS=( - "https://a3216-gcli2api.hf.space/healthz" - ) - - fail=0 - for url in "${URLS[@]}"; do - echo "::group::$url" - ok=0 - # 冷启动可能要 30~60s,给足超时并重试三次。 - for attempt in 1 2 3; do - code=$(curl -s -o /dev/null -w '%{http_code}' -m 90 "$url" || echo "000") - echo "第 ${attempt} 次: HTTP ${code}" - # 关键判据:只要拿到了**任何** HTTP 状态码,就说明 Space 是醒着的。 - # 503 是网关「当前没有可用账号可服务」的业务语义,对保活而言完全正常。 - # 只有 000(连不上/超时)才算这次没打到。 - if [ "$code" != "000" ]; then - ok=1 - break - fi - sleep 20 - done - echo "::endgroup::" - if [ "$ok" -ne 1 ]; then - echo "::error::$url 三次都拿不到响应(Space 可能真的挂了,或正在长时间冷启动)" - fail=1 - fi - done - - exit "$fail" diff --git a/.gitignore b/.gitignore index 2e19b0bcbd2dcac7a07a5700c469a0c702a9a2a8..2d656f120f171ac534a03638e3c3d68c9c27f3c6 100644 --- a/.gitignore +++ b/.gitignore @@ -1,58 +1,65 @@ -# Auth & secrets -auths/ -data/ -*.key -*.pem -*.env -.env -.env.* -# wrangler 本地变量(Cloudflare Worker 的 api_key 等,绝不进版本库) -.dev.vars -.dev.vars.* -# ……但模板必须能进版本库(里面只有占位符,没有真密钥) -!.dev.vars.example -.wrangler/ - -# Binaries (anchored to repo root only — bare "login"/"credit" would also ignore cmd/login/, cmd/credit/) -/login -/credit -/wb2api -/wb2api-launcher -/wb2api-sync -/signin_bin - -# Config with secrets (use config.example.json) -config.json - -# Build artifacts -*.tmp -__pycache__/ - -# Backups (contains auth tokens) -backups/ - -# IDE -.idea/ -.vscode/ -LOOP.md -PLAN.md -SPEC.md -docs/ - -# 设计/计划文档(但 README.md 与 go:embed 的内置提示词必须进版本库) -*.md -!README.md -!internal/prompt/defaultprompt.md - -# Windows binaries -/wb2api.exe -/wb2api-launcher.exe -/wb2api-sync.exe -/login.exe -/credit.exe - -# 本地验证工具(判据逆向过程脚本,结论沉淀于 data/desktop-task-protocol.md) -/cmd/desktopverify*/ -*.zip -server.exe -.DS_Store +# Auth & secrets +auths/ +data/ +*.key +*.pem +*.env +.env +.env.* +# wrangler 本地变量(Cloudflare Worker 的 api_key 等,绝不进版本库) +.dev.vars +.dev.vars.* +# ……但模板必须能进版本库(里面只有占位符,没有真密钥) +!.dev.vars.example +.wrangler/ + +# Binaries (anchored to repo root only — bare "login"/"credit" would also ignore cmd/login/, cmd/credit/) +/login +/credit +/wb2api +/wb2api-launcher +/wb2api-sync +/signin_bin + +# Config with secrets (use config.example.json) +config.json +API_KEY.txt + +# Build artifacts +*.tmp +__pycache__/ + +# Backups (contains auth tokens) +backups/ + +# IDE +.idea/ +.vscode/ +LOOP.md +PLAN.md +SPEC.md +docs/ + +# 设计/计划文档(但 README.md 与 go:embed 的内置提示词必须进版本库) +*.md +!README.md +!AGENTS.md +!internal/prompt/defaultprompt.md + +# Windows binaries +/wb2api.exe +/wb2api-launcher.exe +/wb2api-sync.exe +/login.exe +/credit.exe + +# 本地验证工具(判据逆向过程脚本,结论沉淀于 data/desktop-task-protocol.md) +/cmd/desktopverify*/ +# 抓包取证脚本与原始报文(issue #51 等);结论写进 issue,不进仓库 +/capture/ +*.zip +server.exe + +# 编译产物(16MB 误提交过一次,20261021) +/server +/app.toml diff --git a/AGENTS.md b/AGENTS.md new file mode 100644 index 0000000000000000000000000000000000000000..b972521af3023084c327ba709fb1dc99adc9850a --- /dev/null +++ b/AGENTS.md @@ -0,0 +1,21 @@ +# 版本发布 + +不跟上游 `1.x`。发版是打时间标签并推送,工作流看到 `v*` 才创建 Release。 + +版本号是上海时间,形如 `v2026.9.26.711`: + +- `2026.9.26` 是日期,月和日不补零 +- `711` 是 7:11,时不补零、分两位、不带秒 +- 标签、Release、二进制用同一个号;二进制里不带 `v`,面板会自己加 +- 不要打 `v1.x` 标签,也不要手改 `appVersion` + +```bash +# 注意:本机(Windows / git-bash)没有 tzdata,`TZ=Asia/Shanghai date` 会**静默回落 UTC**, +# 打出来的标签整整早 8 小时。用显式加 8 小时,兼容有无 tzdata 两种环境: +VERSION=$(TZ=Asia/Shanghai date +%Y.%-m.%-d.%-H%M) +[ "$(TZ=UTC date +%H)" = "$(TZ=Asia/Shanghai date +%H)" ] && VERSION=$(date -u -d '+8 hours' +%Y.%-m.%-d.%-H%M) +git tag "v$VERSION" +git push origin "v$VERSION" +``` + +本地构建不注入,面板显示 `dev`。同一分钟再发才会撞号。 diff --git a/AutoBot.yml b/AutoBot.yml new file mode 100644 index 0000000000000000000000000000000000000000..110a11d0b05092237db8faab8b44c72a4c9e6cf3 --- /dev/null +++ b/AutoBot.yml @@ -0,0 +1,164 @@ +# AutoBot.yml —— 参考仓库清单与策略声明。 +# 谁来读它见 .github/workflows/autobot.yml;改行为只改这里,不用改代码。 + +version: 2 + +upstream: + # 逐个 clone 下来交给 agent 分析的对象。 + repos: + # 官方客户端行为的对照实现最全的一个:product.json 取值、每类请求的头/体形状、 + # 备用入口与 HTTPDNS、业务码处置都有抓包依据,docs/official-client.md 是现成清单 + - yreidev/workbuddy2api-panel + # 大仓(3.6k star),2026-11 恢复活跃推送后重新纳入:按行为吸收过的部分(11140 + # 连坐、入站请求体上限)不重复提案,看的是它这之后新增的东西。 + - ardeyouxipianyi/workbuddy2api-hub + - yuechuya/WorkBuddy2API-Gateway + - HUIdada1/AgentHub + - 3155498108/workbuddy-one + - OHCJ099/BuddyHub + - hj01857655/WorkBuddy2api + - JackAIStudio/dsh-workbuddy-dual + - smart-open/TraeWorkAssistant + - deltrivx/AutoBuddy + - techysy/CreditDaddy + - spdw666/multi-agent-checkin-dsh + - 1557335006/workbuddy-checkin-tool + - Yhx888/dsh-free-egg-credits + - Costben/workbuddy2api + - zr987459/workbuddy-app + - bhh3349/workbuddy2api-prime + - dhdbvcg/dsh-workbuddy-console + - chengzhi-c/pi-desktop-wtq-pool + - chengzhi-c/dsh-wtq-pool + - liberation8/hermes-workbuddy-provider + - Misaka10091/workbuddy2api-panel + - xibai6668/Android-AI-gateway + - pandarick916/workbuddy_checkin + - 2861292267/DSH-Official-WorkBuddy-Credit-Proxy + - ithtelab/workbuddy-manager + - caigee-cmd/cli2api + - FireOpalus/dsh-workbuddy2api + - NextAgentX/qoder-trae-workbuddy-switch + - sofs2005/w2a + - dingminhua/dsh-connect-workbuddy + - newtypepan12-svg/workbuddy-qiandao + - pkqzzt/workbuddy2api-panel-plus + - rcwowhoo/workbuddy-checkin + - lehuaner/SSHMonitor + - Faide-cyber/dsh-workbuddy + - wefewe/workbuddy2api + - ChaYeWuu/dsh-hyperworkbuddy + - wicm84266964/Buddy2api + - HXX-ita/workbuddy-checkin + - thintsing/agent-checkin + - stevenwang288/WorkBuddy-Daily + - study-yang/workbuddy2codex + - gray0128/pi-workbuddy-connect + - autumnsentiment/workbuddy-helper + - GeekFong/traework-checkin-assistant + - jerry9692/dsh-workbuddy2api-panel + - babygoton/WorkDaddy + - xbmaxx/cli2openai + - csszyft/wb2api + - PBY-CMYK/workbuddy-daily + - interli3/workbuddy-cloud-worker + - lxpkwwz/ql_scripts + - luoxh8/workbuddy-connect + - maiphucgiang/codebuddy2api + - a1007479270/aidaka + - fancylear/dsh-workbuddy-credits + - Libra1337/Reso2api + - jin66god/workbuddy2api-panel + - HanawaBanana/workbuddy2api + - CangShui/workbuddy-gateway + - Practice019/multi2api + - zhangdailin/API-Console + - aimod-cc/agent2api + - orangeboyChen/codebuddy2api + - Zhengyuuuui/workbuddy2api + - cty1735/wb-proxy + - mmqz/cpa-multi-plugins + - changexbc/workbuddy-switch + - 88lin/workbuddy-auto-signin + - baiyea/workbuddy2api-ui + - L0NE-6/WorkBuddy-Daily + - hawklithm/workbuddy2api + # 读本机桌面端登录态 + 设备风控头 X-Device-Token 的注入形态;敏感词二分查找工具可复用 + - DistPub/workbuddy2api + # —— 多平台合集:Trae / Qoder / MiniMax / 豆包 的 IDE 账号池与签到池,看跨平台账号模型的抽象 + - xu20060420fan-cell/workbuddy2api-panel + # 三协议 + 反检测头族 + 出站代理 + Prometheus 指标;mobile.css 与 /v1/search/messages 也回移自这里 + - jiangwanying/wb2api-panel-plus + # 成长中心补登 / 连登兑换 / 盲盒的**实测接口契约**(方法分工、tier 字段、client_token、need_address) + - Ashfmit/workbuddy-scheduled-tasks + # Claude Code 指纹改写的实测对照表(哪几种写法被拦、哪种放行),含 [1m] 上下文后缀判定 + - 9Ashwin/flow-one + # 管理密钥与网关 Key 分离 / HttpOnly 会话 Cookie / 登录限速,安全边界写得最清楚 + - zhuweiyou/codearts2api + # ESP32 看板:接口只读内存快照(采集 2s、请求路径不查库),面板侧高频读取可借鉴 + - kevinzgai/wd-hub + # 同类 DSH 插件:面板只读接口契约(/v1/balance-summary、/usage、/usage/analytics) + - HimA6652/dsh-workbuddy2api-hub + # 本地桥 + 指纹策略三档(defang / neutral / pass)+ 模型权限预检(11158 不写入目录) + - yang9582/workbuddy-connect + # 三协议本地桥 + 网页控制台(启停 / 诊断 / 体检 / 对话测试),诊断面做得最全 + - Ianzhyh/workbuddy-to-dsh + # 少见的 /v2/embeddings 落地(bge-m3 1024 维,11351 未知模型),实验开关默认关 + - EchoPing07/Buddy-2API-Go + # 九渠道合一:渠道内额度冷却与请求失败冷却分开记账,冷却期得分当 0 且路由硬剔除 + - bluechonk/modelmux + # 组内加权轮询 + 虚拟模型组(客户端只点名组名,组内按权重分摊)+ 多 API Key + - RapidAI/RapidProxy + # 桌面端单 exe 形态:登录态管理 / 保活 / 猫猫旅行 / 本地网关的打包对照 + - wbhubai/wb-desktop + # 35 项任务覆盖:对话类任务走免费模型省积分、新任务三路兜底(专家链 / 对话 / 通用激活) + - HonorC05/workbuddy-auto-checkin + # 多账号签到桌面端(Tauri):积分趋势与账号切换的交互参考 + - onlyveyou/wb-checkin + # 四协议接入(Claude Code / Codex / pi)+ 313 条网关测试,测试面可对照 + - 2439810550/buddy-deck + + # 每片 4 个仓串行:串行是硬要求(免费档 10 RPM 共享一个池), + # 放大每片只为少付 setup 开销(每片一次 pip install ≈2 分钟) + shard_size: 4 + # 每轮最多真正落地几条(每条要起 agent 写代码、跑测试、开 PR)。 + # 每条最坏 60 分钟(方案 30 + diff 30)——抬到 3 就必须同步抬 implement 的 + # job 超时,否则第 3 条落地到一半被 job 超时掐掉,前两条也白跑。 + # 注意:值得度同分(本轮 60/89 都是 3)时排序退化成文件名字母序,选哪三条 + # 没有语义,只是「同分里的三条」。 + land_max: 3 + +policy: + base: main + branch_prefix: autobot/ + label: autobot + + # 硬禁项:这是给执行者的线,不是提示词里的软约束 + never: + - push_main + - merge + - tag + - release + - deploy + - .github/workflows/** + - AGENTS.md + - config.example.json + + # 「不做」清单:不是禁动作,是这个仓明确不要的能力。加一条只改这里。 + # 三处都生效:分析提示词里带上(免得 agent 给 3 分)、报告命中的不落地(省掉 30 分钟实现)、 + # 改动命中的在提交前驳回(报告写得干净、实现照做的也兜得住)。 + # match 是不区分大小写的子串,会在报告正文和 diff 里各扫一遍。 + off_limits: + - name: 多密钥 / 多人共用 + why: 本仓只有一把管理员 api_key(httpauth.VerifyBearer 单串比对),不提供按人分发密钥、按人计量与限额。要多人用就自己搭一层反代。 + match: + - client_keys + - clientkeys + - ClientKey + - api_keys + - admin_key_required + - 客户端密钥 + - 多密钥 + - 多 API Key + - 按人计量 + - 按人限额 \ No newline at end of file diff --git a/Dockerfile b/Dockerfile index 2c50f74c72fc57e55d267b203bc19b17c5a40cf3..fcf66541d6421e4b4f3c97bc065c70863ad9e68a 100644 --- a/Dockerfile +++ b/Dockerfile @@ -1,42 +1,44 @@ -# syntax=docker/dockerfile:1 -# ---------------------------------------------------------------- build stage -FROM golang:1.23-alpine AS build -WORKDIR /src -COPY go.mod go.sum ./ -RUN go mod download -COPY . . -# 全静态二进制:镜像里直接跑脚本,无需 libc。 -RUN CGO_ENABLED=0 go build -trimpath -ldflags="-s -w" -o /out/wb2api ./cmd/server \ - && CGO_ENABLED=0 go build -trimpath -ldflags="-s -w" -o /out/wb2api-launcher ./cmd/launcher \ - && CGO_ENABLED=0 go build -trimpath -ldflags="-s -w" -o /out/signin_bin ./cmd/signin \ - && CGO_ENABLED=0 go build -trimpath -ldflags="-s -w" -o /out/login ./cmd/login \ - && CGO_ENABLED=0 go build -trimpath -ldflags="-s -w" -o /out/credit ./cmd/credit - -# -------------------------------------------------------------- runtime stage -FROM alpine:3.20 -# python3:login.sh 的 JSON 解析 + 入口脚本的配置校验;tzdata:Asia/Shanghai。 -RUN apk add --no-cache wget ca-certificates tzdata python3 bash \ - && mkdir -p /app/auths /app/data -ENV TZ=Asia/Shanghai -WORKDIR /app - -COPY --from=build /out/wb2api /app/wb2api -# 独立启动器:本地/容器里都能「先同步凭证、再拉起网关」,且换 wb2api 版本时它不用重编。 -COPY --from=build /out/wb2api-launcher /app/wb2api-launcher -COPY --from=build /out/signin_bin /app/signin_bin -COPY --from=build /out/login /app/login -COPY --from=build /out/credit /app/credit -COPY login.sh signin.sh credit.sh /app/ -COPY scripts/probe_active.py /app/scripts/probe_active.py -# config.default.json 只是「镜像内模板」:仅当持久卷上还没有 config.json 时被拷过去一次。 -# 真正的运行配置住在私有 Storage Bucket 上(见 docker-entrypoint.sh),公开仓库里不放 api_key。 -COPY config.default.json /app/config.json -COPY docker-entrypoint.sh /app/docker-entrypoint.sh -RUN sed -i 's/\r$//' /app/login.sh /app/signin.sh /app/credit.sh /app/docker-entrypoint.sh \ - && chmod 755 /app/login.sh /app/signin.sh /app/credit.sh /app/docker-entrypoint.sh - -# 以 root 运行:Storage Bucket 卷由挂载器创建,非 root 用户可能写不进去。 -EXPOSE 7861 -HEALTHCHECK --interval=30s --timeout=5s --start-period=10s \ - CMD wget -qO- http://127.0.0.1:7861/healthz || exit 1 -ENTRYPOINT ["/app/docker-entrypoint.sh"] +# syntax=docker/dockerfile:1 +# ---------------------------------------------------------------- build stage +# 必须跟 go.mod 的 `go` 指令一致(上游 1.26.0 起升到 1.26.10;低于它会在 +# `go build` 时要求下载 toolchain,而构建阶段没有外网兜底)。 +FROM golang:1.26.10-alpine AS build +WORKDIR /src +COPY go.mod go.sum ./ +RUN go mod download +COPY . . +# 全静态二进制:镜像里直接跑脚本,无需 libc。 +RUN CGO_ENABLED=0 go build -trimpath -ldflags="-s -w" -o /out/wb2api ./cmd/server \ + && CGO_ENABLED=0 go build -trimpath -ldflags="-s -w" -o /out/wb2api-launcher ./cmd/launcher \ + && CGO_ENABLED=0 go build -trimpath -ldflags="-s -w" -o /out/signin_bin ./cmd/signin \ + && CGO_ENABLED=0 go build -trimpath -ldflags="-s -w" -o /out/login ./cmd/login \ + && CGO_ENABLED=0 go build -trimpath -ldflags="-s -w" -o /out/credit ./cmd/credit + +# -------------------------------------------------------------- runtime stage +FROM alpine:3.20 +# python3:login.sh 的 JSON 解析 + 入口脚本的配置校验;tzdata:Asia/Shanghai。 +RUN apk add --no-cache wget ca-certificates tzdata python3 bash \ + && mkdir -p /app/auths /app/data +ENV TZ=Asia/Shanghai +WORKDIR /app + +COPY --from=build /out/wb2api /app/wb2api +# 独立启动器:本地/容器里都能「先同步凭证、再拉起网关」,且换 wb2api 版本时它不用重编。 +COPY --from=build /out/wb2api-launcher /app/wb2api-launcher +COPY --from=build /out/signin_bin /app/signin_bin +COPY --from=build /out/login /app/login +COPY --from=build /out/credit /app/credit +COPY login.sh signin.sh credit.sh /app/ +COPY scripts/probe_active.py /app/scripts/probe_active.py +# config.default.json 只是「镜像内模板」:仅当持久卷上还没有 config.json 时被拷过去一次。 +# 真正的运行配置住在私有 Storage Bucket 上(见 docker-entrypoint.sh),公开仓库里不放 api_key。 +COPY config.default.json /app/config.json +COPY docker-entrypoint.sh /app/docker-entrypoint.sh +RUN sed -i 's/\r$//' /app/login.sh /app/signin.sh /app/credit.sh /app/docker-entrypoint.sh \ + && chmod 755 /app/login.sh /app/signin.sh /app/credit.sh /app/docker-entrypoint.sh + +# 以 root 运行:Storage Bucket 卷由挂载器创建,非 root 用户可能写不进去。 +EXPOSE 7861 +HEALTHCHECK --interval=30s --timeout=5s --start-period=10s \ + CMD wget -qO- http://127.0.0.1:7861/healthz || exit 1 +ENTRYPOINT ["/app/docker-entrypoint.sh"] diff --git a/LICENSE b/LICENSE index b9ee0c3850a5b26a0aa7465a6d9b955b900cc1f2..73fceb6165c380a06444965514254afb97bd7004 100644 --- a/LICENSE +++ b/LICENSE @@ -1,22 +1,23 @@ -MIT License - -Copyright (c) 2026 Sliverkiss (original project: https://github.com/Sliverkiss/workbuddy2api) -Copyright (c) 2026 linguo2625469 (this fork: https://github.com/linguo2625469/workbuddy2api-panel) - -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. +MIT License + +Copyright (c) 2026 Sliverkiss (original project: https://github.com/Sliverkiss/workbuddy2api) +Copyright (c) 2026 linguo2625469 (fork: https://github.com/linguo2625469/workbuddy2api-panel) +Copyright (c) 2026 misakano7545 (this fork: https://github.com/misakano7545/workbuddy2api-panel) + +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/README.md b/README.md index baa4d419f6a5c44eb785a9f187b30fc49f2738dc..8f8a74deb00666f0969429ee0436da07ce998103 100644 --- a/README.md +++ b/README.md @@ -1,160 +1,260 @@ ---- -title: WorkBuddy2API Panel -emoji: 🧩 -colorFrom: indigo -colorTo: blue -sdk: docker -app_port: 7861 -pinned: false -short_description: WorkBuddy 账号池网关,带面板,数据落私有存储桶 ---- - -# WorkBuddy2API Panel — Hugging Face Spaces 部署 - -把腾讯 WorkBuddy 账号变成 OpenAI 兼容 API 的多账号网关(上游: -[linguo2625469/workbuddy2api-panel](https://github.com/linguo2625469/workbuddy2api-panel))。 -本目录是**面向 HF Spaces 的部署分支**:唯一的改动是「持久化」。 - -## 这个分支改了什么 - -Spaces 的容器根文件系统是 ephemeral 的 —— 重启、休眠唤醒、重新构建都会清空。 -原版把账号和状态放在容器内的 `./auths`、`./data`,在 Spaces 上等于每次重启都要重新登录账号。 - -本分支的做法: - -- 一个**私有 Storage Bucket** 以卷的形式挂载到容器 `/app/storage`(读写); -- `docker-entrypoint.sh` 把运行配置指到卷上: - - `/app/storage/config.json` — 运行配置(含 `api_key`,私有卷上,公开仓库里没有) - - `/app/storage/auths/*.json` — 账号凭证 - - `/app/storage/data/{state,usage,model,output_probes}.json`、`data/request-logs/` — 运行状态与请求归档 -- 启动时做一次「写 + rename」自检(程序所有落盘都走 tmp+rename,FUSE 卷不支持 rename 的话持久化就是假的); -- **安全闸门**:`api_key` 为空等于完全关闭鉴权,入口脚本检测到空 key 会直接拒绝启动。 - -## 一次性配置(已经做完,此处仅为记录) - -```python -from huggingface_hub import HfApi, Volume -api = HfApi() -api.create_bucket("a3216/wb2api-storage", private=True, exist_ok=True) -api.set_space_volumes( - "a3216/gcli2api", - volumes=[Volume(type="bucket", source="a3216/wb2api-storage", mount_path="/app/storage")], -) -``` - -`set_space_volumes` 是**替换**语义;要追加卷,先读 `get_space_runtime(...).volumes` 再一起传进去。 - -## 本地 ↔ 桶:凭证同步与独立启动器 - -**要解决的问题**:同一批账号常常要两处跑 —— 本地机器给工具提供低延迟 API,Space 负责定时签到。 -两边各自维护 `auths/` 就会不同步:本地新加的号 Space 不知道(签到漏掉), -Space 刷新过的 token 本地还在用旧的;最糟的是两边**同时** refresh 同一个账号, -refreshToken 轮换后只有一方拿到新的,另一方直接掉线。 - -`wb2api-launcher` 就是为此而生:**先同步、后启动**。 - -```bash -# 独立 exe:不需要 Go / Python / PowerShell -wb2api-launcher # 同步 → 拉起网关 → 后台每 5 分钟对账 -wb2api-launcher -status # 只看两边差异,不启动网关(有差异退出码 2) -wb2api-launcher -sync-only # 同步一次就退出 -wb2api-launcher -no-sync # 离线启动(用本地已有凭证) -wb2api-launcher -h # 全部选项 -``` - -它是个**独立程序**:与网关之间只有两个契约 ——「`wb2api -config <路径>` 能被拉起来」 -和 `config.json` 里那几个键,不引用网关内部实现。所以**上游更新时你只需要换 `wb2api`, -启动器不用动**;同步引擎直接编在里面,也不需要第二个二进制。 -`start.ps1` / `start.sh` 只是「没有二进制就 `go build`,然后 exec 启动器」的引导壳。 - -配置见 `config.example.json` 的 `sync` 段: - -```json -"sync": { - "bucket": "a3216/wb2api-storage", - "token_file": "./data/hf_token.txt", - "writer": "auto" -} -``` - -两个方向的通道**刻意不同**(实测结论,不是设计偏好): - -| 方向 | 通道 | 为什么 | -| --- | --- | --- | -| **读** | HF Hub REST(纯 HTTPS) | 不触发 Space 冷启动,它休眠/暂停时照样能拉 —— 启动那一次同步必须快 | -| **写** | 官方 `hf` CLI | Bucket 上传必须先做 **Xet 内容寻址上传**,拿文件 SHA-256 当 `xetHash` 会被服务端拒绝(`File not found in Xet storage`)。该协议不适合在 Go 里重造 | - -冲突裁决(两端都有且内容不同时,按优先级):能被网关解析的一方赢 → **`expiresAt` 更晚的一方赢** -("谁刷新过用谁的",这条直接治凭证不同步)→ refreshToken 非空的一方赢 → mtime 更晚的一方赢 → -全平取本端(保证裁决确定性,否则两端会互相覆盖成无限拉锯)。 -刻意**不做字段级合并**:accessToken 与 refreshToken 必须成对来自同一次刷新,拼起来只会造出永远刷不动的凭证。 -也**不会删除账号** —— 删除只能在面板显式操作。 - -> ⚠️ **定时任务只能由一边跑。** 两边同时开签到/保活会互抢 refreshToken(轮换后只有一方拿到新的, -> 另一方直接掉线),这是同步工具救不了的**并发写冲突**。推荐分工:**Space 跑定时任务,本地只做 API** —— -> 把本地 `schedule.*_enabled` 全设 `false` 即可,网关处理请求时本来就会按需刷新 token,不影响可用性。 -> -> ⚠️ **手动禁用 / 暂停不会被同步。** `disabled` / `paused` 是每端各自的运维意图,不属于凭证。 -> 要两边一致请分别在两端面板里设置;也不要靠 `-include-data state.json` 去"抹平"它 -> (那会把对端的冷却/熔断状态一起搬过来)。 - -## 保活:别让 Space 睡过去 - -cpu-basic 免费硬件**连续 48 小时没有任何 HTTP 流量就被暂停**,暂停期间网关的定时任务 -(签到 / 领积分)不会执行。给它一个稳定的定时流量即可。 - -### 方案 A:GitHub Actions(推荐,不占 CF 配额) - -仓库自带 `.github/workflows/space-keepalive.yml`:每 6 小时 ping 一次 Space 的 `/healthz`。 - -**为什么 6 小时就够**:HF 的判定阈值是 **48 小时**,所以有 8 倍余量;GitHub 定时任务 -偶发延迟几十分钟毫无影响。它把**任何 HTTP 状态码都算成功**——`503` 是"当前没有可用账号" -的业务语义,但 Space 是醒着的,保活目的已经达到;只有连不上(`000`)才需要关注。 - -定时工作流只在**默认分支**生效;仓库连续 60 天无活动时 GitHub 会自动停用它 -(Actions 页面点一下重新启用,或随便提交一次)。 - -> ⚠️ **保活必须打 Space 的直连域名(`*.hf.space`),不能打公网入口 `cli.3216gemini.dpdns.org`。** -> 实测那个入口的 `/healthz` 是 **Cloudflare 自己应答的 `ok`** -> (响应带 `cf-ray`,但既没有网关的 `x-service`,也没有 HF 的 `link: …/spaces/a3216/gcli2api` 头), -> **请求根本没到 Space** —— 拿它做保活会稳定返回 200、看着很健康,而 Space 照样被暂停。 -> 该入口只在 `/healthz` 上短路,`/status`、`/panel/*` 仍是透传的。 -> 工作流里因此写死直连域名并注明了原因,**别"顺手优化"掉**。 - -### 方案 B:Cloudflare Worker + Cron - -`deploy/cloudflare-worker/` 是一份单文件 Worker:反代 `cli.3216gemini.dpdns.org/*` -(响应体流式回传,不破坏 SSE)+ `scheduled()` 保活。部署前可以先用 -`node dev-server.mjs` 在本地把它验一遍(该脚本原样 import 同一个 `worker.js`,转发到真实 Space)。 - -> ⚠️ **Cloudflare 免费版的 cron 限制是「每个账号 5 个」,不是每个 Worker 5 个。** -> 名额满了 `wrangler deploy` 会给出**半成功**结果:`Uploaded` / `Deployed` 都成功,但紧接着 -> `✘ [ERROR] ... reached the Workers Free limit of 5 cron triggers per account [code: 10072]` -> —— Worker 代码上线了、cron 没加上,于是它**空转,谁也唤不醒**。要么腾一个名额,要么用方案 A。 -> -> 另外:`wrangler deploy` 打印的 `*.workers.dev` 地址在国内常因 DNS 污染而连不上, -> 这不代表部署失败;`wrangler tail` 若报 400,是它走的 WebSocket 被本地抓包代理挡了, -> 换 Dashboard → Worker → Logs 看即可。 - -## 环境变量 - -| 变量 | 作用 | -| --- | --- | -| `WB2A_API_KEY` | 覆盖配置文件里的 `api_key`(本项目默认不设,key 存在卷上的 config.json 里) | -| `WB2A_PERSIST_DIR` | 卷挂载点,默认 `/app/storage` | -| `WB2A_LISTEN` / `WB2A_AUTH_DIR` / `WB2A_STATE_FILE` … | 上游已有的同名覆盖,见上游 README | - -## 运维 - -- **改 API 密钥**:面板「配置」页改完即热生效,并写回 `/app/storage/config.json`,重启不丢。 -- **加账号**:面板里走 OAuth 添加,或把 `workbuddy-*.json` 丢进桶的 `auths/`。 -- **备份**:桶本身就是备份。本地拉一份: - `hf buckets sync hf://buckets/a3216/wb2api-storage ./backup` -- **看日志**:`hf spaces logs a3216/gcli2api`(构建日志加 `--build`)。 -- **免费硬件会自动休眠**:cpu-basic 上 48 小时没有 HTTP 流量就被暂停,下次有人访问自动唤醒。 - 唤醒后账号和状态从桶里恢复;网关的定时任务(签到/领积分)在暂停期间不会执行。 - → **保活方案见 [保活:别让 Space 睡过去](#保活别让-space-睡过去)。** - -## 说明 - -上游项目与本文档的许可证见 `LICENSE`(上游为 MIT,本分支的部署脚本同样遵循)。 +--- +title: WorkBuddy2API Panel +emoji: 🧩 +colorFrom: indigo +colorTo: blue +sdk: docker +app_port: 7861 +pinned: false +short_description: WorkBuddy 账号池网关,带面板,数据落私有存储桶 +--- + +# WorkBuddy2API Panel — Hugging Face Spaces 部署 + +把腾讯 WorkBuddy 账号变成 OpenAI 兼容 API 的多账号网关(上游: +[misakano7545/workbuddy2api-panel](https://github.com/misakano7545/workbuddy2api-panel); +原 [linguo2625469/workbuddy2api-panel](https://github.com/linguo2625469/workbuddy2api-panel) 已停止维护)。 +本目录是**面向 HF Spaces 的部署分支**:唯一的改动是「持久化」。 + +## 这个分支改了什么 + +Spaces 的容器根文件系统是 ephemeral 的 —— 重启、休眠唤醒、重新构建都会清空。 +原版把账号和状态放在容器内的 `./auths`、`./data`,在 Spaces 上等于每次重启都要重新登录账号。 + +本分支的做法: + +- 一个**私有 Storage Bucket** 以卷的形式挂载到容器 `/app/storage`(读写); +- `docker-entrypoint.sh` 把运行配置指到卷上: + - `/app/storage/config.json` — 运行配置(含 `api_key`,私有卷上,公开仓库里没有) + - `/app/storage/auths/*.json` — 账号凭证 + - `/app/storage/data/{state,usage,model,output_probes}.json`、`data/request-logs/` — 运行状态与请求归档 + - `/app/storage/data/extensions.json` — 扩展模型配置(免费模型清单、自定义模型映射、访问密钥) +- 启动时做一次「写 + rename」自检(程序所有落盘都走 tmp+rename,FUSE 卷不支持 rename 的话持久化就是假的); +- **安全闸门**:`api_key` 为空等于完全关闭鉴权,入口脚本检测到空 key 会直接拒绝启动。 + +## 新增能力(本分支) + +### 1. 免登录免费模型层 + +面板「扩展模型 → 免登录免费模型」把公共免费网关接进同一套 OpenAI 兼容接口。内置两个渠道,也可以自己加: + +| 渠道 | 默认地址 | 说明 | +| --- | --- | --- | +| OpenCode Zen | `https://opencode.ai` | 免登录、免 Key;请求按官方 CLI 指纹整形(系统提示 / 13 工具集 / 会话与项目 id / uTLS Bun ClientHello)。上游按出口 IP 限量,429 会原样透传 | +| Kilo 免费池 | `https://ai-gateway.kilo.ai/api/v1` | 免登录、免 Key;只列 `isFree` 模型;提示词可能被上游记录,勿发敏感内容 | +| 自定义渠道 | 任意 OpenAI 兼容端点 | 面板填 Base URL、模型清单路径、对话路径、筛选方式(全部 / ID 含 free / `isFree=true`)与可选固定鉴权头即可 | + +- 模型对外暴露为 `free:<渠道>/`,`GET /v1/models` 会一并列出,并带 `channel=free`、`channel_label=<渠道显示名>`、`provider` 字段; +- 免费层不占 WorkBuddy 账号、不扣积分,也不受账号池熔断/预算限制; +- 面板可逐渠道启停、逐模型勾选;启动后自动刷新清单,之后每 6 小时一次,也可手动刷新; +- OpenCode 车道复刻了 [dsh-our-free-model](https://github.com/Ebony-Vinyl/dsh-our-free-model) 的请求整形层(官方提示、工具改名、会话/项目 id、Bun TLS 指纹),免费额度跟随上游出口 IP,换一个出口通常就能恢复。 + +模型列表里三类来源一眼可辨:WorkBuddy 账号池模型带 `WorkBuddy` 标签,免费渠道带绿色渠道名标签,自定义映射带 `自定义映射` 标签;面板「模型与档位」页也可按「免费通道 / 自定义映射」筛选。 + +### 2. 自定义模型映射 + +「扩展模型 → 自定义模型映射」添加 `模型名 → 目标模型 + 提示词`: + +```json +{ + "name": "my-assistant", + "target": "cn:deepseek-v4.1-flash", + "prompt": "回答不超过三句话。今天是 {{date}}。", + "mode": "append", + "description": "简洁中文助手", + "temperature": 0.3, + "max_tokens": 1024, + "enabled": true +} +``` + +- `mode`:`append`(默认,追加到 system 末尾)/ `prepend`(拼到首条 user 消息前)/ `replace`(替换 system 提示词); +- 提示词支持 `{{model}}`、`{{target}}`、`{{date}}`、`{{time}}`、`{{datetime}}` 占位符; +- `temperature` / `max_tokens` 可选覆盖客户端请求里的同名参数; +- 目标模型可以是 WorkBuddy 模型(`cn:` / `global:`)或免费模型(`free:*`);映射名同样出现在 `GET /v1/models`,响应里的 `model` 回显客户端请求名。 + +### 3. 访问密钥 + +「扩展模型 → 访问密钥」可生成多把 `sk-wb2api-…` 密钥,用于 `/v1/*` 与 `/status`(面板本身仍只认面板密钥)。 + +- **模型白名单 / 黑名单**:每行一个,支持 `*` 与 `?` 通配;黑名单优先。例如白名单 `free:opencode/*` + 黑名单 `cn:kimi-*`。被限制的模型不会出现在该密钥的 `/v1/models` 里,点名调用返回 403 `model_not_allowed`; +- 密钥可编辑备注、启停、删除,删除后立即 401; +- 主 `api_key` 不受限制;访问密钥与账号池共用同一个请求入口,不额外计费。 + +### 4. 面板密钥环境变量 + +`WB2A_PANEL_KEY` 存在时,面板登录密钥完全由该环境变量托管:面板里改 `api_key` 不会影响面板登录,适合把管理面板密钥与下游 API 密钥分开。未设置时沿用 `api_key`。 + + +## 一次性配置(已经做完,此处仅为记录) + +```python +from huggingface_hub import HfApi, Volume +api = HfApi() +api.create_bucket("a3216/wb2api-storage", private=True, exist_ok=True) +api.set_space_volumes( + "a3216/gcli2api", + volumes=[Volume(type="bucket", source="a3216/wb2api-storage", mount_path="/app/storage")], +) +``` + +`set_space_volumes` 是**替换**语义;要追加卷,先读 `get_space_runtime(...).volumes` 再一起传进去。 + +## 本地 ↔ 桶:凭证同步与独立启动器 + +**要解决的问题**:同一批账号常常要两处跑 —— 本地机器给工具提供低延迟 API,Space 负责定时签到。 +两边各自维护 `auths/` 就会不同步:本地新加的号 Space 不知道(签到漏掉), +Space 刷新过的 token 本地还在用旧的;最糟的是两边**同时** refresh 同一个账号, +refreshToken 轮换后只有一方拿到新的,另一方直接掉线。 + +`wb2api-launcher` 就是为此而生:**先同步、后启动**。 + +```bash +# 独立 exe:不需要 Go / Python / PowerShell +wb2api-launcher # 同步 → 拉起网关 → 后台每 5 分钟对账 +wb2api-launcher -status # 只看两边差异,不启动网关(有差异退出码 2) +wb2api-launcher -sync-only # 同步一次就退出 +wb2api-launcher -no-sync # 离线启动(用本地已有凭证) +wb2api-launcher -h # 全部选项 +``` + +它是个**独立程序**:与网关之间只有两个契约 ——「`wb2api -config <路径>` 能被拉起来」 +和 `config.json` 里那几个键,不引用网关内部实现。所以**上游更新时你只需要换 `wb2api`, +启动器不用动**;同步引擎直接编在里面,也不需要第二个二进制。 +`start.ps1` / `start.sh` 只是「没有二进制就 `go build`,然后 exec 启动器」的引导壳。 + +配置见 `config.example.json` 的 `sync` 段: + +```json +"sync": { + "bucket": "a3216/wb2api-storage", + "token_file": "./data/hf_token.txt", + "writer": "auto" +} +``` + +两个方向的通道**刻意不同**(实测结论,不是设计偏好): + +| 方向 | 通道 | 为什么 | +| --- | --- | --- | +| **读** | HF Hub REST(纯 HTTPS) | 不触发 Space 冷启动,它休眠/暂停时照样能拉 —— 启动那一次同步必须快 | +| **写** | 官方 `hf` CLI | Bucket 上传必须先做 **Xet 内容寻址上传**,拿文件 SHA-256 当 `xetHash` 会被服务端拒绝(`File not found in Xet storage`)。该协议不适合在 Go 里重造 | + +冲突裁决(两端都有且内容不同时,按优先级):能被网关解析的一方赢 → **`expiresAt` 更晚的一方赢** +("谁刷新过用谁的",这条直接治凭证不同步)→ refreshToken 非空的一方赢 → mtime 更晚的一方赢 → +全平取本端(保证裁决确定性,否则两端会互相覆盖成无限拉锯)。 +刻意**不做字段级合并**:accessToken 与 refreshToken 必须成对来自同一次刷新,拼起来只会造出永远刷不动的凭证。 +也**不会删除账号** —— 删除只能在面板显式操作。 + +> ⚠️ **定时任务只能由一边跑。** 两边同时开签到/保活会互抢 refreshToken(轮换后只有一方拿到新的, +> 另一方直接掉线),这是同步工具救不了的**并发写冲突**。推荐分工:**Space 跑定时任务,本地只做 API** —— +> 把本地 `schedule.*_enabled` 全设 `false` 即可,网关处理请求时本来就会按需刷新 token,不影响可用性。 +> +> ⚠️ **手动禁用 / 暂停不会被同步。** `disabled` / `paused` 是每端各自的运维意图,不属于凭证。 +> 要两边一致请分别在两端面板里设置;也不要靠 `-include-data state.json` 去"抹平"它 +> (那会把对端的冷却/熔断状态一起搬过来)。 + +## 保活:别让 Space 睡过去 + +cpu-basic 免费硬件**连续 48 小时没有任何 HTTP 流量就被暂停**,暂停期间网关的定时任务 +(签到 / 领积分)不会执行。给它一个稳定的定时流量即可。 + +### 方案 A:GitHub Actions(推荐,不占 CF 配额) + +仓库自带 `.github/workflows/space-keepalive.yml`:每 6 小时 ping 一次 Space 的 `/healthz`。 + +**为什么 6 小时就够**:HF 的判定阈值是 **48 小时**,所以有 8 倍余量;GitHub 定时任务 +偶发延迟几十分钟毫无影响。它把**任何 HTTP 状态码都算成功**——`503` 是"当前没有可用账号" +的业务语义,但 Space 是醒着的,保活目的已经达到;只有连不上(`000`)才需要关注。 + +定时工作流只在**默认分支**生效;仓库连续 60 天无活动时 GitHub 会自动停用它 +(Actions 页面点一下重新启用,或随便提交一次)。 + +> ⚠️ **保活必须打 Space 的直连域名(`*.hf.space`),不能打公网入口 `cli.3216gemini.dpdns.org`。** +> 实测那个入口的 `/healthz` 是 **Cloudflare 自己应答的 `ok`** +> (响应带 `cf-ray`,但既没有网关的 `x-service`,也没有 HF 的 `link: …/spaces/a3216/gcli2api` 头), +> **请求根本没到 Space** —— 拿它做保活会稳定返回 200、看着很健康,而 Space 照样被暂停。 +> 该入口只在 `/healthz` 上短路,`/status`、`/panel/*` 仍是透传的。 +> 工作流里因此写死直连域名并注明了原因,**别"顺手优化"掉**。 + +### 方案 B:Cloudflare Worker + Cron + +`deploy/cloudflare-worker/` 是一份单文件 Worker:反代 `cli.3216gemini.dpdns.org/*` +(响应体流式回传,不破坏 SSE)+ `scheduled()` 保活。部署前可以先用 +`node dev-server.mjs` 在本地把它验一遍(该脚本原样 import 同一个 `worker.js`,转发到真实 Space)。 + +> ⚠️ **Cloudflare 免费版的 cron 限制是「每个账号 5 个」,不是每个 Worker 5 个。** +> 名额满了 `wrangler deploy` 会给出**半成功**结果:`Uploaded` / `Deployed` 都成功,但紧接着 +> `✘ [ERROR] ... reached the Workers Free limit of 5 cron triggers per account [code: 10072]` +> —— Worker 代码上线了、cron 没加上,于是它**空转,谁也唤不醒**。要么腾一个名额,要么用方案 A。 +> +> 另外:`wrangler deploy` 打印的 `*.workers.dev` 地址在国内常因 DNS 污染而连不上, +> 这不代表部署失败;`wrangler tail` 若报 400,是它走的 WebSocket 被本地抓包代理挡了, +> 换 Dashboard → Worker → Logs 看即可。 + +## 环境变量 + +| 变量 | 作用 | +| --- | --- | +| `WB2A_API_KEY` | 覆盖配置文件里的 `api_key`(本项目默认不设,key 存在卷上的 config.json 里) | +| `WB2A_PANEL_KEY` | 单独托管管理面板的登录密钥(设置后面板不再认 `api_key`;`/v1/*` 仍用 `api_key` + 面板签发的访问密钥) | +| `WB2A_PERSIST_DIR` | 卷挂载点,默认 `/app/storage` | +| `WB2A_LISTEN` / `WB2A_AUTH_DIR` / `WB2A_STATE_FILE` … | 上游已有的同名覆盖,见上游 README | + +## 运维 + +- **改 API 密钥**:面板「配置」页改完即热生效,并写回 `/app/storage/config.json`,重启不丢。 +- **加账号**:面板里走 OAuth 添加,或把 `workbuddy-*.json` 丢进桶的 `auths/`。 +- **备份**:桶本身就是备份。本地拉一份: + `hf buckets sync hf://buckets/a3216/wb2api-storage ./backup` +- **看日志**:`hf spaces logs a3216/gcli2api`(构建日志加 `--build`)。 +- **部署新版本**:在能访问 `huggingface.co` 的机器上执行(网络受限环境里 HF 的 git/API 会被 DNS 污染,本机推不上去): + + ```bash + export HF_TOKEN=hf_xxx + python3 - <<'PY' + import os + from huggingface_hub import HfApi + api = HfApi(token=os.environ["HF_TOKEN"]) + api.upload_folder( + repo_id="a3216/gcli2api", repo_type="space", folder_path=".", + commit_message="deploy: sync from GitHub main", delete_patterns=["*"], + ignore_patterns=[".git/*", ".git", ".github/*", "storage/*", "auths/*", "data/*", "dist/*", "**/__pycache__/*", "**/*.tmp"], + ) + PY + ``` + + 仓库里的 `.github/workflows/deploy-hf.yml` 是同一件事的 Actions 版本(手动触发); + 私有仓库需要先启用 Actions 计费,否则运行会停在 `startup_failure`。 + 本机也访问不了 `huggingface.co` 时,先开 [DevSidecar](https://github.com/docmirror/dev-sidecar) + 或任意能访问 HF 的代理,再执行上面的命令。DevSidecar 本身需要一个可直连的出口; + 纯内网/无直连的容器里它无法凭空打通。 +- **免费硬件会自动休眠**:cpu-basic 上 48 小时没有 HTTP 流量就被暂停,下次有人访问自动唤醒。 + 唤醒后账号和状态从桶里恢复;网关的定时任务(签到/领积分)在暂停期间不会执行。 + → **保活方案见 [保活:别让 Space 睡过去](#保活别让-space-睡过去)。** + +## 说明 + +上游项目与本文档的许可证见 `LICENSE`(上游为 MIT,本分支的部署脚本同样遵循)。 + +### 与上游的关系(同步口径) + +- 本分支跟随 **misakano7545/workbuddy2api-panel**(模块路径同为 + `github.com/misakano7545/workbuddy2api-panel`;老仓 `linguo2625469/*` 已归档)。 +- 同步方式:**逐文件判定**。上游文件逐字节取上游版本;本分支只维护下面这批 + 「HF 专属」文件,冲突时以本分支为准: + `README.md`、`Dockerfile`、`docker-entrypoint.sh`、`docker-compose.yml`、 + `config.default.json`、`config.example.json` 的 `sync` 段、`cmd/launcher/`、 + `cmd/sync/`、`internal/syncer/`、`deploy/cloudflare-worker/`、 + `start.ps1`、`start.sh`、`.github/workflows/space-keepalive.yml`、 + `.github/workflows/deploy-hf.yml`、`binaries.yml` 里的启动器构建。 +- 本分支新增、上游没有的扩展层:`internal/extstore/`、`internal/freemodel/`、 + `internal/panel/extensions.go`、`internal/server/extensions.go`。 + 同步上游时这些文件整块保留;上游若新增同名路径,需按功能逐项合并。 +- 上游的 `.github/workflows/autobot.yml`(每日自动开 PR 的机器人)**不进本分支**: + 这里是部署分支,不需要自动改代码,留着只会每天刷 PR。 +- Go 工具链跟随上游 `go.mod`(当前 `1.26.10`):Dockerfile 的构建阶段必须同步改版本, + 否则 `go build` 会去下载 toolchain。 +- 已知上游遗留:`internal/upstream` 的 `TestChatTimingObservation` 在上游 HEAD 上 + 本身就失败(Prep/Do 测不到)——纯观测路径,与签到/保活无关,故不阻塞本分支。 + diff --git a/cmd/credit/main.go b/cmd/credit/main.go index 766de4954616c53f1b1985770a54d38c90dd2be6..0126b9739f7a713c0923d3b82b34d38c1bde957e 100644 --- a/cmd/credit/main.go +++ b/cmd/credit/main.go @@ -1,294 +1,300 @@ -// credit.go — WorkBuddy 积分查询(全部账号 + 总计),JSON 输出到 stdout。 -// -// 用法: -// -// go run ./cmd/credit # 或编译后 ./credit -// -// 输出结构: -// -// {"service":"workbuddy","ts":N, -// "total":{"remain":N,"used":N,"size":N,"accounts":N,"ok":N,"failed":N}, -// "accounts":[{"uid","nickname","remain","used","size","packages","ok","error?"}]} -// -// 接口与聚合逻辑:POST codebuddy.cn/v2/billing/meter/get-user-resource,聚合所有 package 的 -// Cycle* 字段,TotalDosage 作 size 下限。 -package main - -import ( - "bytes" - "encoding/json" - "fmt" - "net/http" - "os" - "path/filepath" - "sort" - "strings" - "time" -) - -const billingBaseCN = "https://www.codebuddy.cn" - -// billingBaseGlobal 国际版计费域。global 账号打 CN 域会得到 401: -// www.codebuddy.cn 不认 workbuddy.ai 的 token(实测 401,workbuddy.ai 同 token 为 code=0)。 -const billingBaseGlobal = "https://www.workbuddy.ai" - -// billingBaseFor 按账号 realm 选择计费域。 -// -// 判定口径与 internal/auth.Realm() 一致:显式 realm=global 或 domain 落在 -// workbuddy.ai 家族,都按国际版处理。cmd/credit 早先对所有账号硬编码 CN 域, -// 导致 global 账号余额查询恒返回 401(面板显示的是池内缓存值,不是实时的)。 -func billingBaseFor(af *authFile) string { - if strings.EqualFold(strings.TrimSpace(af.Auth.Realm), "global") { - return billingBaseGlobal - } - d := strings.ToLower(strings.TrimSpace(af.Auth.Domain)) - if d == "workbuddy.ai" || strings.HasSuffix(d, ".workbuddy.ai") { - return billingBaseGlobal - } - return billingBaseCN -} - -type authFile struct { - Auth struct { - AccessToken string `json:"accessToken"` - Domain string `json:"domain"` - Realm string `json:"realm"` - } `json:"auth"` - Account struct { - UID string `json:"uid"` - EnterpriseID string `json:"enterpriseId"` - Nickname string `json:"nickname"` - } `json:"account"` -} - -type accountResult struct { - UID string `json:"uid"` - Nickname string `json:"nickname"` - Remain *int64 `json:"remain"` - Used *int64 `json:"used"` - Size *int64 `json:"size"` - Packages int `json:"packages,omitempty"` - OK bool `json:"ok"` - Error string `json:"error,omitempty"` -} - -type resourcePackage struct { - CapacityRemain int64 `json:"CapacityRemain"` - CapacityUsed int64 `json:"CapacityUsed"` - CapacitySize int64 `json:"CapacitySize"` - CycleCapacityRemain int64 `json:"CycleCapacityRemain"` - CycleCapacityUsed int64 `json:"CycleCapacityUsed"` - CycleCapacitySize int64 `json:"CycleCapacitySize"` -} - -// packageRemainUsed 与 billing.go:203-258 一致 -func packageRemainUsed(a resourcePackage) (remain, used, size int64) { - if a.CycleCapacitySize > 0 { - remain = a.CycleCapacityRemain - size = a.CycleCapacitySize - if remain < 0 { - remain = 0 - } - if remain > size { - remain = size - } - used = size - remain - if a.CycleCapacityUsed > used { - used = a.CycleCapacityUsed - if size >= used { - remain = size - used - } - } - return remain, used, size - } - remain = a.CapacityRemain - used = a.CapacityUsed - size = a.CapacitySize - if used == 0 && size > remain { - used = size - remain - } - return remain, used, size -} - -func fetchUserResource(af *authFile) (remain, used, size int64, packs int, err error) { - now := time.Now() - body, _ := json.Marshal(map[string]any{ - "PageNumber": 1, - "PageSize": 100, - "ProductCode": "p_tcaca", - "Status": []int{0, 3}, - "PackageEndTimeRangeBegin": now.Format("2006-01-02 15:04:05"), - "PackageEndTimeRangeEnd": now.Add(365 * 101 * 24 * time.Hour).Format("2006-01-02 15:04:05"), - }) - base := billingBaseFor(af) - // global 域无 /v2 前缀(与 internal/upstream 的 billingMeterPaths 同口径)。 - path := "/v2/billing/meter/get-user-resource" - if base == billingBaseGlobal { - path = "/billing/meter/get-user-resource" - } - req, err := http.NewRequest(http.MethodPost, base+path, bytes.NewReader(body)) - if err != nil { - return 0, 0, 0, 0, err - } - req.Header.Set("Authorization", "Bearer "+af.Auth.AccessToken) - req.Header.Set("Accept", "application/json") - req.Header.Set("Content-Type", "application/json") - if af.Account.UID != "" { - req.Header.Set("X-User-Id", af.Account.UID) - } - if af.Account.EnterpriseID != "" { - req.Header.Set("X-Enterprise-Id", af.Account.EnterpriseID) - req.Header.Set("X-Tenant-Id", af.Account.EnterpriseID) - } - if af.Auth.Domain != "" { - req.Header.Set("X-Domain", af.Auth.Domain) - } - client := &http.Client{Timeout: 20 * time.Second} - resp, err := client.Do(req) - if err != nil { - return 0, 0, 0, 0, err - } - defer resp.Body.Close() - if resp.StatusCode >= 400 { - return 0, 0, 0, 0, fmt.Errorf("http %d", resp.StatusCode) - } - var env struct { - Code int `json:"code"` - Msg string `json:"msg"` - Data struct { - Response struct { - Data struct { - TotalDosage int64 `json:"TotalDosage"` - Accounts []resourcePackage `json:"Accounts"` - } `json:"Data"` - } `json:"Response"` - } `json:"data"` - } - if err := json.NewDecoder(resp.Body).Decode(&env); err != nil { - return 0, 0, 0, 0, err - } - if env.Code != 0 { - return 0, 0, 0, 0, fmt.Errorf("code=%d %s", env.Code, env.Msg) - } - for _, a := range env.Data.Response.Data.Accounts { - r, u, s := packageRemainUsed(a) - remain += r - used += u - size += s - } - packs = len(env.Data.Response.Data.Accounts) - if size > 0 { - if derived := size - remain; derived > used { - used = derived - } - } - if dosage := env.Data.Response.Data.TotalDosage; dosage > size { - size = dosage - if derived := size - remain; derived > used { - used = derived - } - } - return remain, used, size, packs, nil -} - -func main() { - pretty := len(os.Args) > 1 && os.Args[1] == "-pretty" - authDir := "./auths" - if v := os.Getenv("WB2A_AUTH_DIR"); v != "" { - authDir = v - } - files, _ := filepath.Glob(filepath.Join(authDir, "workbuddy-*.json")) - sort.Strings(files) - - accounts := make([]accountResult, 0, len(files)) - for _, f := range files { - var af authFile - raw, err := os.ReadFile(f) - if err != nil || json.Unmarshal(raw, &af) != nil { - continue - } - res := accountResult{UID: af.Account.UID, Nickname: af.Account.Nickname} - if af.Auth.AccessToken == "" { - res.Error = "no accessToken" - accounts = append(accounts, res) - continue - } - remain, used, size, packs, err := fetchUserResource(&af) - if err != nil { - res.Error = err.Error() - } else { - res.Remain = &remain - res.Used = &used - res.Size = &size - res.Packages = packs - res.OK = true - } - accounts = append(accounts, res) - time.Sleep(200 * time.Millisecond) - } - - var totalRemain, totalUsed, totalSize int64 - okCount := 0 - for _, a := range accounts { - if a.OK { - okCount++ - if a.Remain != nil { - totalRemain += *a.Remain - } - if a.Used != nil { - totalUsed += *a.Used - } - if a.Size != nil { - totalSize += *a.Size - } - } - } - out := map[string]any{ - "service": "workbuddy", - "ts": time.Now().Unix(), - "total": map[string]any{ - "remain": totalRemain, - "used": totalUsed, - "size": totalSize, - "accounts": len(accounts), - "ok": okCount, - "failed": len(accounts) - okCount, - }, - "accounts": accounts, - } - if pretty { - printPretty(accounts, totalRemain, totalUsed, totalSize, okCount) - return - } - raw, _ := json.Marshal(out) - fmt.Println(string(raw)) -} - -// printPretty 人类可读日报:四行汇总,无账号明细。 -func printPretty(accounts []accountResult, totalRemain, totalUsed, totalSize int64, okCount int) { - withBalance := 0 - var failed []string - for _, a := range accounts { - if a.OK && a.Remain != nil && *a.Remain > 0 { - withBalance++ - } - if !a.OK { - name := a.Nickname - if name == "" && len(a.UID) >= 8 { - name = a.UID[:8] - } - failed = append(failed, name+" "+a.Error) - } - } - pct := int64(0) - if totalSize > 0 { - pct = totalRemain * 100 / totalSize - } - fmt.Printf("📊 WorkBuddy 积分日报\n") - fmt.Printf("账号: %d/%d\n", withBalance, len(accounts)) - fmt.Printf("总计: %d/%d\n", totalRemain, totalSize) - fmt.Printf("剩余: %d%%\n", pct) - for _, f := range failed { - fmt.Printf("⚠️ %s\n", f) - } -} +// credit.go — WorkBuddy 积分查询(全部账号 + 总计),JSON 输出到 stdout。 +// +// 用法: +// +// go run ./cmd/credit # 或编译后 ./credit +// +// 输出结构: +// +// {"service":"workbuddy","ts":N, +// "total":{"remain":N,"used":N,"size":N,"accounts":N,"ok":N,"failed":N}, +// "accounts":[{"uid","nickname","remain","used","size","packages","ok","error?"}]} +// +// 接口与聚合逻辑:POST codebuddy.cn/v2/billing/meter/get-user-resource,聚合所有 package 的 +// Cycle* 字段,TotalDosage 作 size 下限。 +package main + +import ( + "bytes" + "encoding/json" + "fmt" + "log" + "net/http" + "os" + "path/filepath" + "sort" + "time" + + "github.com/misakano7545/workbuddy2api-panel/internal/auth" + "github.com/misakano7545/workbuddy2api-panel/internal/upstream" +) + +const billingBaseCN = "https://www.codebuddy.cn" + +// billingBaseGlobal 国际版计费域。global 账号打 CN 域会得到 401: +// www.codebuddy.cn 不认 workbuddy.ai 的 token(实测 401,workbuddy.ai 同 token 为 code=0)。 +const billingBaseGlobal = "https://www.workbuddy.ai" + +// billingBaseFor 按账号 realm 选择计费域(判定收敛到 auth.IsGlobal,与主程序 +// 同一口径;此前手抄的 realm/domain 推断靠人工同步)。cmd/credit 早先对所有 +// 账号硬编码 CN 域,导致 global 账号余额查询恒返回 401。 +func billingBaseFor(a *auth.Auth) string { + if a.IsGlobal() { + return billingBaseGlobal + } + return billingBaseCN +} + +type accountResult struct { + UID string `json:"uid"` + Nickname string `json:"nickname"` + Remain *int64 `json:"remain"` + Used *int64 `json:"used"` + Size *int64 `json:"size"` + Packages int `json:"packages,omitempty"` + OK bool `json:"ok"` + Error string `json:"error,omitempty"` +} + +type resourcePackage struct { + CapacityRemain int64 `json:"CapacityRemain"` + CapacityUsed int64 `json:"CapacityUsed"` + CapacitySize int64 `json:"CapacitySize"` + CycleCapacityRemain int64 `json:"CycleCapacityRemain"` + CycleCapacityUsed int64 `json:"CycleCapacityUsed"` + CycleCapacitySize int64 `json:"CycleCapacitySize"` +} + +// packageRemainUsed 与 billing.go:203-258 一致 +func packageRemainUsed(a resourcePackage) (remain, used, size int64) { + if a.CycleCapacitySize > 0 { + remain = a.CycleCapacityRemain + size = a.CycleCapacitySize + if remain < 0 { + remain = 0 + } + if remain > size { + remain = size + } + used = size - remain + if a.CycleCapacityUsed > used { + used = a.CycleCapacityUsed + if size >= used { + remain = size - used + } + } + return remain, used, size + } + remain = a.CapacityRemain + used = a.CapacityUsed + size = a.CapacitySize + if used == 0 && size > remain { + used = size - remain + } + return remain, used, size +} + +func fetchUserResource(a *auth.Auth) (remain, used, size int64, packs int, err error) { + now := time.Now() + body, _ := json.Marshal(map[string]any{ + "PageNumber": 1, + "PageSize": 100, + "ProductCode": "p_tcaca", + "Status": []int{0, 3}, + "PackageEndTimeRangeBegin": now.Format("2006-01-02 15:04:05"), + "PackageEndTimeRangeEnd": now.Add(365 * 101 * 24 * time.Hour).Format("2006-01-02 15:04:05"), + }) + base := billingBaseFor(a) + // global 域无 /v2 前缀(与 internal/upstream 的 billingMeterPaths 同口径)。 + path := "/v2/billing/meter/get-user-resource" + if base == billingBaseGlobal { + path = "/billing/meter/get-user-resource" + } + req, err := http.NewRequest(http.MethodPost, base+path, bytes.NewReader(body)) + if err != nil { + return 0, 0, 0, 0, err + } + req.Header.Set("Authorization", "Bearer "+a.AccessToken) + req.Header.Set("Accept", "application/json") + req.Header.Set("Content-Type", "application/json") + if a.UID != "" { + req.Header.Set("X-User-Id", a.UID) + } + if a.EnterpriseID != "" { + req.Header.Set("X-Enterprise-Id", a.EnterpriseID) + req.Header.Set("X-Tenant-Id", a.EnterpriseID) + } + if a.Domain != "" { + req.Header.Set("X-Domain", a.Domain) + } + client := &http.Client{Timeout: 20 * time.Second} + resp, err := client.Do(req) + if err != nil { + return 0, 0, 0, 0, err + } + defer resp.Body.Close() + if resp.StatusCode >= 400 { + return 0, 0, 0, 0, fmt.Errorf("http %d", resp.StatusCode) + } + var env struct { + Code int `json:"code"` + Msg string `json:"msg"` + Data struct { + Response struct { + Data struct { + TotalDosage int64 `json:"TotalDosage"` + Accounts []resourcePackage `json:"Accounts"` + } `json:"Data"` + } `json:"Response"` + } `json:"data"` + } + if err := json.NewDecoder(resp.Body).Decode(&env); err != nil { + return 0, 0, 0, 0, err + } + if env.Code != 0 { + return 0, 0, 0, 0, fmt.Errorf("code=%d %s", env.Code, env.Msg) + } + for _, a := range env.Data.Response.Data.Accounts { + r, u, s := packageRemainUsed(a) + remain += r + used += u + size += s + } + packs = len(env.Data.Response.Data.Accounts) + if size > 0 { + if derived := size - remain; derived > used { + used = derived + } + } + if dosage := env.Data.Response.Data.TotalDosage; dosage > size { + size = dosage + if derived := size - remain; derived > used { + used = derived + } + } + return remain, used, size, packs, nil +} + +func main() { + pretty := len(os.Args) > 1 && os.Args[1] == "-pretty" + authDir := "./auths" + if v := os.Getenv("WB2A_AUTH_DIR"); v != "" { + authDir = v + } + files, _ := filepath.Glob(filepath.Join(authDir, "workbuddy-*.json")) + sort.Strings(files) + + up := upstream.New() + accounts := make([]accountResult, 0, len(files)) + for _, f := range files { + // 坏文件不再静默跳过(跳过会让 total.accounts 与目录文件数对不上且无任何 + // 线索):计入明细行,与 signin/trial 的 LOAD_ERR 口径一致。auth.Parse 同时 + // 支持嵌套形与扁平形手写文件(此前自定义结构只认嵌套形,扁平形的 token + // 解析为空、报误导性的 no accessToken)。 + raw, err := os.ReadFile(f) + var a *auth.Auth + if err == nil { + a, err = auth.Parse(raw) + } + if err != nil { + accounts = append(accounts, accountResult{UID: "", Nickname: filepath.Base(f), Error: "load: " + err.Error()}) + continue + } + a.FilePath = f + res := accountResult{UID: a.UID, Nickname: a.Nickname} + // 过期 token 自动 refresh 并写回(与 signin 同款;此前 token 一过期全部 + // 账号 failed,必须先跑一遍 signin 才能救回来)。 + if a.NeedsRefresh(2 * time.Hour) { + if rerr := up.RefreshTokenIfNeeded(a, 2*time.Hour); rerr != nil { + res.Error = "refresh: " + rerr.Error() + accounts = append(accounts, res) + continue + } + if serr := a.SaveAtomicRetry(); serr != nil { + log.Printf("credit %s save: %v", a.UID, serr) + } + } + if a.AccessToken == "" { + res.Error = "no accessToken" + accounts = append(accounts, res) + continue + } + remain, used, size, packs, err := fetchUserResource(a) + if err != nil { + res.Error = err.Error() + } else { + res.Remain = &remain + res.Used = &used + res.Size = &size + res.Packages = packs + res.OK = true + } + accounts = append(accounts, res) + time.Sleep(200 * time.Millisecond) + } + + var totalRemain, totalUsed, totalSize int64 + okCount := 0 + for _, a := range accounts { + if a.OK { + okCount++ + if a.Remain != nil { + totalRemain += *a.Remain + } + if a.Used != nil { + totalUsed += *a.Used + } + if a.Size != nil { + totalSize += *a.Size + } + } + } + out := map[string]any{ + "service": "workbuddy", + "ts": time.Now().Unix(), + "total": map[string]any{ + "remain": totalRemain, + "used": totalUsed, + "size": totalSize, + "accounts": len(accounts), + "ok": okCount, + "failed": len(accounts) - okCount, + }, + "accounts": accounts, + } + if pretty { + printPretty(accounts, totalRemain, totalUsed, totalSize, okCount) + return + } + raw, _ := json.Marshal(out) + fmt.Println(string(raw)) +} + +// printPretty 人类可读日报:四行汇总,无账号明细。 +func printPretty(accounts []accountResult, totalRemain, totalUsed, totalSize int64, okCount int) { + withBalance := 0 + var failed []string + for _, a := range accounts { + if a.OK && a.Remain != nil && *a.Remain > 0 { + withBalance++ + } + if !a.OK { + name := a.Nickname + if name == "" && len(a.UID) >= 8 { + name = a.UID[:8] + } + failed = append(failed, name+" "+a.Error) + } + } + pct := int64(0) + if totalSize > 0 { + pct = totalRemain * 100 / totalSize + } + fmt.Printf("📊 WorkBuddy 积分日报\n") + fmt.Printf("账号: %d/%d\n", withBalance, len(accounts)) + fmt.Printf("总计: %d/%d\n", totalRemain, totalSize) + fmt.Printf("剩余: %d%%\n", pct) + for _, f := range failed { + fmt.Printf("⚠️ %s\n", f) + } +} diff --git a/cmd/credit/main_test.go b/cmd/credit/main_test.go new file mode 100644 index 0000000000000000000000000000000000000000..29c1ebfe2507d8754cf1dd2bfe79a9573cd31ee4 --- /dev/null +++ b/cmd/credit/main_test.go @@ -0,0 +1,60 @@ +package main + +import ( + "os" + "path/filepath" + "testing" + + "github.com/misakano7545/workbuddy2api-panel/internal/auth" +) + +// TestBillingBaseForFollowsAuthRealm 计费域选择收敛到 auth.IsGlobal 口径 +// (显式 realm=global 或 domain 落 workbuddy.ai 家族),不再手抄推断。 +func TestBillingBaseForFollowsAuthRealm(t *testing.T) { + cases := []struct { + name string + a *auth.Auth + want string + }{ + {"显式 global", parseAuth(t, `{"realm":"global","accessToken":"t"}`), billingBaseGlobal}, + {"domain 家族", parseAuth(t, `{"accessToken":"t","domain":"www.workbuddy.ai"}`), billingBaseGlobal}, + {"CN", parseAuth(t, `{"accessToken":"t","domain":"www.codebuddy.cn"}`), billingBaseCN}, + {"缺省", parseAuth(t, `{"accessToken":"t"}`), billingBaseCN}, + } + for _, c := range cases { + if got := billingBaseFor(c.a); got != c.want { + t.Errorf("%s: billingBaseFor = %s, want %s", c.name, got, c.want) + } + } +} + +// TestCreditLoadsFlatAuthFile 扁平形手写 auth 文件(无 auth/account 嵌套)也 +// 能解出 token——此前 credit 自定义结构只认嵌套形,扁平形 token 解析为空、 +// 报误导性的 "no accessToken"。 +func TestCreditLoadsFlatAuthFile(t *testing.T) { + dir := t.TempDir() + flat := filepath.Join(dir, "workbuddy-flat.json") + if err := os.WriteFile(flat, []byte(`{"accessToken":"at-1","refreshToken":"rt-1","uid":"u1","expiresAt":9999999999}`), 0o600); err != nil { + t.Fatal(err) + } + raw, err := os.ReadFile(flat) + if err != nil { + t.Fatal(err) + } + a, err := auth.Parse(raw) + if err != nil { + t.Fatalf("扁平形解析失败: %v", err) + } + if a.AccessToken != "at-1" || a.UID != "u1" { + t.Fatalf("flat parse: token=%q uid=%q", a.AccessToken, a.UID) + } +} + +func parseAuth(t *testing.T, js string) *auth.Auth { + t.Helper() + a, err := auth.Parse([]byte(js)) + if err != nil { + t.Fatal(err) + } + return a +} diff --git a/cmd/launcher/flags.go b/cmd/launcher/flags.go index 87961ec591b8519fcb0df66cef3793ec8912f404..b8b64555457506894bbeb8ff9d2a8132f33cb6bd 100644 --- a/cmd/launcher/flags.go +++ b/cmd/launcher/flags.go @@ -7,7 +7,7 @@ import ( "strings" "time" - "github.com/linguo2625469/workbuddy2api-panel/internal/syncer" + "github.com/misakano7545/workbuddy2api-panel/internal/syncer" ) // usageHead 帮助文本前半段。 diff --git a/cmd/launcher/main.go b/cmd/launcher/main.go index f24cd3928d152e3671474de64d1906fda0446c5a..a09b398f8079fb4f6627d8d631011a75a9f96bd8 100644 --- a/cmd/launcher/main.go +++ b/cmd/launcher/main.go @@ -36,7 +36,7 @@ import ( "syscall" "time" - "github.com/linguo2625469/workbuddy2api-panel/internal/syncer" + "github.com/misakano7545/workbuddy2api-panel/internal/syncer" ) // version 版本号(-version)。做成变量便于 -ldflags 注入。 diff --git a/cmd/login/main.go b/cmd/login/main.go index 0c8ceb0040e970a7f36bc8b111672ad0f3727aa6..5fee684aab5a0872fced974d0a028d6132fa37c5 100644 --- a/cmd/login/main.go +++ b/cmd/login/main.go @@ -1,336 +1,461 @@ -// login.go — WorkBuddy OAuth 登录(设备授权流程,CN realm;--realm=global 供国际版)。 -// -// 两个子命令,由 login.sh 顺序驱动: -// -// login [--realm=cn|global] url → POST /v2/plugin/auth/state?platform=CLI 拿 state+authUrl, -// state 落 /tmp/wb2api-login-state.json,stdout 打印授权 URL -// login [--realm=cn|global] poll → 读 state,GET /v2/plugin/auth/token?state= 一次, -// 成功再 GET /v2/plugin/login/account?state= 拿 uid/nickname, -// stdout 打印完整 token+account JSON(含 realm 键) -// -// --realm 默认 cn。按 realm 切换上游端点与 Origin/Referer: -// -// cn → https://copilot.tencent.com(Origin: https://www.codebuddy.cn) -// global → https://www.workbuddy.ai(Origin: https://www.workbuddy.ai) -// -// state 落盘带 realm,poll 读回校验与命令行 --realm 一致(防混域)。 -// 无 PKCE(workbuddy 设备流由服务端签发 state)。 -package main - -import ( - "bufio" - "bytes" - "encoding/json" - "fmt" - "io" - "net/http" - "net/http/cookiejar" - "os" - "path/filepath" - "strings" - "time" - - auth2 "github.com/linguo2625469/workbuddy2api-panel/internal/auth" -) - -// 上游常量:CN → copilot.tencent.com(Origin 为 codebuddy.cn);global → www.workbuddy.ai -// (base 与 Origin/Referer 同域)。端点 URL 由 realmConfig 按 realm 动态拼出,不再硬编码。 -const ( - upstreamBaseCN = "https://copilot.tencent.com" - upstreamBaseGlobal = "https://www.workbuddy.ai" - clientUA = "CLI/2.63.2 CodeBuddy/2.63.2" - originRefererCN = "https://www.codebuddy.cn" - originRefererGlobal = "https://www.workbuddy.ai" -) - -// 登录 state 落盘路径(var 便于测试替换临时文件) -// Portable across OSes: the upstream hardcoded "/tmp/...", which on -// Windows resolves to :\tmp\... and aborts the OAuth flow with -// "The system cannot find the path specified". os.TempDir() is /tmp on Linux. -var stateFile = filepath.Join(os.TempDir(), "wb2api-login-state.json") - -// exitFunc 供测试替换(默认 os.Exit;测试持临时替换为 panic 以进程内捕获 fatal)。 -var exitFunc = os.Exit - -// realmConfig 按 realm 返回上游 base 与 Origin/Referer origin:global → -// (www.workbuddy.ai, www.workbuddy.ai);cn/非法/缺省 → (copilot.tencent.com, codebuddy.cn)。 -func realmConfig(realm string) (base, origin string) { - if realm == realmGlobal { - return upstreamBaseGlobal, originRefererGlobal - } - return upstreamBaseCN, originRefererCN -} - -// commonHeaders 按 origin 设置通用请求头(Origin/Referer 随 realm 变化)。 -// 返回 func(*http.Request),由调用方按 realm 选定的 origin 构造一次后复用。 -func commonHeaders(origin string) func(*http.Request) { - return func(req *http.Request) { - req.Header.Set("Content-Type", "application/json") - req.Header.Set("Accept", "application/json, text/plain, */*") - req.Header.Set("X-Requested-With", "XMLHttpRequest") - req.Header.Set("Origin", origin) - req.Header.Set("Referer", origin+"/") - req.Header.Set("User-Agent", clientUA) - } -} - -// apiEnvelope 与 main.go:429-433 一致 -type apiEnvelope struct { - Code int `json:"code"` - Msg string `json:"msg"` - Data json.RawMessage `json:"data"` -} - -// doJSON 与 oauth.go:33-66 一致:{code,msg,data} 信封,code!=0 → error -func doJSON(client *http.Client, method, fullURL string, headers func(*http.Request), body io.Reader) (json.RawMessage, int, error) { - req, err := http.NewRequest(method, fullURL, body) - if err != nil { - return nil, 0, err - } - if headers != nil { - headers(req) - } else { - // 缺省头:CN origin(与原 commonHeaders() 行为一致,零回归) - commonHeaders(originRefererCN)(req) - } - resp, err := client.Do(req) - if err != nil { - return nil, 0, err - } - defer resp.Body.Close() - raw, _ := io.ReadAll(resp.Body) - if resp.StatusCode >= 400 { - return nil, resp.StatusCode, fmt.Errorf("http_error: upstream %d", resp.StatusCode) - } - if resp.StatusCode >= 300 { - return nil, resp.StatusCode, fmt.Errorf("http_error: upstream redirect %d", resp.StatusCode) - } - var env apiEnvelope - if err := json.Unmarshal(raw, &env); err != nil { - return nil, resp.StatusCode, fmt.Errorf("parse failed: %w", err) - } - if env.Code != 0 { - return nil, resp.StatusCode, fmt.Errorf("code=%d msg=%s", env.Code, env.Msg) - } - return env.Data, resp.StatusCode, nil -} - -func fatal(format string, args ...any) { - fmt.Fprintf(os.Stderr, "login: "+format+"\n", args...) - exitFunc(1) -} - -type loginState struct { - State string `json:"state"` - Realm string `json:"realm,omitempty"` // url 落盘时写回的 realm,poll 读回校验防混域 -} - -// realm 取值枚举(与 internal/auth 的 Realm() 归一化输出一致)。 -const ( - realmCN = "cn" - realmGlobal = "global" -) - -// parseRealmArgs 解析开头的 --realm=cn|global(或分离式 --realm )flag,缺省 cn。 -// 大小写不敏感归一化;非法值/缺值报错。桌椅剩余参数(子命令)顺序不变。 -func parseRealmArgs(args []string) (realm string, rest []string, err error) { - realm = realmCN - for i := 0; i < len(args); i++ { - a := args[i] - switch { - case a == "--realm": - if i+1 >= len(args) { - return "", nil, fmt.Errorf("--realm requires a value") - } - v := strings.ToLower(strings.TrimSpace(args[i+1])) - if v != realmCN && v != realmGlobal { - return "", nil, fmt.Errorf("invalid --realm %q (want cn|global)", args[i+1]) - } - realm = v - i++ - case strings.HasPrefix(a, "--realm="): - v := strings.ToLower(strings.TrimSpace(strings.TrimPrefix(a, "--realm="))) - if v != realmCN && v != realmGlobal { - return "", nil, fmt.Errorf("invalid --realm %q (want cn|global)", v) - } - realm = v - default: - rest = append(rest, a) - } - } - return realm, rest, nil -} - -// resolveRealmInput 把交互式选域的一行输入归一化为 realm(纯函数,login.sh 交互分支 -// 的核心决策,可测)。规则: -// -// "1"/"cn"(大小写不敏感)/""(回车默认)→ cn -// "2"/"global" → global -// 其他 → ("", false)(调用方回默认 cn) -func resolveRealmInput(input string) (string, bool) { - switch strings.ToLower(strings.TrimSpace(input)) { - case "", "1", "cn": - return realmCN, true - case "2", "global": - return realmGlobal, true - } - return "", false -} - -// promptRealm 交互式选域:向 out 打印选项提示(out 接 stderr,stdout 留给 realm 本身), -// 从 in 读一行,返回归一化 realm。非法输入警告后回落 cn;EOF(非交互/管道)回落 cn。 -func promptRealm(in io.Reader, out io.Writer) string { - fmt.Fprintln(out, "选择登录版本: 1) 国内版(cn) 2) 国际版(global) [默认 1/cn]: ") - line, err := bufio.NewReader(in).ReadString('\n') - if err != nil && line == "" { - // EOF/非交互 → 回落默认 cn - return realmCN - } - if realm, ok := resolveRealmInput(line); ok { - return realm - } - fmt.Fprintln(out, "无效选择,默认国内版 cn") - return realmCN -} - -// validateRealmMatch 校验 state 文件 realm 与命令行 --realm 一致(防混域): -// state 无 realm(旧文件)放行;非空且不一致 → error。 -func validateRealmMatch(stateRealm, cliRealm string) error { - if stateRealm != "" && stateRealm != cliRealm { - return fmt.Errorf("realm mismatch: state file realm=%q, command --realm=%q(url 与 poll 需同一 realm)", stateRealm, cliRealm) - } - return nil -} - -// runURL 执行 url 子命令:向 upstreamBase 的 state 端点 POST 取授权 URL, -// state 落盘(带 realm),stdout 打印 authURL。out 接 stdout;stateFile 为落盘路径 -// (可注入临时文件便于测试)。空 realm 视为缺省(调用方已归一)。 -func runURL(base, origin, realm, statePath string, client *http.Client, out io.Writer) { - headers := commonHeaders(origin) - data, _, err := doJSON(client, http.MethodPost, base+"/v2/plugin/auth/state?platform=CLI", headers, bytes.NewReader([]byte("{}"))) - if err != nil { - fatal("auth state failed: %v", err) - } - var st struct { - State string `json:"state"` - AuthURL string `json:"authUrl"` - } - if err := json.Unmarshal(data, &st); err != nil || st.State == "" || st.AuthURL == "" { - fatal("auth state: missing state or authUrl") - } - raw, _ := json.Marshal(loginState{State: st.State, Realm: realm}) - if err := os.WriteFile(statePath, raw, 0o600); err != nil { - fatal("write state: %v", err) - } - fmt.Fprintln(out, st.AuthURL) -} - -// runPoll 执行 poll 子命令:读 state 文件(realm 校验),向 upstreamBase 的 token 端点 -// GET 一次,成功再 GET login/account(带 Bearer),stdout 打印完整 token+account JSON。 -// statePath 可注入临时文件便于测试。 -func runPoll(base, origin, realm, statePath string, client *http.Client, out io.Writer) { - raw, err := os.ReadFile(statePath) - if err != nil { - fatal("read state: %v (先跑 login url)", err) - } - var ls loginState - if err := json.Unmarshal(raw, &ls); err != nil { - fatal("parse state: %v", err) - } - // 防混域:state 落盘 realm 与命令行 --realm 不一致则拒绝(url 与 poll 必须同域) - if err := validateRealmMatch(ls.Realm, realm); err != nil { - fatal("%v", err) - } - headers := commonHeaders(origin) - // handlePollLogin (oauth.go:108-162):auth/token 是权威登录状态端点, - // pending 时业务 code 非 0("login ing"),完成时 code=0 + token bundle - tokRaw, status, errTok := doJSON(client, http.MethodGet, base+"/v2/plugin/auth/token?state="+ls.State, headers, nil) - if errTok != nil { - if status == 0 || status >= 500 { - fatal("token endpoint error: %v", errTok) - } - fatal("登录未完成(waiting for login)。请确认已在浏览器完成登录再按 y") - } - var tok struct { - AccessToken string `json:"accessToken"` - RefreshToken string `json:"refreshToken"` - ExpiresIn int64 `json:"expiresIn"` - Domain string `json:"domain"` - } - if err := json.Unmarshal(tokRaw, &tok); err != nil || tok.AccessToken == "" { - fatal("登录未完成(waiting for login)。请确认已在浏览器完成登录再按 y") - } - // login/account 拿 uid/nickname(带 Bearer) - var acct struct { - UID string `json:"uid"` - EnterpriseID string `json:"enterpriseId"` - Nickname string `json:"nickname"` - } - acctHeaders := func(r *http.Request) { - headers(r) - r.Header.Set("Authorization", "Bearer "+tok.AccessToken) - } - if acctRaw, _, errAcct := doJSON(client, http.MethodGet, base+"/v2/plugin/login/account?state="+ls.State, acctHeaders, nil); errAcct == nil { - _ = json.Unmarshal(acctRaw, &acct) - } - oraw, _ := json.Marshal(buildLoginOutput(tok, realm, acct)) - fmt.Fprintln(out, string(oraw)) - os.Remove(statePath) -} - -// buildLoginOutput 组装 poll 输出的完整 JSON(login.sh 据此落盘 auth 文件)。 -// realm 永不空:显式 --realm 优先(ResolveRealm 处理),否则按上游返回的 domain 推断—— -// 保证登录落盘的 auth 文件恒带 realm 键。 -func buildLoginOutput(tok struct { - AccessToken string `json:"accessToken"` - RefreshToken string `json:"refreshToken"` - ExpiresIn int64 `json:"expiresIn"` - Domain string `json:"domain"` -}, realm string, acct struct { - UID string `json:"uid"` - EnterpriseID string `json:"enterpriseId"` - Nickname string `json:"nickname"` -}) map[string]any { - return map[string]any{ - "access_token": tok.AccessToken, - "refresh_token": tok.RefreshToken, - "expires_in": tok.ExpiresIn, - "domain": tok.Domain, - "realm": auth2.ResolveRealm(realm, tok.Domain), - "uid": acct.UID, - "enterprise_id": acct.EnterpriseID, - "nickname": acct.Nickname, - } -} - -func main() { - realm, rest, err := parseRealmArgs(os.Args[1:]) - if err != nil { - fatal("%v (usage: login [--realm=cn|global] )", err) - } - if len(rest) < 1 { - fatal("usage: login [--realm=cn|global] ") - } - // 每个流程独立 cookie jar(oauth.go:22-29:多账号登录互不串会话) - jar, _ := cookiejar.New(nil) - client := &http.Client{Timeout: 30 * time.Second, Jar: jar} - - base, origin := realmConfig(realm) - - switch rest[0] { - case "url": - runURL(base, origin, realm, stateFile, client, os.Stdout) - - case "poll": - runPoll(base, origin, realm, stateFile, client, os.Stdout) - - case "realm": - // 交互式选域(login.sh 无 --realm 传参且 stdin 为 tty 时调用)。 - // 提示打到 stderr,stdout 只输出归一化 realm,供 $( ) 捕获。 - realm := promptRealm(os.Stdin, os.Stderr) - fmt.Println(realm) - - default: - fatal("unknown subcommand %q (want url|poll|realm)", rest[0]) - } -} +// login.go — WorkBuddy OAuth 登录(设备授权流程,CN realm;--realm=global 供国际版)。 +// +// 两个子命令,由 login.sh 顺序驱动: +// +// login [--realm=cn|global] url → POST /v2/plugin/auth/state?platform=<站点 Platform> 拿 state+authUrl, +// state 落 /tmp/wb2api-login-state.json,stdout 打印授权 URL +// login [--realm=cn|global] poll → 读 state,GET /v2/plugin/auth/token?state= 一次, +// 成功再 GET /v2/plugin/login/account?state= 拿 uid/nickname, +// stdout 打印完整 token+account JSON(含 realm 键) +// +// --realm 默认 cn。按 realm 切换上游端点与 Origin/Referer: +// +// cn → https://copilot.tencent.com(Origin: https://www.codebuddy.cn) +// global → https://www.workbuddy.ai(Origin: https://www.workbuddy.ai) +// +// state 落盘带 realm,poll 读回校验与命令行 --realm 一致(防混域)。 +// 无 PKCE(workbuddy 设备流由服务端签发 state)。 +package main + +import ( + "bufio" + "bytes" + "encoding/json" + "errors" + "fmt" + "io" + "net/http" + "net/http/cookiejar" + "os" + "path/filepath" + "strings" + "time" + + auth2 "github.com/misakano7545/workbuddy2api-panel/internal/auth" + "github.com/misakano7545/workbuddy2api-panel/internal/loginsite" +) + +// 上游常量:站点表与 UA 统一来自 internal/loginsite(官方口径唯一来源)。 +// CN → copilot.tencent.com;国际站两套主机名并存: +// intl → www.codebuddy.ai(官方 CLI externalDomain)、workbuddy → www.workbuddy.ai +// (旧桌面端)。UA 按站点取(loginsite.Site.UserAgent),不再有全局 CLI 串。 +// +// 登录 state 落盘路径(var 便于测试替换临时文件) +// Portable across OSes: the upstream hardcoded "/tmp/...", which on +// Windows resolves to : mp\... and aborts the OAuth flow with +// "The system cannot find the path specified". os.TempDir() is /tmp on Linux. +var stateFile = filepath.Join(os.TempDir(), "wb2api-login-state.json") + +// exitFunc 供测试替换(默认 os.Exit;测试持临时替换为 panic 以进程内捕获 fatal)。 +var exitFunc = os.Exit + +// realmConfig 按 realm 返回上游 base 与 Origin/Referer origin(兼容旧调用): +// global → 旧桌面端 workbuddy.ai;cn/非法/缺省 → copilot.tencent.com + codebuddy.cn。 +// 新代码请直接用 loginsite.Site(要官方国际站用 SiteIntl)。 +func realmConfig(realm string) (base, origin string) { + s := loginsite.ForRealm(realm) + return s.API, s.Origin +} + +// commonHeaders 设备码端点的公共头族,直接取站点定义的真机头族 +// (loginsite.Site.EndpointHeaders)。返回 func(*http.Request),由调用方按站点 +// 构造一次后复用。 +// +// 不再发 Origin / Referer / X-Requested-With:2026-10-30 双版本真机抓包显示这三条 +// 端点由桌面端 node fetch 发出,恒无这三个头;浏览器的同源语义只属于「打开授权页」 +// 那一步,不属于 API 调用。UA 也换成桌面端 RPC 族,不再是 CodeBuddy CLI 家族串。 +// +// 端点差异头(x-device-token / x-no-* / Bearer)由 withExtra 叠加。 +func commonHeaders(site loginsite.Site) func(*http.Request) { + hdrs := site.EndpointHeaders() + return func(req *http.Request) { + for k, v := range hdrs { + if v != "" { + req.Header.Set(k, v) + } + } + } +} + +// withExtra 在基础头函数之上叠加端点差异头(空值跳过)。 +func withExtra(base func(*http.Request), extra map[string]string) func(*http.Request) { + return func(req *http.Request) { + base(req) + for k, v := range extra { + if v != "" { + req.Header.Set(k, v) + } + } + } +} + +// apiEnvelope 与 main.go:429-433 一致 +type apiEnvelope struct { + Code int `json:"code"` + Msg string `json:"msg"` + Data json.RawMessage `json:"data"` +} + +// envelopeError 上游业务码非 0 的结构化错误:调用方按官方码表区分 +// 「继续轮询」(11217/12151)与「终态失败」(12005/11212/11216)。 +type envelopeError struct { + Code int + Msg string + Status int +} + +func (e *envelopeError) Error() string { + return fmt.Sprintf("code=%d msg=%s", e.Code, e.Msg) +} + +// doJSON 与 oauth.go:33-66 一致:{code,msg,data} 信封,code!=0 → error +func doJSON(client *http.Client, method, fullURL string, headers func(*http.Request), body io.Reader) (json.RawMessage, int, error) { + req, err := http.NewRequest(method, fullURL, body) + if err != nil { + return nil, 0, err + } + if headers != nil { + headers(req) + } else { + // 缺省头:国内站(与原 commonHeaders() 行为一致,零回归) + commonHeaders(loginsite.For(""))(req) + } + resp, err := client.Do(req) + if err != nil { + return nil, 0, err + } + defer resp.Body.Close() + raw, _ := io.ReadAll(resp.Body) + if resp.StatusCode >= 400 { + return nil, resp.StatusCode, fmt.Errorf("http_error: upstream %d", resp.StatusCode) + } + if resp.StatusCode >= 300 { + return nil, resp.StatusCode, fmt.Errorf("http_error: upstream redirect %d", resp.StatusCode) + } + var env apiEnvelope + if err := json.Unmarshal(raw, &env); err != nil { + return nil, resp.StatusCode, fmt.Errorf("parse failed: %w", err) + } + if env.Code != 0 { + // 结构化:调用方按官方码表区分 pending / 终态。 + return nil, resp.StatusCode, &envelopeError{Code: env.Code, Msg: env.Msg, Status: resp.StatusCode} + } + return env.Data, resp.StatusCode, nil +} + +func fatal(format string, args ...any) { + fmt.Fprintf(os.Stderr, "login: "+format+"\n", args...) + exitFunc(1) +} + +type loginState struct { + State string `json:"state"` + Realm string `json:"realm,omitempty"` // url 落盘时写回的 realm,poll 读回校验防混域 + Site string `json:"site,omitempty"` // 站点标识(cn/intl/workbuddy),poll 读回校验防换站 +} + +// realm 取值枚举(与 internal/auth 的 Realm() 归一化输出一致)。 +const ( + realmCN = "cn" + realmGlobal = "global" +) + +// parseRealmArgs 解析开头的 --realm=cn|global(或分离式 --realm )flag,缺省 cn。 +// 大小写不敏感归一化;非法值/缺值报错。桌椅剩余参数(子命令)顺序不变。 +func parseRealmArgs(args []string) (realm string, rest []string, err error) { + realm = realmCN + for i := 0; i < len(args); i++ { + a := args[i] + switch { + case a == "--realm": + if i+1 >= len(args) { + return "", nil, fmt.Errorf("--realm requires a value") + } + v := strings.ToLower(strings.TrimSpace(args[i+1])) + if v != realmCN && v != realmGlobal { + return "", nil, fmt.Errorf("invalid --realm %q (want cn|global)", args[i+1]) + } + realm = v + i++ + case strings.HasPrefix(a, "--realm="): + v := strings.ToLower(strings.TrimSpace(strings.TrimPrefix(a, "--realm="))) + if v != realmCN && v != realmGlobal { + return "", nil, fmt.Errorf("invalid --realm %q (want cn|global)", v) + } + realm = v + default: + rest = append(rest, a) + } + } + return realm, rest, nil +} + +// resolveRealmInput 把交互式选域的一行输入归一化为 realm(纯函数,login.sh 交互分支 +// 的核心决策,可测)。规则: +// +// "1"/"cn"(大小写不敏感)/""(回车默认)→ cn +// "2"/"global" → global +// 其他 → ("", false)(调用方回默认 cn) +func resolveRealmInput(input string) (string, bool) { + switch strings.ToLower(strings.TrimSpace(input)) { + case "", "1", "cn": + return realmCN, true + case "2", "global": + return realmGlobal, true + } + return "", false +} + +// parseSiteArgs 解析 --site=cn|intl|workbuddy(官方域表),并把剩余参数里的 +// --realm 一并消化:显式 --site 优先;否则按 --realm 映射(cn → 国内站, +// global → 旧桌面端 workbuddy.ai,保持老脚本语义)。 +func parseSiteArgs(args []string) (site loginsite.Site, rest []string, err error) { + var siteID string + var kept []string + for i := 0; i < len(args); i++ { + a := args[i] + switch { + case a == "--site": + if i+1 >= len(args) { + return loginsite.Site{}, nil, fmt.Errorf("--site requires a value") + } + siteID = args[i+1] + i++ + case strings.HasPrefix(a, "--site="): + siteID = strings.TrimPrefix(a, "--site=") + default: + kept = append(kept, a) + } + } + if siteID != "" { + id := strings.ToLower(strings.TrimSpace(siteID)) + if !loginsite.ValidID(id) { + return loginsite.Site{}, nil, fmt.Errorf("invalid --site %q (want cn|intl|workbuddy)", siteID) + } + // 仍消化 --realm(老脚本会同时传),但以 --site 为准。 + _, kept, err = parseRealmArgs(kept) + if err != nil { + return loginsite.Site{}, nil, err + } + return loginsite.For(id), kept, nil + } + realm, kept, err := parseRealmArgs(kept) + if err != nil { + return loginsite.Site{}, nil, err + } + return loginsite.ForRealm(realm), kept, nil +} + +// promptRealm 交互式选域:向 out 打印选项提示(out 接 stderr,stdout 留给 realm 本身), +// 从 in 读一行,返回归一化 realm。非法输入警告后回落 cn;EOF(非交互/管道)回落 cn。 +func promptRealm(in io.Reader, out io.Writer) string { + fmt.Fprintln(out, "选择登录版本: 1) 国内版(cn) 2) 国际版(global) [默认 1/cn]: ") + line, err := bufio.NewReader(in).ReadString('\n') + if err != nil && line == "" { + // EOF/非交互 → 回落默认 cn + return realmCN + } + if realm, ok := resolveRealmInput(line); ok { + return realm + } + fmt.Fprintln(out, "无效选择,默认国内版 cn") + return realmCN +} + +// validateRealmMatch 校验 state 文件 realm 与命令行 --realm 一致(防混域): +// state 无 realm(旧文件)放行;非空且不一致 → error。 +func validateRealmMatch(stateRealm, cliRealm string) error { + if stateRealm != "" && stateRealm != cliRealm { + return fmt.Errorf("realm mismatch: state file realm=%q, command --realm=%q(url 与 poll 需同一 realm)", stateRealm, cliRealm) + } + return nil +} + +// runURL 执行 url 子命令:向站点的 state 端点 POST 取授权 URL,state 落盘 +// (带 realm+site),stdout 打印 authURL(已按官方补齐 version / ww_device_nonce)。 +// out 接 stdout;statePath 为落盘路径(可注入临时文件便于测试)。 +func runURL(site loginsite.Site, statePath string, client *http.Client, out io.Writer) { + stateURL, _, _, _ := site.Endpoints() + // auth/state 真机带 x-device-token(取到才发)+ x-custom-channel-id + 四个 x-no-*。 + headers := withExtra(commonHeaders(site), site.HeadersForState(loginDeviceToken())) + data, _, err := doJSON(client, http.MethodPost, stateURL, headers, bytes.NewReader([]byte("{}"))) + if err != nil { + fatal("auth state failed: %v", err) + } + var st struct { + State string `json:"state"` + AuthURL string `json:"authUrl"` + } + if err := json.Unmarshal(data, &st); err != nil || st.State == "" || st.AuthURL == "" { + fatal("auth state: missing state or authUrl") + } + raw, _ := json.Marshal(loginState{State: st.State, Realm: site.Realm, Site: site.ID}) + if err := os.WriteFile(statePath, raw, 0o600); err != nil { + fatal("write state: %v", err) + } + fmt.Fprintln(out, loginsite.DecorateAuthURL(st.AuthURL, site, loginDeviceNonce(), loginsite.NewLoginSessionID())) +} + +// loginDeviceNonce 官方 ww_device_nonce 的来源(桌面端 Turing 设备 SDK)。本仓无 +// SDK,取部署侧环境变量;空 = 不加该参数(不伪造设备指纹)。 +func loginDeviceNonce() string { + return strings.TrimSpace(os.Getenv("CODEBUDDY_LOGIN_DEVICE_NONCE")) +} + +// loginDeviceToken 设备风控 token(X-Device-Token,auth/state 出站头)。 +// +// 真机为 `v3:`,由桌面端 qimei 组件本地生成,无法从 machineId 推导。 +// 取不到就返回空串(调用方据此不发该头)——伪造比缺失更容易被判成非客户端。 +// 来源:CODEBUDDY_LOGIN_DEVICE_TOKEN 环境变量,或 CODEBUDDY_LOGIN_DEVICE_TOKEN_FILE。 +func loginDeviceToken() string { + if v := strings.TrimSpace(os.Getenv("CODEBUDDY_LOGIN_DEVICE_TOKEN")); v != "" { + return v + } + if p := strings.TrimSpace(os.Getenv("CODEBUDDY_LOGIN_DEVICE_TOKEN_FILE")); p != "" { + if b, err := os.ReadFile(p); err == nil { + return strings.TrimSpace(string(b)) + } + } + return "" +} + +// runPoll 执行 poll 子命令:读 state 文件(realm/site 校验),向站点 token 端点 +// GET 一次,成功再 GET login/account(带 Bearer),stdout 打印完整 token+account JSON。 +// +// 官方码表语义:11217(RetryFetchToken)/ 12151(RetryFetchAccount)是 pending, +// 12005/11212/11216 是终态许可错误——后者必须直接报错退出,否则 login.sh 的 +// 「登录还没完成就按了 y」提示会把「席位满 / 许可证过期」误导成操作问题。 +func runPoll(site loginsite.Site, statePath string, client *http.Client, out io.Writer) { + raw, err := os.ReadFile(statePath) + if err != nil { + fatal("read state: %v (先跑 login url)", err) + } + var ls loginState + if err := json.Unmarshal(raw, &ls); err != nil { + fatal("parse state: %v", err) + } + // 防混域/换站:state 落盘标识与本次站点不一致则拒绝(url 与 poll 必须同站)。 + if err := validateRealmMatch(ls.Realm, site.Realm); err != nil { + fatal("%v", err) + } + if ls.Site != "" && ls.Site != site.ID { + fatal("site mismatch: state file site=%q, command site=%q(url 与 poll 需同一站点)", ls.Site, site.ID) + } + // auth/token 真机是唯一不带 x-domain 的端点(只有公共头 + 四个 x-no-*)。 + tokenH := withExtra(commonHeaders(site), site.HeadersForToken()) + // handlePollLogin (oauth.go:108-162):auth/token 是权威登录状态端点, + // pending 时业务码 11217,完成时 code=0 + token bundle + tokRaw, status, errTok := doJSON(client, http.MethodGet, site.API+"/v2/plugin/auth/token?state="+ls.State, tokenH, nil) + if errTok != nil { + var envErr *envelopeError + if errors.As(errTok, &envErr) { + if loginsite.CodeFatal(envErr.Code) { + fatal("登录被上游拒绝(code=%d):%s", envErr.Code, envErr.Msg) + } + if loginsite.CodePending(envErr.Code) { + fatal("登录未完成(waiting for login)。请确认已在浏览器完成登录再按 y") + } + } + if status == 0 || status >= 500 { + fatal("token endpoint error: %v", errTok) + } + // 走到这里的是「非信封 4xx」(HTML 错误页等):state 多半已过期/失效, + // 反复「确认浏览器登录 + 按 y」永远不会再成功——正确动作是重跑 login url, + // 不能与「还没登录完」共用同一句提示。 + fatal("登录状态查询被拒(HTTP %d):%v\nstate 可能已过期,请重新运行 login url", status, errTok) + } + var tok struct { + AccessToken string `json:"accessToken"` + RefreshToken string `json:"refreshToken"` + ExpiresIn int64 `json:"expiresIn"` + Domain string `json:"domain"` + } + if err := json.Unmarshal(tokRaw, &tok); err != nil || tok.AccessToken == "" { + fatal("登录未完成(waiting for login)。请确认已在浏览器完成登录再按 y") + } + // login/account 拿 uid/nickname(带 Bearer)。12151 是「token 已发、账号信息还在 + // 落库」的 pending 态,提示重试而不是当成失败。 + var acct struct { + UID string `json:"uid"` + EnterpriseID string `json:"enterpriseId"` + Nickname string `json:"nickname"` + } + // login/account 真机带 x-domain + Bearer + 三个 x-no-*(无 x-no-authorization)。 + acctHeaders := withExtra(commonHeaders(site), site.HeadersForAccount(tok.AccessToken)) + acctRaw, _, errAcct := doJSON(client, http.MethodGet, site.API+"/v2/plugin/login/account?state="+ls.State, acctHeaders, nil) + if errAcct == nil { + _ = json.Unmarshal(acctRaw, &acct) + } else { + var envErr *envelopeError + if errors.As(errAcct, &envErr) { + if loginsite.CodeFatal(envErr.Code) { + fatal("登录被上游拒绝(code=%d):%s", envErr.Code, envErr.Msg) + } + if loginsite.CodePending(envErr.Code) { + fatal("账号信息尚未就绪(code=%d)。请稍等几秒再按 y 重试", envErr.Code) + } + } + } + raw, _ = json.Marshal(buildLoginOutput(tok, site.Realm, acct)) + fmt.Fprintln(out, string(raw)) + os.Remove(statePath) +} + +// buildLoginOutput 组装 poll 输出的完整 JSON(login.sh 据此落盘 auth 文件)。 +// realm 永不空:显式 --realm 优先(ResolveRealm 处理),否则按上游返回的 domain 推断—— +// 保证登录落盘的 auth 文件恒带 realm 键。 +func buildLoginOutput(tok struct { + AccessToken string `json:"accessToken"` + RefreshToken string `json:"refreshToken"` + ExpiresIn int64 `json:"expiresIn"` + Domain string `json:"domain"` +}, realm string, acct struct { + UID string `json:"uid"` + EnterpriseID string `json:"enterpriseId"` + Nickname string `json:"nickname"` +}) map[string]any { + return map[string]any{ + "access_token": tok.AccessToken, + "refresh_token": tok.RefreshToken, + "expires_in": tok.ExpiresIn, + "domain": tok.Domain, + "realm": auth2.ResolveRealm(realm, tok.Domain), + "uid": acct.UID, + "enterprise_id": acct.EnterpriseID, + "nickname": acct.Nickname, + } +} + +func main() { + site, rest, err := parseSiteArgs(os.Args[1:]) + if err != nil { + fatal("%v (usage: login [--site=cn|intl|workbuddy] [--realm=cn|global] )", err) + } + if len(rest) < 1 { + fatal("usage: login [--site=cn|intl|workbuddy] [--realm=cn|global] ") + } + // 每个流程独立 cookie jar(oauth.go:22-29:多账号登录互不串会话) + jar, _ := cookiejar.New(nil) + client := &http.Client{Timeout: 30 * time.Second, Jar: jar} + + switch rest[0] { + case "url": + runURL(site, stateFile, client, os.Stdout) + + case "poll": + runPoll(site, stateFile, client, os.Stdout) + + case "realm": + // 交互式选域(login.sh 无 --realm 传参且 stdin 为 tty 时调用)。 + // 提示打到 stderr,stdout 只输出归一化 realm,供 $( ) 捕获。 + realm := promptRealm(os.Stdin, os.Stderr) + fmt.Println(realm) + + case "site": + // 输出归一化站点标识(cn/intl/workbuddy),供脚本 $( ) 捕获。 + fmt.Println(site.ID) + + default: + fatal("unknown subcommand %q (want url|poll|realm|site)", rest[0]) + } +} diff --git a/cmd/login/realm_test.go b/cmd/login/realm_test.go index faadc00199b84de74175c8d657f76b636f8ae42a..b76236e405749dd9f4b2eaa3ed2a91546841b8ad 100644 --- a/cmd/login/realm_test.go +++ b/cmd/login/realm_test.go @@ -1,169 +1,341 @@ -package main - -import ( - "bytes" - "reflect" - "strings" - "testing" -) - -// TestParseRealmArgs 覆盖 --realm 参数解析:缺省 cn、等号/分离式写法、 -// 非法值/缺值报错、大小写归一、剥离 flag 后剩余参数保持相对顺序。 -func TestParseRealmArgs(t *testing.T) { - cases := []struct { - name string - args []string - wantRealm string - wantRest []string - wantErr bool - }{ - {name: "缺省 cn", args: []string{"url"}, wantRealm: "cn", wantRest: []string{"url"}}, - {name: "等号 global 在前", args: []string{"--realm=global", "url"}, wantRealm: "global", wantRest: []string{"url"}}, - {name: "等号 cn 在后", args: []string{"poll", "--realm=cn"}, wantRealm: "cn", wantRest: []string{"poll"}}, - {name: "分离式 global", args: []string{"--realm", "global", "url"}, wantRealm: "global", wantRest: []string{"url"}}, - {name: "非法值报错", args: []string{"--realm=foo", "url"}, wantErr: true}, - {name: "分离式缺值报错", args: []string{"--realm", "url"}, wantErr: true}, - {name: "大小写归一", args: []string{"--realm=GLOBAL", "url"}, wantRealm: "global", wantRest: []string{"url"}}, - } - for _, c := range cases { - t.Run(c.name, func(t *testing.T) { - realm, rest, err := parseRealmArgs(c.args) - if c.wantErr { - if err == nil { - t.Fatalf("parseRealmArgs(%v) err=nil, want error", c.args) - } - return - } - if err != nil { - t.Fatalf("parseRealmArgs(%v) err=%v", c.args, err) - } - if realm != c.wantRealm { - t.Errorf("realm=%q want %q", realm, c.wantRealm) - } - if !reflect.DeepEqual(rest, c.wantRest) { - t.Errorf("rest=%v want %v", rest, c.wantRest) - } - }) - } -} - -// TestResolveRealmInput 覆盖交互式选域的输入→realm 映射(login.sh 交互分支的核心决策): -// "1"/"cn"/""(回车默认)→ cn;"2"/"global" → global;大小写不敏感;非法 → ("",false)。 -func TestResolveRealmInput(t *testing.T) { - cases := []struct { - input string - want string - }{ - {input: "1", want: "cn"}, - {input: "cn", want: "cn"}, - {input: "CN", want: "cn"}, - {input: "", want: "cn"}, // 回车默认 - {input: "2", want: "global"}, - {input: "global", want: "global"}, - {input: "GLOBAL", want: "global"}, - } - for _, c := range cases { - got, ok := resolveRealmInput(c.input) - if !ok { - t.Errorf("resolveRealmInput(%q) ok=false want true", c.input) - continue - } - if got != c.want { - t.Errorf("resolveRealmInput(%q)=%q want %q", c.input, got, c.want) - } - } - // 非法输入 → (false)。 - for _, bad := range []string{"3", "cnn", "globalx", "foo"} { - if got, ok := resolveRealmInput(bad); ok { - t.Errorf("resolveRealmInput(%q)=(%q,true) want (_,false)", bad, got) - } - } -} - -// TestPromptRealm 覆盖 promptRealm 的 I/O 行为(out 将接 os.Stderr,stdout 只出 realm): -// -// 1 / 2 / 回车默认 → 分别输出来 cn / global / cn;均打印"选择登录版本"提示; -// 非法输入 → 警告并回落 cn;EOF(非交互直接管道)→ 回落 cn。 -func TestPromptRealm(t *testing.T) { - cases := []struct { - name string - input string - want string - wantHint bool // 输出中出现"选择登录版本"提示 - }{ - {name: "选 cn", input: "1\n", want: "cn", wantHint: true}, - {name: "选 global", input: "2\n", want: "global", wantHint: true}, - {name: "回车默认 cn", input: "\n", want: "cn", wantHint: true}, - {name: "非法回落 cn", input: "foo\n", want: "cn", wantHint: true}, - {name: "EOF 回落 cn", input: "", want: "cn", wantHint: true}, - } - for _, c := range cases { - t.Run(c.name, func(t *testing.T) { - var out bytes.Buffer - got := promptRealm(strings.NewReader(c.input), &out) - if got != c.want { - t.Errorf("promptRealm(%q)=%q want %q", c.input, got, c.want) - } - if c.wantHint && !strings.Contains(out.String(), "选择登录版本") { - t.Errorf("prompt should contain '选择登录版本', got %q", out.String()) - } - }) - } -} - -// TestRealmSubcommandSelection 通过命令形式验证 realm 子命令(login.sh 交互分支调用): -// 子命令剥离 --realm,剩余参数为首个 "realm"。 -func TestRealmSubcommandSelection(t *testing.T) { - realm, rest, err := parseRealmArgs([]string{"realm"}) - if err != nil { - t.Fatalf("parseRealmArgs(realm) err=%v", err) - } - if realm != "cn" { - t.Errorf("realm default=%q want cn", realm) - } - if len(rest) != 1 || rest[0] != "realm" { - t.Errorf("rest=%v want [realm]", rest) - } -} - -// TestBuildLoginOutputRealmAlwaysSet 登录产物(login.sh 据此落盘 auth 文件)恒含 realm 键: -// 显式 --realm 优先,缺省时按 domain 推断(echo 出的 global 账号即便未显式指定也带 global)。 -// 这是「登录落盘永远带 realm 标识」契约的测试载体。 -func TestBuildLoginOutputRealmAlwaysSet(t *testing.T) { - tok := struct { - AccessToken string `json:"accessToken"` - RefreshToken string `json:"refreshToken"` - ExpiresIn int64 `json:"expiresIn"` - Domain string `json:"domain"` - }{AccessToken: "at", RefreshToken: "rt", ExpiresIn: 3600, Domain: "www.codebuddy.cn"} - acct := struct { - UID string `json:"uid"` - EnterpriseID string `json:"enterpriseId"` - Nickname string `json:"nickname"` - }{UID: "u1", Nickname: "n1"} - - cases := []struct { - name string - realm string - domain string - wantRealm string - }{ - {name: "显式 global 优先", realm: "global", domain: "www.codebuddy.cn", wantRealm: "global"}, - {name: "显式 cn 优先", realm: "cn", domain: "www.workbuddy.ai", wantRealm: "cn"}, - {name: "缺省按 domain 推断 global", realm: "", domain: "www.workbuddy.ai", wantRealm: "global"}, - {name: "缺省空 domain 回落 cn", realm: "", domain: "", wantRealm: "cn"}, - } - for _, c := range cases { - t.Run(c.name, func(t *testing.T) { - tok.Domain = c.domain - out := buildLoginOutput(tok, c.realm, acct) - m, ok := out["realm"].(string) - if !ok { - t.Fatalf("missing realm key in login output: %v", out) - } - if m != c.wantRealm { - t.Errorf("realm=%q want %q", m, c.wantRealm) - } - }) - } -} +package main + +import ( + "bytes" + "encoding/json" + "fmt" + "io" + "net/http" + "net/http/httptest" + "net/url" + "os" + "path/filepath" + "reflect" + "strings" + "testing" + + "github.com/misakano7545/workbuddy2api-panel/internal/loginsite" +) + +// TestParseRealmArgs 覆盖 --realm 参数解析:缺省 cn、等号/分离式写法、 +// 非法值/缺值报错、大小写归一、剥离 flag 后剩余参数保持相对顺序。 +func TestParseRealmArgs(t *testing.T) { + cases := []struct { + name string + args []string + wantRealm string + wantRest []string + wantErr bool + }{ + {name: "缺省 cn", args: []string{"url"}, wantRealm: "cn", wantRest: []string{"url"}}, + {name: "等号 global 在前", args: []string{"--realm=global", "url"}, wantRealm: "global", wantRest: []string{"url"}}, + {name: "等号 cn 在后", args: []string{"poll", "--realm=cn"}, wantRealm: "cn", wantRest: []string{"poll"}}, + {name: "分离式 global", args: []string{"--realm", "global", "url"}, wantRealm: "global", wantRest: []string{"url"}}, + {name: "非法值报错", args: []string{"--realm=foo", "url"}, wantErr: true}, + {name: "分离式缺值报错", args: []string{"--realm", "url"}, wantErr: true}, + {name: "大小写归一", args: []string{"--realm=GLOBAL", "url"}, wantRealm: "global", wantRest: []string{"url"}}, + } + for _, c := range cases { + t.Run(c.name, func(t *testing.T) { + realm, rest, err := parseRealmArgs(c.args) + if c.wantErr { + if err == nil { + t.Fatalf("parseRealmArgs(%v) err=nil, want error", c.args) + } + return + } + if err != nil { + t.Fatalf("parseRealmArgs(%v) err=%v", c.args, err) + } + if realm != c.wantRealm { + t.Errorf("realm=%q want %q", realm, c.wantRealm) + } + if !reflect.DeepEqual(rest, c.wantRest) { + t.Errorf("rest=%v want %v", rest, c.wantRest) + } + }) + } +} + +// TestParseSiteArgs 覆盖 --site 解析:显式 --site 优先于 --realm,未知值报错, +// 缺省/无参回落国内站;同时确认 --site/--realm 都被剥离,子命令留在 rest。 +func TestParseSiteArgs(t *testing.T) { + cases := []struct { + name string + args []string + wantID string + wantRest []string + wantErr bool + }{ + {name: "缺省 cn", args: []string{"url"}, wantID: "cn", wantRest: []string{"url"}}, + {name: "site=intl", args: []string{"--site=intl", "url"}, wantID: "intl", wantRest: []string{"url"}}, + {name: "site=workbuddy 分离式", args: []string{"--site", "workbuddy", "poll"}, wantID: "workbuddy", wantRest: []string{"poll"}}, + {name: "site 大小写归一", args: []string{"--site=INTL", "url"}, wantID: "intl", wantRest: []string{"url"}}, + // --site 优先:老脚本同时传两个也不冲突。 + {name: "site 优先于 realm", args: []string{"--site=intl", "--realm=cn", "url"}, wantID: "intl", wantRest: []string{"url"}}, + // 只传 realm 时保持历史语义(global → workbuddy 旧桌面端)。 + {name: "realm=global 映射旧桌面端", args: []string{"--realm=global", "url"}, wantID: "workbuddy", wantRest: []string{"url"}}, + {name: "realm=cn", args: []string{"--realm=cn", "url"}, wantID: "cn", wantRest: []string{"url"}}, + {name: "未知 site 报错", args: []string{"--site=global", "url"}, wantErr: true}, + {name: "site 缺值报错", args: []string{"--site"}, wantErr: true}, + } + for _, c := range cases { + t.Run(c.name, func(t *testing.T) { + site, rest, err := parseSiteArgs(c.args) + if c.wantErr { + if err == nil { + t.Fatalf("parseSiteArgs(%v) err=nil, want error", c.args) + } + return + } + if err != nil { + t.Fatalf("parseSiteArgs(%v) err=%v", c.args, err) + } + if site.ID != c.wantID { + t.Errorf("site.ID=%q want %q", site.ID, c.wantID) + } + if !reflect.DeepEqual(rest, c.wantRest) { + t.Errorf("rest=%v want %v", rest, c.wantRest) + } + }) + } +} + +// TestRunURLDecoratesAuthURL 覆盖 url 子命令的输出:授权链接必须带官方 version +// 参数(对齐 CLI appendAuthUrlParams),且 state 落盘带 realm+site 供 poll 校验。 +func TestRunURLDecoratesAuthURL(t *testing.T) { + dir := t.TempDir() + statePath := filepath.Join(dir, "state.json") + + srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { + if !strings.HasSuffix(r.URL.Path, "/v2/plugin/auth/state") { + t.Errorf("unexpected path %s", r.URL.Path) + } + if got := r.URL.Query().Get("platform"); got != "workbuddy-ai" { + t.Errorf("platform=%q want workbuddy-ai(intl 站点真机口径)", got) + } + // 授权 URL 用测试服务器自身地址,便于断言参数。 + base := "http://" + r.Host + w.Header().Set("Content-Type", "application/json") + fmt.Fprintf(w, `{"code":0,"msg":"OK","data":{"state":"st-1","authUrl":"%s/login?platform=CLI&state=st-1"}}`, base) + })) + defer srv.Close() + + // 用自定义站点指向测试服务器(真实站点表不便打外网)。 + site := loginsite.For(loginsite.SiteIntl) + site.API = srv.URL + site.Origin = srv.URL + + var out bytes.Buffer + runURL(site, statePath, srv.Client(), &out) + + got := strings.TrimSpace(out.String()) + u, err := url.Parse(got) + if err != nil { + t.Fatalf("解析授权 URL 失败 %q: %v", got, err) + } + // 授权 URL 不再补 version(授权页 bundle 只读 platform/fromSource)。 + if v := u.Query().Get("version"); v != "" { + t.Errorf("授权 URL 不该带 version:%q", got) + } + if s := u.Query().Get("state"); s != "st-1" { + t.Errorf("state=%q want st-1", s) + } + + raw, err := os.ReadFile(statePath) + if err != nil { + t.Fatalf("state 未落盘: %v", err) + } + var ls loginState + if err := json.Unmarshal(raw, &ls); err != nil { + t.Fatalf("state 解析失败: %v", err) + } + if ls.State != "st-1" || ls.Realm != "global" || ls.Site != "intl" { + t.Errorf("state={state:%s realm:%s site:%s} want {st-1 global intl}", ls.State, ls.Realm, ls.Site) + } +} + +// TestRunPollFatalCode 覆盖 poll 的终态码处理:上游返回 12005(席位满)时必须 +// 直接退出并给出上游 msg,而不是报「登录未完成」让用户反复重按 y。 +func TestRunPollFatalCode(t *testing.T) { + dir := t.TempDir() + statePath := filepath.Join(dir, "state.json") + if err := os.WriteFile(statePath, []byte(`{"state":"st-1","realm":"cn","site":"cn"}`), 0o600); err != nil { + t.Fatal(err) + } + + srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { + w.Header().Set("Content-Type", "application/json") + fmt.Fprint(w, `{"code":12005,"msg":"license seat limit reached"}`) + })) + defer srv.Close() + + site := loginsite.For(loginsite.SiteCN) + site.API = srv.URL + site.Origin = srv.URL + + // 捕获 fatal(exitFunc 换成 panic,与既有 realm_test 的用法一致)。 + var msg string + oldExit := exitFunc + exitFunc = func(code int) { panic("exit") } + defer func() { exitFunc = oldExit }() + // fatal 写 stderr,这里只看 panic 是否发生。 + func() { + defer func() { + if r := recover(); r != nil { + msg = "fatal" + } + }() + runPoll(site, statePath, srv.Client(), io.Discard) + }() + if msg != "fatal" { + t.Fatal("12005 应触发 fatal 退出,实际未退出(会被误当成「登录未完成」)") + } +} + +// TestRunPollSiteMismatch 覆盖防换站:state 文件记录的站点与本次 --site 不一致时 +// 必须拒绝(国际域两套主机名同后端,混用会把请求打到非签发域)。 +func TestRunPollSiteMismatch(t *testing.T) { + dir := t.TempDir() + statePath := filepath.Join(dir, "state.json") + if err := os.WriteFile(statePath, []byte(`{"state":"st-1","realm":"global","site":"workbuddy"}`), 0o600); err != nil { + t.Fatal(err) + } + oldExit := exitFunc + exitFunc = func(code int) { panic("exit") } + defer func() { exitFunc = oldExit }() + + var fatal bool + func() { + defer func() { + if r := recover(); r != nil { + fatal = true + } + }() + runPoll(loginsite.For(loginsite.SiteIntl), statePath, http.DefaultClient, io.Discard) + }() + if !fatal { + t.Fatal("site 不一致应拒绝,实际继续执行了") + } +} + +// TestResolveRealmInput 覆盖交互式选域的输入→realm 映射(login.sh 交互分支的核心决策): +// "1"/"cn"/""(回车默认)→ cn;"2"/"global" → global;大小写不敏感;非法 → ("",false)。 +func TestResolveRealmInput(t *testing.T) { + cases := []struct { + input string + want string + }{ + {input: "1", want: "cn"}, + {input: "cn", want: "cn"}, + {input: "CN", want: "cn"}, + {input: "", want: "cn"}, // 回车默认 + {input: "2", want: "global"}, + {input: "global", want: "global"}, + {input: "GLOBAL", want: "global"}, + } + for _, c := range cases { + got, ok := resolveRealmInput(c.input) + if !ok { + t.Errorf("resolveRealmInput(%q) ok=false want true", c.input) + continue + } + if got != c.want { + t.Errorf("resolveRealmInput(%q)=%q want %q", c.input, got, c.want) + } + } + // 非法输入 → (false)。 + for _, bad := range []string{"3", "cnn", "globalx", "foo"} { + if got, ok := resolveRealmInput(bad); ok { + t.Errorf("resolveRealmInput(%q)=(%q,true) want (_,false)", bad, got) + } + } +} + +// TestPromptRealm 覆盖 promptRealm 的 I/O 行为(out 将接 os.Stderr,stdout 只出 realm): +// +// 1 / 2 / 回车默认 → 分别输出来 cn / global / cn;均打印"选择登录版本"提示; +// 非法输入 → 警告并回落 cn;EOF(非交互直接管道)→ 回落 cn。 +func TestPromptRealm(t *testing.T) { + cases := []struct { + name string + input string + want string + wantHint bool // 输出中出现"选择登录版本"提示 + }{ + {name: "选 cn", input: "1\n", want: "cn", wantHint: true}, + {name: "选 global", input: "2\n", want: "global", wantHint: true}, + {name: "回车默认 cn", input: "\n", want: "cn", wantHint: true}, + {name: "非法回落 cn", input: "foo\n", want: "cn", wantHint: true}, + {name: "EOF 回落 cn", input: "", want: "cn", wantHint: true}, + } + for _, c := range cases { + t.Run(c.name, func(t *testing.T) { + var out bytes.Buffer + got := promptRealm(strings.NewReader(c.input), &out) + if got != c.want { + t.Errorf("promptRealm(%q)=%q want %q", c.input, got, c.want) + } + if c.wantHint && !strings.Contains(out.String(), "选择登录版本") { + t.Errorf("prompt should contain '选择登录版本', got %q", out.String()) + } + }) + } +} + +// TestRealmSubcommandSelection 通过命令形式验证 realm 子命令(login.sh 交互分支调用): +// 子命令剥离 --realm,剩余参数为首个 "realm"。 +func TestRealmSubcommandSelection(t *testing.T) { + realm, rest, err := parseRealmArgs([]string{"realm"}) + if err != nil { + t.Fatalf("parseRealmArgs(realm) err=%v", err) + } + if realm != "cn" { + t.Errorf("realm default=%q want cn", realm) + } + if len(rest) != 1 || rest[0] != "realm" { + t.Errorf("rest=%v want [realm]", rest) + } +} + +// TestBuildLoginOutputRealmAlwaysSet 登录产物(login.sh 据此落盘 auth 文件)恒含 realm 键: +// 显式 --realm 优先,缺省时按 domain 推断(echo 出的 global 账号即便未显式指定也带 global)。 +// 这是「登录落盘永远带 realm 标识」契约的测试载体。 +func TestBuildLoginOutputRealmAlwaysSet(t *testing.T) { + tok := struct { + AccessToken string `json:"accessToken"` + RefreshToken string `json:"refreshToken"` + ExpiresIn int64 `json:"expiresIn"` + Domain string `json:"domain"` + }{AccessToken: "at", RefreshToken: "rt", ExpiresIn: 3600, Domain: "www.codebuddy.cn"} + acct := struct { + UID string `json:"uid"` + EnterpriseID string `json:"enterpriseId"` + Nickname string `json:"nickname"` + }{UID: "u1", Nickname: "n1"} + + cases := []struct { + name string + realm string + domain string + wantRealm string + }{ + {name: "显式 global 优先", realm: "global", domain: "www.codebuddy.cn", wantRealm: "global"}, + {name: "显式 cn 优先", realm: "cn", domain: "www.workbuddy.ai", wantRealm: "cn"}, + {name: "缺省按 domain 推断 global", realm: "", domain: "www.workbuddy.ai", wantRealm: "global"}, + {name: "缺省空 domain 回落 cn", realm: "", domain: "", wantRealm: "cn"}, + } + for _, c := range cases { + t.Run(c.name, func(t *testing.T) { + tok.Domain = c.domain + out := buildLoginOutput(tok, c.realm, acct) + m, ok := out["realm"].(string) + if !ok { + t.Fatalf("missing realm key in login output: %v", out) + } + if m != c.wantRealm { + t.Errorf("realm=%q want %q", m, c.wantRealm) + } + }) + } +} diff --git a/cmd/server/banner_test.go b/cmd/server/banner_test.go new file mode 100644 index 0000000000000000000000000000000000000000..b7af87bb2e3ec37490a29cd6ebdefc772151356c --- /dev/null +++ b/cmd/server/banner_test.go @@ -0,0 +1,57 @@ +package main + +import ( + "strings" + "testing" +) + +// 掩码只留首尾各两位,短密钥/空密钥整条隐去——横幅是写进 journal 的,不能出明文。 +func TestMaskSecret(t *testing.T) { + const key = "gZb95oiQqT-A7VdssgI27FO" + cases := []struct{ in, want string }{ + {"", "(未设置)"}, + {"abc", "***"}, + {key, "gZ" + strings.Repeat("*", len(key)-4) + "FO"}, + {"密钥密钥密钥密钥密钥", "密钥" + strings.Repeat("*", 6) + "密钥"}, + } + for _, c := range cases { + if got := maskSecret(c.in); got != c.want { + t.Errorf("maskSecret(%q)=%q want %q", c.in, got, c.want) + } + } +} + +// issue #155:改了 config.json 却不生效时,旧横幅只写 api_key=true,看不出是 +// WB2A_API_KEY 覆盖了文件,还是改错了文件。横幅必须报来源,且密钥只出掩码。 +func TestListenBannerReportsKeySource(t *testing.T) { + const key = "gZb95oiQqT-A7VdssgI27FO" + t.Setenv("WB2A_API_KEY", "") + + got := listenBanner("127.0.0.1:7863", "/etc/wb/config.json", key) + want := "workbuddy2api listening on 127.0.0.1:7863 (api_key=gZ" + strings.Repeat("*", len(key)-4) + + "FO, 来源 配置文件 /etc/wb/config.json),管理面板 http://127.0.0.1:7863/panel/" + if got != want { + t.Fatalf("横幅=%q want %q", got, want) + } + if strings.Contains(got, key) { + t.Fatalf("横幅泄露了明文 api_key:%q", got) + } + // 前缀不能动:面板「运行日志」按它归类(ring_test.go 的 ChSys 用例)。 + if !strings.HasPrefix(got, "workbuddy2api listening on 127.0.0.1:7863") { + t.Fatalf("横幅前缀被改动,面板日志归类会失配:%q", got) + } + + // env 非空即覆盖文件(同 applyEnv):来源必须改口。 + t.Setenv("WB2A_API_KEY", "env-key-12345678") + got = listenBanner(":7863", "/etc/wb/config.json", "env-key-12345678") + if !strings.Contains(got, "来源 环境变量 WB2A_API_KEY") { + t.Fatalf("env 覆盖时来源仍报文件,issue #155 的困惑照旧:%q", got) + } + + // 目录只读、自动生成失败 → 退回默认+env:来源不许继续写那份没读到的路径。 + t.Setenv("WB2A_API_KEY", "") + got = listenBanner(":7863", "", "abc") + if !strings.Contains(got, "来源 内置默认值") || strings.Contains(got, "配置文件") { + t.Fatalf("退回默认时来源应报内置默认值、且不许再提配置文件:%q", got) + } +} diff --git a/cmd/server/cn_chat_base_test.go b/cmd/server/cn_chat_base_test.go new file mode 100644 index 0000000000000000000000000000000000000000..30019d0e571c3c066b2d27c24994f5e84c7ae501 --- /dev/null +++ b/cmd/server/cn_chat_base_test.go @@ -0,0 +1,49 @@ +package main + +import ( + "slices" + "testing" + + "github.com/misakano7545/workbuddy2api-panel/internal/upstream" +) + +// 老配置(无 cn 段)必须保留内置 CN base,零回归。 +func TestCNChatBaseDefaultKeepsBuiltin(t *testing.T) { + cfg, err := ParseConfig([]byte(`{}`)) + if err != nil { + t.Fatalf("parse: %v", err) + } + up := upstream.New() + want := up.ChatBaseCN + applyCNChatBase(up, cfg) + if up.ChatBaseCN != want { + t.Fatalf("ChatBaseCN=%q want builtin %q", up.ChatBaseCN, want) + } +} + +func TestCNChatBaseOverride(t *testing.T) { + cfg, err := ParseConfig([]byte(`{"cn":{"chat_base":"https://www.workbuddy.cn"}}`)) + if err != nil { + t.Fatalf("parse: %v", err) + } + up := upstream.New() + applyCNChatBase(up, cfg) + if up.ChatBaseCN != "https://www.workbuddy.cn" { + t.Fatalf("ChatBaseCN=%q want override", up.ChatBaseCN) + } + // global base 不受 cn 覆盖影响。 + if up.ChatBaseGlobal != "" { + t.Fatalf("ChatBaseGlobal=%q want untouched", up.ChatBaseGlobal) + } +} + +// cn.chat_base 只在装配期生效,面板保存后须提示重启。 +func TestCNChatBaseRequiresRestart(t *testing.T) { + cfg := Default() + // 本 fork 的 restartRequiredFields 比较「运行值 vs 新值」,故造一个差异。 + next := Default() + next.CN.ChatBase = "https://example.invalid" + if !slices.Contains(restartRequiredFields(cfg, next), "cn.chat_base") { + t.Fatal("cn.chat_base missing from restart-required fields") + } +} diff --git a/cmd/server/config.go b/cmd/server/config.go index 3453bc9d527b8ca7727b88baf2f01e5818d4043a..fa72e921592a2a226376df7c5b036b852cd4b0ab 100644 --- a/cmd/server/config.go +++ b/cmd/server/config.go @@ -1,658 +1,1488 @@ -// config.go 加载 JSON 配置 + 环境变量覆盖。 -package main - -import ( - "crypto/rand" - "encoding/base64" - "encoding/json" - "fmt" - "os" - "path/filepath" - "strconv" - "strings" - "time" - - "github.com/linguo2625469/workbuddy2api-panel/internal/prompt" -) - -// Config 顶层配置。 -type Config struct { - Listen string `json:"listen"` // ":7863" - APIKey string `json:"api_key"` // 空 = 不鉴权 - AuthDir string `json:"auth_dir"` // ./auths - StateFile string `json:"state_file"` // ./data/state.json - - Panel struct { - // PackageDetailLimit 积分构成页单账号默认展示的最近到期包数;<=0 回落 5。 - PackageDetailLimit int `json:"package_detail_limit"` - } `json:"panel"` - - Logging struct { - // RequestArchiveEnabled 请求元数据 JSONL 归档开关,缺省 true。 - RequestArchiveEnabled bool `json:"request_archive_enabled"` - // RequestRetentionDays 归档保留天数,缺省 7;<=0 回落默认。 - RequestRetentionDays int `json:"request_retention_days"` - // RequestArchiveMaxMB 归档总上限(MiB),缺省 100;<=0 回落默认。 - RequestArchiveMaxMB int `json:"request_archive_max_mb"` - // RequestClientInfo 是否在请求日志(归档事件 + stdout 流水行 + 面板运行 - // 日志)里记录调用来源:客户端 IP 与 User-Agent。缺省 true。 - // - // 为什么做成开关而不是恒开:来源信息是排查"谁在打网关"的第一手线索, - // 但它比 token 计数敏感(IP 属个人信息),共享部署/多租户场景可能需要 - // 关掉。关闭后 Event.ClientIP/UserAgent 保持为空,归档里不出现该字段。 - // 热生效(经 livecfg 快照),无需重启。 - RequestClientInfo bool `json:"request_client_info"` - } `json:"logging"` - - Server struct { - // ReadTimeout 入站请求读取(含 body 上传)总时长上限(issue #100)。 - // http.Server 的 ReadTimeout 覆盖整个请求读取:大上下文/文件块请求经 - // 反代链转发时上传可超过旧固定值 60s,被掐后客户端拿到 - // 400 "read body: ... i/o timeout"。缺省 "300s";"0" = 不限制 - //(慢速 body 可无限占用连接,自担风险);改动需重启进程。 - ReadTimeout string `json:"read_timeout"` // "300s";"0" = 不限制 - } `json:"server"` - - Cooldown struct { - // hard_credit / err_threshold / err_cooldown 三个历史键已退役: - // 硬冷却固定为次日 04:00(CooldownUntilTomorrow4AM),连续错误语义并入熔断器。 - // 旧 config 中的这些键因 JSON 未知字段而自然忽略,不报错。 - SoftRate string `json:"soft_rate"` // "600s",软限流冷却基数 - // SoftRateMax 软冷却指数退避的封顶,默认 "2h"。 - // 空值回落默认,非法值报错(处理风格同 soft_rate)。 - SoftRateMax string `json:"soft_rate_max"` // "2h" - } `json:"cooldown"` - - Schedule struct { - CheckinHours []int `json:"checkin_hours"` // [9,21] - TravelHours []int `json:"travel_hours"` // [9,21] - ActivityHours []int `json:"activity_hours"` // [10] - KeepaliveHours []int `json:"keepalive_hours"` // [22] - BlackcatHours []int `json:"blackcat_hours"` // [23] 夜猫子窗口(23:00–08:00 计数) - GrowthHours []int `json:"growth_hours"` // [1] 成长任务队列(Sequential 族每日零点解锁,01:00 自动扫描执行) - // CheckinEnabled/TravelEnabled/ActivityEnabled/KeepaliveEnabled/BlackcatEnabled 显式禁用开关(缺省 true)。 - // - // 为什么用独立 bool 而不是空数组/哨兵值表意"禁用": - // - 空数组与 null 在老语义里已被"未配置 → 回落默认"占用,改判会静默翻转 - // 所有老 config 的行为(用户只想删掉一行,结果关掉了签到);bool 缺省 true - // 则对老配置零影响,向后完全兼容。 - // - 开关与取值解耦:禁用时仍保留用户显式配的小时,重新启用无需补配。 - // - 无需猜测哨兵([-1] 之类),非法小时一律报错并提示改用本开关。 - // 旧 config 里的该键因 JSON 未知字段而自然忽略,不报错。 - CheckinEnabled bool `json:"checkin_enabled"` // 缺省 true;false = 关签到 - TravelEnabled bool `json:"travel_enabled"` // 缺省 true;false = 完全停猫猫旅行 - ActivityEnabled bool `json:"activity_enabled"` // 缺省 true;false = 停活跃上报 - KeepaliveEnabled bool `json:"keepalive_enabled"` // 缺省 true;false = 关 token 保活 - BlackcatEnabled bool `json:"blackcat_enabled"` // 缺省 true;false = 关夜猫子 - GrowthEnabled bool `json:"growth_enabled"` // 缺省 true;false = 关成长任务自动排程 - - // IncludeDisabledInTasks 让「保号类」定时任务(签到 / 活跃上报 / token 保活 / - // 余额刷新)对**已禁用(disabled)**的账号也执行。 - // - // 为什么需要它:面板「禁用」的语义是「不再参与选号」(见面板确认文案),但这四类 - // 任务此前一律 `if st.Disabled { continue }`,等于把「停用流量」放大成「停止一切 - // 上游保号行为」——被禁用的号拿不到签到积分、不续 token、余额也不再刷新;而 - // ReenableIfCredits 明确不复活 disabled 账号(见 pool.state.go),于是签到这条唯一 - // 的自动回血路径也断了,账号只能靠人工「解冻」回来。 - // - // 对「一次只放开一个号、用禁用做流量开关」的轮换用法(同 IP 多号防风控),闲置 - // 待命的号恰恰是最需要签到的那批——本开关即为该用法提供出口。 - // - // 缺省 false = 保持既有行为,对老配置零影响。打开后禁用号仍会签到 / 保活,但 - // **依旧不参与选号**:pool 选号侧的 disabled 过滤不受本开关影响。 - IncludeDisabledInTasks bool `json:"include_disabled_in_tasks"` - - // 余额后台周期刷新:两次签到时点之间 credits 也能保持新鲜(面板/状态观测用)。 - // 解冻语义同签到(余额 > 0 的冷却账号自动解冻),但不做签到不刷 token。 - BalanceRefreshEnabled bool `json:"balance_refresh_enabled"` // 缺省 true;false = 关闭 - BalanceRefreshMinutes int `json:"balance_refresh_minutes"` // 缺省 5;<=0 回落 5 - } `json:"schedule"` - - Global struct { - // Enabled global realm 路由开关。缺省 true:Realm() 正常把 realm=global/ - // domain=workbuddy.ai 的账号判为 global 并路由 global base/路径。 - // 显式 "enabled": false 关闭(逃生门,纯 CN 锁定:即便 auth 写了 realm=global - // 也不路由,auth.Realm() 双保险的第一道闸)。纯 CN 部署行为不变:CN 账号 - // 恒判 cn,global base 只在 realm=global 的账号上被使用。 - Enabled bool `json:"enabled"` - // ChatBase / BillingBase 国际版上游 base 覆盖;空 = 回落内置默认 - // https://www.workbuddy.ai(internal/upstream.defaultGlobalBase)。 - ChatBase string `json:"chat_base"` - BillingBase string `json:"billing_base"` - } `json:"global"` - - Upstream struct { - // TimeoutSeconds 短 RPC(refresh/checkin/balance/FetchModels)总时长上限,默认 120。 - TimeoutSeconds int `json:"timeout_seconds"` - // HeaderTimeoutSeconds 聊天 SSE 首字节前(响应头)上限;<=0 回落 TimeoutSeconds。 - HeaderTimeoutSeconds int `json:"header_timeout_seconds"` - // IdleTimeoutSeconds 聊天 SSE 流中空闲上限(活跃吐数据续命不掐);<=0 回落默认 300。 - IdleTimeoutSeconds int `json:"idle_timeout_seconds"` - // UserAgent 出站 User-Agent 显式覆盖(非空时全路径生效,优先于默认三段式)。 - // 全部出站请求生效:chat/refresh/checkin/balance/report/travel/FetchModels。 - // 默认值已对齐官方 WorkBuddy 桌面形态(三段式),用户仍可配完全自定义值改写。 - UserAgent string `json:"user_agent"` - // ClientVersion WorkBuddy 客户端版本段(出站 UA 的 `WorkBuddy/` 与归属头 - // X-IDE-Version)。空 = 内置默认(对齐官方 5.5.4 分发包)。 - ClientVersion string `json:"client_version"` - // CliVersion 出站 UA 中 `CLI/` 段的版本。空 = 内置默认(官方内置 CLI 2.137.1)。 - CliVersion string `json:"cli_version"` - // ClientName 用量归属头取值(X-Product / X-IDE-Name / X-IDE-Type / X-IDE-Version)。 - // 空 = 旧行为 X-Product="SaaS" 不设 X-IDE-*;配 "WorkBuddy" 则四头跟随。 - ClientName string `json:"client_name"` - // DeviceToken 设备风控 Token(X-Device-Token 头)全局兜底;空 = 不注入。 - // 每号 auth 文件的 device_token 键优先于本项。 - DeviceToken string `json:"device_token"` - // DeviceTokenFile device token 文件路径兜底(宿主落盘的桌面端 token,5 分钟读取缓存)。 - DeviceTokenFile string `json:"device_token_file"` - // PassthroughIP 是否透传客户端 IP 给上游(默认 false,反代安全边界)。 - PassthroughIP bool `json:"passthrough_ip"` - } `json:"upstream"` - - Features struct { - // SanitizeBlacklistFingerprints 出站请求体黑名单指纹脱敏(默认 true;false 完全还原)。 - SanitizeBlacklistFingerprints bool `json:"sanitize_blacklist_fingerprints"` - } `json:"features"` - - Prompt struct { - // Mode passthrough(默认)= 透传客户端原始 system(降级重试仍会切到 Degraded); - // custom = 网关用自有系统提示词替换客户端 system/developer; - // append = 两者并用:开头连续 system/developer 块后插网关 system,既有消息逐字不动(issue #129)。 - Mode string `json:"mode"` // "passthrough" / "custom" / "append" - // File 提示词文件路径;空 = 内置默认 defaultprompt.md; - // 路径非空但不可读 → 启动报错(fail fast,避免静默回落到内置默认)。 - File string `json:"file"` - } `json:"prompt"` - - // PromptText 解析后的系统提示词文本(custom/append 模式使用)。 - PromptText string `json:"-"` - - Upstash struct { - URL string `json:"url"` // 空 = 纯内存模式;支持完整 rediss:// URL 或 https://xxx.upstash.io host - Token string `json:"token"` // url 非完整连接串时用于组装 rediss://default:@:6379 - } `json:"upstash"` - - Pool struct { - MaxInFlight int `json:"max_in_flight"` // 单账号最大在途请求数,0 = 不限 - MaxInFlightGlobal int `json:"max_in_flight_global"` // global 域单账号在途上限(WAF 风控紧域压低并发),0 = 回落默认 2 - BreakerThreshold int `json:"breaker_threshold"` // 连续失败次数触发熔断,默认 3 - BreakerCooldown string `json:"breaker_cooldown"` // 基础熔断时长,默认 "30m" - BreakerCooldownMax string `json:"breaker_cooldown_max"` // 指数退避封顶,默认 "6h" - // 连败降权(issue #114):ErrClient/传输层这类「不罚号」失败连续计数,达阈 - // 临时出池。与冷却/熔断并存取更长者不叠加。默认 5 次 / 10m。 - DegradeThreshold int `json:"degrade_threshold"` // 连败次数触发降权,默认 5 - DegradeCooldown string `json:"degrade_cooldown"` // 降权时长(固定,非指数退避),默认 "10m" - DegradeCooldownMax string `json:"degrade_cooldown_max"` // 降权时长的上限钳制,默认 "2h"(仅当 cooldown 超该值才钳制) - IdleWeightPerHour float64 `json:"idle_weight_per_hour"` // 闲置补偿:每小时未用 +0.5 权重 - IdleWeightMax float64 `json:"idle_weight_max"` // 闲置补偿封顶,默认 5.0 - // PreferExpiring 快过期积分加权开关,默认 true。开启且 expiring_soon 窗口内 - // 存在有效批次时,该账号选号权重 ×3(虚拟实例,见 pool 路由加权); - // 不按到期时间排序、与批次金额无关(issue #101 对齐实现口径)。 - // 关闭后完全不使用到期信息选号。 - PreferExpiring bool `json:"prefer_expiring"` - // ExpiringSoon 快过期积分窗口(如 "168h"=7天):签到/余额刷新时,到期时间在 - // 此窗口内的批次令账号命中上述 ×3 加权;窗口开大 → 命中账号变多、 - // 偏好被稀释。空/0 = 禁用该加权门槛。 - ExpiringSoon string `json:"expiring_soon"` - // CostExploreInterval costTier 条件探索窗口(issue #136 方案 a′):tier 0 - // 垄断层存在且 tier 1 有成员时,距上次探索 ≥ 窗口则本次 pick 生效层切 - // tier 1-only(探索=搭车改道,零新增上游请求;成功即毕业,失败走既有 - // 错误策略)。默认 "30m"(≤48 次/天/模型);"0" 关停(完全回到现状行为); - // 空值回落默认。 - CostExploreInterval string `json:"cost_explore_interval"` - // CreditFloor 积分保底:账号余额低于该值时,对实测收费模型(tier 2)不再 - // 参与选号——防止收费请求把余额打穿、连免费模型都 402 冷却到次日签到。 - // tier 0(免费)/ tier 1(无观测)不受限;签到回血越过 floor 自动恢复。 - // 默认 0 = 关闭;负值钳 0。 - CreditFloor int64 `json:"credit_floor"` - } `json:"pool"` - - SessionSticky struct { - Enabled bool `json:"enabled"` // 默认 true - TTL string `json:"ttl"` // 会话绑定 TTL,默认 "30m" - GCInterval string `json:"gc_interval"` // 会话 GC 周期,默认 "5m" - } `json:"session_sticky"` - - // 解析后 - SoftRateDur time.Duration `json:"-"` - SoftRateMaxDur time.Duration `json:"-"` - BreakerCooldownDur time.Duration `json:"-"` - BreakerCooldownMaxD time.Duration `json:"-"` - DegradeCooldownDur time.Duration `json:"-"` - DegradeCooldownMaxD time.Duration `json:"-"` - SessionTTL time.Duration `json:"-"` - SessionGCInterval time.Duration `json:"-"` - BalanceRefreshInterval time.Duration `json:"-"` // 0 = 不启动(enabled=false) - ExpiringSoonDur time.Duration `json:"-"` - // CostExploreIntervalDur 解析后的 costTier 探索窗口(issue #136);0 = 关停。 - CostExploreIntervalDur time.Duration `json:"-"` - // ServerReadTimeoutDur 解析后的入站请求读取上限(issue #100);0 = 不限制。 - ServerReadTimeoutDur time.Duration `json:"-"` -} - -// Default 默认配置。 -func Default() *Config { - c := &Config{ - Listen: ":7863", - APIKey: "", - AuthDir: "./auths", - StateFile: "./data/state.json", - } - c.Cooldown.SoftRate = "600s" - c.Cooldown.SoftRateMax = "2h" - c.Server.ReadTimeout = "300s" - c.Panel.PackageDetailLimit = 5 - c.Logging.RequestArchiveEnabled = true - c.Logging.RequestRetentionDays = 7 - c.Logging.RequestArchiveMaxMB = 100 - // 缺省 true 靠显式赋值实现(同 Schedule 开关):JSON 里键缺席时字段保留此值, - // 只有显式 false 才关闭来源记录。 - c.Logging.RequestClientInfo = true - c.Schedule.CheckinHours = []int{9, 21} - c.Schedule.TravelHours = []int{9, 21} - c.Schedule.ActivityHours = []int{10} - c.Schedule.KeepaliveHours = []int{22} - c.Schedule.BlackcatHours = []int{23} - c.Schedule.GrowthHours = []int{1} - // 开关「缺省 true」靠这几行实现:Load 先取 Default() 再 json.Unmarshal 覆盖, - // 键缺席(或为 null)时字段原样保留 true,只有显式 false 才关。 - c.Schedule.CheckinEnabled = true - c.Schedule.GrowthEnabled = true - c.Schedule.TravelEnabled = true - c.Schedule.ActivityEnabled = true - c.Schedule.KeepaliveEnabled = true - c.Schedule.BlackcatEnabled = true - c.Schedule.BalanceRefreshEnabled = true - c.Schedule.BalanceRefreshMinutes = 5 - c.Upstream.TimeoutSeconds = 120 - // HeaderTimeoutSeconds/IdleTimeoutSeconds 默认 0(未设置态),回落见 normalize()。 - c.Upstream.HeaderTimeoutSeconds = 0 - c.Upstream.IdleTimeoutSeconds = 0 - // Global.Enabled 缺省 true(纯 CN 行为不变:CN 账号恒判 cn,global base 不被使用); - // ChatBase/BillingBase 缺省空(回落内置默认)。 - c.Global.Enabled = true - c.Features.SanitizeBlacklistFingerprints = true - c.Prompt.Mode = "passthrough" // 缺省 passthrough:透传客户端原始 system(对齐上游;custom 由用户显式选择) - c.Pool.MaxInFlight = 3 - // MaxInFlightGlobal 缺省 2:global 域 WAF 风控更紧,压低单号并发(WAF 403 修复 - // P1-1);0/负数 normalize 回落默认(与 max_in_flight 的 0=不限语义不同,分档键 - // 的 0 没有合理语义,回退分档默认最稳)。 - c.Pool.MaxInFlightGlobal = 2 - c.Pool.BreakerThreshold = 3 - c.Pool.BreakerCooldown = "30m" - c.Pool.BreakerCooldownMax = "6h" - c.Pool.DegradeThreshold = 5 - c.Pool.DegradeCooldown = "10m" - c.Pool.DegradeCooldownMax = "2h" - c.Pool.IdleWeightPerHour = 0.5 - c.Pool.IdleWeightMax = 5.0 - c.Pool.PreferExpiring = true - c.Pool.ExpiringSoon = "168h" // 快过期窗口默认 7 天:官方活动奖励积分多在两周内过期 - // costTier 探索默认 30m(issue #136:垄断破除 + 搭车改道零新增请求);"0" 关停。 - c.Pool.CostExploreInterval = "30m" - c.SessionSticky.Enabled = true - c.SessionSticky.TTL = "30m" - c.SessionSticky.GCInterval = "5m" - return c -} - -// Load 从文件读,再用 WB2A_* env 覆盖。 -func Load(path string) (*Config, error) { - c := Default() - if path != "" { - // 目录检查:Docker bind mount 在宿主机文件缺失时会静默创建同名目录, - // 直接 ReadFile 会报 "Incorrect function" 之类晦涩错误,这里给出可操作提示。 - if st, statErr := os.Stat(path); statErr == nil && st.IsDir() { - return nil, fmt.Errorf("config %s 是目录而非文件——"+ - "Docker 部署时若宿主机缺少 config.json,bind mount 会创建同名目录。"+ - "请先 `cp config.example.json config.json` 或删除该目录(程序会自动生成配置)", path) - } - raw, err := os.ReadFile(path) - if err != nil { - return nil, fmt.Errorf("read config: %w", err) - } - if _, err := ParseConfigInto(raw, c); err != nil { - return nil, err - } - } - applyEnv(c) - if err := c.normalize(); err != nil { - return nil, err - } - return c, nil -} - -// ParseConfigInto 把 JSON 覆盖到 c 上并 normalize(不做 env、不读文件)。 -// 面板保存配置走这条路径:与 Load 完全同一套解析/校验逻辑,避免两处漂移。 -func ParseConfigInto(raw []byte, c *Config) (*Config, error) { - if err := json.Unmarshal(raw, c); err != nil { - return nil, fmt.Errorf("parse config: %w", err) - } - if err := c.normalize(); err != nil { - return nil, err - } - return c, nil -} - -// ParseConfig 基于默认值解析一段配置 JSON(等价于 Load 的文件分支,但不读环境变量)。 -func ParseConfig(raw []byte) (*Config, error) { - return ParseConfigInto(raw, Default()) -} - -// WriteDefault 在 path 落一份推荐配置(首次运行自动生成,双击即开免手工复制样例)。 -// 值取自 Default()(含超时/熔断/签到排程等推荐值),api_key 用 crypto/rand 随机生成: -// 安全默认优于示例占位符(listen 绑定 0.0.0.0,空 key 会把网关裸暴露给局域网)。 -// 返回生成的 key 供启动日志透出。已存在时经 O_EXCL 原子拒绝,绝不改写用户配置。 -func WriteDefault(path string) (string, error) { - raw := make([]byte, 18) - if _, err := rand.Read(raw); err != nil { - return "", fmt.Errorf("gen api_key: %w", err) - } - key := "sk-" + base64.RawURLEncoding.EncodeToString(raw) - c := Default() - c.APIKey = key - _ = c.normalize() // Default() 全合法,normalize 仅补齐 header/idle 超时的展示值 - out, err := json.MarshalIndent(c, "", " ") - if err != nil { - return "", fmt.Errorf("marshal config: %w", err) - } - if dir := filepath.Dir(path); dir != "" && dir != "." { - if err := os.MkdirAll(dir, 0o755); err != nil { - return "", fmt.Errorf("mkdir config dir: %w", err) - } - } - // O_EXCL 原子拒绝覆盖:即使调用方漏判"不存在",也绝不悄悄改写用户已有配置。 - f, err := os.OpenFile(path, os.O_WRONLY|os.O_CREATE|os.O_EXCL, 0o600) - if err != nil { - return "", fmt.Errorf("write config: %w", err) - } - defer f.Close() - if _, err := f.Write(out); err != nil { - return "", fmt.Errorf("write config: %w", err) - } - return key, nil -} - -func applyEnv(c *Config) { - if v := os.Getenv("WB2A_LISTEN"); v != "" { - c.Listen = v - } - if v := os.Getenv("WB2A_API_KEY"); v != "" { - c.APIKey = v - } - if v := os.Getenv("WB2A_AUTH_DIR"); v != "" { - c.AuthDir = v - } - if v := os.Getenv("WB2A_STATE_FILE"); v != "" { - c.StateFile = v - } - if v := os.Getenv("WB2A_SOFT_RATE"); v != "" { - c.Cooldown.SoftRate = v - } - if v := os.Getenv("WB2A_SOFT_RATE_MAX"); v != "" { - c.Cooldown.SoftRateMax = v - } - if v := os.Getenv("WB2A_TIMEOUT_SECONDS"); v != "" { - if n, err := strconv.Atoi(v); err == nil { - c.Upstream.TimeoutSeconds = n - } - } - if v := os.Getenv("WB2A_HEADER_TIMEOUT_SECONDS"); v != "" { - if n, err := strconv.Atoi(v); err == nil { - c.Upstream.HeaderTimeoutSeconds = n - } - } - if v := os.Getenv("WB2A_IDLE_TIMEOUT_SECONDS"); v != "" { - if n, err := strconv.Atoi(v); err == nil { - c.Upstream.IdleTimeoutSeconds = n - } - } - if v := os.Getenv("WB2A_USER_AGENT"); v != "" { - c.Upstream.UserAgent = v - } - if v := os.Getenv("WB2A_CLIENT_VERSION"); v != "" { - c.Upstream.ClientVersion = v - } - if v := os.Getenv("WB2A_CLI_VERSION"); v != "" { - c.Upstream.CliVersion = v - } - if v := os.Getenv("WB2A_CLIENT_NAME"); v != "" { - c.Upstream.ClientName = v - } - if v := os.Getenv("WB2A_DEVICE_TOKEN"); v != "" { - c.Upstream.DeviceToken = v - } - if v := os.Getenv("WB2A_DEVICE_TOKEN_FILE"); v != "" { - c.Upstream.DeviceTokenFile = v - } - if v := os.Getenv("WB2A_PASSTHROUGH_IP"); v != "" { - if b, err := strconv.ParseBool(v); err == nil { - c.Upstream.PassthroughIP = b - } - } - if v := os.Getenv("WB2A_SANITIZE_FINGERPRINTS"); v != "" { - if b, err := strconv.ParseBool(v); err == nil { - c.Features.SanitizeBlacklistFingerprints = b - } - } - if v := os.Getenv("WB2A_PROMPT_MODE"); v != "" { - c.Prompt.Mode = v - } - if v := os.Getenv("WB2A_PROMPT_FILE"); v != "" { - c.Prompt.File = v - } - if v := os.Getenv("WB2A_EXPIRING_SOON"); v != "" { - c.Pool.ExpiringSoon = v - } - if v := os.Getenv("WB2A_PREFER_EXPIRING"); v != "" { - if b, err := strconv.ParseBool(v); err == nil { - c.Pool.PreferExpiring = b - } - } -} - -func (c *Config) normalize() error { - var err error - if c.Panel.PackageDetailLimit <= 0 { - c.Panel.PackageDetailLimit = 5 - } - if c.Logging.RequestRetentionDays <= 0 { - c.Logging.RequestRetentionDays = 7 - } - if c.Logging.RequestArchiveMaxMB <= 0 { - c.Logging.RequestArchiveMaxMB = 100 - } - // 入站读取上限(issue #100):空值回落默认 300s;"0" 合法(不限制); - // 负值无语义,fail fast(静默钳 0 会把保护悄悄关掉)。 - if c.Server.ReadTimeout == "" { - c.Server.ReadTimeout = "300s" - } - if c.ServerReadTimeoutDur, err = time.ParseDuration(c.Server.ReadTimeout); err != nil { - return fmt.Errorf("server.read_timeout: %w", err) - } - if c.ServerReadTimeoutDur < 0 { - return fmt.Errorf("server.read_timeout: 负时长 %q 无意义", c.Server.ReadTimeout) - } - if c.SoftRateDur, err = time.ParseDuration(c.Cooldown.SoftRate); err != nil { - return fmt.Errorf("cooldown.soft_rate: %w", err) - } - // 空值回落默认 2h(Default() 已置值;此兜底覆盖显式 "" 与 Default() 被绕过的场景)。 - if c.Cooldown.SoftRateMax == "" { - c.Cooldown.SoftRateMax = "2h" - } - if c.SoftRateMaxDur, err = time.ParseDuration(c.Cooldown.SoftRateMax); err != nil { - return fmt.Errorf("cooldown.soft_rate_max: %w", err) - } - if c.BreakerCooldownDur, err = time.ParseDuration(c.Pool.BreakerCooldown); err != nil { - return fmt.Errorf("pool.breaker_cooldown: %w", err) - } - if c.BreakerCooldownMaxD, err = time.ParseDuration(c.Pool.BreakerCooldownMax); err != nil { - return fmt.Errorf("pool.breaker_cooldown_max: %w", err) - } - if c.DegradeCooldownDur, err = time.ParseDuration(c.Pool.DegradeCooldown); err != nil { - return fmt.Errorf("pool.degrade_cooldown: %w", err) - } - if c.DegradeCooldownMaxD, err = time.ParseDuration(c.Pool.DegradeCooldownMax); err != nil { - return fmt.Errorf("pool.degrade_cooldown_max: %w", err) - } - if c.SessionTTL, err = time.ParseDuration(c.SessionSticky.TTL); err != nil { - return fmt.Errorf("session_sticky.ttl: %w", err) - } - if c.SessionGCInterval, err = time.ParseDuration(c.SessionSticky.GCInterval); err != nil { - return fmt.Errorf("session_sticky.gc_interval: %w", err) - } - // 快过期窗口:空 = 禁用(ExpiringSoonDur 0);非空必须可解析(拼写错误 fail fast)。 - if c.Pool.ExpiringSoon != "" { - if c.ExpiringSoonDur, err = time.ParseDuration(c.Pool.ExpiringSoon); err != nil { - return fmt.Errorf("pool.expiring_soon: %w", err) - } - } - if c.ExpiringSoonDur < 0 { - c.ExpiringSoonDur = 0 - c.Pool.ExpiringSoon = "0" - } - // costTier 探索窗口(issue #136):空值回落默认 30m(Default 已置;此兜底覆盖 - // 显式 "");"0" 是合法值(关停,完全回到现状行为),不回落;负值钳 0 同关停 - //("−5m" 无合理语义)。 - if c.Pool.CostExploreInterval == "" { - c.Pool.CostExploreInterval = "30m" - } - if c.CostExploreIntervalDur, err = time.ParseDuration(c.Pool.CostExploreInterval); err != nil { - return fmt.Errorf("pool.cost_explore_interval: %w", err) - } - if c.CostExploreIntervalDur < 0 { - c.CostExploreIntervalDur = 0 - } - // 积分保底:负值钳 0(= 关闭)。0 是合法默认(关闭),无需空值回落。 - if c.Pool.CreditFloor < 0 { - c.Pool.CreditFloor = 0 - } - if c.Pool.BreakerThreshold <= 0 { - c.Pool.BreakerThreshold = 3 - } - // 连败降权参数缺省归一(非法/未设置回落默认,与 breaker_threshold 同风格)。 - if c.Pool.DegradeThreshold <= 0 { - c.Pool.DegradeThreshold = 5 - } - if c.Pool.DegradeCooldown == "" { - c.Pool.DegradeCooldown = "10m" - } - if c.Pool.DegradeCooldownMax == "" { - c.Pool.DegradeCooldownMax = "2h" - } - // global 在途分档:0/负数视为未设置回落默认 2(WAF 403 修复 P1-1)。 - if c.Pool.MaxInFlightGlobal <= 0 { - c.Pool.MaxInFlightGlobal = 2 - } - if c.Pool.IdleWeightPerHour <= 0 { - c.Pool.IdleWeightPerHour = 0.5 - } - if c.Pool.IdleWeightMax <= 0 { - c.Pool.IdleWeightMax = 5.0 - } - if c.Upstream.TimeoutSeconds <= 0 { - c.Upstream.TimeoutSeconds = 120 - } - // header 缺省回落 timeout(保"首字节前换号"既有语义);idle 缺省走内置大值。 - // 任务书约定:0 一律视为"未设置"走默认,真正的"禁用"留待后续(避免歧义)。 - if c.Upstream.HeaderTimeoutSeconds <= 0 { - c.Upstream.HeaderTimeoutSeconds = c.Upstream.TimeoutSeconds - } - if c.Upstream.IdleTimeoutSeconds <= 0 { - c.Upstream.IdleTimeoutSeconds = 300 - } - if !strings.HasPrefix(c.Listen, ":") && !strings.Contains(c.Listen, ":") { - c.Listen = ":" + c.Listen - } - // 空数组与 null 反序列化后覆盖掉 Default() 的排程值(键缺席才保留),在此补齐。 - // 空 = 未配置 → 回落默认;「禁用」一律走 *_enabled=false,两者互不混淆。 - if len(c.Schedule.CheckinHours) == 0 { - c.Schedule.CheckinHours = []int{9, 21} - } - if len(c.Schedule.TravelHours) == 0 { - c.Schedule.TravelHours = []int{9, 21} - } - if len(c.Schedule.ActivityHours) == 0 { - c.Schedule.ActivityHours = []int{10} - } - if len(c.Schedule.KeepaliveHours) == 0 { - c.Schedule.KeepaliveHours = []int{22} - } - if len(c.Schedule.BlackcatHours) == 0 { - c.Schedule.BlackcatHours = []int{23} - } - if len(c.Schedule.GrowthHours) == 0 { - c.Schedule.GrowthHours = []int{1} - } - // 余额后台刷新:启用时 minutes<=0 回落默认 5;关闭时 interval 保持 0(不启动)。 - if c.Schedule.BalanceRefreshEnabled { - if c.Schedule.BalanceRefreshMinutes <= 0 { - c.Schedule.BalanceRefreshMinutes = 5 - } - c.BalanceRefreshInterval = time.Duration(c.Schedule.BalanceRefreshMinutes) * time.Minute - } - if err := c.validateScheduleHours(); err != nil { - return err - } - return c.normalizePrompt() -} - -// normalizePrompt 校验 prompt.mode 并按 file 加载提示词文本(custom/append 模式)。 -// -// mode 非法(非 passthrough/custom/append)启动报错,避免静默回落到某一分支; -// custom/append 模式下 file 非空但不可读 → 报错(fail fast),file 空 → 用内置默认 -// (两模式共用同一加载路径,PromptText 均非空)。 -// passthrough 模式不加载文本(透传客户端原始 system,文本在降级时用 prompt.Degraded)。 -func (c *Config) normalizePrompt() error { - switch m := strings.ToLower(strings.TrimSpace(c.Prompt.Mode)); m { - case "", "passthrough": - c.Prompt.Mode = "passthrough" - case "custom": - c.Prompt.Mode = "custom" - case "append": - c.Prompt.Mode = "append" - default: - return fmt.Errorf("prompt.mode: %q 不是合法值(passthrough / custom / append)", c.Prompt.Mode) - } - if c.Prompt.Mode == "custom" || c.Prompt.Mode == "append" { - text, err := prompt.Load(c.Prompt.Mode, c.Prompt.File) - if err != nil { - return err - } - c.PromptText = text - } - return nil -} - -// validateScheduleHours 校验排程小时落在 0-23。 -// -// 为什么不用 `[-1]` 之类的哨兵值表意"禁用":非法小时被静默吞掉时,用户以为关掉了签到, -// 实际可能被当成另一个整点照常执行;这里直接快速失败,并在错误信息里指向正确的开关 -// (checkin_enabled / keepalive_enabled),避免用户靠猜哨兵值来配。 -func (c *Config) validateScheduleHours() error { - if err := checkHourRange("schedule.checkin_hours", "checkin_enabled", c.Schedule.CheckinHours); err != nil { - return err - } - if err := checkHourRange("schedule.travel_hours", "travel_enabled", c.Schedule.TravelHours); err != nil { - return err - } - if err := checkHourRange("schedule.activity_hours", "activity_enabled", c.Schedule.ActivityHours); err != nil { - return err - } - if err := checkHourRange("schedule.keepalive_hours", "keepalive_enabled", c.Schedule.KeepaliveHours); err != nil { - return err - } - if err := checkHourRange("schedule.blackcat_hours", "blackcat_enabled", c.Schedule.BlackcatHours); err != nil { - return err - } - return checkHourRange("schedule.growth_hours", "growth_enabled", c.Schedule.GrowthHours) -} - -func checkHourRange(field, switchKey string, hours []int) error { - for _, h := range hours { - if h < 0 || h > 23 { - return fmt.Errorf("%s: %d 不是合法小时(0-23);如要关闭该任务请设 schedule.%s=false", field, h, switchKey) - } - } - return nil -} +// config.go 加载 JSON 配置 + 环境变量覆盖。 +package main + +import ( + "crypto/rand" + "encoding/base64" + "encoding/json" + "fmt" + "net/url" + "os" + "path/filepath" + "strconv" + "strings" + "time" + + "github.com/misakano7545/workbuddy2api-panel/internal/prompt" + "github.com/misakano7545/workbuddy2api-panel/internal/safefile" + "github.com/misakano7545/workbuddy2api-panel/internal/upstream" +) + +// Config 顶层配置。 +type Config struct { + Listen string `json:"listen"` // "127.0.0.1:7863"(缺省只绑回环) + APIKey string `json:"api_key"` // 空 = 不鉴权 + AuthDir string `json:"auth_dir"` // ./auths + StateFile string `json:"state_file"` // ./data/state.json + + // DNSServers 出站解析用的 DNS 服务器(空 = 用系统解析器);也可用 WB2A_DNS 覆盖 + // (逗号分隔)。给没有 /etc/resolv.conf 的环境用:Android 上 Go 的解析器会退回 + // [::1]:53,所有域名解析直接失败;本地 DNS 被污染时也可借此直连可信解析器。 + DNSServers []string `json:"dns_servers,omitempty"` + + Panel struct { + // PackageDetailLimit 积分构成页单账号默认展示的最近到期包数;<=0 回落 5。 + PackageDetailLimit int `json:"package_detail_limit"` + // PollIntervalSec 面板自动刷新间隔(秒)。0 = 用前端缺省(5s); + // 负值 = 关闭自动刷新(只在手动操作时更新)。账号多、或只是开着面板 + // 当监控用时,调大间隔能显著降低浏览器与服务端负担。 + PollIntervalSec int `json:"poll_interval_sec"` + } `json:"panel"` + + Update struct { + // AutoEnabled 每日按上海时间自动检查并安装原生 Release。 + AutoEnabled bool `json:"auto_enabled"` + // AutoTime 自动更新时间,格式 HH:MM(Asia/Shanghai)。 + AutoTime string `json:"auto_time"` + // Proxy 更新走哪个出口(issue #198,可热生效):空 = 不显式设置; + // 支持 http:// / https:// / socks5://。出站被墙、api.github.com 通而 + // release-assets 不通时填这里(或 mirror)。 + Proxy string `json:"proxy"` + // ProxyFromEnv 是否沿用进程环境变量里的 HTTP(S)_PROXY(默认 true)。 + // 设为 false 时只看 proxy 字段——容器里环境变量被别处塞了值、但更新 + // 需要走另一条通道时用。 + ProxyFromEnv *bool `json:"proxy_from_env"` + // Mirror 资产下载镜像前缀(issue #198),例如 https://ghfast.top/。 + // 只作用于**资产下载**:Release 元数据(tag/digest/size)永远直连 + // api.github.com,校验口径不变,镜像无法投毒。空 = 直连。 + Mirror string `json:"mirror"` + } `json:"update"` + + Accounts struct { + // ReloadInterval 账号目录热重载轮询间隔(issue #199)。空 = 默认 10s; + // "0s" = 关闭轮询(手动接口 POST /panel/api/accounts/reload 仍然可用)。 + // + // 为什么默认开启:外部脚本/另一台机器往 auths/ 同步文件是最常见用法, + // 而重启进程会丢在途请求。轮询只读 ReadDir + 少量解析,几十个号的目录 + // 是微秒级开销。 + ReloadInterval string `json:"reload_interval"` + // ReloadDeleteConfirm 文件消失后要连续几轮扫描确认才把账号移出池(默认 2)。 + // 半写文件、临时移走文件都可能让账号「这一轮看不见」;剔除会写进 state.json, + // 下次启动也不复活,所以要连续确认。1 = 立即删(不建议)。 + ReloadDeleteConfirm int `json:"reload_delete_confirm"` + } `json:"accounts"` + + Logging struct { + // RequestArchiveEnabled 请求元数据 JSONL 归档开关,缺省 true。 + RequestArchiveEnabled bool `json:"request_archive_enabled"` + // RequestRetentionDays 归档保留天数,缺省 7;<=0 回落默认。 + RequestRetentionDays int `json:"request_retention_days"` + // RequestArchiveMaxMB 归档总上限(MiB),缺省 100;<=0 回落默认。 + RequestArchiveMaxMB int `json:"request_archive_max_mb"` + // RequestClientInfo 是否在请求日志(归档事件 + stdout 流水行 + 面板运行 + // 日志)里记录调用来源:客户端 IP 与 User-Agent。缺省 true。 + // + // 为什么做成开关而不是恒开:来源信息是排查"谁在打网关"的第一手线索, + // 但它比 token 计数敏感(IP 属个人信息),共享部署/多租户场景可能需要 + // 关掉。关闭后 Event.ClientIP/UserAgent 保持为空,归档里不出现该字段。 + // 热生效(经 livecfg 快照),无需重启。 + RequestClientInfo bool `json:"request_client_info"` + // RequestArchiveContext 是否把会话上下文(system + messages / 出图 prompt)记入 + // 请求事件,面板「请求事件日志」点行展开即可看当轮发出去的内容。缺省 false。 + // + // 为什么默认关:这是**用户提示词**,比 IP 敏感一个量级——开了等于把每次对话的 + // 原文落到 state 目录的归档文件里(保留 7 天、上限 100MiB)。排查「上游为什么 + // 拒这条请求」时它是唯一能对上的证据,但那该是运维主动开的临时手段, + // 不是默认行为。热生效,无需重启。 + RequestArchiveContext bool `json:"request_archive_context"` + // PanelLogEnabled 面板「运行日志」是否按天落盘,缺省 true。 + // + // 为什么默认开:内存环每频道只有 500 条,一次长会话就能把上午的行冲掉, + // 重启更是全部归零——「昨天下午那波 429 从几点开始的」这类问题原本无解。 + // 落盘是纯增量文本(一天几 MB),代价远小于丢失事故现场。 + PanelLogEnabled bool `json:"panel_log_enabled"` + // PanelLogRetentionDays 面板日志保留天数,缺省 7;<=0 回落默认。 + PanelLogRetentionDays int `json:"panel_log_retention_days"` + // PanelLogMaxMB 面板日志总量上限(MiB,按天文件,单文件超限轮转),缺省 50。 + PanelLogMaxMB int `json:"panel_log_max_mb"` + } `json:"logging"` + + Server struct { + // ReadTimeout 入站请求读取(含 body 上传)总时长上限(issue #100)。 + // http.Server 的 ReadTimeout 覆盖整个请求读取:大上下文/文件块请求经 + // 反代链转发时上传可超过旧固定值 60s,被掐后客户端拿到 + // 400 "read body: ... i/o timeout"。缺省 "300s";"0" = 不限制 + //(慢速 body 可无限占用连接,自担风险);改动需重启进程。 + ReadTimeout string `json:"read_timeout"` // "300s";"0" = 不限制 + // ShutdownTimeout 优雅关停窗口(SIGTERM / 更新重启时,等在途请求排干的 + // 时限)。长流式 SSE 合法时长可达分钟级,固定 5s 必然把在途请求掐成 + // 连接重置。缺省 "30s";"0" = 不等待直接退。改动需重启进程。 + ShutdownTimeout string `json:"shutdown_timeout"` + // HeadKeepalive 等上游首帧期间向客户端补 SSE 注释帧的间隔。 + // 缺省 "1500ms";"0" = 关闭(回到首帧否决窗口内零字节的旧行为)。 + // 改动需重启进程。 + HeadKeepalive string `json:"head_keepalive"` + // MaxPayloadBytes 入站请求体安全上限(字节),缺省 67108864(64 MiB)。 + // 这不是「大请求预拦截」:旧的 8 MB 紧上限因为多图/长会话被移除过(大请求 + // 交上游自然响应)。这里只挡「大到能把进程读死」的上传——读体是 io.ReadAll + // 无界的,一次几百 MB 的 body 就能把网关 OOM 掉。允许范围 8–512 MiB; + // 改动需重启进程。超限回 413(OpenAI 形状 / Anthropic 形状各自适配)。 + MaxPayloadBytes int64 `json:"max_payload_bytes"` + } `json:"server"` + + Cooldown struct { + // hard_credit / err_threshold / err_cooldown 三个历史键已退役: + // 硬冷却固定为次日 04:00(CooldownUntilTomorrow4AM),连续错误语义并入熔断器。 + // 旧 config 中的这些键因 JSON 未知字段而自然忽略,不报错。 + SoftRate string `json:"soft_rate"` // "600s",软限流冷却基数 + // SoftRateMax 软冷却指数退避的封顶,默认 "2h"。 + // 空值回落默认,非法值报错(处理风格同 soft_rate)。 + SoftRateMax string `json:"soft_rate_max"` // "2h" + } `json:"cooldown"` + + Schedule struct { + CheckinHours []int `json:"checkin_hours"` // [9,21] + TravelHours []int `json:"travel_hours"` // [9,21] + ActivityHours []int `json:"activity_hours"` // [10] + KeepaliveHours []int `json:"keepalive_hours"` // [22] + // KeepaliveRefreshWindow 周期 token 保活的临期窗口(如 "168h"=7 天):排程到点 + // 的保活只刷新剩余有效期 <= 窗口(或已过期/无 expiry)的凭证;面板手动 + // 「全部保活」始终全量,不受影响。空 = 默认 "168h";非法或 <=0 的值 fail fast。 + KeepaliveRefreshWindow string `json:"keepalive_refresh_window"` + GrowthHours []int `json:"growth_hours"` // [11] 成长任务队列(任务中心待办)自动执行 + // CheckinEnabled/TravelEnabled/ActivityEnabled/KeepaliveEnabled/GrowthEnabled 显式禁用开关(缺省 true)。 + // + // 为什么用独立 bool 而不是空数组/哨兵值表意"禁用": + // - 空数组与 null 在老语义里已被"未配置 → 回落默认"占用,改判会静默翻转 + // 所有老 config 的行为(用户只想删掉一行,结果关掉了签到);bool 缺省 true + // 则对老配置零影响,向后完全兼容。 + // - 开关与取值解耦:禁用时仍保留用户显式配的小时,重新启用无需补配。 + // - 无需猜测哨兵([-1] 之类),非法小时一律报错并提示改用本开关。 + // 旧 config 里的该键因 JSON 未知字段而自然忽略,不报错。 + CheckinEnabled bool `json:"checkin_enabled"` // 缺省 true;false = 关签到 + TravelEnabled bool `json:"travel_enabled"` // 缺省 true;false = 完全停猫猫旅行 + ActivityEnabled bool `json:"activity_enabled"` // 缺省 true;false = 停活跃上报 + KeepaliveEnabled bool `json:"keepalive_enabled"` // 缺省 true;false = 关 token 保活 + GrowthEnabled bool `json:"growth_enabled"` // 缺省 true;false = 关成长任务队列 + // WebActivityEnabled 国际版「网页通道」每日活跃腿(issue #111)。**缺省 false**, + // 与上面五个「缺省 true」的开关相反:上游实测每日 30 积分由活跃上报本身触发, + // 网页会话不是必要条件;这条腿每天要为每个国际号建一条真实会话并占一条活跃 + // 名额(上限 10),没必要默认开着。显式 true 才跑。 + WebActivityEnabled bool `json:"web_activity_enabled"` + + // IncludeDisabledInTasks 让「保号类」定时任务(签到 / 活跃上报 / token 保活 / + // 余额刷新)对**已禁用(disabled)**的账号也执行。 + // + // 为什么需要它:面板「禁用」的语义是「不再参与选号」,但这四类任务此前一律 + // `if st.Disabled { continue }`,等于把「停用流量」放大成「停止一切上游保号行为」 + // ——被禁用的号拿不到签到积分、不续 token、余额也不再刷新;而 ReenableIfCredits + // 明确不复活 disabled 账号,于是签到这条唯一的自动回血路径也断了。 + // + // 对「一次只放开一个号、用禁用做流量开关」的轮换用法(同 IP 多号防风控),闲置 + // 待命的号恰恰是最需要签到的那批——本开关即为该用法提供出口。 + // + // 缺省 false = 保持既有行为,对老配置零影响。打开后禁用号仍会签到 / 保活,但 + // **依旧不参与选号**:pool 选号侧的 disabled 过滤不受本开关影响。 + IncludeDisabledInTasks bool `json:"include_disabled_in_tasks"` + // GrowthConcurrency 排程轮次的账号间并发(缺省 1,上限 4):与面板手动 + // 「执行队列」同一个并发语义;调高更快的代价是上游风控暴露面。 + GrowthConcurrency int `json:"growth_concurrency"` + // JitterMinutes 0 = 精确整点。正值把触发时刻摊在该窗口内,同一小时偏移固定。 + JitterMinutes int `json:"jitter_minutes"` + // AccountSpreadMinutes 账号级摊开窗口(issue #45):0 = 关闭(同一秒打全池)。 + // >0 时排程触发的签到 / 旅行 / 活跃上报 / 保活把每个账号放在窗口内 + // 各自的偏移上(按 账号+任务+日期 哈希,当天固定),面板手动触发不受影响。 + // 窗口应小于相邻时点的间隔,否则上一批会跨过下一个时点。 + AccountSpreadMinutes int `json:"account_spread_minutes"` + // AccountSpreadMinGapSeconds 同批两个账号的最小间隔(偏移撞车时把后者推开)。 + // 0 = 只做随机。账号数 × 该值接近窗口时末尾会挤在一起。 + AccountSpreadMinGapSeconds int `json:"account_spread_min_gap_seconds"` + + // 余额后台周期刷新:两次签到时点之间 credits 也能保持新鲜(面板/状态观测用)。 + // 解冻语义同签到(余额 > 0 的冷却账号自动解冻),但不做签到不刷 token。 + BalanceRefreshEnabled bool `json:"balance_refresh_enabled"` // 缺省 true;false = 关闭 + BalanceRefreshMinutes int `json:"balance_refresh_minutes"` // 缺省 5;<=0 回落 5 + + // 补领清扫(issue #174):周期把「已达标未领」的任务领掉、把「待接受」的接受掉, + // 不跑任何行为链路。补的是新号自动跑当时还没达标(awaiting_progress)与 + // autoActions 白名单外的任务——它们此前除了手动一键完成没有任何补领路径。 + TaskSweepEnabled bool `json:"task_sweep_enabled"` // 缺省 true;false = 关闭 + TaskSweepMinutes int `json:"task_sweep_minutes"` // 缺省 15;<=0 回落 15 + + // 周期抖动(人味化,anti-fingerprint):>0 时余额刷新/补领清扫的每轮间隔 + // 在 ±(值/1000)×基准间隔内随机偏移,不再精确固定间隔打卡;余额刷新 + // 另把账号遍历摊开到同量级窗口内(见 internal/scheduler/humanize.go)。 + // 0 = 关闭(旧行为:精确 interval ticker + 全账号并发齐射)。上限 500 = 50%。 + // 例:balance_refresh_minutes=5 + 200 → 实际间隔在 3–7 分钟之间抖。 + BalanceRefreshJitterPermill int `json:"balance_refresh_jitter_permill"` // 缺省 0;0–500 + TaskSweepJitterPermill int `json:"task_sweep_jitter_permill"` // 缺省 0;0–500 + + // MakeupCardsPerRound 每轮连登管家最多用几张补签卡,0 = 不限(补到卡用光, + // 即 2026-10 之前的行为)。 + // + // 为什么留一个上限:补签是**会改账号历史**的写操作,一次把当月漏签全补齐 + // (对照实现 workbuddy-scheduled-tasks 的策略是「每轮最多 1 张」,理由写明 + // 「无卡/无断点/数据异常一律跳过,绝不瞎补」)。这里默认不动既有行为, + // 想保守的部署把它设成 1 即可——两轮之间还有次日签到,急不来。 + MakeupCardsPerRound int `json:"makeup_cards_per_round"` // 缺省 0(不限);>0 = 每轮上限 + + // 额度窗口探针(pool/window.go + scheduler/windowprobe.go):上游 429 带 + // 「将在 … 重置」时登记窗口,到点主动发一个最小请求,把新一轮额度窗口的 + // 计时起点钉在重置那一刻。 + // + // 为什么需要:上游按**首次请求**起算窗口。重置时刻到了却没人发请求,窗口就 + // 不开始,额度一直空转;等下一条真实请求进来,起点落到那一刻,中间那段额度 + // 白扔。关闭后行为回到「只解除冷却、不主动起窗」。 + WindowProbeEnabled bool `json:"window_probe_enabled"` // 缺省 true;false = 关闭 + } `json:"schedule"` + + Global struct { + // Enabled global realm 路由开关。缺省 true:Realm() 正常把 realm=global/ + // domain=workbuddy.ai 的账号判为 global 并路由 global base/路径。 + // 显式 "enabled": false 关闭(逃生门,纯 CN 锁定:即便 auth 写了 realm=global + // 也不路由,auth.Realm() 双保险的第一道闸)。纯 CN 部署行为不变:CN 账号 + // 恒判 cn,global base 只在 realm=global 的账号上被使用。 + Enabled bool `json:"enabled"` + // ChatBase / BillingBase 国际版上游 base 覆盖;空 = 按账号 auth 文件的 + // domain 选官方主机(internal/loginsite.BaseForDomain): + // *.codebuddy.ai → https://www.codebuddy.ai(官方 CLI 国际站,缺省) + // *.workbuddy.ai → https://www.workbuddy.ai(旧桌面端) + // domain 缺失时回落 https://www.codebuddy.ai。 + // 两个国际域实测同一后端,差别只在主机名与 WAF 口径——所以不要为了 + // 「统一」把 base 写死成一个域,老账号的 token 只在签发域可用。 + ChatBase string `json:"chat_base"` + BillingBase string `json:"billing_base"` + } `json:"global"` + + CN struct { + // ChatBase 国内版 chat/模型目录上游 base 覆盖;空 = 回落内置默认 + // https://www.workbuddy.cn(internal/upstream.New 的 ChatBaseCN,官方桌面端 + // product.json 的 endpoint)。 + // 备选入口 copilot.tencent.com 对海外出口(如 Clash 全局 + TUN)的 TLS 握手 + // 直接复位,CN 模型目录与对话全部 EOF;需要时用它填这个键回落。 + ChatBase string `json:"chat_base"` + // BillingBase 国内 billing/growth 上游 base 覆盖;空 = 内置默认 + // https://www.workbuddy.cn(2026-10-28 起对齐 WorkBuddy 5.9.3 客户端: + // 客户端把 CN 全部 billing/activity 都打到 workbuddy.cn)。 + // 旧口径是 www.codebuddy.cn(CodeBuddy CLI 时代,按 CLI 指纹点亮任务用), + // 需要退回时填 "https://www.codebuddy.cn"。 + BillingBase string `json:"billing_base"` + } `json:"cn"` + + Upstream struct { + // TimeoutSeconds 短 RPC(refresh/checkin/balance/FetchModels)总时长上限,默认 120。 + TimeoutSeconds int `json:"timeout_seconds"` + // TLSFingerprint 出站 ClientHello 指纹档位: + // "node"(缺省)复刻官方 Node/OpenSSL 形态,JA3/JA4 与真机一致; + // "go" 用 crypto/tls 原生形态(排障 / 回滚用)。 + // 默认 node:不配也走复刻,避免"忘了配就裸奔"。 + // 选 go 的唯一理由是指纹复刻导致握手异常时紧急回滚。 + TLSFingerprint string `json:"tls_fingerprint"` + // HeaderTimeoutSeconds 聊天 SSE 首字节前(响应头)上限;<=0 回落 TimeoutSeconds。 + HeaderTimeoutSeconds int `json:"header_timeout_seconds"` + // IdleTimeoutSeconds 聊天 SSE 流中空闲上限(活跃吐数据续命不掐);<=0 回落默认 300。 + IdleTimeoutSeconds int `json:"idle_timeout_seconds"` + // UserAgent 出站 User-Agent 显式覆盖(非空时全路径生效,优先于默认三段式)。 + // 全部出站请求生效:chat/refresh/checkin/balance/report/travel/FetchModels。 + // 默认值已对齐官方 WorkBuddy 桌面形态(三段式),用户仍可配完全自定义值改写。 + UserAgent string `json:"user_agent"` + // ClientVersion WorkBuddy 客户端版本段(出站 UA 的 `WorkBuddy/` 与归属头 + // X-IDE-Version)。空 = 内置默认(对齐官方 5.5.4 分发包)。 + ClientVersion string `json:"client_version"` + // CliVersion 出站 UA 中 `CLI/` 段的版本。空 = 内置默认(官方内置 CLI 2.137.1)。 + CliVersion string `json:"cli_version"` + // ClientName 用量归属头取值(X-Product / X-IDE-Name / X-IDE-Type / X-IDE-Version)。 + // 空 = 旧行为 X-Product="SaaS" 不设 X-IDE-*;配 "WorkBuddy" 则四头跟随。 + ClientName string `json:"client_name"` + // DeviceToken 设备风控 Token(X-Device-Token 头)全局兜底;空 = 不注入。 + // 每号 auth 文件的 device_token 键优先于本项。 + DeviceToken string `json:"device_token"` + // DeviceTokenFile device token 文件路径兜底(宿主落盘的桌面端 token,5 分钟读取缓存)。 + DeviceTokenFile string `json:"device_token_file"` + // PassthroughIP 是否透传客户端 IP 给上游(默认 false,反代安全边界)。 + PassthroughIP bool `json:"passthrough_ip"` + // DumpDir 非空时把 chat 请求的出站报文 + 上游原始响应落盘(诊断用,见 + // internal/upstream/dump.go)。默认空 = 不落盘:正文含用户提示词。 + DumpDir string `json:"dump_dir"` + // DumpMaxBytes 落盘文件里「出站请求体」片段的上限,默认 262144(256 KB)。 + // 长会话把 tools 定义排在几百条 messages 之后,256 KB 常在中途截断, + // 排障时看不到工具声明(issue #44 的反馈)。0 = 用默认值。 + DumpMaxBytes int `json:"dump_max_bytes"` + // RestrictionHoldSeconds 11140 风控连坐的全池暂停时长(秒),缺省 1800。 + // 上游把「账号存在异常行为」判在设备/出口上:一个请求顺着换号打下去会把 + // 一串账号送进风控。命中 11140 网关一律就地停手(不换号);同一 15 分钟窗 + // 内出现 2 个不同账号被限制时,再全池暂停这么久(期间 503 + Retry-After)。 + // 0 = 关掉全池暂停,只保留「命中即停手」。改动需重启进程。 + RestrictionHoldSeconds int `json:"restriction_hold_seconds"` + } `json:"upstream"` + + Features struct { + // SanitizeBlacklistFingerprints 出站请求体黑名单指纹脱敏(默认 true;false 完全还原)。 + SanitizeBlacklistFingerprints bool `json:"sanitize_blacklist_fingerprints"` + // SanitizeBrandScope 身份类规则(品牌词)作用域:"all" = 所有消息角色(默认,与上游既有行为一致); + // "identity" = 仅 system/developer,其余角色按用户数据原样透传(features.sanitize_brand_scope)。 + SanitizeBrandScope string `json:"sanitize_brand_scope"` + // EmbeddingsEnabled 实验特性:OpenAI 兼容嵌入端点 /v1/embeddings 的总开关。 + // 默认关闭——上游嵌入只注册了 bge-m3 一个模型(1024 维),实际可用性随账号/租户 + // 而异,且与对话模型是两套注册表,不适合默认敞开。面板保存后经 livecfg 热生效。 + // 关闭时端点仍在,但回 403 embeddings_disabled(而不是 404:让调用方看得出 + // 「功能存在、只是没开」,不用去猜路径拼错)。 + EmbeddingsEnabled bool `json:"embeddings_enabled"` + + // BusyRetry 6020/6021 渠道排队时,先在网关内按上游 retry_after 等一轮再试一次, + // 避免把「等 40 秒就好」的排队当成不可重试错误甩给客户端(默认 true)。 + BusyRetry bool `json:"busy_retry"` + // BusyWaitSeconds 单次排队等待上限(秒,默认 60)。0 = 用默认;负数 = 不等。 + BusyWaitSeconds int `json:"busy_wait_seconds"` + + // WatermarkStripEnabled 实验特性:水印裁切端点 POST /v1/images/strip-watermark + // 与 MCP 工具 strip_watermark 的总开关,默认 false。 + // + // 为什么默认关:这条链路要把成品图回读、解码、裁、再以 base64 回传(一张 + // 1024x1536 的 PNG 约 2.5MB → base64 3.4MB),只在「成品要彻底去水印」时划算; + // 而且它依赖提示词真的留出底部白边(实测模型只肯给 25~38%,深色桌面那张给了 + // 1%),所以不适合当默认行为。关闭时端点回 403 watermark_strip_disabled, + // MCP 工具不出现在 tools/list 里。面板保存后经 livecfg 热生效。 + WatermarkStripEnabled bool `json:"watermark_strip_enabled"` + } `json:"features"` + + Models struct { + // Hidden 不对外暴露的模型黑名单。裸名=两域都藏;"cn:xxx"/"global:xxx"=只藏该域。 + // 生效点:GET /v1/models 列表过滤 + POST /v1/chat/completions 点名拒绝 + // (只藏列表不够——知道名字仍可硬调)。面板保存后经 livecfg 热生效,无需重启。 + Hidden []string `json:"hidden"` + // Allowed 对外暴露的模型白名单(issue #68)。条目语法与 Hidden 一致: + // 裸名=两域都允许;"cn:xxx"/"global:xxx"=只允许该域。空数组/未配置 = + // 白名单不启用(默认放行全部,向后兼容)。非空时仅白名单内模型可出现在 + // /v1/models 并被点名调用,白名单外一律 400 拒绝(不打上游)。生效点在 + // 别名映射之后(别名解析出的真实目标同样受检,不能绕过白名单);与 Hidden + // 共存时取交集语义:Allowed 圈定「可能可见」集合,Hidden 仍可从中再剔除。 + // 面板保存后经 livecfg 热生效,无需重启。 + Allowed []string `json:"allowed"` + // Aliases 模型映射表(issue #30):"客户端名=真实模型名" 条目数组,与 Hidden + // 同存储形态(数组整体覆盖,面板删条目无需重启)。键:裸名=两域生效, + // "cn:x"/"global:x"=只在该域生效;键大小写不敏感。值可带 realm 前缀实现跨域 + // 指向("my-glm": "global:glm-5.2")。生效点:chat 请求解析 realm/裸名之后、 + // 隐藏检查/选号/出站 body 之前整体替换;被映射到的目标仍受 Hidden 约束 + // (别名不能绕过黑名单)。响应/日志/账本按实际生效模型名口径。 + // 面板保存后经 livecfg 热生效,无需重启。 + Aliases []string `json:"aliases"` + } `json:"models"` + + // Thinking 网关思考档位策略(issue #18 / #21)。网关按模型声明的 + // supportedEfforts 解析目标档:缺档时补默认档,可按开关以网关优先改写客户端 + // 档位;面板保存后经 upstream.Client.SetEffortPolicy 热生效,无需重启。 + Thinking struct { + // Enabled 策略总开关。false = 网关完全不碰档位(只剩既有 injectThinking + // 与降级管线),老配置不写本键时按 Default() 的 true 生效。 + Enabled bool `json:"enabled"` + // DefaultEffort 网关目标档。取值 "max"(默认;取模型支持的最高档)或 + // low/medium/high/xhigh 等具体档位(模型不支持时落到 ≤ 该档的最高支持档)。 + // 对 deepseek 等缺档请求,网关会同时注入 thinking.type=enabled。 + DefaultEffort string `json:"default_effort"` + // ClientPriority true = 客户端优先:客户端发了档位就照单全收(含 off), + // 只在客户端没发时补 DefaultEffort;false = 网关优先,按 OverrideScope 改写。 + ClientPriority bool `json:"client_priority"` + // OverrideScope 网关优先的作用域(ClientPriority=false 时生效): + // "level"(默认)= 只覆盖档位,客户端「关闭思考」(off/none/disabled 或 + // thinking.type=disabled)一律尊重; + // "all" = 档位与开关一起覆盖:客户端的关闭意图也会被改写成开启 + 目标档。 + OverrideScope string `json:"override_scope"` + // ModelDefaults 按模型覆盖 DefaultEffort:键 "cn:model" / "global:model" + // (精确到域)或裸 "model"(两域共用);值 "max"/"high"/…,或 "inherit" + // 表示不覆盖。解析时剔除空值与 inherit,键值统一转小写。 + ModelDefaults map[string]string `json:"model_defaults,omitempty"` + } `json:"thinking"` + + Prompt struct { + // Mode passthrough(默认)= 透传客户端原始 system(降级重试仍会切到 Degraded); + // custom = 网关用自有系统提示词替换客户端 system/developer; + // append = 两者并用:开头连续 system/developer 块后插网关 system,既有消息逐字不动(issue #129)。 + Mode string `json:"mode"` // "passthrough" / "custom" / "append" + // File 提示词文件路径;空 = 内置默认 defaultprompt.md; + // 路径非空但不可读 → 启动报错(fail fast,避免静默回落到内置默认)。 + File string `json:"file"` + // KeepRecentRounds 只保留最近 N 轮对话(issue #99):出站前丢掉更早的 + // user/assistant/tool 消息,system 全留。0 = 关闭(全量透传)。 + // 多轮长对话的输入 token 主要花在这上面;丢的是上下文而不是协议。 + KeepRecentRounds int `json:"keep_recent_rounds"` + } `json:"prompt"` + + // PromptText 解析后的系统提示词文本(custom/append 模式使用)。 + PromptText string `json:"-"` + + Upstash struct { + URL string `json:"url"` // 空 = 纯内存模式;支持完整 rediss:// URL 或 https://xxx.upstash.io host + Token string `json:"token"` // url 非完整连接串时用于组装 rediss://default:@:6379 + } `json:"upstash"` + + Pool struct { + MaxInFlight int `json:"max_in_flight"` // 单账号最大在途请求数,0 = 不限 + MaxInFlightGlobal int `json:"max_in_flight_global"` // global 域单账号在途上限(WAF 风控紧域压低并发),0 = 回落默认 2 + BreakerThreshold int `json:"breaker_threshold"` // 连续失败次数触发熔断,默认 3 + BreakerCooldown string `json:"breaker_cooldown"` // 基础熔断时长,默认 "30m" + BreakerCooldownMax string `json:"breaker_cooldown_max"` // 指数退避封顶,默认 "6h" + // 连败降权(issue #114):ErrClient/传输层这类「不罚号」失败连续计数,达阈 + // 临时出池。与冷却/熔断并存取更长者不叠加。默认 5 次 / 10m。 + DegradeThreshold int `json:"degrade_threshold"` // 连败次数触发降权,默认 5 + DegradeCooldown string `json:"degrade_cooldown"` // 降权时长(固定,非指数退避),默认 "10m" + DegradeCooldownMax string `json:"degrade_cooldown_max"` // 降权时长的上限钳制,默认 "2h"(仅当 cooldown 超该值才钳制) + // SelectionStrategy 选号策略(pool 包 strategy.go):weighted(缺省,加权随机)/ + // round_robin(轮询,每次请求换下一个)/ sequential(顺序耗尽,当前号用到不可用 + // 才换)。空或未知值 = weighted。 + // + // 三条策略都只在**已过全部可用性判定**的候选里决定「选哪个」:健康、冷却、 + // 在途上限、积分保底、成本分层、账号优先级全部先于它生效。所以切到 + // sequential 也烧不穿 credit_floor——这是有意的边界,不是实现疏忽。 + // 热生效(面板保存配置即换),无需重启。 + SelectionStrategy string `json:"selection_strategy"` + IdleWeightPerHour float64 `json:"idle_weight_per_hour"` // 闲置补偿:每小时未用 +0.5 权重 + IdleWeightMax float64 `json:"idle_weight_max"` // 闲置补偿封顶,默认 5.0 + // PreferExpiring 快过期积分加权开关,默认 true。开启且 expiring_soon 窗口内 + // 存在有效批次时,该账号选号权重 ×3(虚拟实例,见 pool 路由加权); + // 不按到期时间排序、与批次金额无关(issue #101 对齐实现口径)。 + // 关闭后完全不使用到期信息选号。 + PreferExpiring bool `json:"prefer_expiring"` + // ExpiringSoon 快过期积分窗口(如 "720h"=30天):签到/余额刷新时,到期时间在 + // 此窗口内的批次令账号命中上述加权;窗口开大 → 命中账号变多、 + // 偏好被稀释。空/0 = 禁用该加权门槛。 + // 窗口外的批次完全不参与:账号最早批次在窗口外时即使它最近到期也不加权。 + ExpiringSoon string `json:"expiring_soon"` + // CostExploreInterval costTier 条件探索窗口(issue #136 方案 a′):tier 0 + // 垄断层存在且 tier 1 有成员时,距上次探索 ≥ 窗口则本次 pick 生效层切 + // tier 1-only(探索=搭车改道,零新增上游请求;成功即毕业,失败走既有 + // 错误策略)。默认 "30m"(≤48 次/天/模型);"0" 关停(完全回到现状行为); + // 空值回落默认。 + CostExploreInterval string `json:"cost_explore_interval"` + // BalanceWindow 窗口用量调度窗口(issue #112,默认 "1h","0" 关停): + // 按 (账号, 模型) 在该窗口内累计消费的 token 反比降权,把热点号打散, + // 避免一个号烧到 6004 限额而同期其他号闲置。与快过期加权/闲置补偿叠加。 + // 软降权:积分保底、账号优先级、账号占比这些硬语义不受影响。 + BalanceWindow string `json:"balance_window"` + // ReserveCredits 保留积分阈值:余额已知且 <= 该值的账号停止接单(仍在池中、 + // 照常跑定时任务,充值后自动恢复)。上游余额耗尽会发提醒短信,设阈值即避免 + // 被用到 0。未配置(键缺席)→ 默认 10;显式写 0 = 关闭;从未查到余额的账号不受影响。 + // 指针类型用于区分「未配置」(nil → 默认 10)与「显式 0」(关闭)。 + ReserveCredits *int64 `json:"reserve_credits"` + // ReserveCreditsByRealm 按域覆盖上面的阈值(issue #147):键 "cn"/"global", + // 值为该域阈值(0 = 该域关闭)。场景是国内版留 1000 分养号、国际版只留 350 + // 分接低流量模型——两域共用一个数值时只能取更严的那个。未写的域用全局值。 + ReserveCreditsByRealm map[string]int64 `json:"reserve_credits_by_realm"` + // AccountPriority / AccountShare 账号级路由偏好(issue #62)。键 = uid(面板账号 + // 行的短 uid,悬停看完整值)。缺省/空表 = 全部未配置,选号行为与旧版完全一致。 + // account_priority: {"": 1} 小 = 先消耗。配了的号构成「先烧层」,层内号 + // 可用时其余号不接单;层内号烧空/冷却/停牌后自动让位给下一层。 + // account_share: {"": 70, "": 30} 同层内按归一化比例分流量 + // (70/30 与 7/3 同义,不必凑满 100)。**优先于 prefer_expiring**:配了占比 + // 的号独占本层流量,到期优先只对没配占比的号生效。 + // 非正值(priority ≤ 0 / share ≤ 0)由校验剔除,等价于未配置。 + AccountPriority map[string]int `json:"account_priority"` + AccountShare map[string]float64 `json:"account_share"` + // CreditFloor 积分保底:账号余额低于该值时,对实测收费模型(tier 2)不再 + // 参与选号——防止收费请求把余额打穿、连免费模型都 402 冷却到次日签到。 + // tier 0(免费)不受限;tier 1(无观测)按目录倍率分档:≤ 下面的 + // CreditFloorMaxRate 放行(让便宜新模型跑出第一笔账本),更高的仍拦。 + // 签到回血越过 floor 自动恢复。默认 0 = 关闭;负值钳 0。 + CreditFloor int64 `json:"credit_floor"` + // CreditFloorMaxRate 保底兜底允许的目录倍率上限(issue #30 / PR #2)。 + // 0.2 = 便宜模型(x0.11 这类)在触底号上放行入账,x1.62 这类仍按收费拦。 + // 0 = 严格模式(任何已知正倍率都拦);负值钳 0。面板「积分保底」档位旁可改。 + CreditFloorMaxRate float64 `json:"credit_floor_max_rate"` + // ModelFallback 模型降级路由表:key = 客户端请求的模型(裸名), + // value = 该模型被 6004 模型级限流时改用的等价模型。 + // 例:{"deepseek-v4.1-flash": "deepseek-v4-flash"}。 + // + // 语义:等价模型是同一底层能力、只是计价不同;便宜的那个被限流时改用 + // 稍贵的继续服务(可用性优先),限流解除后自动回原模型(不写持久状态)。 + // 只对 6004 生效;11102/11101/普通 429/5xx 都不降级。 + // 缺省 nil = 不降级(对老配置零影响)。 + ModelFallback map[string]string `json:"model_fallback"` + } `json:"pool"` + + SessionSticky struct { + Enabled bool `json:"enabled"` // 默认 true + TTL string `json:"ttl"` // 会话绑定 TTL,默认 "30m" + GCInterval string `json:"gc_interval"` // 会话 GC 周期,默认 "5m" + } `json:"session_sticky"` + + // Jitter 在 schedule 里。下面几段缺省关闭,旧配置行为不变。 + Admin struct { + Enabled bool `json:"enabled"` + AuditEnabled bool `json:"audit_enabled"` + AuditFile string `json:"audit_file"` + } `json:"admin"` + Metrics struct { + Enabled bool `json:"enabled"` + } `json:"metrics"` + Alerting struct { + Enabled bool `json:"enabled"` + WebhookURL string `json:"webhook_url"` + Secret string `json:"secret"` + IntervalSeconds int `json:"interval_seconds"` + TimeoutSeconds int `json:"timeout_seconds"` + StartupGraceSeconds int `json:"startup_grace_seconds"` + MinHealthyCN int `json:"min_healthy_cn"` + MinHealthyGlobal int `json:"min_healthy_global"` + RecoverHealthy int `json:"recover_healthy"` + BreakerThreshold int `json:"breaker_threshold"` + ForTicks int `json:"for_ticks"` + ClearTicks int `json:"clear_ticks"` + SendResolve bool `json:"send_resolve"` + } `json:"alerting"` + + // Watchdog 上游目录改版监控:定期对 /v1/models 结果取指纹,变了经告警 webhook 通知。 + // 默认关闭——它只在「想第一时间知道上游改了目录」时有价值,开了才有轮询成本。 + Watchdog struct { + Enabled bool `json:"enabled"` + IntervalSeconds int `json:"interval_seconds"` + } `json:"watchdog"` + Budget struct { + DailyCreditLimit float64 `json:"daily_credit_limit"` // 0 = 不限 + // BurstCreditLimit 5 分钟窗口内累计 credit 达此值即拒绝(0 = 关闭)。 + // issue #229:高倍率模型 140k 上下文一次 20+ 积分,日上限止血太慢。 + BurstCreditLimit float64 `json:"burst_credit_limit"` + // CacheLowRate 连续 5 轮缓存命中率低于此百分比即冷却 60s(0 = 关闭)。 + CacheLowRate float64 `json:"cache_low_rate"` + } `json:"budget"` + + // 解析后 + SoftRateDur time.Duration `json:"-"` + SoftRateMaxDur time.Duration `json:"-"` + BreakerCooldownDur time.Duration `json:"-"` + BreakerCooldownMaxD time.Duration `json:"-"` + DegradeCooldownDur time.Duration `json:"-"` + DegradeCooldownMaxD time.Duration `json:"-"` + SessionTTL time.Duration `json:"-"` + SessionGCInterval time.Duration `json:"-"` + BalanceRefreshInterval time.Duration `json:"-"` // 0 = 不启动(enabled=false) + TaskSweepInterval time.Duration `json:"-"` // 0 = 不启动(task_sweep_enabled=false) + ExpiringSoonDur time.Duration `json:"-"` + // KeepaliveRefreshWindowDur 解析后的周期保活临期窗口;空回落 168h,<=0 报错。 + KeepaliveRefreshWindowDur time.Duration `json:"-"` + // CostExploreIntervalDur 解析后的 costTier 探索窗口(issue #136);0 = 关停。 + CostExploreIntervalDur time.Duration `json:"-"` + // BalanceWindowDur 解析后的窗口用量调度窗口(issue #112);0 = 关停。 + BalanceWindowDur time.Duration `json:"-"` + // ServerReadTimeoutDur 解析后的入站请求读取上限(issue #100);0 = 不限制。 + ServerReadTimeoutDur time.Duration `json:"-"` + // HeadKeepaliveDur 解析后的首帧心跳间隔(缺省 1.5s,0 = 关闭)。 + HeadKeepaliveDur time.Duration `json:"-"` + // ShutdownTimeoutDur 解析后的优雅关停窗口;0 = 不等待在途请求直接退。 + ShutdownTimeoutDur time.Duration `json:"-"` + // ReloadIntervalDur 解析后的账号目录轮询间隔(issue #199);0 = 关闭轮询。 + ReloadIntervalDur time.Duration `json:"-"` +} + +// Default 默认配置。 +func Default() *Config { + c := &Config{ + // 默认只绑回环:网关 + 面板 + 空/弱 api_key 同时暴露在公网是这份配置最危险的 + // 组合。要对外先过反代(nginx/caddy),确需直连再显式改 0.0.0.0:7863。 + Listen: "127.0.0.1:7863", + APIKey: "", + AuthDir: "./auths", + StateFile: "./data/state.json", + } + c.Cooldown.SoftRate = "600s" + c.Cooldown.SoftRateMax = "2h" + c.Server.ReadTimeout = "300s" + c.Server.ShutdownTimeout = "30s" + c.Server.MaxPayloadBytes = 64 << 20 + c.Upstream.RestrictionHoldSeconds = 1800 + c.Panel.PackageDetailLimit = 5 + c.Update.AutoTime = "04:00" + // 账号目录热重载(issue #199):默认 10s 轮询、连续 2 次确认才删。 + c.Accounts.ReloadInterval = "10s" + c.Accounts.ReloadDeleteConfirm = 2 + c.Logging.RequestArchiveEnabled = true + c.Logging.RequestRetentionDays = 7 + c.Logging.RequestArchiveMaxMB = 100 + c.Logging.PanelLogEnabled = true + c.Logging.PanelLogRetentionDays = 7 + c.Logging.PanelLogMaxMB = 50 + // 缺省 true 靠显式赋值实现(同 Schedule 开关):JSON 里键缺席时字段保留此值, + // 只有显式 false 才关闭来源记录。 + c.Logging.RequestClientInfo = true + c.Schedule.CheckinHours = []int{9, 21} + c.Schedule.TravelHours = []int{9, 21} + c.Schedule.ActivityHours = []int{10} + c.Schedule.KeepaliveHours = []int{22} + // 周期保活临期窗口默认 7 天:排程保活只刷新一周内到期的凭证,其余账号不动。 + c.Schedule.KeepaliveRefreshWindow = "168h" + c.Schedule.GrowthHours = []int{11} + // 开关「缺省 true」靠这几行实现:Load 先取 Default() 再 json.Unmarshal 覆盖, + // 键缺席(或为 null)时字段原样保留 true,只有显式 false 才关。 + c.Schedule.CheckinEnabled = true + c.Schedule.TravelEnabled = true + c.Schedule.ActivityEnabled = true + c.Schedule.KeepaliveEnabled = true + c.Schedule.GrowthEnabled = true + c.Schedule.BalanceRefreshEnabled = true + c.Schedule.BalanceRefreshMinutes = 5 + c.Schedule.TaskSweepEnabled = true + c.Schedule.TaskSweepMinutes = 15 + c.Schedule.WindowProbeEnabled = true + c.Upstream.TimeoutSeconds = 120 + // HeaderTimeoutSeconds/IdleTimeoutSeconds 默认 0(未设置态),回落见 normalize()。 + c.Upstream.HeaderTimeoutSeconds = 0 + c.Upstream.IdleTimeoutSeconds = 0 + // Global.Enabled 缺省 true(纯 CN 行为不变:CN 账号恒判 cn,global base 不被使用); + // ChatBase/BillingBase 缺省空(回落内置默认)。 + c.Global.Enabled = true + c.Features.SanitizeBlacklistFingerprints = true + c.Features.SanitizeBrandScope = "all" + // 6020/6021 排队等待(见 internal/server/handler.go 的 ErrUpstreamBusy 分支): + // 缺省等一轮(60s 上限),避免把上游明说「40 秒后再来」的排队秒变成客户端可见失败。 + c.Features.BusyRetry = true + c.Features.BusyWaitSeconds = 60 + c.Prompt.Mode = "passthrough" // 缺省 passthrough:透传客户端原始 system(对齐上游;custom 由用户显式选择) + // 思考档位策略缺省:网关按模型最高档补缺档请求,但客户端显式档位优先 + // (client_priority=true),且不覆盖客户端的关闭思考意图(override_scope=level)。 + c.Thinking.Enabled = true + c.Thinking.DefaultEffort = upstream.DefaultGatewayEffort + c.Thinking.ClientPriority = true + c.Thinking.OverrideScope = "level" + c.Pool.MaxInFlight = 3 + // MaxInFlightGlobal 缺省 2:global 域 WAF 风控更紧,压低单号并发(WAF 403 修复 + // P1-1);0/负数 normalize 回落默认(与 max_in_flight 的 0=不限语义不同,分档键 + // 的 0 没有合理语义,回退分档默认最稳)。 + c.Pool.MaxInFlightGlobal = 2 + c.Pool.BreakerThreshold = 3 + c.Pool.BreakerCooldown = "30m" + c.Pool.BreakerCooldownMax = "6h" + c.Pool.DegradeThreshold = 5 + c.Pool.DegradeCooldown = "10m" + c.Pool.DegradeCooldownMax = "2h" + c.Pool.IdleWeightPerHour = 0.5 + c.Pool.IdleWeightMax = 5.0 + c.Pool.PreferExpiring = true + // 快过期窗口默认 30 天。7 天太窄:奖励积分的批次到期日普遍排在 2~4 周后, + // 窗口内常常一个号都不命中,加权形同未开(实测三号池最早批次 22/25/27 天后, + // credits_expiring 全 0,选号退化成普通加权)。窗口内是相对紧迫度,放宽不会 + // 让紧迫度失真,只是把「今天到期 vs 四周后到期」也纳入同一条曲线。 + c.Pool.ExpiringSoon = "720h" + // costTier 探索默认 30m(issue #136:垄断破除 + 搭车改道零新增请求);"0" 关停。 + c.Pool.CostExploreInterval = "30m" + // 窗口用量调度默认 1h(issue #112:热点号降权,把流量摊给闲置号);"0" 关停。 + c.Pool.BalanceWindow = "1h" + c.SessionSticky.Enabled = true + c.SessionSticky.TTL = "30m" + c.SessionSticky.GCInterval = "5m" + c.Admin.AuditFile = "./data/admin_audit.log" + c.Alerting.IntervalSeconds = 30 + c.Alerting.TimeoutSeconds = 5 + c.Alerting.StartupGraceSeconds = 30 + c.Alerting.MinHealthyCN = 1 + c.Alerting.RecoverHealthy = 1 + c.Alerting.ForTicks = 2 + c.Alerting.ClearTicks = 2 + c.Watchdog.IntervalSeconds = 3600 // 目录变化是低频事件,一小时一次足够 + return c +} + +// Load 从文件读,再用 WB2A_* env 覆盖。 +func Load(path string) (*Config, error) { + c := Default() + if path != "" { + // 目录检查:Docker bind mount 在宿主机文件缺失时会静默创建同名目录, + // 直接 ReadFile 会报 "Incorrect function" 之类晦涩错误,这里给出可操作提示。 + if st, statErr := os.Stat(path); statErr == nil && st.IsDir() { + return nil, fmt.Errorf("config %s 是目录而非文件——"+ + "Docker 部署时若宿主机缺少 config.json,bind mount 会创建同名目录。"+ + "请先 `cp config.example.json config.json` 或删除该目录(程序会自动生成配置)", path) + } + // safefile:正文坏(掉电留下全 0 / 半截)时回退 config.json.bak, + // 两边都坏才报错——不再让「配置损坏」直接变成起不来。 + raw, err := safefile.Read(path, nil) + if err != nil { + return nil, fmt.Errorf("read config: %w", err) + } + if _, err := ParseConfigInto(raw, c); err != nil { + return nil, err + } + } + applyEnv(c) + if err := c.normalize(); err != nil { + return nil, err + } + return c, nil +} + +// ParseConfigInto 把 JSON 覆盖到 c 上并 normalize(不做 env、不读文件)。 +// 面板保存配置走这条路径:与 Load 完全同一套解析/校验逻辑,避免两处漂移。 +func ParseConfigInto(raw []byte, c *Config) (*Config, error) { + if err := json.Unmarshal(raw, c); err != nil { + return nil, fmt.Errorf("parse config: %w", err) + } + if err := c.normalize(); err != nil { + return nil, err + } + return c, nil +} + +// ParseConfig 基于默认值解析一段配置 JSON(等价于 Load 的文件分支,但不读环境变量)。 +func ParseConfig(raw []byte) (*Config, error) { + return ParseConfigInto(raw, Default()) +} + +// WriteDefault 在 path 落一份推荐配置(首次运行自动生成,双击即开免手工复制样例)。 +// 值取自 Default()(含超时/熔断/签到排程等推荐值),api_key 用 crypto/rand 随机生成: +// 安全默认优于示例占位符(listen 绑定 0.0.0.0,空 key 会把网关裸暴露给局域网)。 +// 返回生成的 key 供启动日志透出。已存在时经 O_EXCL 原子拒绝,绝不改写用户配置。 +func WriteDefault(path string) (string, error) { + raw := make([]byte, 18) + if _, err := rand.Read(raw); err != nil { + return "", fmt.Errorf("gen api_key: %w", err) + } + key := "sk-" + base64.RawURLEncoding.EncodeToString(raw) + c := Default() + c.APIKey = key + _ = c.normalize() // Default() 全合法,normalize 仅补齐 header/idle 超时的展示值 + out, err := json.MarshalIndent(c, "", " ") + if err != nil { + return "", fmt.Errorf("marshal config: %w", err) + } + if dir := filepath.Dir(path); dir != "" && dir != "." { + if err := os.MkdirAll(dir, 0o755); err != nil { + return "", fmt.Errorf("mkdir config dir: %w", err) + } + } + // O_EXCL 原子拒绝覆盖:即使调用方漏判"不存在",也绝不悄悄改写用户已有配置。 + f, err := os.OpenFile(path, os.O_WRONLY|os.O_CREATE|os.O_EXCL, 0o600) + if err != nil { + return "", fmt.Errorf("write config: %w", err) + } + defer f.Close() + if _, err := f.Write(out); err != nil { + return "", fmt.Errorf("write config: %w", err) + } + return key, nil +} + +func applyEnv(c *Config) { + if v := os.Getenv("WB2A_LISTEN"); v != "" { + c.Listen = v + } + if v := os.Getenv("WB2A_API_KEY"); v != "" { + c.APIKey = v + } + if v := os.Getenv("WB2A_AUTH_DIR"); v != "" { + c.AuthDir = v + } + if v := os.Getenv("WB2A_STATE_FILE"); v != "" { + c.StateFile = v + } + if v := os.Getenv("WB2A_DNS"); v != "" { + c.DNSServers = splitCSV(v) + } + if v := os.Getenv("WB2A_SOFT_RATE"); v != "" { + c.Cooldown.SoftRate = v + } + if v := os.Getenv("WB2A_SOFT_RATE_MAX"); v != "" { + c.Cooldown.SoftRateMax = v + } + if v := os.Getenv("WB2A_TIMEOUT_SECONDS"); v != "" { + if n, err := strconv.Atoi(v); err == nil { + c.Upstream.TimeoutSeconds = n + } + } + if v := os.Getenv("WB2A_HEADER_TIMEOUT_SECONDS"); v != "" { + if n, err := strconv.Atoi(v); err == nil { + c.Upstream.HeaderTimeoutSeconds = n + } + } + if v := os.Getenv("WB2A_IDLE_TIMEOUT_SECONDS"); v != "" { + if n, err := strconv.Atoi(v); err == nil { + c.Upstream.IdleTimeoutSeconds = n + } + } + if v := os.Getenv("WB2A_USER_AGENT"); v != "" { + c.Upstream.UserAgent = v + } + if v := os.Getenv("WB2A_TLS_FINGERPRINT"); v != "" { + c.Upstream.TLSFingerprint = v + } + if v := os.Getenv("WB2A_CLIENT_VERSION"); v != "" { + c.Upstream.ClientVersion = v + } + if v := os.Getenv("WB2A_CLI_VERSION"); v != "" { + c.Upstream.CliVersion = v + } + if v := os.Getenv("WB2A_CLIENT_NAME"); v != "" { + c.Upstream.ClientName = v + } + if v := os.Getenv("WB2A_DEVICE_TOKEN"); v != "" { + c.Upstream.DeviceToken = v + } + if v := os.Getenv("WB2A_DEVICE_TOKEN_FILE"); v != "" { + c.Upstream.DeviceTokenFile = v + } + if v := os.Getenv("WB2A_DUMP_UPSTREAM"); v != "" { + c.Upstream.DumpDir = v + } + if v := os.Getenv("WB2A_PASSTHROUGH_IP"); v != "" { + if b, err := strconv.ParseBool(v); err == nil { + c.Upstream.PassthroughIP = b + } + } + if v := os.Getenv("WB2A_SANITIZE_FINGERPRINTS"); v != "" { + if b, err := strconv.ParseBool(v); err == nil { + c.Features.SanitizeBlacklistFingerprints = b + } + } + if v := os.Getenv("WB2A_SANITIZE_BRAND_SCOPE"); v != "" { + c.Features.SanitizeBrandScope = v + } + if v := os.Getenv("WB2A_PROMPT_MODE"); v != "" { + c.Prompt.Mode = v + } + if v := os.Getenv("WB2A_PROMPT_FILE"); v != "" { + c.Prompt.File = v + } + // 思考档位策略(thinking 节)。bool 解析失败视为不生效(与其它 env 同口径)。 + if v := os.Getenv("WB2A_THINKING_ENABLED"); v != "" { + if b, err := strconv.ParseBool(v); err == nil { + c.Thinking.Enabled = b + } + } + if v := os.Getenv("WB2A_THINKING_DEFAULT_EFFORT"); v != "" { + c.Thinking.DefaultEffort = v + } + if v := os.Getenv("WB2A_THINKING_CLIENT_PRIORITY"); v != "" { + if b, err := strconv.ParseBool(v); err == nil { + c.Thinking.ClientPriority = b + } + } + if v := os.Getenv("WB2A_THINKING_OVERRIDE_SCOPE"); v != "" { + c.Thinking.OverrideScope = v + } + if v := os.Getenv("WB2A_EXPIRING_SOON"); v != "" { + c.Pool.ExpiringSoon = v + } + if v := os.Getenv("WB2A_SCHEDULE_JITTER_MINUTES"); v != "" { + if n, err := strconv.Atoi(v); err == nil { + c.Schedule.JitterMinutes = n + } + } + if v := os.Getenv("WB2A_SCHEDULE_ACCOUNT_SPREAD_MINUTES"); v != "" { + if n, err := strconv.Atoi(v); err == nil { + c.Schedule.AccountSpreadMinutes = n + } + } + if v := os.Getenv("WB2A_SCHEDULE_ACCOUNT_SPREAD_MIN_GAP_SECONDS"); v != "" { + if n, err := strconv.Atoi(v); err == nil { + c.Schedule.AccountSpreadMinGapSeconds = n + } + } + if v := os.Getenv("WB2A_SCHEDULE_BALANCE_REFRESH_JITTER_PERMILL"); v != "" { + if n, err := strconv.Atoi(v); err == nil { + c.Schedule.BalanceRefreshJitterPermill = n + } + } + if v := os.Getenv("WB2A_SCHEDULE_TASK_SWEEP_JITTER_PERMILL"); v != "" { + if n, err := strconv.Atoi(v); err == nil { + c.Schedule.TaskSweepJitterPermill = n + } + } + if v := os.Getenv("WB2A_ADMIN_ENABLED"); v != "" { + if b, err := strconv.ParseBool(v); err == nil { + c.Admin.Enabled = b + } + } + if v := os.Getenv("WB2A_ADMIN_AUDIT_ENABLED"); v != "" { + if b, err := strconv.ParseBool(v); err == nil { + c.Admin.AuditEnabled = b + } + } + if v := os.Getenv("WB2A_ADMIN_AUDIT_FILE"); v != "" { + c.Admin.AuditFile = v + } + if v := os.Getenv("WB2A_METRICS_ENABLED"); v != "" { + if b, err := strconv.ParseBool(v); err == nil { + c.Metrics.Enabled = b + } + } + if v := os.Getenv("WB2A_BUDGET_DAILY_CREDIT_LIMIT"); v != "" { + if f, err := strconv.ParseFloat(v, 64); err == nil { + c.Budget.DailyCreditLimit = f + } + } + if v := os.Getenv("WB2A_ALERTING_ENABLED"); v != "" { + if b, err := strconv.ParseBool(v); err == nil { + c.Alerting.Enabled = b + } + } + if v := os.Getenv("WB2A_ALERTING_WEBHOOK_URL"); v != "" { + c.Alerting.WebhookURL = v + } + if v := os.Getenv("WB2A_PREFER_EXPIRING"); v != "" { + if b, err := strconv.ParseBool(v); err == nil { + c.Pool.PreferExpiring = b + } + } +} + +// EnvironmentManagedFields 列出被启动环境变量覆盖的配置字段路径(**值不回传**—— +// 面板只用这些名字把对应输入框禁用/提示,避免「改了也不生效」的无效编辑)。 +// 只报告「值合法、启动时确实会生效」的项:int/bool/float 解析不过的 env 视为不生效、不列出。 +// 移植上游 PR #104;字段表覆盖本 fork 全部 WB2A_* 覆盖项(含本 fork 扩展的 +// schedule/admin/metrics/budget/alerting 族)。 +func (c *Config) EnvironmentManagedFields() []string { + fields := []struct{ env, path, kind string }{ + {"WB2A_LISTEN", "listen", ""}, {"WB2A_API_KEY", "api_key", ""}, + {"WB2A_AUTH_DIR", "auth_dir", ""}, {"WB2A_STATE_FILE", "state_file", ""}, + {"WB2A_DNS", "dns_servers", ""}, + {"WB2A_SOFT_RATE", "cooldown.soft_rate", ""}, {"WB2A_SOFT_RATE_MAX", "cooldown.soft_rate_max", ""}, + {"WB2A_TIMEOUT_SECONDS", "upstream.timeout_seconds", "int"}, {"WB2A_HEADER_TIMEOUT_SECONDS", "upstream.header_timeout_seconds", "int"}, + {"WB2A_IDLE_TIMEOUT_SECONDS", "upstream.idle_timeout_seconds", "int"}, {"WB2A_USER_AGENT", "upstream.user_agent", ""}, + {"WB2A_TLS_FINGERPRINT", "upstream.tls_fingerprint", ""}, + {"WB2A_CLIENT_VERSION", "upstream.client_version", ""}, {"WB2A_CLI_VERSION", "upstream.cli_version", ""}, + {"WB2A_CLIENT_NAME", "upstream.client_name", ""}, {"WB2A_DEVICE_TOKEN", "upstream.device_token", ""}, + {"WB2A_DEVICE_TOKEN_FILE", "upstream.device_token_file", ""}, {"WB2A_PASSTHROUGH_IP", "upstream.passthrough_ip", "bool"}, + {"WB2A_SANITIZE_FINGERPRINTS", "features.sanitize_blacklist_fingerprints", "bool"}, + {"WB2A_SANITIZE_BRAND_SCOPE", "features.sanitize_brand_scope", ""}, + {"WB2A_PROMPT_MODE", "prompt.mode", ""}, {"WB2A_PROMPT_FILE", "prompt.file", ""}, + {"WB2A_THINKING_ENABLED", "thinking.enabled", "bool"}, + {"WB2A_THINKING_DEFAULT_EFFORT", "thinking.default_effort", ""}, + {"WB2A_THINKING_CLIENT_PRIORITY", "thinking.client_priority", "bool"}, + {"WB2A_THINKING_OVERRIDE_SCOPE", "thinking.override_scope", ""}, + {"WB2A_EXPIRING_SOON", "pool.expiring_soon", ""}, {"WB2A_PREFER_EXPIRING", "pool.prefer_expiring", "bool"}, + {"WB2A_SCHEDULE_JITTER_MINUTES", "schedule.jitter_minutes", "int"}, + {"WB2A_SCHEDULE_ACCOUNT_SPREAD_MINUTES", "schedule.account_spread_minutes", "int"}, + {"WB2A_SCHEDULE_ACCOUNT_SPREAD_MIN_GAP_SECONDS", "schedule.account_spread_min_gap_seconds", "int"}, + {"WB2A_ADMIN_ENABLED", "admin.enabled", "bool"}, {"WB2A_ADMIN_AUDIT_ENABLED", "admin.audit_enabled", "bool"}, + {"WB2A_ADMIN_AUDIT_FILE", "admin.audit_file", ""}, + {"WB2A_METRICS_ENABLED", "metrics.enabled", "bool"}, + {"WB2A_BUDGET_DAILY_CREDIT_LIMIT", "budget.daily_credit_limit", "float"}, + {"WB2A_ALERTING_ENABLED", "alerting.enabled", "bool"}, {"WB2A_ALERTING_WEBHOOK_URL", "alerting.webhook_url", ""}, + } + var out []string + for _, field := range fields { + value := os.Getenv(field.env) + if value == "" { + continue + } + switch field.kind { + case "int": + if _, err := strconv.Atoi(value); err != nil { + continue + } + case "bool": + if _, err := strconv.ParseBool(value); err != nil { + continue + } + case "float": + if _, err := strconv.ParseFloat(value, 64); err != nil { + continue + } + } + out = append(out, field.path) + } + return out +} + +// splitCSV 逗号分隔 → 去空白、丢空项(WB2A_DNS 用)。 +func splitCSV(raw string) []string { + parts := strings.Split(raw, ",") + out := make([]string, 0, len(parts)) + for _, p := range parts { + if v := strings.TrimSpace(p); v != "" { + out = append(out, v) + } + } + return out +} + +func (c *Config) normalize() error { + var err error + if err = c.normalizeThinking(); err != nil { + return err + } + if c.Panel.PackageDetailLimit <= 0 { + c.Panel.PackageDetailLimit = 5 + } + if c.Watchdog.IntervalSeconds <= 0 { + c.Watchdog.IntervalSeconds = 3600 + } + if c.Update.AutoTime == "" { + c.Update.AutoTime = "04:00" + } + if !isClockTime(c.Update.AutoTime) { + return fmt.Errorf("update.auto_time: %q 不是合法时间(HH:MM,按上海时间)", c.Update.AutoTime) + } + // PollIntervalSec 不做回落:0 = 缺省(前端 5s),负数 = 关闭自动刷新。 + // 两者都是合法取值,normalize 必须原样保留(回落会把「关闭」变成「5 秒」)。 + if c.Logging.RequestRetentionDays <= 0 { + c.Logging.RequestRetentionDays = 7 + } + if c.Logging.RequestArchiveMaxMB <= 0 { + c.Logging.RequestArchiveMaxMB = 100 + c.Logging.PanelLogEnabled = true + c.Logging.PanelLogRetentionDays = 7 + c.Logging.PanelLogMaxMB = 50 + } + // 入站读取上限(issue #100):空值回落默认 300s;"0" 合法(不限制); + // 负值无语义,fail fast(静默钳 0 会把保护悄悄关掉)。 + if c.Server.ReadTimeout == "" { + c.Server.ReadTimeout = "300s" + } + if c.ServerReadTimeoutDur, err = time.ParseDuration(c.Server.ReadTimeout); err != nil { + return fmt.Errorf("server.read_timeout: %w", err) + } + if c.ServerReadTimeoutDur < 0 { + return fmt.Errorf("server.read_timeout: 负时长 %q 无意义", c.Server.ReadTimeout) + } + // 首帧心跳间隔:空回落 1.5s(等上游首帧期间补 SSE 注释帧,见 headkeepalive.go); + // "0" 合法(关闭,回到零字节旧行为);负值 fail fast。 + if c.Server.HeadKeepalive == "" { + c.Server.HeadKeepalive = "1500ms" + } + if c.HeadKeepaliveDur, err = time.ParseDuration(c.Server.HeadKeepalive); err != nil { + return fmt.Errorf("server.head_keepalive: %q %w", c.Server.HeadKeepalive, err) + } + if c.HeadKeepaliveDur < 0 { + return fmt.Errorf("server.head_keepalive: 负时长 %q 无意义", c.Server.HeadKeepalive) + } + // 排队等待上限:0 回落缺省 60s;负数合法(= 不等,直接把排队交给客户端); + // 超过 Retry-After 上报上限(600s)没有意义也无从验证,fail fast。 + if c.Features.BusyWaitSeconds == 0 { + c.Features.BusyWaitSeconds = 60 + } + if c.Features.BusyWaitSeconds > 600 { + return fmt.Errorf("features.busy_wait_seconds: %d 超出允许范围 1–600", c.Features.BusyWaitSeconds) + } + // 优雅关停窗口:空回落 30s(分钟级在途 SSE 远比旧固定 5s 常见);"0" 合法 + //(立即退);负值 fail fast。 + if c.Server.ShutdownTimeout == "" { + c.Server.ShutdownTimeout = "30s" + } + if c.ShutdownTimeoutDur, err = time.ParseDuration(c.Server.ShutdownTimeout); err != nil { + return fmt.Errorf("server.shutdown_timeout: %q %w", c.Server.ShutdownTimeout, err) + } + if c.ShutdownTimeoutDur < 0 { + return fmt.Errorf("server.shutdown_timeout: 负时长 %q 无意义", c.Server.ShutdownTimeout) + } + // 请求体安全上限(OOM 护栏,不是预拦截):0 = 用默认;越界直接报错——静默钳 + // 会让护栏悄悄换成另一个数,运维以为配上了其实没配上。 + if c.Server.MaxPayloadBytes == 0 { + c.Server.MaxPayloadBytes = 64 << 20 + } + if c.Server.MaxPayloadBytes < 8<<20 || c.Server.MaxPayloadBytes > 512<<20 { + return fmt.Errorf("server.max_payload_bytes: %d 超出允许范围 8–512 MiB", c.Server.MaxPayloadBytes) + } + // 11140 连坐暂停时长:0 = 关闭(只保留命中即停手),负值无意义。 + if c.Upstream.RestrictionHoldSeconds < 0 { + return fmt.Errorf("upstream.restriction_hold_seconds: 负值 %d 无意义(0 = 关闭)", c.Upstream.RestrictionHoldSeconds) + } + if c.SoftRateDur, err = time.ParseDuration(c.Cooldown.SoftRate); err != nil { + return fmt.Errorf("cooldown.soft_rate: %w", err) + } + // 空值回落默认 2h(Default() 已置值;此兜底覆盖显式 "" 与 Default() 被绕过的场景)。 + if c.Cooldown.SoftRateMax == "" { + c.Cooldown.SoftRateMax = "2h" + } + if c.SoftRateMaxDur, err = time.ParseDuration(c.Cooldown.SoftRateMax); err != nil { + return fmt.Errorf("cooldown.soft_rate_max: %w", err) + } + if c.BreakerCooldownDur, err = time.ParseDuration(c.Pool.BreakerCooldown); err != nil { + return fmt.Errorf("pool.breaker_cooldown: %w", err) + } + if c.BreakerCooldownMaxD, err = time.ParseDuration(c.Pool.BreakerCooldownMax); err != nil { + return fmt.Errorf("pool.breaker_cooldown_max: %w", err) + } + if c.DegradeCooldownDur, err = time.ParseDuration(c.Pool.DegradeCooldown); err != nil { + return fmt.Errorf("pool.degrade_cooldown: %w", err) + } + if c.DegradeCooldownMaxD, err = time.ParseDuration(c.Pool.DegradeCooldownMax); err != nil { + return fmt.Errorf("pool.degrade_cooldown_max: %w", err) + } + if c.SessionTTL, err = time.ParseDuration(c.SessionSticky.TTL); err != nil { + return fmt.Errorf("session_sticky.ttl: %w", err) + } + if c.SessionGCInterval, err = time.ParseDuration(c.SessionSticky.GCInterval); err != nil { + return fmt.Errorf("session_sticky.gc_interval: %w", err) + } + // 快过期窗口:空 = 禁用(ExpiringSoonDur 0);非空必须可解析(拼写错误 fail fast)。 + if c.Pool.ExpiringSoon != "" { + if c.ExpiringSoonDur, err = time.ParseDuration(c.Pool.ExpiringSoon); err != nil { + return fmt.Errorf("pool.expiring_soon: %w", err) + } + } + if c.ExpiringSoonDur < 0 { + c.ExpiringSoonDur = 0 + c.Pool.ExpiringSoon = "0" + } + // costTier 探索窗口(issue #136):空值回落默认 30m(Default 已置;此兜底覆盖 + // 显式 "");"0" 是合法值(关停,完全回到现状行为),不回落;负值钳 0 同关停 + //("−5m" 无合理语义)。 + if c.Pool.CostExploreInterval == "" { + c.Pool.CostExploreInterval = "30m" + } + if c.CostExploreIntervalDur, err = time.ParseDuration(c.Pool.CostExploreInterval); err != nil { + return fmt.Errorf("pool.cost_explore_interval: %w", err) + } + if c.CostExploreIntervalDur < 0 { + c.CostExploreIntervalDur = 0 + } + // 账号目录热重载轮询(issue #199)。空值回落默认 10s;"0s" 是合法值(关闭), + // 负值钳 0 同关闭("-5s" 无合理语义)。 + if c.Accounts.ReloadInterval == "" { + c.Accounts.ReloadInterval = "10s" + } + if c.ReloadIntervalDur, err = time.ParseDuration(c.Accounts.ReloadInterval); err != nil { + return fmt.Errorf("accounts.reload_interval: %w", err) + } + if c.ReloadIntervalDur < 0 { + c.ReloadIntervalDur = 0 + } + if c.Accounts.ReloadDeleteConfirm <= 0 { + c.Accounts.ReloadDeleteConfirm = 2 + } + // 窗口用量调度窗口(issue #112):空值回落默认 1h;"0" 合法(关停);负值钳 0。 + if c.Pool.BalanceWindow == "" { + c.Pool.BalanceWindow = "1h" + } + if c.BalanceWindowDur, err = time.ParseDuration(c.Pool.BalanceWindow); err != nil { + return fmt.Errorf("pool.balance_window: %w", err) + } + if c.BalanceWindowDur < 0 { + c.BalanceWindowDur = 0 + } + // 积分保底:负值钳 0(= 关闭)。0 是合法默认(关闭),无需空值回落。 + if c.Pool.CreditFloor < 0 { + c.Pool.CreditFloor = 0 + } + // 保底倍率上限:负值钳 0(= 严格模式,任何已知正倍率都拦)。 + // 不设非零默认是有意的——这是钱相关开关,升级不该静默放宽既有防护。 + if c.Pool.CreditFloorMaxRate < 0 { + c.Pool.CreditFloorMaxRate = 0 + } + if c.Pool.BreakerThreshold <= 0 { + c.Pool.BreakerThreshold = 3 + } + // 连败降权参数缺省归一(非法/未设置回落默认,与 breaker_threshold 同风格)。 + if c.Pool.DegradeThreshold <= 0 { + c.Pool.DegradeThreshold = 5 + } + if c.Pool.DegradeCooldown == "" { + c.Pool.DegradeCooldown = "10m" + } + if c.Pool.DegradeCooldownMax == "" { + c.Pool.DegradeCooldownMax = "2h" + } + // global 在途分档:0/负数视为未设置回落默认 2(WAF 403 修复 P1-1)。 + if c.Pool.MaxInFlightGlobal <= 0 { + c.Pool.MaxInFlightGlobal = 2 + } + if c.Pool.IdleWeightPerHour <= 0 { + c.Pool.IdleWeightPerHour = 0.5 + } + if c.Pool.IdleWeightMax <= 0 { + c.Pool.IdleWeightMax = 5.0 + } + // 保留积分:负值非法归零(0 = 关闭,是合法值,不能像 idle_weight 那样回落默认)。 + // ponytail: nil → 默认 10;显式 0 = 关闭;负值归零。 + switch { + case c.Pool.ReserveCredits == nil: + v := int64(10) + c.Pool.ReserveCredits = &v + case *c.Pool.ReserveCredits < 0: + *c.Pool.ReserveCredits = 0 + } + // 保留积分按域覆盖(issue #147):非法键剔除,负值归零(0 = 该域关闭)。 + // 未写的域回落 reserve_credits。删除时不能边遍历边 delete 之外还改值——先收集再改。 + for k, v := range c.Pool.ReserveCreditsByRealm { + if k != "cn" && k != "global" { + delete(c.Pool.ReserveCreditsByRealm, k) + continue + } + if v < 0 { + c.Pool.ReserveCreditsByRealm[k] = 0 + } + } + // 账号优先级/占比(issue #62):非正值视为「未配置」直接剔除——0 在这里不是有意义的 + // 配置(不是"最低优先级",也不是"零占比"),留着会让语义有两种解释。剔除后空表与 + // 键缺席等价,选号行为不变。 + for uid, pr := range c.Pool.AccountPriority { + if pr <= 0 { + delete(c.Pool.AccountPriority, uid) + } + } + for uid, sh := range c.Pool.AccountShare { + if sh <= 0 { + delete(c.Pool.AccountShare, uid) + } + } + if c.Upstream.TimeoutSeconds <= 0 { + c.Upstream.TimeoutSeconds = 120 + } + // header 缺省回落 timeout(保"首字节前换号"既有语义);idle 缺省走内置大值。 + // 任务书约定:0 一律视为"未设置"走默认,真正的"禁用"留待后续(避免歧义)。 + if c.Upstream.HeaderTimeoutSeconds <= 0 { + c.Upstream.HeaderTimeoutSeconds = c.Upstream.TimeoutSeconds + } + if c.Upstream.IdleTimeoutSeconds <= 0 { + c.Upstream.IdleTimeoutSeconds = 300 + } + if !strings.HasPrefix(c.Listen, ":") && !strings.Contains(c.Listen, ":") { + c.Listen = ":" + c.Listen + } + // 空数组与 null 反序列化后覆盖掉 Default() 的排程值(键缺席才保留),在此补齐。 + // 空 = 未配置 → 回落默认;「禁用」一律走 *_enabled=false,两者互不混淆。 + if len(c.Schedule.CheckinHours) == 0 { + c.Schedule.CheckinHours = []int{9, 21} + } + if len(c.Schedule.TravelHours) == 0 { + c.Schedule.TravelHours = []int{9, 21} + } + if len(c.Schedule.ActivityHours) == 0 { + c.Schedule.ActivityHours = []int{10} + } + if len(c.Schedule.KeepaliveHours) == 0 { + c.Schedule.KeepaliveHours = []int{22} + } + // 周期保活临期窗口:空回落默认 168h(Default 已置,兜底显式 "");非法值 + // fail fast(拼写错误静默吞掉等于窗口变 0 → 全量刷新,违背本字段意图); + // <=0 无合理语义(0/负值想全量应直接删键),报错。 + if c.Schedule.KeepaliveRefreshWindow == "" { + c.Schedule.KeepaliveRefreshWindow = "168h" + } + if c.KeepaliveRefreshWindowDur, err = time.ParseDuration(c.Schedule.KeepaliveRefreshWindow); err != nil { + return fmt.Errorf("schedule.keepalive_refresh_window: %w", err) + } + if c.KeepaliveRefreshWindowDur <= 0 { + return fmt.Errorf("schedule.keepalive_refresh_window: %q 必须为正时长(如 168h)", c.Schedule.KeepaliveRefreshWindow) + } + if len(c.Schedule.GrowthHours) == 0 { + c.Schedule.GrowthHours = []int{11} + } + // 排程轮次账号间并发:缺省/0 → 1(老 config 无此键,不能当非法值报错)。 + if c.Schedule.GrowthConcurrency <= 0 { + c.Schedule.GrowthConcurrency = 1 + } + if c.Schedule.GrowthConcurrency > 4 { + return fmt.Errorf("schedule.growth_concurrency: %d 非法(1-4,手动入口同为 4 上限)", c.Schedule.GrowthConcurrency) + } + if c.Schedule.JitterMinutes < 0 || c.Schedule.JitterMinutes > 1440 { + return fmt.Errorf("schedule.jitter_minutes: %d 非法(0 = 关闭,上限 1440)", c.Schedule.JitterMinutes) + } + if c.Schedule.AccountSpreadMinutes < 0 || c.Schedule.AccountSpreadMinutes > 1440 { + return fmt.Errorf("schedule.account_spread_minutes: %d 非法(0 = 关闭,上限 1440)", c.Schedule.AccountSpreadMinutes) + } + if c.Schedule.AccountSpreadMinGapSeconds < 0 || c.Schedule.AccountSpreadMinGapSeconds > 3600 { + return fmt.Errorf("schedule.account_spread_min_gap_seconds: %d 非法(0 = 只做随机,上限 3600)", c.Schedule.AccountSpreadMinGapSeconds) + } + if c.Budget.DailyCreditLimit < 0 { + return fmt.Errorf("budget.daily_credit_limit: %v 不得为负;0 = 不限", c.Budget.DailyCreditLimit) + } + if c.Budget.BurstCreditLimit < 0 { + return fmt.Errorf("budget.burst_credit_limit: %v 不得为负;0 = 关闭", c.Budget.BurstCreditLimit) + } + if c.Budget.CacheLowRate < 0 || c.Budget.CacheLowRate > 100 { + return fmt.Errorf("budget.cache_low_rate: %v 须在 0-100 之间(百分比);0 = 关闭", c.Budget.CacheLowRate) + } + if c.Admin.Enabled && strings.TrimSpace(c.APIKey) == "" { + return fmt.Errorf("admin.enabled=true 但 api_key 为空") + } + if c.Admin.AuditEnabled { + if !c.Admin.Enabled { + return fmt.Errorf("admin.audit_enabled=true 但 admin.enabled=false") + } + if strings.TrimSpace(c.Admin.AuditFile) == "" { + c.Admin.AuditFile = "./data/admin_audit.log" + } + } + switch strings.ToLower(strings.TrimSpace(c.Features.SanitizeBrandScope)) { + case "", "all": + c.Features.SanitizeBrandScope = "all" + case "identity": + c.Features.SanitizeBrandScope = "identity" + default: + return fmt.Errorf("features.sanitize_brand_scope: %q 非法(all = 所有消息角色;identity = 仅 system/developer)", c.Features.SanitizeBrandScope) + } + if err := c.normalizeAlerting(); err != nil { + return err + + } + // 余额后台刷新:启用时 minutes<=0 回落默认 5;关闭时 interval 保持 0(不启动)。 + if c.Schedule.BalanceRefreshEnabled { + if c.Schedule.BalanceRefreshMinutes <= 0 { + c.Schedule.BalanceRefreshMinutes = 5 + } + c.BalanceRefreshInterval = time.Duration(c.Schedule.BalanceRefreshMinutes) * time.Minute + } + if c.Schedule.TaskSweepEnabled { + if c.Schedule.TaskSweepMinutes <= 0 { + c.Schedule.TaskSweepMinutes = 15 + } + c.TaskSweepInterval = time.Duration(c.Schedule.TaskSweepMinutes) * time.Minute + } + // 抖动合法性(上限 50%):非法值直接报错而非静默钳位——配置错误该在启动时暴露。 + if c.Schedule.BalanceRefreshJitterPermill < 0 || c.Schedule.BalanceRefreshJitterPermill > 500 { + return fmt.Errorf("schedule.balance_refresh_jitter_permill: %d 非法(0 = 关闭,上限 500)", c.Schedule.BalanceRefreshJitterPermill) + } + if c.Schedule.TaskSweepJitterPermill < 0 || c.Schedule.TaskSweepJitterPermill > 500 { + return fmt.Errorf("schedule.task_sweep_jitter_permill: %d 非法(0 = 关闭,上限 500)", c.Schedule.TaskSweepJitterPermill) + } + if c.Schedule.MakeupCardsPerRound < 0 { + return fmt.Errorf("schedule.makeup_cards_per_round: %d 非法(0 = 不限,>0 = 每轮上限)", c.Schedule.MakeupCardsPerRound) + } + if err := c.validateScheduleHours(); err != nil { + return err + } + return c.normalizePrompt() +} + +// normalizePrompt 校验 prompt.mode 并按 file 加载提示词文本(custom/append 模式)。 +// +// mode 非法(非 passthrough/custom/append)启动报错,避免静默回落到某一分支; +// custom/append 模式下 file 非空但不可读 → 报错(fail fast),file 空 → 用内置默认 +// (两模式共用同一加载路径,PromptText 均非空)。 +// passthrough 模式不加载文本(透传客户端原始 system,文本在降级时用 prompt.Degraded)。 +// normalizeThinking 校验并规范化 thinking 节(思考档位策略)。 +// +// 空串回落默认;非法档位 / 作用域 fail fast——静默丢弃会让「面板填了 high」 +// 悄悄按 max 跑,用户无从判断策略是否生效。thinking.model_defaults 的 val 为 +// "" 或 "inherit" 表示「不覆盖」(等价于删除该键),用于面板「恢复全局默认」; +// val 可以是 off(该模型在网关侧固定关闭思考),全局 default_effort 不允许 off。 +func (c *Config) normalizeThinking() error { + c.Thinking.DefaultEffort = strings.ToLower(strings.TrimSpace(c.Thinking.DefaultEffort)) + if c.Thinking.DefaultEffort == "" { + c.Thinking.DefaultEffort = upstream.DefaultGatewayEffort + } + if c.Thinking.DefaultEffort == "off" || !upstream.IsEffortLevel(c.Thinking.DefaultEffort) { + return fmt.Errorf("thinking.default_effort: %q 不是合法档位(max 或 low/medium/high/xhigh 等)", c.Thinking.DefaultEffort) + } + scope := strings.ToLower(strings.TrimSpace(c.Thinking.OverrideScope)) + if scope == "" { + scope = "level" + } + if scope != "level" && scope != "all" { + return fmt.Errorf("thinking.override_scope: %q 不是合法作用域(level = 只覆盖档位、保留关闭意图;all = 档位与开关一起覆盖)", c.Thinking.OverrideScope) + } + c.Thinking.OverrideScope = scope + out := make(map[string]string, len(c.Thinking.ModelDefaults)) + for k, v := range c.Thinking.ModelDefaults { + key := strings.ToLower(strings.TrimSpace(k)) + val := strings.ToLower(strings.TrimSpace(v)) + if key == "" { + continue + } + if val == "" || val == "inherit" { + continue // 显式不覆盖:等价于删除该键 + } + if !upstream.IsEffortLevel(val) { + return fmt.Errorf("thinking.model_defaults[%q]: %q 不是合法档位(max/xhigh/high/medium/low/minimal/off,或 inherit 表示不覆盖)", k, v) + } + out[key] = val + } + c.Thinking.ModelDefaults = out + return nil +} + +func (c *Config) normalizePrompt() error { + switch m := strings.ToLower(strings.TrimSpace(c.Prompt.Mode)); m { + case "", "passthrough": + c.Prompt.Mode = "passthrough" + case "custom": + c.Prompt.Mode = "custom" + case "append": + c.Prompt.Mode = "append" + default: + return fmt.Errorf("prompt.mode: %q 不是合法值(passthrough / custom / append)", c.Prompt.Mode) + } + if c.Prompt.Mode == "custom" || c.Prompt.Mode == "append" { + text, err := prompt.Load(c.Prompt.Mode, c.Prompt.File) + if err != nil { + return err + } + c.PromptText = text + } + return nil +} + +// validateScheduleHours 校验排程小时落在 0-23。 +// +// 为什么不用 `[-1]` 之类的哨兵值表意"禁用":非法小时被静默吞掉时,用户以为关掉了签到, +// 实际可能被当成另一个整点照常执行;这里直接快速失败,并在错误信息里指向正确的开关 +// (checkin_enabled / keepalive_enabled),避免用户靠猜哨兵值来配。 +func (c *Config) validateScheduleHours() error { + if err := checkHourRange("schedule.checkin_hours", "checkin_enabled", c.Schedule.CheckinHours); err != nil { + return err + } + if err := checkHourRange("schedule.travel_hours", "travel_enabled", c.Schedule.TravelHours); err != nil { + return err + } + if err := checkHourRange("schedule.activity_hours", "activity_enabled", c.Schedule.ActivityHours); err != nil { + return err + } + if err := checkHourRange("schedule.keepalive_hours", "keepalive_enabled", c.Schedule.KeepaliveHours); err != nil { + return err + } + return checkHourRange("schedule.growth_hours", "growth_enabled", c.Schedule.GrowthHours) +} + +func checkHourRange(field, switchKey string, hours []int) error { + for _, h := range hours { + if h < 0 || h > 23 { + return fmt.Errorf("%s: %d 不是合法小时(0-23);如要关闭该任务请设 schedule.%s=false", field, h, switchKey) + } + } + return nil +} + +func isClockTime(value string) bool { + if len(value) != 5 || value[2] != ':' { + return false + } + for _, i := range []int{0, 1, 3, 4} { + if value[i] < '0' || value[i] > '9' { + return false + } + } + hour, errH := strconv.Atoi(value[:2]) + minute, errM := strconv.Atoi(value[3:]) + return errH == nil && errM == nil && hour >= 0 && hour <= 23 && minute >= 0 && minute <= 59 +} + +func (c *Config) normalizeAlerting() error { + a := &c.Alerting + if a.IntervalSeconds < 0 || a.TimeoutSeconds < 0 || a.StartupGraceSeconds < 0 || + a.MinHealthyCN < 0 || a.MinHealthyGlobal < 0 || a.RecoverHealthy < 0 || + a.BreakerThreshold < 0 || a.ForTicks < 0 || a.ClearTicks < 0 { + return fmt.Errorf("alerting: 数值不得为负") + } + if a.IntervalSeconds == 0 { + a.IntervalSeconds = 30 + } + if a.TimeoutSeconds == 0 { + a.TimeoutSeconds = 5 + } + if a.StartupGraceSeconds == 0 { + a.StartupGraceSeconds = 30 + } + if a.ForTicks == 0 { + a.ForTicks = 2 + } + if a.ClearTicks == 0 { + a.ClearTicks = 2 + } + if a.RecoverHealthy == 0 { + a.RecoverHealthy = 1 + } + if !a.Enabled { + return nil + } + raw := strings.TrimSpace(a.WebhookURL) + if raw == "" { + return fmt.Errorf("alerting.enabled=true 但 alerting.webhook_url 为空") + } + u, err := url.Parse(raw) + if err != nil { + return fmt.Errorf("alerting.webhook_url: %w", err) + } + if (u.Scheme != "http" && u.Scheme != "https") || u.Host == "" { + return fmt.Errorf("alerting.webhook_url: 需要 http(s) 地址") + } + return nil +} diff --git a/cmd/server/config_example_test.go b/cmd/server/config_example_test.go new file mode 100644 index 0000000000000000000000000000000000000000..7f3babe0c88a845919019f211943be1db8782d67 --- /dev/null +++ b/cmd/server/config_example_test.go @@ -0,0 +1,48 @@ +package main + +import ( + "encoding/json" + "os" + "path/filepath" + "testing" +) + +// TestConfigExampleIsValid 守卫仓库根目录的 config.example.json 是合法 JSON、 +// 且能被 Config 结构解析(键名拼错/漏逗号都不会被编译期发现)。 +// +// 来由:PR #55 加 features.sanitize_brand_scope 时漏了上一行的逗号, +// 文件变成非法 JSON 而 CI 全绿——因为它只在运行时被 `cp config.example.json +// config.json` 的人读到,报错现场离提交很远。这个测试把现场挪回 CI。 +func TestConfigExampleIsValid(t *testing.T) { + path := filepath.Join("..", "..", "config.example.json") + raw, err := os.ReadFile(path) + if err != nil { + t.Fatalf("读不到 %s: %v", path, err) + } + if !json.Valid(raw) { + t.Fatalf("%s 不是合法 JSON", path) + } + var c Config + if err := json.Unmarshal(raw, &c); err != nil { + t.Fatalf("%s 无法解析为 Config: %v", path, err) + } + // 新增的对外配置项必须在示例里可见,否则用户只能从 README 反推。 + if c.Features.SanitizeBrandScope != "all" { + t.Errorf("features.sanitize_brand_scope 示例值应为 all,得到 %q", c.Features.SanitizeBrandScope) + } + if !c.Features.SanitizeBlacklistFingerprints { + t.Error("features.sanitize_blacklist_fingerprints 示例值应为 true") + } + if c.Pool.ModelFallback == nil { + t.Error("pool.model_fallback 示例应存在(空对象即可),否则用户不知道有这张表") + } + // models.allowed(issue #68):示例必须是存在的数组(仿上方各项的「示例可见」 + // 口径)。空数组解析为非 nil 空切片;nil = 键缺失,用户无从发现白名单配置。 + if c.Models.Allowed == nil { + t.Error("models.allowed 示例应存在(空数组即可),否则用户不知道有白名单") + } + // 6020/6021 排队等待的默认值也要在示例里可见(PR #217)。 + if !c.Features.BusyRetry || c.Features.BusyWaitSeconds != 60 { + t.Errorf("features.busy_retry / busy_wait_seconds 示例应为 true / 60: %+v", c.Features) + } +} diff --git a/cmd/server/config_save_test.go b/cmd/server/config_save_test.go new file mode 100644 index 0000000000000000000000000000000000000000..07fbb41bdc4ae44e2b3d9e35066770f6adb87720 --- /dev/null +++ b/cmd/server/config_save_test.go @@ -0,0 +1,211 @@ +package main + +import ( + "encoding/json" + "os" + "path/filepath" + "reflect" + "testing" + + "github.com/misakano7545/workbuddy2api-panel/internal/livecfg" + "github.com/misakano7545/workbuddy2api-panel/internal/pool" + "github.com/misakano7545/workbuddy2api-panel/internal/scheduler" + "github.com/misakano7545/workbuddy2api-panel/internal/upstream" +) + +func TestSaveConfigPreservesAndUpdatesModelFallback(t *testing.T) { + cfg := Default() + cfg.Pool.ModelFallback = map[string]string{"model-a": "model-b"} + if err := cfg.normalize(); err != nil { + t.Fatal(err) + } + raw, _ := json.Marshal(cfg) + path := filepath.Join(t.TempDir(), "config.json") + if err := os.WriteFile(path, raw, 0600); err != nil { + t.Fatal(err) + } + live := livecfg.New(livecfg.Snapshot{ModelFallback: cfg.Pool.ModelFallback}) + p := pool.New("") + defer p.Close() + up := upstream.New() + sch := scheduler.New(scheduler.Config{Pool: p, Upstream: up}) + for _, tc := range []struct{ body, want string }{ + {`{"api_key":"changed"}`, "model-b"}, + {`{"pool":{"model_fallback":{"model-a":"model-c"}}}`, "model-c"}, + {`{"pool":{"model_fallback":null}}`, ""}, + } { + if _, err := saveConfig([]byte(tc.body), path, live, p, up, sch, nil, nil, cfg); err != nil { + t.Fatal(err) + } + if got := live.Load().ModelFallback["model-a"]; got != tc.want { + t.Errorf("save %s: fallback = %q, want %q", tc.body, got, tc.want) + } + } +} + +// TestSaveConfigReportsActualAndPendingRestarts 重启清单 = 「运行中配置 vs 新配置」的 +// 实际差异:改动即入列、第二处保存不丢上一处的待重启项、改回原值自动清除。 +// 移植上游 PR #104(saveConfig 多传 running 基线;本 fork 多 gw/pn 两参传 nil)。 +func TestSaveConfigReportsActualAndPendingRestarts(t *testing.T) { + cfg := Default() + if err := cfg.normalize(); err != nil { + t.Fatal(err) + } + raw, err := json.Marshal(cfg) + if err != nil { + t.Fatal(err) + } + path := filepath.Join(t.TempDir(), "config.json") + if err := os.WriteFile(path, raw, 0600); err != nil { + t.Fatal(err) + } + live := livecfg.New(livecfg.Snapshot{}) + p := pool.New("") + defer p.Close() + up := upstream.New() + sch := scheduler.New(scheduler.Config{Pool: p, Upstream: up}) + save := func(body string) []string { + t.Helper() + fields, err := saveConfig([]byte(body), path, live, p, up, sch, nil, nil, cfg) + if err != nil { + t.Fatal(err) + } + return fields + } + if fields := save(`{"api_key":"changed"}`); len(fields) != 0 { + t.Fatalf("hot save restart fields=%v", fields) + } + if live.Load().APIKey != "changed" { + t.Fatal("key was not applied immediately") + } + if fields := save(`{"listen":":9999"}`); !reflect.DeepEqual(fields, []string{"listen"}) { + t.Fatalf("changed fields=%v", fields) + } + if fields := save(`{"api_key":"second"}`); !reflect.DeepEqual(fields, []string{"listen"}) { + t.Fatalf("pending restart disappeared: %v", fields) + } + if fields := save(`{"listen":"127.0.0.1:7863"}`); len(fields) != 0 { + t.Fatalf("reverted pending fields=%v", fields) + } +} + +// TestSaveConfigWhenDirNotWritable 目录不可写但 config.json 可写时仍要能保存:Docker 里 +// /app 属主是镜像内的 app(10001),而 compose 让容器以 PUID 运行 —— 原子替换的 tmp 建不 +// 出来(issue #134),必须退回原地重写。 +// +// root 不受目录权限位约束(CAP_DAC_OVERRIDE),所以本机 root 下 skip;CI 以普通用户跑, +// 这条才真的会红/绿。 +func TestSaveConfigWhenDirNotWritable(t *testing.T) { + if os.Geteuid() == 0 { + t.Skip("目录权限位对 root 无效,需非 root 运行才有牙齿(CI 生效)") + } + cfg := Default() + if err := cfg.normalize(); err != nil { + t.Fatal(err) + } + raw, _ := json.Marshal(cfg) + dir := t.TempDir() + path := filepath.Join(dir, "config.json") + if err := os.WriteFile(path, raw, 0600); err != nil { + t.Fatal(err) + } + if err := os.Chmod(dir, 0o555); err != nil { // 目录不可写:tmp 建不出来 + t.Fatal(err) + } + defer os.Chmod(dir, 0o755) + + live := livecfg.New(livecfg.Snapshot{}) + p := pool.New("") + defer p.Close() + up := upstream.New() + sch := scheduler.New(scheduler.Config{Pool: p, Upstream: up}) + if _, err := saveConfig([]byte(`{"api_key":"changed-in-place"}`), path, live, p, up, sch, nil, nil, cfg); err != nil { + t.Fatalf("目录不可写时应原地重写而不是报错: %v", err) + } + if live.Load().APIKey != "changed-in-place" { + t.Fatal("key was not applied immediately") + } + saved, err := os.ReadFile(path) + if err != nil { + t.Fatal(err) + } + var got map[string]any + if err := json.Unmarshal(saved, &got); err != nil { + t.Fatalf("落盘内容不是完整 JSON(原地重写写坏了?): %v", err) + } + if got["api_key"] != "changed-in-place" { + t.Fatalf("api_key=%v", got["api_key"]) + } + if _, err := os.Stat(path + ".tmp"); !os.IsNotExist(err) { + t.Error("不应残留 config.json.tmp") + } +} + +// TestRestartRequiredIncludesAllAssemblyFields 装配期字段(监听/身份/双域/提示词/ +// 会话粘性/upstash)逐族抽查:变化必须被 restartRequiredFields 报告。 +func TestRestartRequiredIncludesAllAssemblyFields(t *testing.T) { + current, err := ParseConfig([]byte(`{}`)) + if err != nil { + t.Fatal(err) + } + next, err := ParseConfig([]byte(`{"global":{"enabled":false},"prompt":{"mode":"custom"},"upstream":{"user_agent":"new-agent"},"session_sticky":{"enabled":false},"server":{"read_timeout":"120s"},"upstash":{"url":"https://example.upstash.io","token":"sample"}}`)) + if err != nil { + t.Fatal(err) + } + fields := restartRequiredFields(current, next) + for _, want := range []string{"global.enabled", "prompt.mode", "upstream.user_agent", "session_sticky.enabled", "server.read_timeout", "upstash.url", "upstash.token"} { + found := false + for _, field := range fields { + found = found || field == want + } + if !found { + t.Fatalf("missing %s in %v", want, fields) + } + } +} + +// TestSaveConfigRetainsEnvironmentManagedKey WB2A_API_KEY 托管时:保存提交的文件值 +// 不得抢班(运行值恒为 env 值),且不产生重启项。移植上游 PR #104。 +func TestSaveConfigRetainsEnvironmentManagedKey(t *testing.T) { + t.Setenv("WB2A_API_KEY", "environment-key") + path := filepath.Join(t.TempDir(), "config.json") + if err := os.WriteFile(path, []byte(`{"api_key":"file-key"}`), 0600); err != nil { + t.Fatal(err) + } + cfg, err := Load(path) + if err != nil { + t.Fatal(err) + } + live := livecfg.New(livecfg.Snapshot{APIKey: cfg.APIKey}) + p := pool.New("") + defer p.Close() + up := upstream.New() + sch := scheduler.New(scheduler.Config{Pool: p, Upstream: up}) + fields, err := saveConfig([]byte(`{"api_key":"submitted-key"}`), path, live, p, up, sch, nil, nil, cfg) + if err != nil { + t.Fatal(err) + } + if len(fields) != 0 || live.Load().APIKey != "environment-key" { + t.Fatalf("fields=%v key changed=%v", fields, live.Load().APIKey != "environment-key") + } +} + +// TestEnvironmentManagedFieldsMatchesValidOverrides 托管清单只收「值合法」的 env: +// 非法值(WB2A_TIMEOUT_SECONDS=invalid)等同未设置,不进清单。 +func TestEnvironmentManagedFieldsMatchesValidOverrides(t *testing.T) { + t.Setenv("WB2A_API_KEY", "env-key") + t.Setenv("WB2A_SOFT_RATE", "30s") + t.Setenv("WB2A_TIMEOUT_SECONDS", "invalid") + fields := Default().EnvironmentManagedFields() + has := func(want string) bool { + for _, field := range fields { + if field == want { + return true + } + } + return false + } + if !has("api_key") || !has("cooldown.soft_rate") || has("upstream.timeout_seconds") { + t.Fatalf("managed=%v", fields) + } +} diff --git a/cmd/server/config_test.go b/cmd/server/config_test.go index 2a99931b4f68f767155c3834376c128dbb50e1e1..88f3bfa2a6ad82a947271e19d0c1361c2889f319 100644 --- a/cmd/server/config_test.go +++ b/cmd/server/config_test.go @@ -1,861 +1,1190 @@ -package main - -import ( - "encoding/json" - "os" - "path/filepath" - "strings" - "testing" - "time" -) - -func TestDefault(t *testing.T) { - c := Default() - if c.Listen != ":7863" { - t.Errorf("listen=%s", c.Listen) - } - if err := c.normalize(); err != nil { - t.Fatalf("normalize: %v", err) - } - if c.SoftRateDur.Seconds() != 600 { - t.Errorf("soft=%v want 600s", c.SoftRateDur) - } -} - -func TestPanelPackageDetailLimit(t *testing.T) { - c := Default() - if err := c.normalize(); err != nil { - t.Fatalf("normalize: %v", err) - } - if c.Panel.PackageDetailLimit != 5 { - t.Fatalf("default package_detail_limit=%d want 5", c.Panel.PackageDetailLimit) - } - - configured, err := ParseConfig([]byte(`{"panel":{"package_detail_limit":8}}`)) - if err != nil { - t.Fatalf("parse configured limit: %v", err) - } - if configured.Panel.PackageDetailLimit != 8 { - t.Fatalf("configured package_detail_limit=%d want 8", configured.Panel.PackageDetailLimit) - } - - fallback, err := ParseConfig([]byte(`{"panel":{"package_detail_limit":0}}`)) - if err != nil { - t.Fatalf("parse fallback limit: %v", err) - } - if fallback.Panel.PackageDetailLimit != 5 { - t.Fatalf("fallback package_detail_limit=%d want 5", fallback.Panel.PackageDetailLimit) - } -} - -func TestLoggingDefaults(t *testing.T) { - c := Default() - if err := c.normalize(); err != nil { - t.Fatal(err) - } - if !c.Logging.RequestArchiveEnabled || c.Logging.RequestRetentionDays != 7 || c.Logging.RequestArchiveMaxMB != 100 { - t.Fatalf("logging defaults = %+v", c.Logging) - } - // 来源记录(IP/UA)缺省开启:键缺席时必须保持 true,只有显式 false 才关闭。 - if !c.Logging.RequestClientInfo { - t.Fatalf("request_client_info default = false, want true: %+v", c.Logging) - } - configured, err := ParseConfig([]byte(`{"logging":{"request_archive_enabled":false,"request_retention_days":30,"request_archive_max_mb":500}}`)) - if err != nil { - t.Fatal(err) - } - if configured.Logging.RequestArchiveEnabled || configured.Logging.RequestRetentionDays != 30 || configured.Logging.RequestArchiveMaxMB != 500 { - t.Fatalf("configured logging = %+v", configured.Logging) - } - off, err := ParseConfig([]byte(`{"logging":{"request_client_info":false}}`)) - if err != nil { - t.Fatal(err) - } - if off.Logging.RequestClientInfo { - t.Fatalf("explicit false ignored: %+v", off.Logging) - } - fallback, err := ParseConfig([]byte(`{"logging":{"request_retention_days":0,"request_archive_max_mb":0}}`)) - if err != nil { - t.Fatal(err) - } - if fallback.Logging.RequestRetentionDays != 7 || fallback.Logging.RequestArchiveMaxMB != 100 { - t.Fatalf("logging fallback = %+v", fallback.Logging) - } -} - -func TestLoadFile(t *testing.T) { - dir := t.TempDir() - fp := filepath.Join(dir, "c.json") - os.WriteFile(fp, []byte(`{"listen":":9999","api_key":"k"}`), 0o600) - c, err := Load(fp) - if err != nil { - t.Fatal(err) - } - if c.Listen != ":9999" || c.APIKey != "k" { - t.Errorf("c=%+v", c) - } -} - -func TestEnvOverride(t *testing.T) { - t.Setenv("WB2A_LISTEN", ":7777") - t.Setenv("WB2A_API_KEY", "envkey") - c, err := Load("") - if err != nil { - t.Fatal(err) - } - if c.Listen != ":7777" || c.APIKey != "envkey" { - t.Errorf("c=%+v", c) - } -} - -func TestBadDuration(t *testing.T) { - dir := t.TempDir() - fp := filepath.Join(dir, "c.json") - os.WriteFile(fp, []byte(`{"cooldown":{"soft_rate":"not-a-duration"}}`), 0o600) - if _, err := Load(fp); err == nil { - t.Fatal("want error for bad duration") - } -} - -func TestHardCreditKeyIgnored(t *testing.T) { - // 退役的 hard_credit 键作为 JSON 未知字段被自然忽略,不报错。 - dir := t.TempDir() - fp := filepath.Join(dir, "c.json") - os.WriteFile(fp, []byte(`{"cooldown":{"hard_credit":"not-a-duration","soft_rate":"30s"}}`), 0o600) - c, err := Load(fp) - if err != nil { - t.Fatalf("hard_credit must be ignored (not validated): %v", err) - } - if c.SoftRateDur.Seconds() != 30 { - t.Errorf("soft_rate=%v want 30s", c.SoftRateDur) - } -} - -func TestNewPoolConfigDefaults(t *testing.T) { - c := Default() - if err := c.normalize(); err != nil { - t.Fatalf("normalize: %v", err) - } - if c.Pool.MaxInFlight != 3 { - t.Errorf("max_in_flight=%d want 3", c.Pool.MaxInFlight) - } - if c.Pool.BreakerThreshold != 3 { - t.Errorf("breaker_threshold=%d want 3", c.Pool.BreakerThreshold) - } - if c.BreakerCooldownDur.Minutes() != 30 { - t.Errorf("breaker_cooldown=%v want 30m", c.BreakerCooldownDur) - } - if c.BreakerCooldownMaxD.Hours() != 6 { - t.Errorf("breaker_cooldown_max=%v want 6h", c.BreakerCooldownMaxD) - } - if c.Pool.IdleWeightPerHour != 0.5 || c.Pool.IdleWeightMax != 5.0 { - t.Errorf("idle weights=%v/%v", c.Pool.IdleWeightPerHour, c.Pool.IdleWeightMax) - } - if !c.Pool.PreferExpiring || c.ExpiringSoonDur != 7*24*time.Hour { - t.Errorf("expiring defaults: enabled=%v window=%v", c.Pool.PreferExpiring, c.ExpiringSoonDur) - } - if c.SoftRateMaxDur.Hours() != 2 { - t.Errorf("soft_rate_max=%v want 2h", c.SoftRateMaxDur) - } - if !c.SessionSticky.Enabled { - t.Error("session_sticky.enabled want true") - } - if c.SessionTTL.Minutes() != 30 || c.SessionGCInterval.Minutes() != 5 { - t.Errorf("session durations=%v/%v", c.SessionTTL, c.SessionGCInterval) - } - if c.Upstash.URL != "" || c.Upstash.Token != "" { - t.Errorf("upstash default should be empty: %+v", c.Upstash) - } -} - -func TestPoolConfigParsedFromFile(t *testing.T) { - dir := t.TempDir() - fp := filepath.Join(dir, "c.json") - os.WriteFile(fp, []byte(`{ - "upstash":{"url":"https://foo.upstash.io","token":"tok"}, - "pool":{ - "max_in_flight":5, - "breaker_threshold":4, - "breaker_cooldown":"10m", - "breaker_cooldown_max":"2h", - "idle_weight_per_hour":0.7, - "idle_weight_max":8.0, - "prefer_expiring":false, - "expiring_soon":"72h" - }, - "session_sticky":{"enabled":false,"ttl":"1h","gc_interval":"2m"} - }`), 0o600) - c, err := Load(fp) - if err != nil { - t.Fatal(err) - } - if c.Upstash.URL != "https://foo.upstash.io" || c.Upstash.Token != "tok" { - t.Errorf("upstash=%+v", c.Upstash) - } - if c.Pool.MaxInFlight != 5 || c.Pool.BreakerThreshold != 4 { - t.Errorf("pool=%+v", c.Pool) - } - if c.BreakerCooldownDur.Minutes() != 10 || c.BreakerCooldownMaxD.Hours() != 2 { - t.Errorf("breaker durations=%v/%v", c.BreakerCooldownDur, c.BreakerCooldownMaxD) - } - if c.Pool.IdleWeightPerHour != 0.7 || c.Pool.IdleWeightMax != 8.0 { - t.Errorf("idle weights=%v/%v", c.Pool.IdleWeightPerHour, c.Pool.IdleWeightMax) - } - if c.Pool.PreferExpiring || c.ExpiringSoonDur != 72*time.Hour { - t.Errorf("expiring override: enabled=%v window=%v", c.Pool.PreferExpiring, c.ExpiringSoonDur) - } - if c.SessionSticky.Enabled { - t.Error("session_sticky.enabled want false from file") - } - if c.SessionTTL.Hours() != 1 || c.SessionGCInterval.Minutes() != 2 { - t.Errorf("session durations=%v/%v", c.SessionTTL, c.SessionGCInterval) - } -} - -func TestSoftRateMaxParsedFromFile(t *testing.T) { - dir := t.TempDir() - fp := filepath.Join(dir, "c.json") - os.WriteFile(fp, []byte(`{"cooldown":{"soft_rate":"5m","soft_rate_max":"45m"}}`), 0o600) - c, err := Load(fp) - if err != nil { - t.Fatal(err) - } - if c.SoftRateDur.Minutes() != 5 { - t.Errorf("soft_rate=%v want 5m", c.SoftRateDur) - } - if c.SoftRateMaxDur.Minutes() != 45 { - t.Errorf("soft_rate_max=%v want 45m", c.SoftRateMaxDur) - } -} - -func TestLegacyConfigKeepsPreferExpiringEnabled(t *testing.T) { - dir := t.TempDir() - fp := filepath.Join(dir, "c.json") - os.WriteFile(fp, []byte(`{"pool":{"idle_weight_max":3}}`), 0o600) - c, err := Load(fp) - if err != nil { - t.Fatal(err) - } - if !c.Pool.PreferExpiring { - t.Fatal("missing prefer_expiring must preserve default true") - } -} - -func TestNegativeExpiringSoonClampsToDisabled(t *testing.T) { - dir := t.TempDir() - fp := filepath.Join(dir, "c.json") - os.WriteFile(fp, []byte(`{"pool":{"expiring_soon":"-1h"}}`), 0o600) - c, err := Load(fp) - if err != nil { - t.Fatal(err) - } - if c.ExpiringSoonDur != 0 || c.Pool.ExpiringSoon != "0" { - t.Fatalf("negative window=%v/%q want 0/0", c.ExpiringSoonDur, c.Pool.ExpiringSoon) - } -} - -func TestSoftRateMaxEmptyFallsBackToDefault(t *testing.T) { - // 键缺席 → Default() 的 2h 保留(空串无法 ParseDuration)。 - dir := t.TempDir() - fp := filepath.Join(dir, "c.json") - os.WriteFile(fp, []byte(`{"cooldown":{"soft_rate":"90s"}}`), 0o600) - c, err := Load(fp) - if err != nil { - t.Fatal(err) - } - if c.SoftRateMaxDur.Hours() != 2 { - t.Errorf("soft_rate_max=%v want 2h fallback", c.SoftRateMaxDur) - } -} - -func TestBadSoftRateMax(t *testing.T) { - dir := t.TempDir() - fp := filepath.Join(dir, "c.json") - os.WriteFile(fp, []byte(`{"cooldown":{"soft_rate_max":"oops"}}`), 0o600) - if _, err := Load(fp); err == nil { - t.Fatal("want error for bad soft_rate_max") - } -} - -func TestBadBreakerCooldown(t *testing.T) { - dir := t.TempDir() - fp := filepath.Join(dir, "c.json") - os.WriteFile(fp, []byte(`{"pool":{"breaker_cooldown":"oops"}}`), 0o600) - if _, err := Load(fp); err == nil { - t.Fatal("want error for bad breaker_cooldown") - } -} - -func TestUpstreamTimeoutDefaults(t *testing.T) { - // 默认:header 回落 timeout,idle 回落 300。 - c := Default() - if err := c.normalize(); err != nil { - t.Fatalf("normalize: %v", err) - } - if c.Upstream.TimeoutSeconds != 120 { - t.Errorf("timeout_seconds=%d want 120", c.Upstream.TimeoutSeconds) - } - if c.Upstream.HeaderTimeoutSeconds != 120 { - t.Errorf("header_timeout_seconds=%d want fallback 120", c.Upstream.HeaderTimeoutSeconds) - } - if c.Upstream.IdleTimeoutSeconds != 300 { - t.Errorf("idle_timeout_seconds=%d want fallback 300", c.Upstream.IdleTimeoutSeconds) - } -} - -func TestUpstreamHeaderFallsBackToTimeout(t *testing.T) { - // 只设 timeout_seconds:header 回落同值,idle 回落 300。 - dir := t.TempDir() - fp := filepath.Join(dir, "c.json") - os.WriteFile(fp, []byte(`{"upstream":{"timeout_seconds":60}}`), 0o600) - c, err := Load(fp) - if err != nil { - t.Fatal(err) - } - if c.Upstream.HeaderTimeoutSeconds != 60 { - t.Errorf("header_timeout_seconds=%d want fallback 60", c.Upstream.HeaderTimeoutSeconds) - } - if c.Upstream.IdleTimeoutSeconds != 300 { - t.Errorf("idle_timeout_seconds=%d want fallback 300", c.Upstream.IdleTimeoutSeconds) - } -} - -func TestUpstreamExplicitHeaderIdle(t *testing.T) { - dir := t.TempDir() - fp := filepath.Join(dir, "c.json") - os.WriteFile(fp, []byte(`{"upstream":{"timeout_seconds":120,"header_timeout_seconds":30,"idle_timeout_seconds":600}}`), 0o600) - c, err := Load(fp) - if err != nil { - t.Fatal(err) - } - if c.Upstream.HeaderTimeoutSeconds != 30 { - t.Errorf("header_timeout_seconds=%d want 30", c.Upstream.HeaderTimeoutSeconds) - } - if c.Upstream.IdleTimeoutSeconds != 600 { - t.Errorf("idle_timeout_seconds=%d want 600", c.Upstream.IdleTimeoutSeconds) - } -} - -func TestUpstreamEnvOverride(t *testing.T) { - t.Setenv("WB2A_HEADER_TIMEOUT_SECONDS", "45") - t.Setenv("WB2A_IDLE_TIMEOUT_SECONDS", "900") - c, err := Load("") - if err != nil { - t.Fatal(err) - } - if c.Upstream.HeaderTimeoutSeconds != 45 { - t.Errorf("header_timeout_seconds=%d want env 45", c.Upstream.HeaderTimeoutSeconds) - } - if c.Upstream.IdleTimeoutSeconds != 900 { - t.Errorf("idle_timeout_seconds=%d want env 900", c.Upstream.IdleTimeoutSeconds) - } -} - -// TestRetiredTravelIntervalKeyIgnored 退役的 travel_interval_minutes 键按未知字段忽略,不报错。 -func TestRetiredTravelIntervalKeyIgnored(t *testing.T) { - dir := t.TempDir() - fp := filepath.Join(dir, "c.json") - os.WriteFile(fp, []byte(`{"schedule":{"travel_interval_minutes":15,"checkin_hours":[9]}}`), 0o600) - c, err := Load(fp) - if err != nil { - t.Fatalf("retired key should not fail load: %v", err) - } - if len(c.Schedule.CheckinHours) != 1 || c.Schedule.CheckinHours[0] != 9 { - t.Errorf("checkin_hours=%v want [9](同段其余键照常生效)", c.Schedule.CheckinHours) - } -} - -// TestScheduleEnabledByDefault 四个任务的 enabled 开关默认均为 true: -// 老 config 不写这些键,行为必须与从前完全一致。 -func TestScheduleEnabledByDefault(t *testing.T) { - c := Default() - if err := c.normalize(); err != nil { - t.Fatalf("normalize: %v", err) - } - if !c.Schedule.CheckinEnabled || !c.Schedule.KeepaliveEnabled { - t.Errorf("enabled defaults want true/true, got %v/%v", - c.Schedule.CheckinEnabled, c.Schedule.KeepaliveEnabled) - } - if !c.Schedule.TravelEnabled || !c.Schedule.ActivityEnabled { - t.Errorf("travel/activity enabled defaults want true/true, got %v/%v", - c.Schedule.TravelEnabled, c.Schedule.ActivityEnabled) - } - if len(c.Schedule.TravelHours) != 2 || c.Schedule.TravelHours[0] != 9 || c.Schedule.TravelHours[1] != 21 { - t.Errorf("travel_hours=%v want [9,21]", c.Schedule.TravelHours) - } - if len(c.Schedule.ActivityHours) != 1 || c.Schedule.ActivityHours[0] != 10 { - t.Errorf("activity_hours=%v want [10]", c.Schedule.ActivityHours) - } -} - -// TestScheduleLegacyConfigKeepsRunning 老 config(只写签到/保活小时数组,无新键)加载后仍是启用态, -// 新开关缺省 true、新 hours 回落默认——对老配置零影响。 -func TestScheduleLegacyConfigKeepsRunning(t *testing.T) { - dir := t.TempDir() - fp := filepath.Join(dir, "c.json") - os.WriteFile(fp, []byte(`{"schedule":{"checkin_hours":[9,21],"keepalive_hours":[22]}}`), 0o600) - c, err := Load(fp) - if err != nil { - t.Fatal(err) - } - if !c.Schedule.CheckinEnabled || !c.Schedule.KeepaliveEnabled { - t.Errorf("legacy config must stay enabled: %+v", c.Schedule) - } - if !c.Schedule.TravelEnabled || !c.Schedule.ActivityEnabled { - t.Errorf("new switches must default true on legacy config: %+v", c.Schedule) - } - if len(c.Schedule.CheckinHours) != 2 { - t.Errorf("checkin_hours=%v", c.Schedule.CheckinHours) - } - // 新 hours 缺省 → 回落默认(非空)。 - if len(c.Schedule.TravelHours) != 2 || c.Schedule.TravelHours[0] != 9 || c.Schedule.TravelHours[1] != 21 { - t.Errorf("travel_hours=%v want default [9,21]", c.Schedule.TravelHours) - } - if len(c.Schedule.ActivityHours) != 1 || c.Schedule.ActivityHours[0] != 10 { - t.Errorf("activity_hours=%v want default [10]", c.Schedule.ActivityHours) - } -} - -// TestScheduleExplicitDisable 显式 checkin_enabled=false 即可真正关掉签到 -// (issue #27 边界:此前无论怎么配小时都关不掉)。 -func TestScheduleExplicitDisable(t *testing.T) { - dir := t.TempDir() - fp := filepath.Join(dir, "c.json") - os.WriteFile(fp, []byte(`{"schedule":{"checkin_enabled":false,"keepalive_enabled":false}}`), 0o600) - c, err := Load(fp) - if err != nil { - t.Fatal(err) - } - if c.Schedule.CheckinEnabled || c.Schedule.KeepaliveEnabled { - t.Errorf("want both disabled: %+v", c.Schedule) - } - // 小时数组仍回落默认值(禁用与默认值互不干扰:重新启用无需补配小时)。 - if len(c.Schedule.CheckinHours) != 2 || c.Schedule.CheckinHours[0] != 9 || c.Schedule.CheckinHours[1] != 21 { - t.Errorf("checkin_hours=%v want default [9 21] even when disabled", c.Schedule.CheckinHours) - } - if len(c.Schedule.KeepaliveHours) != 1 || c.Schedule.KeepaliveHours[0] != 22 { - t.Errorf("keepalive_hours=%v want default [22] even when disabled", c.Schedule.KeepaliveHours) - } -} - -// TestScheduleTravelActivityExplicitDisable 显式关闭旅行/活跃上报开关。 -func TestScheduleTravelActivityExplicitDisable(t *testing.T) { - dir := t.TempDir() - fp := filepath.Join(dir, "c.json") - os.WriteFile(fp, []byte(`{"schedule":{"travel_enabled":false,"activity_enabled":false}}`), 0o600) - c, err := Load(fp) - if err != nil { - t.Fatal(err) - } - if c.Schedule.TravelEnabled || c.Schedule.ActivityEnabled { - t.Errorf("want travel/activity disabled: %+v", c.Schedule) - } - // 签到/保活开关缺省 true(互不干扰)。 - if !c.Schedule.CheckinEnabled || !c.Schedule.KeepaliveEnabled { - t.Errorf("checkin/keepalive should stay enabled: %+v", c.Schedule) - } - // hours 仍回落默认。 - if len(c.Schedule.TravelHours) != 2 || c.Schedule.TravelHours[0] != 9 || c.Schedule.TravelHours[1] != 21 { - t.Errorf("travel_hours=%v want default [9,21] even when disabled", c.Schedule.TravelHours) - } - if len(c.Schedule.ActivityHours) != 1 || c.Schedule.ActivityHours[0] != 10 { - t.Errorf("activity_hours=%v want default [10] even when disabled", c.Schedule.ActivityHours) - } -} - -// TestScheduleTravelActivityInvalidHoursRejected 旅行/活跃非法小时报错并指向正确开关。 -func TestScheduleTravelActivityInvalidHoursRejected(t *testing.T) { - cases := []struct{ body, wantSwitch string }{ - {`{"schedule":{"travel_hours":[25]}}`, "travel_enabled"}, - {`{"schedule":{"travel_hours":[-1]}}`, "travel_enabled"}, - {`{"schedule":{"activity_hours":[24]}}`, "activity_enabled"}, - {`{"schedule":{"activity_hours":[-1]}}`, "activity_enabled"}, - } - for _, tc := range cases { - dir := t.TempDir() - fp := filepath.Join(dir, "c.json") - os.WriteFile(fp, []byte(tc.body), 0o600) - _, err := Load(fp) - if err == nil { - t.Fatalf("want error for %s", tc.body) - } - if !strings.Contains(err.Error(), tc.wantSwitch) { - t.Errorf("error for %s should point at schedule.%s: %v", tc.body, tc.wantSwitch, err) - } - } -} - -// TestScheduleTravelActivityExplicitHours 显式配置旅行/活跃小时。 -func TestScheduleTravelActivityExplicitHours(t *testing.T) { - dir := t.TempDir() - fp := filepath.Join(dir, "c.json") - os.WriteFile(fp, []byte(`{"schedule":{"travel_hours":[9,21],"activity_hours":[11]}}`), 0o600) - c, err := Load(fp) - if err != nil { - t.Fatal(err) - } - if len(c.Schedule.TravelHours) != 2 || c.Schedule.TravelHours[0] != 9 || c.Schedule.TravelHours[1] != 21 { - t.Errorf("travel_hours=%v want [9 21]", c.Schedule.TravelHours) - } - if len(c.Schedule.ActivityHours) != 1 || c.Schedule.ActivityHours[0] != 11 { - t.Errorf("activity_hours=%v want [11]", c.Schedule.ActivityHours) - } -} - -// TestScheduleDisableKeepsExplicitHours 禁用不擦除用户配置的小时(便于原样恢复)。 -func TestScheduleDisableKeepsExplicitHours(t *testing.T) { - dir := t.TempDir() - fp := filepath.Join(dir, "c.json") - os.WriteFile(fp, []byte(`{"schedule":{"checkin_enabled":false,"checkin_hours":[10,14]}}`), 0o600) - c, err := Load(fp) - if err != nil { - t.Fatal(err) - } - if c.Schedule.CheckinEnabled { - t.Error("checkin should be disabled") - } - if len(c.Schedule.CheckinHours) != 2 || c.Schedule.CheckinHours[0] != 10 || c.Schedule.CheckinHours[1] != 14 { - t.Errorf("explicit hours must be preserved: %v", c.Schedule.CheckinHours) - } -} - -// TestScheduleEmptyHoursFallsBackToDefault 空数组 / null / 缺省都视同「未配置」→ 回落默认。 -func TestScheduleEmptyHoursFallsBackToDefault(t *testing.T) { - cases := map[string]string{ - "absent": `{}`, - "empty": `{"schedule":{}}`, - "null": `{"schedule":{"checkin_hours":null,"keepalive_hours":null,"travel_hours":null,"activity_hours":null}}`, - "emptyarr": `{"schedule":{"checkin_hours":[],"keepalive_hours":[],"travel_hours":[],"activity_hours":[]}}`, - } - for name, body := range cases { - t.Run(name, func(t *testing.T) { - dir := t.TempDir() - fp := filepath.Join(dir, "c.json") - os.WriteFile(fp, []byte(body), 0o600) - c, err := Load(fp) - if err != nil { - t.Fatal(err) - } - if len(c.Schedule.CheckinHours) != 2 || c.Schedule.CheckinHours[0] != 9 || c.Schedule.CheckinHours[1] != 21 { - t.Errorf("checkin_hours=%v want default [9 21]", c.Schedule.CheckinHours) - } - if len(c.Schedule.KeepaliveHours) != 1 || c.Schedule.KeepaliveHours[0] != 22 { - t.Errorf("keepalive_hours=%v want default [22]", c.Schedule.KeepaliveHours) - } - if len(c.Schedule.TravelHours) != 2 || c.Schedule.TravelHours[0] != 9 || c.Schedule.TravelHours[1] != 21 { - t.Errorf("travel_hours=%v want default [9 21]", c.Schedule.TravelHours) - } - if len(c.Schedule.ActivityHours) != 1 || c.Schedule.ActivityHours[0] != 10 { - t.Errorf("activity_hours=%v want default [10]", c.Schedule.ActivityHours) - } - if !c.Schedule.CheckinEnabled || !c.Schedule.KeepaliveEnabled { - t.Errorf("empty hours must not imply disabled: %+v", c.Schedule) - } - if !c.Schedule.TravelEnabled || !c.Schedule.ActivityEnabled { - t.Errorf("empty hours must not imply disabled: %+v", c.Schedule) - } - }) - } -} - -// TestScheduleInvalidHourRejected 非法小时快速失败:指向正确的禁用开关,避免用户 -// 猜测哨兵值([-1] 之类)被静默当成"改到别的整点"。 -func TestScheduleInvalidHourRejected(t *testing.T) { - cases := []struct{ body, wantSwitch string }{ - {`{"schedule":{"checkin_hours":[25]}}`, "checkin_enabled"}, - {`{"schedule":{"checkin_hours":[-1]}}`, "checkin_enabled"}, - {`{"schedule":{"keepalive_hours":[-1]}}`, "keepalive_enabled"}, - } - for _, tc := range cases { - dir := t.TempDir() - fp := filepath.Join(dir, "c.json") - os.WriteFile(fp, []byte(tc.body), 0o600) - _, err := Load(fp) - if err == nil { - t.Fatalf("want error for %s", tc.body) - } - if !strings.Contains(err.Error(), tc.wantSwitch) { - t.Errorf("error for %s should point at schedule.%s: %v", tc.body, tc.wantSwitch, err) - } - } -} - -func TestBadSessionTTL(t *testing.T) { - dir := t.TempDir() - fp := filepath.Join(dir, "c.json") - os.WriteFile(fp, []byte(`{"session_sticky":{"ttl":"oops"}}`), 0o600) - if _, err := Load(fp); err == nil { - t.Fatal("want error for bad session_sticky.ttl") - } -} - -func TestWriteDefault(t *testing.T) { - dir := t.TempDir() - fp := filepath.Join(dir, "sub", "config.json") // 顺带验证父目录自动创建 - key, err := WriteDefault(fp) - if err != nil { - t.Fatal(err) - } - // key 形如 sk-<24字符随机串>,两次生成不重复 - if !strings.HasPrefix(key, "sk-") || len(key) < 20 { - t.Errorf("key=%q want sk-", key) - } - if key2, _ := WriteDefault(filepath.Join(dir, "another.json")); key2 == key { - t.Errorf("two generated keys identical: %q", key) - } - // 落盘文件可被 Load 正常加载,推荐值齐备且 api_key 生效 - c, err := Load(fp) - if err != nil { - t.Fatalf("load generated config: %v", err) - } - if c.APIKey != key { - t.Errorf("api_key=%q want %q", c.APIKey, key) - } - if c.Listen != ":7863" || c.AuthDir != "./auths" || c.StateFile != "./data/state.json" { - t.Errorf("generated defaults off: %+v", c) - } - if len(c.Schedule.CheckinHours) == 0 || !c.Schedule.CheckinEnabled { - t.Errorf("generated schedule off: %+v", c.Schedule) - } - // 已存在的文件不覆盖:二次写入同一路径必须报错 - if _, err := WriteDefault(fp); err == nil { - t.Error("WriteDefault must refuse to overwrite existing file") - } -} - -func TestBalanceRefreshDefaults(t *testing.T) { - // 缺省:启用 + 30 分钟 - c := Default() - if err := c.normalize(); err != nil { - t.Fatal(err) - } - if !c.Schedule.BalanceRefreshEnabled || c.BalanceRefreshInterval != 5*time.Minute { - t.Errorf("default balance refresh: enabled=%v interval=%v", c.Schedule.BalanceRefreshEnabled, c.BalanceRefreshInterval) - } - // 显式配置 10 分钟 - dir := t.TempDir() - fp := filepath.Join(dir, "c.json") - os.WriteFile(fp, []byte(`{"schedule":{"balance_refresh_minutes":10}}`), 0o600) - c2, err := Load(fp) - if err != nil { - t.Fatal(err) - } - if c2.BalanceRefreshInterval != 10*time.Minute { - t.Errorf("interval=%v want 10m", c2.BalanceRefreshInterval) - } - // 显式关闭:interval 归零(不启动) - os.WriteFile(fp, []byte(`{"schedule":{"balance_refresh_enabled":false}}`), 0o600) - c3, err := Load(fp) - if err != nil { - t.Fatal(err) - } - if c3.BalanceRefreshInterval != 0 { - t.Errorf("disabled interval=%v want 0", c3.BalanceRefreshInterval) - } - // 启用但 minutes<=0 → 回落默认 30 - os.WriteFile(fp, []byte(`{"schedule":{"balance_refresh_minutes":-5}}`), 0o600) - c4, err := Load(fp) - if err != nil { - t.Fatal(err) - } - if c4.BalanceRefreshInterval != 5*time.Minute { - t.Errorf("fallback interval=%v want 30m", c4.BalanceRefreshInterval) - } -} - -// TestPromptDefaultPassthrough 默认 prompt.mode=passthrough(对齐上游:透传客户端 -// 原始 system 是更保守的缺省);custom 由用户显式选择,此时 PromptText 为内置默认(非空)。 -func TestPromptDefaultPassthrough(t *testing.T) { - c, err := Load("") - if err != nil { - t.Fatal(err) - } - if c.Prompt.Mode != "passthrough" { - t.Errorf("prompt.mode=%q want passthrough", c.Prompt.Mode) - } - // passthrough 不加载提示词文本(透传客户端 system);切 custom 时 normalize 会加载。 -} - -// TestPromptExplicitPassthrough passthrough 模式不加载文本(透传客户端原始 system)。 -func TestPromptExplicitPassthrough(t *testing.T) { - dir := t.TempDir() - fp := filepath.Join(dir, "c.json") - os.WriteFile(fp, []byte(`{"prompt":{"mode":"passthrough"}}`), 0o600) - c, err := Load(fp) - if err != nil { - t.Fatal(err) - } - if c.Prompt.Mode != "passthrough" { - t.Errorf("mode=%q want passthrough", c.Prompt.Mode) - } - if c.PromptText != "" { - t.Errorf("passthrough should not load PromptText, got len=%d", len(c.PromptText)) - } -} - -// TestPromptInvalidMode 非法 mode 启动报错。 -func TestPromptInvalidMode(t *testing.T) { - dir := t.TempDir() - fp := filepath.Join(dir, "c.json") - os.WriteFile(fp, []byte(`{"prompt":{"mode":"bogus"}}`), 0o600) - if _, err := Load(fp); err == nil { - t.Fatal("want error for invalid prompt.mode") - } -} - -// TestPromptFileMissing 文件路径非空但不存在 → 启动报错(fail fast)。 -func TestPromptFileMissing(t *testing.T) { - dir := t.TempDir() - fp := filepath.Join(dir, "c.json") - os.WriteFile(fp, []byte(`{"prompt":{"mode":"custom","file":"/nonexistent/p.md"}}`), 0o600) - if _, err := Load(fp); err == nil { - t.Fatal("want error for missing prompt file") - } -} - -// TestPromptFileOverride 自定义 file 覆盖内置默认。 -func TestPromptFileOverride(t *testing.T) { - dir := t.TempDir() - pf := filepath.Join(dir, "my.md") - want := "我的自定义人格入口" - os.WriteFile(pf, []byte(want), 0o600) - cf := filepath.Join(dir, "c.json") - // 用 json.Marshal 拼路径:Windows 反斜杠必须转义,手工字符串拼接会产出非法 JSON。 - cfgJSON, err := json.Marshal(map[string]any{"prompt": map[string]any{"mode": "custom", "file": pf}}) - if err != nil { - t.Fatal(err) - } - os.WriteFile(cf, cfgJSON, 0o600) - c, err := Load(cf) - if err != nil { - t.Fatal(err) - } - if c.PromptText != want { - t.Errorf("PromptText=%q want %q", c.PromptText, want) - } -} - -// TestPromptEnvOverride env 覆盖 prompt.mode 与 prompt.file。 -func TestPromptEnvOverride(t *testing.T) { - t.Setenv("WB2A_PROMPT_MODE", "passthrough") - c, err := Load("") - if err != nil { - t.Fatal(err) - } - if c.Prompt.Mode != "passthrough" { - t.Errorf("mode=%q want passthrough", c.Prompt.Mode) - } -} - -// TestPromptLegacyConfigNoImpact 旧 config(无 prompt 段)零影响:mode 缺省 passthrough。 -func TestPromptLegacyConfigNoImpact(t *testing.T) { - dir := t.TempDir() - fp := filepath.Join(dir, "c.json") - os.WriteFile(fp, []byte(`{"listen":":9999","api_key":"k"}`), 0o600) - c, err := Load(fp) - if err != nil { - t.Fatal(err) - } - if c.Prompt.Mode != "passthrough" { - t.Errorf("legacy config should default to passthrough, got %q", c.Prompt.Mode) - } - if c.Listen != ":9999" { - t.Errorf("listen=%q", c.Listen) - } -} - -// TestUpstreamUserAgentConfig 配置 upstream.user_agent 与 env WB2A_USER_AGENT 均生效, -// 缺省空串保持现状(headers 层回落到 clientUA)。 -func TestUpstreamUserAgentConfig(t *testing.T) { - // JSON 配置 - dir := t.TempDir() - fp := filepath.Join(dir, "c.json") - os.WriteFile(fp, []byte(`{"upstream":{"user_agent":"WorkBuddy/1.2.3"}}`), 0o600) - c, err := Load(fp) - if err != nil { - t.Fatal(err) - } - if c.Upstream.UserAgent != "WorkBuddy/1.2.3" { - t.Errorf("user_agent=%q want WorkBuddy/1.2.3", c.Upstream.UserAgent) - } - // 缺省为空 - if c2, err := Load(""); err != nil || c2.Upstream.UserAgent != "" { - t.Errorf("default user_agent=%q want empty (err=%v)", c2.Upstream.UserAgent, err) - } - // env 覆盖 - t.Setenv("WB2A_USER_AGENT", "EnvAgent/9") - c3, err := Load("") - if err != nil { - t.Fatal(err) - } - if c3.Upstream.UserAgent != "EnvAgent/9" { - t.Errorf("env user_agent=%q want EnvAgent/9", c3.Upstream.UserAgent) - } -} - -// TestLoadConfigPathIsDirectory config 路径是目录时给出可操作提示(Docker bind mount 陷阱)。 -// 复现:compose 挂载 ./config.json 但宿主机缺该文件 → Docker 创建同名目录 → 启动失败。 -// 旧行为只报 "read config: ... Incorrect function" 之类晦涩错误,无从排查。 -func TestLoadConfigPathIsDirectory(t *testing.T) { - dir := t.TempDir() - asDir := filepath.Join(dir, "config.json") - if err := os.Mkdir(asDir, 0o755); err != nil { - t.Fatal(err) - } - _, err := Load(asDir) - if err == nil { - t.Fatal("want error when config path is a directory") - } - msg := err.Error() - if !strings.Contains(msg, "是目录") { - t.Errorf("error should explain it is a directory: %v", err) - } - if !strings.Contains(msg, "config.example.json") { - t.Errorf("error should suggest the fix (cp config.example.json): %v", err) - } -} - -// TestServerReadTimeout 入站读取上限(issue #100):空值回落默认 300s; -// "0" = 显式不限制(0 是合法值不回落);负值 fail fast(静默钳 0 会把保护悄悄关掉)。 -func TestServerReadTimeout(t *testing.T) { - c := Default() - if c.Server.ReadTimeout != "300s" { - t.Errorf("default read_timeout=%q want 300s", c.Server.ReadTimeout) - } - if err := c.normalize(); err != nil { - t.Fatalf("normalize: %v", err) - } - if c.ServerReadTimeoutDur != 300*time.Second { - t.Errorf("default dur=%v want 300s", c.ServerReadTimeoutDur) - } - - c = Default() - c.Server.ReadTimeout = "" // 显式清空 = 未配置 → 回落默认 - if err := c.normalize(); err != nil { - t.Fatalf("normalize empty: %v", err) - } - if c.ServerReadTimeoutDur != 300*time.Second { - t.Errorf("empty dur=%v want 300s", c.ServerReadTimeoutDur) - } - - c = Default() - c.Server.ReadTimeout = "0" // 显式 0 = 不限制(http.Server ReadTimeout 0 即无超时) - if err := c.normalize(); err != nil { - t.Fatalf("normalize zero: %v", err) - } - if c.ServerReadTimeoutDur != 0 { - t.Errorf("zero dur=%v want 0", c.ServerReadTimeoutDur) - } - - c = Default() - c.Server.ReadTimeout = "-5s" - if err := c.normalize(); err == nil { - t.Error("negative read_timeout should fail fast") - } - - c = Default() - c.Server.ReadTimeout = "bogus" - if err := c.normalize(); err == nil { - t.Error("unparsable read_timeout should fail fast") - } -} +package main + +import ( + "encoding/json" + "os" + "path/filepath" + "strings" + "testing" + "time" + + "github.com/misakano7545/workbuddy2api-panel/internal/upstream" +) + +func TestDefault(t *testing.T) { + c := Default() + if c.Listen != "127.0.0.1:7863" { + t.Errorf("listen=%s", c.Listen) + } + if err := c.normalize(); err != nil { + t.Fatalf("normalize: %v", err) + } + if c.SoftRateDur.Seconds() != 600 { + t.Errorf("soft=%v want 600s", c.SoftRateDur) + } + if c.Update.AutoEnabled { + t.Error("update.auto_enabled default should be false") + } + if c.Update.AutoTime != "04:00" { + t.Errorf("update.auto_time=%q want 04:00", c.Update.AutoTime) + } +} + +func TestUpdateAutoTimeValidation(t *testing.T) { + for _, value := range []string{"4:00", "+0:00", "24:00", "12:60", "noon"} { + if _, err := ParseConfig([]byte(`{"update":{"auto_time":"` + value + `"}}`)); err == nil { + t.Fatalf("auto_time %q should be rejected", value) + } + } + for _, value := range []string{"00:00", "04:00", "23:59"} { + c, err := ParseConfig([]byte(`{"update":{"auto_time":"` + value + `"}}`)) + if err != nil || c.Update.AutoTime != value { + t.Fatalf("auto_time %q parse failed: cfg=%+v err=%v", value, c, err) + } + } +} + +// TestPanelPollInterval 面板自动刷新间隔:0 = 缺省、负数 = 关闭自动刷新。 +// normalize **不得**把负数回落成 0(那会把「关闭」变成「5 秒」)。 +func TestPanelPollInterval(t *testing.T) { + c := Default() + if err := c.normalize(); err != nil { + t.Fatalf("normalize: %v", err) + } + if c.Panel.PollIntervalSec != 0 { + t.Fatalf("缺省 poll_interval_sec=%d want 0(= 前端缺省 5s)", c.Panel.PollIntervalSec) + } + + off, err := ParseConfig([]byte(`{"panel":{"poll_interval_sec":-1}}`)) + if err != nil { + t.Fatalf("parse off: %v", err) + } + if off.Panel.PollIntervalSec != -1 { + t.Fatalf("poll_interval_sec=%d want -1(关闭自动刷新,normalize 不得回落)", off.Panel.PollIntervalSec) + } + + slow, err := ParseConfig([]byte(`{"panel":{"poll_interval_sec":60}}`)) + if err != nil { + t.Fatalf("parse slow: %v", err) + } + if slow.Panel.PollIntervalSec != 60 { + t.Fatalf("poll_interval_sec=%d want 60", slow.Panel.PollIntervalSec) + } +} + +func TestPanelPackageDetailLimit(t *testing.T) { + c := Default() + if err := c.normalize(); err != nil { + t.Fatalf("normalize: %v", err) + } + if c.Panel.PackageDetailLimit != 5 { + t.Fatalf("default package_detail_limit=%d want 5", c.Panel.PackageDetailLimit) + } + + configured, err := ParseConfig([]byte(`{"panel":{"package_detail_limit":8}}`)) + if err != nil { + t.Fatalf("parse configured limit: %v", err) + } + if configured.Panel.PackageDetailLimit != 8 { + t.Fatalf("configured package_detail_limit=%d want 8", configured.Panel.PackageDetailLimit) + } + + fallback, err := ParseConfig([]byte(`{"panel":{"package_detail_limit":0}}`)) + if err != nil { + t.Fatalf("parse fallback limit: %v", err) + } + if fallback.Panel.PackageDetailLimit != 5 { + t.Fatalf("fallback package_detail_limit=%d want 5", fallback.Panel.PackageDetailLimit) + } +} + +func TestLoggingDefaults(t *testing.T) { + c := Default() + if err := c.normalize(); err != nil { + t.Fatal(err) + } + if !c.Logging.RequestArchiveEnabled || c.Logging.RequestRetentionDays != 7 || c.Logging.RequestArchiveMaxMB != 100 { + t.Fatalf("logging defaults = %+v", c.Logging) + } + // 来源记录(IP/UA)缺省开启:键缺席时必须保持 true,只有显式 false 才关闭。 + if !c.Logging.RequestClientInfo { + t.Fatalf("request_client_info default = false, want true: %+v", c.Logging) + } + configured, err := ParseConfig([]byte(`{"logging":{"request_archive_enabled":false,"request_retention_days":30,"request_archive_max_mb":500}}`)) + if err != nil { + t.Fatal(err) + } + if configured.Logging.RequestArchiveEnabled || configured.Logging.RequestRetentionDays != 30 || configured.Logging.RequestArchiveMaxMB != 500 { + t.Fatalf("configured logging = %+v", configured.Logging) + } + off, err := ParseConfig([]byte(`{"logging":{"request_client_info":false}}`)) + if err != nil { + t.Fatal(err) + } + if off.Logging.RequestClientInfo { + t.Fatalf("explicit false ignored: %+v", off.Logging) + } + fallback, err := ParseConfig([]byte(`{"logging":{"request_retention_days":0,"request_archive_max_mb":0}}`)) + if err != nil { + t.Fatal(err) + } + if fallback.Logging.RequestRetentionDays != 7 || fallback.Logging.RequestArchiveMaxMB != 100 { + t.Fatalf("logging fallback = %+v", fallback.Logging) + } +} + +func TestLoadFile(t *testing.T) { + dir := t.TempDir() + fp := filepath.Join(dir, "c.json") + os.WriteFile(fp, []byte(`{"listen":":9999","api_key":"k"}`), 0o600) + c, err := Load(fp) + if err != nil { + t.Fatal(err) + } + if c.Listen != ":9999" || c.APIKey != "k" { + t.Errorf("c=%+v", c) + } +} + +func TestEnvOverride(t *testing.T) { + t.Setenv("WB2A_LISTEN", ":7777") + t.Setenv("WB2A_API_KEY", "envkey") + c, err := Load("") + if err != nil { + t.Fatal(err) + } + if c.Listen != ":7777" || c.APIKey != "envkey" { + t.Errorf("c=%+v", c) + } +} + +func TestBadDuration(t *testing.T) { + dir := t.TempDir() + fp := filepath.Join(dir, "c.json") + os.WriteFile(fp, []byte(`{"cooldown":{"soft_rate":"not-a-duration"}}`), 0o600) + if _, err := Load(fp); err == nil { + t.Fatal("want error for bad duration") + } +} + +func TestHardCreditKeyIgnored(t *testing.T) { + // 退役的 hard_credit 键作为 JSON 未知字段被自然忽略,不报错。 + dir := t.TempDir() + fp := filepath.Join(dir, "c.json") + os.WriteFile(fp, []byte(`{"cooldown":{"hard_credit":"not-a-duration","soft_rate":"30s"}}`), 0o600) + c, err := Load(fp) + if err != nil { + t.Fatalf("hard_credit must be ignored (not validated): %v", err) + } + if c.SoftRateDur.Seconds() != 30 { + t.Errorf("soft_rate=%v want 30s", c.SoftRateDur) + } +} + +func TestNewPoolConfigDefaults(t *testing.T) { + c := Default() + if err := c.normalize(); err != nil { + t.Fatalf("normalize: %v", err) + } + if c.Pool.MaxInFlight != 3 { + t.Errorf("max_in_flight=%d want 3", c.Pool.MaxInFlight) + } + if c.Pool.BreakerThreshold != 3 { + t.Errorf("breaker_threshold=%d want 3", c.Pool.BreakerThreshold) + } + if c.BreakerCooldownDur.Minutes() != 30 { + t.Errorf("breaker_cooldown=%v want 30m", c.BreakerCooldownDur) + } + if c.BreakerCooldownMaxD.Hours() != 6 { + t.Errorf("breaker_cooldown_max=%v want 6h", c.BreakerCooldownMaxD) + } + if c.Pool.IdleWeightPerHour != 0.5 || c.Pool.IdleWeightMax != 5.0 { + t.Errorf("idle weights=%v/%v", c.Pool.IdleWeightPerHour, c.Pool.IdleWeightMax) + } + if !c.Pool.PreferExpiring || c.ExpiringSoonDur != 30*24*time.Hour { + t.Errorf("expiring defaults: enabled=%v window=%v", c.Pool.PreferExpiring, c.ExpiringSoonDur) + } + if c.SoftRateMaxDur.Hours() != 2 { + t.Errorf("soft_rate_max=%v want 2h", c.SoftRateMaxDur) + } + if !c.SessionSticky.Enabled { + t.Error("session_sticky.enabled want true") + } + if c.SessionTTL.Minutes() != 30 || c.SessionGCInterval.Minutes() != 5 { + t.Errorf("session durations=%v/%v", c.SessionTTL, c.SessionGCInterval) + } + if c.Upstash.URL != "" || c.Upstash.Token != "" { + t.Errorf("upstash default should be empty: %+v", c.Upstash) + } +} + +func TestPoolConfigParsedFromFile(t *testing.T) { + dir := t.TempDir() + fp := filepath.Join(dir, "c.json") + os.WriteFile(fp, []byte(`{ + "upstash":{"url":"https://foo.upstash.io","token":"tok"}, + "pool":{ + "max_in_flight":5, + "breaker_threshold":4, + "breaker_cooldown":"10m", + "breaker_cooldown_max":"2h", + "idle_weight_per_hour":0.7, + "idle_weight_max":8.0, + "prefer_expiring":false, + "expiring_soon":"72h" + }, + "session_sticky":{"enabled":false,"ttl":"1h","gc_interval":"2m"} + }`), 0o600) + c, err := Load(fp) + if err != nil { + t.Fatal(err) + } + if c.Upstash.URL != "https://foo.upstash.io" || c.Upstash.Token != "tok" { + t.Errorf("upstash=%+v", c.Upstash) + } + if c.Pool.MaxInFlight != 5 || c.Pool.BreakerThreshold != 4 { + t.Errorf("pool=%+v", c.Pool) + } + if c.BreakerCooldownDur.Minutes() != 10 || c.BreakerCooldownMaxD.Hours() != 2 { + t.Errorf("breaker durations=%v/%v", c.BreakerCooldownDur, c.BreakerCooldownMaxD) + } + if c.Pool.IdleWeightPerHour != 0.7 || c.Pool.IdleWeightMax != 8.0 { + t.Errorf("idle weights=%v/%v", c.Pool.IdleWeightPerHour, c.Pool.IdleWeightMax) + } + if c.Pool.PreferExpiring || c.ExpiringSoonDur != 72*time.Hour { + t.Errorf("expiring override: enabled=%v window=%v", c.Pool.PreferExpiring, c.ExpiringSoonDur) + } + if c.SessionSticky.Enabled { + t.Error("session_sticky.enabled want false from file") + } + if c.SessionTTL.Hours() != 1 || c.SessionGCInterval.Minutes() != 2 { + t.Errorf("session durations=%v/%v", c.SessionTTL, c.SessionGCInterval) + } +} + +func TestSoftRateMaxParsedFromFile(t *testing.T) { + dir := t.TempDir() + fp := filepath.Join(dir, "c.json") + os.WriteFile(fp, []byte(`{"cooldown":{"soft_rate":"5m","soft_rate_max":"45m"}}`), 0o600) + c, err := Load(fp) + if err != nil { + t.Fatal(err) + } + if c.SoftRateDur.Minutes() != 5 { + t.Errorf("soft_rate=%v want 5m", c.SoftRateDur) + } + if c.SoftRateMaxDur.Minutes() != 45 { + t.Errorf("soft_rate_max=%v want 45m", c.SoftRateMaxDur) + } +} + +func TestLegacyConfigKeepsPreferExpiringEnabled(t *testing.T) { + dir := t.TempDir() + fp := filepath.Join(dir, "c.json") + os.WriteFile(fp, []byte(`{"pool":{"idle_weight_max":3}}`), 0o600) + c, err := Load(fp) + if err != nil { + t.Fatal(err) + } + if !c.Pool.PreferExpiring { + t.Fatal("missing prefer_expiring must preserve default true") + } +} + +func TestNegativeExpiringSoonClampsToDisabled(t *testing.T) { + dir := t.TempDir() + fp := filepath.Join(dir, "c.json") + os.WriteFile(fp, []byte(`{"pool":{"expiring_soon":"-1h"}}`), 0o600) + c, err := Load(fp) + if err != nil { + t.Fatal(err) + } + if c.ExpiringSoonDur != 0 || c.Pool.ExpiringSoon != "0" { + t.Fatalf("negative window=%v/%q want 0/0", c.ExpiringSoonDur, c.Pool.ExpiringSoon) + } +} + +func TestSoftRateMaxEmptyFallsBackToDefault(t *testing.T) { + // 键缺席 → Default() 的 2h 保留(空串无法 ParseDuration)。 + dir := t.TempDir() + fp := filepath.Join(dir, "c.json") + os.WriteFile(fp, []byte(`{"cooldown":{"soft_rate":"90s"}}`), 0o600) + c, err := Load(fp) + if err != nil { + t.Fatal(err) + } + if c.SoftRateMaxDur.Hours() != 2 { + t.Errorf("soft_rate_max=%v want 2h fallback", c.SoftRateMaxDur) + } +} + +func TestBadSoftRateMax(t *testing.T) { + dir := t.TempDir() + fp := filepath.Join(dir, "c.json") + os.WriteFile(fp, []byte(`{"cooldown":{"soft_rate_max":"oops"}}`), 0o600) + if _, err := Load(fp); err == nil { + t.Fatal("want error for bad soft_rate_max") + } +} + +func TestBadBreakerCooldown(t *testing.T) { + dir := t.TempDir() + fp := filepath.Join(dir, "c.json") + os.WriteFile(fp, []byte(`{"pool":{"breaker_cooldown":"oops"}}`), 0o600) + if _, err := Load(fp); err == nil { + t.Fatal("want error for bad breaker_cooldown") + } +} + +func TestUpstreamTimeoutDefaults(t *testing.T) { + // 默认:header 回落 timeout,idle 回落 300。 + c := Default() + if err := c.normalize(); err != nil { + t.Fatalf("normalize: %v", err) + } + if c.Upstream.TimeoutSeconds != 120 { + t.Errorf("timeout_seconds=%d want 120", c.Upstream.TimeoutSeconds) + } + if c.Upstream.HeaderTimeoutSeconds != 120 { + t.Errorf("header_timeout_seconds=%d want fallback 120", c.Upstream.HeaderTimeoutSeconds) + } + if c.Upstream.IdleTimeoutSeconds != 300 { + t.Errorf("idle_timeout_seconds=%d want fallback 300", c.Upstream.IdleTimeoutSeconds) + } +} + +func TestUpstreamHeaderFallsBackToTimeout(t *testing.T) { + // 只设 timeout_seconds:header 回落同值,idle 回落 300。 + dir := t.TempDir() + fp := filepath.Join(dir, "c.json") + os.WriteFile(fp, []byte(`{"upstream":{"timeout_seconds":60}}`), 0o600) + c, err := Load(fp) + if err != nil { + t.Fatal(err) + } + if c.Upstream.HeaderTimeoutSeconds != 60 { + t.Errorf("header_timeout_seconds=%d want fallback 60", c.Upstream.HeaderTimeoutSeconds) + } + if c.Upstream.IdleTimeoutSeconds != 300 { + t.Errorf("idle_timeout_seconds=%d want fallback 300", c.Upstream.IdleTimeoutSeconds) + } +} + +func TestUpstreamExplicitHeaderIdle(t *testing.T) { + dir := t.TempDir() + fp := filepath.Join(dir, "c.json") + os.WriteFile(fp, []byte(`{"upstream":{"timeout_seconds":120,"header_timeout_seconds":30,"idle_timeout_seconds":600}}`), 0o600) + c, err := Load(fp) + if err != nil { + t.Fatal(err) + } + if c.Upstream.HeaderTimeoutSeconds != 30 { + t.Errorf("header_timeout_seconds=%d want 30", c.Upstream.HeaderTimeoutSeconds) + } + if c.Upstream.IdleTimeoutSeconds != 600 { + t.Errorf("idle_timeout_seconds=%d want 600", c.Upstream.IdleTimeoutSeconds) + } +} + +func TestUpstreamEnvOverride(t *testing.T) { + t.Setenv("WB2A_HEADER_TIMEOUT_SECONDS", "45") + t.Setenv("WB2A_IDLE_TIMEOUT_SECONDS", "900") + c, err := Load("") + if err != nil { + t.Fatal(err) + } + if c.Upstream.HeaderTimeoutSeconds != 45 { + t.Errorf("header_timeout_seconds=%d want env 45", c.Upstream.HeaderTimeoutSeconds) + } + if c.Upstream.IdleTimeoutSeconds != 900 { + t.Errorf("idle_timeout_seconds=%d want env 900", c.Upstream.IdleTimeoutSeconds) + } +} + +// TestRetiredTravelIntervalKeyIgnored 退役的 travel_interval_minutes 键按未知字段忽略,不报错。 +func TestRetiredTravelIntervalKeyIgnored(t *testing.T) { + dir := t.TempDir() + fp := filepath.Join(dir, "c.json") + os.WriteFile(fp, []byte(`{"schedule":{"travel_interval_minutes":15,"checkin_hours":[9]}}`), 0o600) + c, err := Load(fp) + if err != nil { + t.Fatalf("retired key should not fail load: %v", err) + } + if len(c.Schedule.CheckinHours) != 1 || c.Schedule.CheckinHours[0] != 9 { + t.Errorf("checkin_hours=%v want [9](同段其余键照常生效)", c.Schedule.CheckinHours) + } +} + +// TestScheduleEnabledByDefault 四个任务的 enabled 开关默认均为 true: +// 老 config 不写这些键,行为必须与从前完全一致。 +func TestScheduleEnabledByDefault(t *testing.T) { + c := Default() + if err := c.normalize(); err != nil { + t.Fatalf("normalize: %v", err) + } + if !c.Schedule.CheckinEnabled || !c.Schedule.KeepaliveEnabled { + t.Errorf("enabled defaults want true/true, got %v/%v", + c.Schedule.CheckinEnabled, c.Schedule.KeepaliveEnabled) + } + if !c.Schedule.TravelEnabled || !c.Schedule.ActivityEnabled { + t.Errorf("travel/activity enabled defaults want true/true, got %v/%v", + c.Schedule.TravelEnabled, c.Schedule.ActivityEnabled) + } + if len(c.Schedule.TravelHours) != 2 || c.Schedule.TravelHours[0] != 9 || c.Schedule.TravelHours[1] != 21 { + t.Errorf("travel_hours=%v want [9,21]", c.Schedule.TravelHours) + } + if len(c.Schedule.ActivityHours) != 1 || c.Schedule.ActivityHours[0] != 10 { + t.Errorf("activity_hours=%v want [10]", c.Schedule.ActivityHours) + } +} + +// TestScheduleLegacyConfigKeepsRunning 老 config(只写签到/保活小时数组,无新键)加载后仍是启用态, +// 新开关缺省 true、新 hours 回落默认——对老配置零影响。 +func TestScheduleLegacyConfigKeepsRunning(t *testing.T) { + dir := t.TempDir() + fp := filepath.Join(dir, "c.json") + os.WriteFile(fp, []byte(`{"schedule":{"checkin_hours":[9,21],"keepalive_hours":[22]}}`), 0o600) + c, err := Load(fp) + if err != nil { + t.Fatal(err) + } + if !c.Schedule.CheckinEnabled || !c.Schedule.KeepaliveEnabled { + t.Errorf("legacy config must stay enabled: %+v", c.Schedule) + } + if !c.Schedule.TravelEnabled || !c.Schedule.ActivityEnabled { + t.Errorf("new switches must default true on legacy config: %+v", c.Schedule) + } + if len(c.Schedule.CheckinHours) != 2 { + t.Errorf("checkin_hours=%v", c.Schedule.CheckinHours) + } + // 新 hours 缺省 → 回落默认(非空)。 + if len(c.Schedule.TravelHours) != 2 || c.Schedule.TravelHours[0] != 9 || c.Schedule.TravelHours[1] != 21 { + t.Errorf("travel_hours=%v want default [9,21]", c.Schedule.TravelHours) + } + if len(c.Schedule.ActivityHours) != 1 || c.Schedule.ActivityHours[0] != 10 { + t.Errorf("activity_hours=%v want default [10]", c.Schedule.ActivityHours) + } +} + +// TestScheduleExplicitDisable 显式 checkin_enabled=false 即可真正关掉签到 +// (issue #27 边界:此前无论怎么配小时都关不掉)。 +func TestScheduleExplicitDisable(t *testing.T) { + dir := t.TempDir() + fp := filepath.Join(dir, "c.json") + os.WriteFile(fp, []byte(`{"schedule":{"checkin_enabled":false,"keepalive_enabled":false}}`), 0o600) + c, err := Load(fp) + if err != nil { + t.Fatal(err) + } + if c.Schedule.CheckinEnabled || c.Schedule.KeepaliveEnabled { + t.Errorf("want both disabled: %+v", c.Schedule) + } + // 小时数组仍回落默认值(禁用与默认值互不干扰:重新启用无需补配小时)。 + if len(c.Schedule.CheckinHours) != 2 || c.Schedule.CheckinHours[0] != 9 || c.Schedule.CheckinHours[1] != 21 { + t.Errorf("checkin_hours=%v want default [9 21] even when disabled", c.Schedule.CheckinHours) + } + if len(c.Schedule.KeepaliveHours) != 1 || c.Schedule.KeepaliveHours[0] != 22 { + t.Errorf("keepalive_hours=%v want default [22] even when disabled", c.Schedule.KeepaliveHours) + } +} + +// TestScheduleTravelActivityExplicitDisable 显式关闭旅行/活跃上报开关。 +func TestScheduleTravelActivityExplicitDisable(t *testing.T) { + dir := t.TempDir() + fp := filepath.Join(dir, "c.json") + os.WriteFile(fp, []byte(`{"schedule":{"travel_enabled":false,"activity_enabled":false}}`), 0o600) + c, err := Load(fp) + if err != nil { + t.Fatal(err) + } + if c.Schedule.TravelEnabled || c.Schedule.ActivityEnabled { + t.Errorf("want travel/activity disabled: %+v", c.Schedule) + } + // 签到/保活开关缺省 true(互不干扰)。 + if !c.Schedule.CheckinEnabled || !c.Schedule.KeepaliveEnabled { + t.Errorf("checkin/keepalive should stay enabled: %+v", c.Schedule) + } + // hours 仍回落默认。 + if len(c.Schedule.TravelHours) != 2 || c.Schedule.TravelHours[0] != 9 || c.Schedule.TravelHours[1] != 21 { + t.Errorf("travel_hours=%v want default [9,21] even when disabled", c.Schedule.TravelHours) + } + if len(c.Schedule.ActivityHours) != 1 || c.Schedule.ActivityHours[0] != 10 { + t.Errorf("activity_hours=%v want default [10] even when disabled", c.Schedule.ActivityHours) + } +} + +// TestScheduleTravelActivityInvalidHoursRejected 旅行/活跃非法小时报错并指向正确开关。 +func TestScheduleTravelActivityInvalidHoursRejected(t *testing.T) { + cases := []struct{ body, wantSwitch string }{ + {`{"schedule":{"travel_hours":[25]}}`, "travel_enabled"}, + {`{"schedule":{"travel_hours":[-1]}}`, "travel_enabled"}, + {`{"schedule":{"activity_hours":[24]}}`, "activity_enabled"}, + {`{"schedule":{"activity_hours":[-1]}}`, "activity_enabled"}, + } + for _, tc := range cases { + dir := t.TempDir() + fp := filepath.Join(dir, "c.json") + os.WriteFile(fp, []byte(tc.body), 0o600) + _, err := Load(fp) + if err == nil { + t.Fatalf("want error for %s", tc.body) + } + if !strings.Contains(err.Error(), tc.wantSwitch) { + t.Errorf("error for %s should point at schedule.%s: %v", tc.body, tc.wantSwitch, err) + } + } +} + +// TestScheduleTravelActivityExplicitHours 显式配置旅行/活跃小时。 +func TestScheduleTravelActivityExplicitHours(t *testing.T) { + dir := t.TempDir() + fp := filepath.Join(dir, "c.json") + os.WriteFile(fp, []byte(`{"schedule":{"travel_hours":[9,21],"activity_hours":[11]}}`), 0o600) + c, err := Load(fp) + if err != nil { + t.Fatal(err) + } + if len(c.Schedule.TravelHours) != 2 || c.Schedule.TravelHours[0] != 9 || c.Schedule.TravelHours[1] != 21 { + t.Errorf("travel_hours=%v want [9 21]", c.Schedule.TravelHours) + } + if len(c.Schedule.ActivityHours) != 1 || c.Schedule.ActivityHours[0] != 11 { + t.Errorf("activity_hours=%v want [11]", c.Schedule.ActivityHours) + } +} + +// TestScheduleDisableKeepsExplicitHours 禁用不擦除用户配置的小时(便于原样恢复)。 +func TestScheduleDisableKeepsExplicitHours(t *testing.T) { + dir := t.TempDir() + fp := filepath.Join(dir, "c.json") + os.WriteFile(fp, []byte(`{"schedule":{"checkin_enabled":false,"checkin_hours":[10,14]}}`), 0o600) + c, err := Load(fp) + if err != nil { + t.Fatal(err) + } + if c.Schedule.CheckinEnabled { + t.Error("checkin should be disabled") + } + if len(c.Schedule.CheckinHours) != 2 || c.Schedule.CheckinHours[0] != 10 || c.Schedule.CheckinHours[1] != 14 { + t.Errorf("explicit hours must be preserved: %v", c.Schedule.CheckinHours) + } +} + +// TestScheduleEmptyHoursFallsBackToDefault 空数组 / null / 缺省都视同「未配置」→ 回落默认。 +func TestScheduleEmptyHoursFallsBackToDefault(t *testing.T) { + cases := map[string]string{ + "absent": `{}`, + "empty": `{"schedule":{}}`, + "null": `{"schedule":{"checkin_hours":null,"keepalive_hours":null,"travel_hours":null,"activity_hours":null}}`, + "emptyarr": `{"schedule":{"checkin_hours":[],"keepalive_hours":[],"travel_hours":[],"activity_hours":[]}}`, + } + for name, body := range cases { + t.Run(name, func(t *testing.T) { + dir := t.TempDir() + fp := filepath.Join(dir, "c.json") + os.WriteFile(fp, []byte(body), 0o600) + c, err := Load(fp) + if err != nil { + t.Fatal(err) + } + if len(c.Schedule.CheckinHours) != 2 || c.Schedule.CheckinHours[0] != 9 || c.Schedule.CheckinHours[1] != 21 { + t.Errorf("checkin_hours=%v want default [9 21]", c.Schedule.CheckinHours) + } + if len(c.Schedule.KeepaliveHours) != 1 || c.Schedule.KeepaliveHours[0] != 22 { + t.Errorf("keepalive_hours=%v want default [22]", c.Schedule.KeepaliveHours) + } + if len(c.Schedule.TravelHours) != 2 || c.Schedule.TravelHours[0] != 9 || c.Schedule.TravelHours[1] != 21 { + t.Errorf("travel_hours=%v want default [9 21]", c.Schedule.TravelHours) + } + if len(c.Schedule.ActivityHours) != 1 || c.Schedule.ActivityHours[0] != 10 { + t.Errorf("activity_hours=%v want default [10]", c.Schedule.ActivityHours) + } + if !c.Schedule.CheckinEnabled || !c.Schedule.KeepaliveEnabled { + t.Errorf("empty hours must not imply disabled: %+v", c.Schedule) + } + if !c.Schedule.TravelEnabled || !c.Schedule.ActivityEnabled { + t.Errorf("empty hours must not imply disabled: %+v", c.Schedule) + } + }) + } +} + +// TestScheduleInvalidHourRejected 非法小时快速失败:指向正确的禁用开关,避免用户 +// 猜测哨兵值([-1] 之类)被静默当成"改到别的整点"。 +func TestScheduleInvalidHourRejected(t *testing.T) { + cases := []struct{ body, wantSwitch string }{ + {`{"schedule":{"checkin_hours":[25]}}`, "checkin_enabled"}, + {`{"schedule":{"checkin_hours":[-1]}}`, "checkin_enabled"}, + {`{"schedule":{"keepalive_hours":[-1]}}`, "keepalive_enabled"}, + } + for _, tc := range cases { + dir := t.TempDir() + fp := filepath.Join(dir, "c.json") + os.WriteFile(fp, []byte(tc.body), 0o600) + _, err := Load(fp) + if err == nil { + t.Fatalf("want error for %s", tc.body) + } + if !strings.Contains(err.Error(), tc.wantSwitch) { + t.Errorf("error for %s should point at schedule.%s: %v", tc.body, tc.wantSwitch, err) + } + } +} + +func TestBadSessionTTL(t *testing.T) { + dir := t.TempDir() + fp := filepath.Join(dir, "c.json") + os.WriteFile(fp, []byte(`{"session_sticky":{"ttl":"oops"}}`), 0o600) + if _, err := Load(fp); err == nil { + t.Fatal("want error for bad session_sticky.ttl") + } +} + +func TestWriteDefault(t *testing.T) { + dir := t.TempDir() + fp := filepath.Join(dir, "sub", "config.json") // 顺带验证父目录自动创建 + key, err := WriteDefault(fp) + if err != nil { + t.Fatal(err) + } + // key 形如 sk-<24字符随机串>,两次生成不重复 + if !strings.HasPrefix(key, "sk-") || len(key) < 20 { + t.Errorf("key=%q want sk-", key) + } + if key2, _ := WriteDefault(filepath.Join(dir, "another.json")); key2 == key { + t.Errorf("two generated keys identical: %q", key) + } + // 落盘文件可被 Load 正常加载,推荐值齐备且 api_key 生效 + c, err := Load(fp) + if err != nil { + t.Fatalf("load generated config: %v", err) + } + if c.APIKey != key { + t.Errorf("api_key=%q want %q", c.APIKey, key) + } + if c.Listen != "127.0.0.1:7863" || c.AuthDir != "./auths" || c.StateFile != "./data/state.json" { + t.Errorf("generated defaults off: %+v", c) + } + if len(c.Schedule.CheckinHours) == 0 || !c.Schedule.CheckinEnabled { + t.Errorf("generated schedule off: %+v", c.Schedule) + } + // 已存在的文件不覆盖:二次写入同一路径必须报错 + if _, err := WriteDefault(fp); err == nil { + t.Error("WriteDefault must refuse to overwrite existing file") + } +} + +// 补领清扫(issue #174):缺省启用 + 15 分钟;显式关闭时 interval 归零(不启动); +// minutes<=0 回落 15。 +func TestTaskSweepDefaults(t *testing.T) { + c := Default() + if err := c.normalize(); err != nil { + t.Fatal(err) + } + if !c.Schedule.TaskSweepEnabled || c.TaskSweepInterval != 15*time.Minute { + t.Errorf("default task sweep: enabled=%v interval=%v", c.Schedule.TaskSweepEnabled, c.TaskSweepInterval) + } + dir := t.TempDir() + fp := filepath.Join(dir, "c.json") + os.WriteFile(fp, []byte(`{"schedule":{"task_sweep_minutes":3}}`), 0o600) + c2, err := Load(fp) + if err != nil { + t.Fatal(err) + } + if c2.TaskSweepInterval != 3*time.Minute { + t.Errorf("interval=%v want 3m", c2.TaskSweepInterval) + } + os.WriteFile(fp, []byte(`{"schedule":{"task_sweep_enabled":false}}`), 0o600) + c3, err := Load(fp) + if err != nil { + t.Fatal(err) + } + if c3.TaskSweepInterval != 0 { + t.Errorf("disabled interval=%v want 0", c3.TaskSweepInterval) + } + os.WriteFile(fp, []byte(`{"schedule":{"task_sweep_minutes":-5}}`), 0o600) + c4, err := Load(fp) + if err != nil { + t.Fatal(err) + } + if c4.TaskSweepInterval != 15*time.Minute { + t.Errorf("negative minutes interval=%v want 15m", c4.TaskSweepInterval) + } +} + +// TestKeepaliveRefreshWindow checks defaults, explicit durations, and invalid values. +func TestKeepaliveRefreshWindow(t *testing.T) { + c := Default() + if err := c.normalize(); err != nil { + t.Fatal(err) + } + if c.Schedule.KeepaliveRefreshWindow != "168h" || c.KeepaliveRefreshWindowDur != 168*time.Hour { + t.Fatalf("default keepalive window=%q/%v want 168h", c.Schedule.KeepaliveRefreshWindow, c.KeepaliveRefreshWindowDur) + } + + dir := t.TempDir() + fp := filepath.Join(dir, "c.json") + if err := os.WriteFile(fp, []byte(`{"schedule":{"keepalive_refresh_window":"24h"}}`), 0o600); err != nil { + t.Fatal(err) + } + c2, err := Load(fp) + if err != nil { + t.Fatal(err) + } + if c2.KeepaliveRefreshWindowDur != 24*time.Hour { + t.Fatalf("explicit keepalive window=%v want 24h", c2.KeepaliveRefreshWindowDur) + } + + // 老 config 没这个键:缺键必须回落到默认,不能报错。 + if err := os.WriteFile(fp, []byte(`{"schedule":{"keepalive_hours":[22]}}`), 0o600); err != nil { + t.Fatal(err) + } + c3, err := Load(fp) + if err != nil { + t.Fatalf("缺键不应报错: %v", err) + } + if c3.KeepaliveRefreshWindowDur != 168*time.Hour { + t.Errorf("缺键窗口=%v want 168h", c3.KeepaliveRefreshWindowDur) + } + + for _, raw := range []string{"0s", "-1h", "not-a-duration"} { + if err := os.WriteFile(fp, []byte(`{"schedule":{"keepalive_refresh_window":"`+raw+`"}}`), 0o600); err != nil { + t.Fatal(err) + } + if _, err := Load(fp); err == nil { + t.Errorf("keepalive_refresh_window=%q should be rejected", raw) + } + } +} + +func TestBalanceRefreshDefaults(t *testing.T) { + // 缺省:启用 + 30 分钟 + c := Default() + if err := c.normalize(); err != nil { + t.Fatal(err) + } + if !c.Schedule.BalanceRefreshEnabled || c.BalanceRefreshInterval != 5*time.Minute { + t.Errorf("default balance refresh: enabled=%v interval=%v", c.Schedule.BalanceRefreshEnabled, c.BalanceRefreshInterval) + } + // 显式配置 10 分钟 + dir := t.TempDir() + fp := filepath.Join(dir, "c.json") + os.WriteFile(fp, []byte(`{"schedule":{"balance_refresh_minutes":10}}`), 0o600) + c2, err := Load(fp) + if err != nil { + t.Fatal(err) + } + if c2.BalanceRefreshInterval != 10*time.Minute { + t.Errorf("interval=%v want 10m", c2.BalanceRefreshInterval) + } + // 显式关闭:interval 归零(不启动) + os.WriteFile(fp, []byte(`{"schedule":{"balance_refresh_enabled":false}}`), 0o600) + c3, err := Load(fp) + if err != nil { + t.Fatal(err) + } + if c3.BalanceRefreshInterval != 0 { + t.Errorf("disabled interval=%v want 0", c3.BalanceRefreshInterval) + } + // 启用但 minutes<=0 → 回落默认 30 + os.WriteFile(fp, []byte(`{"schedule":{"balance_refresh_minutes":-5}}`), 0o600) + c4, err := Load(fp) + if err != nil { + t.Fatal(err) + } + if c4.BalanceRefreshInterval != 5*time.Minute { + t.Errorf("fallback interval=%v want 30m", c4.BalanceRefreshInterval) + } +} + +// TestPromptDefaultPassthrough 默认 prompt.mode=passthrough(对齐上游:透传客户端 +// 原始 system 是更保守的缺省);custom 由用户显式选择,此时 PromptText 为内置默认(非空)。 +func TestPromptDefaultPassthrough(t *testing.T) { + c, err := Load("") + if err != nil { + t.Fatal(err) + } + if c.Prompt.Mode != "passthrough" { + t.Errorf("prompt.mode=%q want passthrough", c.Prompt.Mode) + } + // passthrough 不加载提示词文本(透传客户端 system);切 custom 时 normalize 会加载。 +} + +// TestPromptExplicitPassthrough passthrough 模式不加载文本(透传客户端原始 system)。 +func TestPromptExplicitPassthrough(t *testing.T) { + dir := t.TempDir() + fp := filepath.Join(dir, "c.json") + os.WriteFile(fp, []byte(`{"prompt":{"mode":"passthrough"}}`), 0o600) + c, err := Load(fp) + if err != nil { + t.Fatal(err) + } + if c.Prompt.Mode != "passthrough" { + t.Errorf("mode=%q want passthrough", c.Prompt.Mode) + } + if c.PromptText != "" { + t.Errorf("passthrough should not load PromptText, got len=%d", len(c.PromptText)) + } +} + +// TestPromptInvalidMode 非法 mode 启动报错。 +func TestPromptInvalidMode(t *testing.T) { + dir := t.TempDir() + fp := filepath.Join(dir, "c.json") + os.WriteFile(fp, []byte(`{"prompt":{"mode":"bogus"}}`), 0o600) + if _, err := Load(fp); err == nil { + t.Fatal("want error for invalid prompt.mode") + } +} + +// TestPromptFileMissing 文件路径非空但不存在 → 启动报错(fail fast)。 +func TestPromptFileMissing(t *testing.T) { + dir := t.TempDir() + fp := filepath.Join(dir, "c.json") + os.WriteFile(fp, []byte(`{"prompt":{"mode":"custom","file":"/nonexistent/p.md"}}`), 0o600) + if _, err := Load(fp); err == nil { + t.Fatal("want error for missing prompt file") + } +} + +// TestPromptFileOverride 自定义 file 覆盖内置默认。 +func TestPromptFileOverride(t *testing.T) { + dir := t.TempDir() + pf := filepath.Join(dir, "my.md") + want := "我的自定义人格入口" + os.WriteFile(pf, []byte(want), 0o600) + cf := filepath.Join(dir, "c.json") + // 用 json.Marshal 拼路径:Windows 反斜杠必须转义,手工字符串拼接会产出非法 JSON。 + cfgJSON, err := json.Marshal(map[string]any{"prompt": map[string]any{"mode": "custom", "file": pf}}) + if err != nil { + t.Fatal(err) + } + os.WriteFile(cf, cfgJSON, 0o600) + c, err := Load(cf) + if err != nil { + t.Fatal(err) + } + if c.PromptText != want { + t.Errorf("PromptText=%q want %q", c.PromptText, want) + } +} + +// TestPromptEnvOverride env 覆盖 prompt.mode 与 prompt.file。 +func TestPromptEnvOverride(t *testing.T) { + t.Setenv("WB2A_PROMPT_MODE", "passthrough") + c, err := Load("") + if err != nil { + t.Fatal(err) + } + if c.Prompt.Mode != "passthrough" { + t.Errorf("mode=%q want passthrough", c.Prompt.Mode) + } +} + +// TestPromptLegacyConfigNoImpact 旧 config(无 prompt 段)零影响:mode 缺省 passthrough。 +func TestPromptLegacyConfigNoImpact(t *testing.T) { + dir := t.TempDir() + fp := filepath.Join(dir, "c.json") + os.WriteFile(fp, []byte(`{"listen":":9999","api_key":"k"}`), 0o600) + c, err := Load(fp) + if err != nil { + t.Fatal(err) + } + if c.Prompt.Mode != "passthrough" { + t.Errorf("legacy config should default to passthrough, got %q", c.Prompt.Mode) + } + if c.Listen != ":9999" { + t.Errorf("listen=%q", c.Listen) + } +} + +// TestUpstreamUserAgentConfig 配置 upstream.user_agent 与 env WB2A_USER_AGENT 均生效, +// 缺省空串保持现状(headers 层回落到 clientUA)。 +func TestUpstreamUserAgentConfig(t *testing.T) { + // JSON 配置 + dir := t.TempDir() + fp := filepath.Join(dir, "c.json") + os.WriteFile(fp, []byte(`{"upstream":{"user_agent":"WorkBuddy/1.2.3"}}`), 0o600) + c, err := Load(fp) + if err != nil { + t.Fatal(err) + } + if c.Upstream.UserAgent != "WorkBuddy/1.2.3" { + t.Errorf("user_agent=%q want WorkBuddy/1.2.3", c.Upstream.UserAgent) + } + // 缺省为空 + if c2, err := Load(""); err != nil || c2.Upstream.UserAgent != "" { + t.Errorf("default user_agent=%q want empty (err=%v)", c2.Upstream.UserAgent, err) + } + // env 覆盖 + t.Setenv("WB2A_USER_AGENT", "EnvAgent/9") + c3, err := Load("") + if err != nil { + t.Fatal(err) + } + if c3.Upstream.UserAgent != "EnvAgent/9" { + t.Errorf("env user_agent=%q want EnvAgent/9", c3.Upstream.UserAgent) + } +} + +// TestLoadConfigPathIsDirectory config 路径是目录时给出可操作提示(Docker bind mount 陷阱)。 +// 复现:compose 挂载 ./config.json 但宿主机缺该文件 → Docker 创建同名目录 → 启动失败。 +// 旧行为只报 "read config: ... Incorrect function" 之类晦涩错误,无从排查。 +func TestLoadConfigPathIsDirectory(t *testing.T) { + dir := t.TempDir() + asDir := filepath.Join(dir, "config.json") + if err := os.Mkdir(asDir, 0o755); err != nil { + t.Fatal(err) + } + _, err := Load(asDir) + if err == nil { + t.Fatal("want error when config path is a directory") + } + msg := err.Error() + if !strings.Contains(msg, "是目录") { + t.Errorf("error should explain it is a directory: %v", err) + } + if !strings.Contains(msg, "config.example.json") { + t.Errorf("error should suggest the fix (cp config.example.json): %v", err) + } +} + +// TestReserveCreditsDefaultAndOff 保留积分默认值语义: +// 键缺席 → 10(默认留一线);显式 0 → 关闭;显式值 → 原样。 +func TestReserveCreditsDefaultAndOff(t *testing.T) { + dir := t.TempDir() + load := func(t *testing.T, body string) *int64 { + t.Helper() + fp := filepath.Join(dir, strings.ReplaceAll(t.Name(), "/", "_")+".json") + if err := os.WriteFile(fp, []byte(body), 0o600); err != nil { + t.Fatal(err) + } + c, err := Load(fp) + if err != nil { + t.Fatalf("load: %v", err) + } + return c.Pool.ReserveCredits + } + if v := load(t, `{}`); v == nil || *v != 10 { + t.Errorf("键缺席 reserve_credits=%v want 10(默认)", v) + } + if v := load(t, `{"pool":{"reserve_credits":0}}`); v == nil || *v != 0 { + t.Errorf("显式 0 reserve_credits=%v want 0(关闭)", v) + } + if v := load(t, `{"pool":{"reserve_credits":5000}}`); v == nil || *v != 5000 { + t.Errorf("显式值 reserve_credits=%v want 5000", v) + } + if v := load(t, `{"pool":{"reserve_credits":-5}}`); v == nil || *v != 0 { + t.Errorf("负值 reserve_credits=%v want 0(归零)", v) + } +} + +// TestServerReadTimeout 入站读取上限(issue #100):空值回落默认 300s; +// "0" = 显式不限制(0 是合法值不回落);负值 fail fast(静默钳 0 会把保护悄悄关掉)。 +func TestServerReadTimeout(t *testing.T) { + c := Default() + if c.Server.ReadTimeout != "300s" { + t.Errorf("default read_timeout=%q want 300s", c.Server.ReadTimeout) + } + if err := c.normalize(); err != nil { + t.Fatalf("normalize: %v", err) + } + if c.ServerReadTimeoutDur != 300*time.Second { + t.Errorf("default dur=%v want 300s", c.ServerReadTimeoutDur) + } + + c = Default() + c.Server.ReadTimeout = "" // 显式清空 = 未配置 → 回落默认 + if err := c.normalize(); err != nil { + t.Fatalf("normalize empty: %v", err) + } + if c.ServerReadTimeoutDur != 300*time.Second { + t.Errorf("empty dur=%v want 300s", c.ServerReadTimeoutDur) + } + + c = Default() + c.Server.ReadTimeout = "0" // 显式 0 = 不限制(http.Server ReadTimeout 0 即无超时) + if err := c.normalize(); err != nil { + t.Fatalf("normalize zero: %v", err) + } + if c.ServerReadTimeoutDur != 0 { + t.Errorf("zero dur=%v want 0", c.ServerReadTimeoutDur) + } + + c = Default() + c.Server.ReadTimeout = "-5s" + if err := c.normalize(); err == nil { + t.Error("negative read_timeout should fail fast") + } + + c = Default() + c.Server.ReadTimeout = "bogus" + if err := c.normalize(); err == nil { + t.Error("unparsable read_timeout should fail fast") + } +} + +// TestDNSServersConfigAndEnv dns_servers 两种来源:配置文件数组原样保留; +// WB2A_DNS 逗号分隔覆盖(去空白、丢空项)。空 = 系统解析器,不得塞空串进去。 +func TestDNSServersConfigAndEnv(t *testing.T) { + c, err := ParseConfig([]byte(`{"dns_servers":["223.5.5.5","1.1.1.1:5353"]}`)) + if err != nil { + t.Fatal(err) + } + if got := strings.Join(c.DNSServers, ","); got != "223.5.5.5,1.1.1.1:5353" { + t.Fatalf("文件配置 dns_servers=%v", c.DNSServers) + } + + t.Setenv("WB2A_DNS", " 119.29.29.29 , ,8.8.8.8") + c2, err := Load("") + if err != nil { + t.Fatal(err) + } + if got := strings.Join(c2.DNSServers, ","); got != "119.29.29.29,8.8.8.8" { + t.Fatalf("WB2A_DNS 覆盖结果=%v", c2.DNSServers) + } + + // 面板/环境变量管理的字段清单要认它,否则面板会让人以为改了配置能生效。 + managed := c2.EnvironmentManagedFields() + found := false + for _, f := range managed { + if f == "dns_servers" { + found = true + } + } + if !found { + t.Fatalf("dns_servers 应出现在环境变量管理字段里:%v", managed) + } + + c3, err := ParseConfig([]byte(`{}`)) + if err != nil { + t.Fatal(err) + } + if len(c3.DNSServers) != 0 { + t.Fatalf("缺省应为空(系统解析器):%v", c3.DNSServers) + } +} + +func TestPeriodicJitterPermillConfig(t *testing.T) { + dir := t.TempDir() + fp := filepath.Join(dir, "c.json") + os.WriteFile(fp, []byte(`{"listen":":9999","api_key":"k","schedule":{"balance_refresh_jitter_permill":200,"task_sweep_jitter_permill":300}}`), 0o600) + c, err := Load(fp) + if err != nil { + t.Fatal(err) + } + if c.Schedule.BalanceRefreshJitterPermill != 200 || c.Schedule.TaskSweepJitterPermill != 300 { + t.Fatalf("c.Schedule=%+v", c.Schedule) + } + + // 超上限拒绝(上限 500 = 50%)。 + os.WriteFile(fp, []byte(`{"listen":":9999","api_key":"k","schedule":{"balance_refresh_jitter_permill":501}}`), 0o600) + if _, err := Load(fp); err == nil { + t.Fatal("want error for jitter_permill > 500") + } + + // 负数拒绝。 + os.WriteFile(fp, []byte(`{"listen":":9999","api_key":"k","schedule":{"task_sweep_jitter_permill":-1}}`), 0o600) + if _, err := Load(fp); err == nil { + t.Fatal("want error for negative jitter_permill") + } + + // env 覆盖。 + t.Setenv("WB2A_SCHEDULE_BALANCE_REFRESH_JITTER_PERMILL", "250") + t.Setenv("WB2A_SCHEDULE_TASK_SWEEP_JITTER_PERMILL", "100") + c2, err := Load("") + if err != nil { + t.Fatal(err) + } + if c2.Schedule.BalanceRefreshJitterPermill != 250 || c2.Schedule.TaskSweepJitterPermill != 100 { + t.Fatalf("env override: %+v", c2.Schedule) + } +} + +func TestThinkingDefaults(t *testing.T) { + c := Default() + if !c.Thinking.Enabled { + t.Error("thinking.enabled default should be true") + } + // 缺省 high(upstream.DefaultGatewayEffort),不是 max:思考与正文共用一份输出 + // 额度,max 会把预算烧在思考上、正文只剩半句。 + if c.Thinking.DefaultEffort != upstream.DefaultGatewayEffort { + t.Errorf("thinking.default_effort=%q want %q", c.Thinking.DefaultEffort, upstream.DefaultGatewayEffort) + } + if !c.Thinking.ClientPriority { + t.Error("thinking.client_priority default should be true") + } + if c.Thinking.OverrideScope != "level" { + t.Errorf("thinking.override_scope=%q want level", c.Thinking.OverrideScope) + } +} + +func TestThinkingRejectsInvalid(t *testing.T) { + for _, raw := range []string{ + `{"thinking":{"default_effort":"turbo"}}`, + `{"thinking":{"default_effort":"off"}}`, + `{"thinking":{"override_scope":"everything"}}`, + `{"thinking":{"model_defaults":{"glm-5.2":"ultra"}}}`, + } { + if _, err := ParseConfig([]byte(raw)); err == nil { + t.Fatalf("%s should be rejected", raw) + } + } +} + +func TestThinkingNormalize(t *testing.T) { + c, err := ParseConfig([]byte(`{"thinking":{"default_effort":" HIGH ","override_scope":"ALL",` + + `"model_defaults":{" glm-5.2 ":"Max","legacy":"inherit","":"high","blank":" ","glm-5.3":"Off"}}}`)) + if err != nil { + t.Fatalf("parse: %v", err) + } + if c.Thinking.DefaultEffort != "high" { + t.Errorf("default_effort=%q want high", c.Thinking.DefaultEffort) + } + if c.Thinking.OverrideScope != "all" { + t.Errorf("override_scope=%q want all", c.Thinking.OverrideScope) + } + if got := c.Thinking.ModelDefaults; len(got) != 2 || got["glm-5.2"] != "max" || got["glm-5.3"] != "off" { + t.Fatalf("model_defaults=%v(inherit/空键/空值应被剔除,off 是合法的按模型关闭)", got) + } +} + +func TestThinkingEnvOverride(t *testing.T) { + t.Setenv("WB2A_THINKING_ENABLED", "false") + t.Setenv("WB2A_THINKING_DEFAULT_EFFORT", "xhigh") + t.Setenv("WB2A_THINKING_CLIENT_PRIORITY", "false") + t.Setenv("WB2A_THINKING_OVERRIDE_SCOPE", "all") + c := Default() + applyEnv(c) + if err := c.normalize(); err != nil { + t.Fatalf("normalize: %v", err) + } + if c.Thinking.Enabled || c.Thinking.ClientPriority { + t.Fatalf("bool env override failed: %+v", c.Thinking) + } + if c.Thinking.DefaultEffort != "xhigh" || c.Thinking.OverrideScope != "all" { + t.Fatalf("string env override failed: %+v", c.Thinking) + } + if fields := c.EnvironmentManagedFields(); len(fields) == 0 { + t.Error("thinking env vars should be reported as managed") + } +} + +func TestConfigExampleParses(t *testing.T) { + raw, err := os.ReadFile(filepath.Join("..", "..", "config.example.json")) + if err != nil { + t.Fatalf("read example: %v", err) + } + var cfg Config + if err := json.Unmarshal(raw, &cfg); err != nil { + t.Fatalf("parse example: %v", err) + } + if err := cfg.normalizeThinking(); err != nil { + t.Fatalf("normalize example thinking: %v", err) + } + // default_effort 期望 high 而不是 max:思考与正文共用一份输出额度,max 会把预算 + // 烧在思考上、正文只剩半句(实测 max 正文 1906 token vs high 3236 token)。 + // 与 hub 的 WB_DEFAULT_REASONING_EFFORT 默认值同口径(issue #508)。 + if !cfg.Thinking.Enabled || !cfg.Thinking.ClientPriority || cfg.Thinking.OverrideScope != "level" || cfg.Thinking.DefaultEffort != "high" { + t.Fatalf("unexpected example thinking defaults: %+v", cfg.Thinking) + } +} diff --git a/cmd/server/credit_floor_config_test.go b/cmd/server/credit_floor_config_test.go index 087ed94cc282a76a812055efe3e390c0e147d5f1..b6ad53d64e66b9a42d91a326ffaf2d96c72e80fd 100644 --- a/cmd/server/credit_floor_config_test.go +++ b/cmd/server/credit_floor_config_test.go @@ -1,48 +1,48 @@ -// credit_floor_config_test.go pool.credit_floor 配置测试: -// 默认 0(关闭,零回归)/ 文件覆盖 / 负值钳 0 / 大值合法。 -package main - -import ( - "os" - "path/filepath" - "testing" -) - -// TestCreditFloorDefault 键缺席 → 默认 0(保底关闭,行为与引入前一致)。 -func TestCreditFloorDefault(t *testing.T) { - c := Default() - if err := c.normalize(); err != nil { - t.Fatalf("normalize: %v", err) - } - if c.Pool.CreditFloor != 0 { - t.Errorf("credit_floor=%d want 0 (default off)", c.Pool.CreditFloor) - } -} - -// TestCreditFloorParsedFromFile 显式配置覆盖默认。 -func TestCreditFloorParsedFromFile(t *testing.T) { - dir := t.TempDir() - fp := filepath.Join(dir, "c.json") - os.WriteFile(fp, []byte(`{"pool":{"credit_floor":100}}`), 0o600) - c, err := Load(fp) - if err != nil { - t.Fatal(err) - } - if c.Pool.CreditFloor != 100 { - t.Errorf("credit_floor=%d want 100", c.Pool.CreditFloor) - } -} - -// TestCreditFloorNegativeClamped 负值钳 0(非法即关闭,不报错:老配置误写不炸启动)。 -func TestCreditFloorNegativeClamped(t *testing.T) { - dir := t.TempDir() - fp := filepath.Join(dir, "c.json") - os.WriteFile(fp, []byte(`{"pool":{"credit_floor":-5}}`), 0o600) - c, err := Load(fp) - if err != nil { - t.Fatal(err) - } - if c.Pool.CreditFloor != 0 { - t.Errorf("credit_floor=%d want 0 (negative clamped)", c.Pool.CreditFloor) - } -} +// credit_floor_config_test.go pool.credit_floor 配置测试: +// 默认 0(关闭,零回归)/ 文件覆盖 / 负值钳 0 / 大值合法。 +package main + +import ( + "os" + "path/filepath" + "testing" +) + +// TestCreditFloorDefault 键缺席 → 默认 0(保底关闭,行为与引入前一致)。 +func TestCreditFloorDefault(t *testing.T) { + c := Default() + if err := c.normalize(); err != nil { + t.Fatalf("normalize: %v", err) + } + if c.Pool.CreditFloor != 0 { + t.Errorf("credit_floor=%d want 0 (default off)", c.Pool.CreditFloor) + } +} + +// TestCreditFloorParsedFromFile 显式配置覆盖默认。 +func TestCreditFloorParsedFromFile(t *testing.T) { + dir := t.TempDir() + fp := filepath.Join(dir, "c.json") + os.WriteFile(fp, []byte(`{"pool":{"credit_floor":100}}`), 0o600) + c, err := Load(fp) + if err != nil { + t.Fatal(err) + } + if c.Pool.CreditFloor != 100 { + t.Errorf("credit_floor=%d want 100", c.Pool.CreditFloor) + } +} + +// TestCreditFloorNegativeClamped 负值钳 0(非法即关闭,不报错:老配置误写不炸启动)。 +func TestCreditFloorNegativeClamped(t *testing.T) { + dir := t.TempDir() + fp := filepath.Join(dir, "c.json") + os.WriteFile(fp, []byte(`{"pool":{"credit_floor":-5}}`), 0o600) + c, err := Load(fp) + if err != nil { + t.Fatal(err) + } + if c.Pool.CreditFloor != 0 { + t.Errorf("credit_floor=%d want 0 (negative clamped)", c.Pool.CreditFloor) + } +} diff --git a/cmd/server/insecure_key_test.go b/cmd/server/insecure_key_test.go new file mode 100644 index 0000000000000000000000000000000000000000..483f4cb34a8c322471eb82786cc9e2a68cc12a43 --- /dev/null +++ b/cmd/server/insecure_key_test.go @@ -0,0 +1,34 @@ +package main + +import "testing" + +// TestInsecureKeyWarning 空 api_key(完全不鉴权)与样例占位符 test_key 叠加 +// 非回环监听时的启动告警;强 key 或只听回环不告警。 +func TestInsecureKeyWarning(t *testing.T) { + cases := []struct { + listen, apiKey string + want bool + }{ + {":7863", "", true}, // 缺省监听绑所有网卡 + 不鉴权 + {":7863", "test_key", true}, // 照抄样例占位符 + {"0.0.0.0:7863", "", true}, // 显式全网卡 + {"192.168.1.5:7863", "test_key", true}, // 具体内网地址 + {"127.0.0.1:7863", "", false}, // 只听回环 + {"[::1]:7863", "", false}, // IPv6 回环 + {"localhost:7863", "", false}, // localhost + {":7863", "strong-key-xyz", false}, // 有有效 key + } + for _, c := range cases { + got := insecureKeyWarning(c.listen, c.apiKey) + if (got != "") != c.want { + t.Errorf("insecureKeyWarning(%q, %q) = %q, want 告警=%v", c.listen, redact(c.apiKey), got, c.want) + } + } +} + +func redact(key string) string { + if key == "" { + return "" + } + return "" +} diff --git a/cmd/server/main.go b/cmd/server/main.go index e9c4e0be5524f84630f2472ebc3745aef148dda3..8019e1750749eac8eba7d791cc15d528e7be19f1 100644 --- a/cmd/server/main.go +++ b/cmd/server/main.go @@ -1,563 +1,1124 @@ -// main.go workbuddy2api 入口:加载配置、构建 pool、起调度器与 HTTP 服务。 -package main - -import ( - "context" - "encoding/json" - "errors" - "flag" - "fmt" - "io" - "io/fs" - "log" - "net/http" - "os" - "os/signal" - "path/filepath" - "syscall" - "time" - - "github.com/linguo2625469/workbuddy2api-panel/internal/auth" - "github.com/linguo2625469/workbuddy2api-panel/internal/livecfg" - "github.com/linguo2625469/workbuddy2api-panel/internal/panel" - "github.com/linguo2625469/workbuddy2api-panel/internal/pool" - "github.com/linguo2625469/workbuddy2api-panel/internal/redisstore" - "github.com/linguo2625469/workbuddy2api-panel/internal/reqlog" - "github.com/linguo2625469/workbuddy2api-panel/internal/scheduler" - "github.com/linguo2625469/workbuddy2api-panel/internal/server" - "github.com/linguo2625469/workbuddy2api-panel/internal/session" - "github.com/linguo2625469/workbuddy2api-panel/internal/upstream" - "github.com/linguo2625469/workbuddy2api-panel/internal/usage" -) - -// appVersion 网关版本(fork 版:面板 + 任务体系),透出到 /panel/api/overview。 -const appVersion = "1.12.0-panel" - -// usagePathFor 由 state 文件路径推出用量文件路径:同目录、文件名 usage.json。 -// 这样 config 里改 state_file 时用量数据跟着走,不需要额外配置项。 -func usagePathFor(stateFile string) string { return stateSibling(stateFile, "usage.json") } - -// stateSibling 返回与 state 文件同目录的指定文件名路径(相对路径场景回落当前目录)。 -// usage.json(用量记录)与 output_probes.json(模型上限探测)共用本规则。 -func stateSibling(stateFile, name string) string { - dir := filepath.Dir(stateFile) - if dir == "" || dir == "." { - return name - } - return filepath.Join(dir, name) -} - -func main() { - cfgPath := flag.String("config", "config.json", "配置文件路径(默认当前目录 config.json;不存在时自动生成推荐配置)") - flag.Parse() - - cfg, err := Load(*cfgPath) - if err != nil { - // errors.Is 才能看穿 Load 里 fmt.Errorf("%w") 的包装;os.IsNotExist 不行。 - if errors.Is(err, fs.ErrNotExist) { - // 首次运行:目录下没有配置 → 自动落一份推荐配置(含随机 api_key)再加载。 - // 双击 exe / 裸跑 docker 即开,无需先手工复制样例。 - if key, werr := WriteDefault(*cfgPath); werr == nil { - log.Printf("config %s 不存在,已生成推荐配置(api_key=%s,记录在该文件里,可自行修改)", *cfgPath, key) - cfg, err = Load(*cfgPath) - } - if err != nil { - // 生成失败(目录只读等):退回纯默认 + env(旧行为兜底),不阻塞启动。 - log.Printf("config %s not found (auto-generate failed), using defaults+env: %v", *cfgPath, err) - cfg, err = Load("") - } - } - if err != nil { - log.Fatalf("load config: %v", err) - } - } - - auths, err := auth.LoadDir(cfg.AuthDir) - if err != nil { - log.Fatalf("load auths: %v", err) - } - log.Printf("loaded %d account(s) from %s", len(auths), cfg.AuthDir) - - // redisstore:未配置/连接失败 → Noop(纯内存模式,一切功能照常)。 - store := redisstore.New(cfg.Upstash.URL, cfg.Upstash.Token) - - p := pool.New(cfg.StateFile) - // 停机序:先 pool.Close()(最后一次 Flush → SaveState 已提交到 store), - // 再 store.Close() 排空在途异步写(最后一笔 Redis 镜像必须写完才关连接)。 - defer func() { - p.Close() - _ = store.Close() - }() - p.SetStore(store) - p.RestoreFromSnapshot() // 择新恢复:Redis 快照比本地新才采用,否则本地优先 - p.SyncToDir(auths) // 与 auths 目录对齐:新账号加入、已删除文件账号剔除(状态保留) - - // 熔断器 + 在途上限(含 global 分档)+ 连败降权 + 闲置补偿调优(从 config 注入, - // 非正值回退默认)。 - p.SetBreaker(cfg.Pool.BreakerThreshold, cfg.BreakerCooldownDur, cfg.BreakerCooldownMaxD) - p.SetMaxInFlight(cfg.Pool.MaxInFlight) - p.SetMaxInFlightGlobal(cfg.Pool.MaxInFlightGlobal) // global 域 WAF 风控分档(P1-1) - p.SetDegrade(cfg.Pool.DegradeThreshold, cfg.DegradeCooldownDur, cfg.DegradeCooldownMaxD) - p.SetSoftRateMax(cfg.SoftRateMaxDur) // 软冷却指数退避封顶(soft_rate_max,默认 2h) - p.SetCostExploreInterval(cfg.CostExploreIntervalDur) // costTier 探索窗口(issue #136,默认 30m;0 关停) - p.SetCreditFloor(cfg.Pool.CreditFloor) // 积分保底(默认 0 = 关闭) - p.SetWeights(cfg.Pool.IdleWeightPerHour, cfg.Pool.IdleWeightMax) - p.SetPreferExpiring(cfg.Pool.PreferExpiring) - - // 会话粘性路由(可配关闭)。 - var sessRouter *session.Router - redisMode := "noop" - if _, ok := store.(redisstore.Noop); !ok { - redisMode = "upstash" - } - if cfg.SessionSticky.Enabled { - sessRouter = session.New(session.Config{ - TTL: cfg.SessionTTL, - GCInterval: cfg.SessionGCInterval, - Store: store, - Available: p.AvailableUIDs, - // realm 感知闭包:带前缀模型名按 realm 过滤可用账号(跨 realm 不泄漏); - // 裸名走 cn(现状零回归)。闭包内部 resolveModel 剥前缀,再按 realm 过滤。 - AvailableForModel: realmAwareAvailableForModel(p), - }) - sessRouter.LoadFromStore() // 启动时从 Redis 恢复粘性(读操作仅此处) - sessRouter.StartGC() - defer sessRouter.StopGC() - } - sessCount := func() int { - if sessRouter != nil { - return sessRouter.Count() - } - return 0 - } - - up := upstream.New() - - // 积分保底的「收费」兜底判据:接上游模型目录的积分倍率表。本地实测台账无观测 - // 时用它判收费——否则「没学过」恒等于「放行」,高价新模型会把触底号一笔打穿 - // (kimi-k3-1 实案:全池无观测 → 保底全放行 → 两笔打穿并硬冷却到次日 04:00)。 - // 位于 up 装配之后:倍率表由探测下发,闭包每次调用读实时快照。 - p.SetModelRateOf(func(realm, model string) string { return up.ModelRate(realm, model) }) - - // 短 RPC 总时长上限(refresh/checkin/balance/FetchModels),语义不变。 - up.HTTP.Timeout = time.Duration(cfg.Upstream.TimeoutSeconds) * time.Second - // 聊天 SSE 首字节前(响应头)上限:cfg 已 normalize(缺省回落 timeout_seconds)。 - up.HeaderTimeout = time.Duration(cfg.Upstream.HeaderTimeoutSeconds) * time.Second - if tr, ok := up.ChatHTTP.Transport.(*http.Transport); ok { - tr.ResponseHeaderTimeout = up.HeaderTimeout - } - // 聊天 SSE 流中空闲上限(S3 空闲监控读取)。 - up.IdleTimeout = time.Duration(cfg.Upstream.IdleTimeoutSeconds) * time.Second - up.SanitizeFingerprints.Store(cfg.Features.SanitizeBlacklistFingerprints) - // 出站 UA 与归属头(issue #42 + 上游同步): - // UserAgent 非空则完全覆盖;ClientVersion/CliVersion 缺省对齐官方形态; - // ClientName 非空时 chat 路径注入 X-IDE-* 四头(用量归因对齐官方桌面端)。 - up.UserAgent = cfg.Upstream.UserAgent - up.ClientVersion = cfg.Upstream.ClientVersion - up.CliVersion = cfg.Upstream.CliVersion - up.ClientName = cfg.Upstream.ClientName - up.DeviceToken = cfg.Upstream.DeviceToken - up.DeviceTokenFile = cfg.Upstream.DeviceTokenFile - up.PassthroughIP = cfg.Upstream.PassthroughIP - // global realm 路由(config global 段):上游侧开关(第一道闸)+ base 覆盖; - // auth 侧开关(auth.SetGlobalEnabled)是第二道闸,两者同 config global.enabled。 - up.GlobalEnabled = cfg.Global.Enabled - up.ChatBaseGlobal = cfg.Global.ChatBase - up.BillingBaseGlobal = cfg.Global.BillingBase - auth.SetGlobalEnabled(cfg.Global.Enabled) - // model.json 本地缓存接线(context_length/max_output_tokens 四级查找链第 3 级): - // 数据目录与 state.json 同风格(Docker volume 持久化路径)。首次缺失/损坏自动 - // 回落仓库内嵌种子;models.dev 按需拉取成功后原子写回。 - upstream.SetModelCatalogPath(stateSibling(cfg.StateFile, "model.json")) - - sch := scheduler.New(scheduler.Config{ - Pool: p, - Upstream: up, - CheckinHours: cfg.Schedule.CheckinHours, - TravelHours: cfg.Schedule.TravelHours, - ActivityHours: cfg.Schedule.ActivityHours, - KeepaliveHours: cfg.Schedule.KeepaliveHours, - BlackcatHours: cfg.Schedule.BlackcatHours, - GrowthHours: cfg.Schedule.GrowthHours, - // 快过期积分优先消耗:签到/余额刷新按此窗口分桶(issue:积分过期)。 - ExpiringSoonWindow: cfg.ExpiringSoonDur, - CheckinDisabled: !cfg.Schedule.CheckinEnabled, - TravelDisabled: !cfg.Schedule.TravelEnabled, - ActivityDisabled: !cfg.Schedule.ActivityEnabled, - KeepaliveDisabled: !cfg.Schedule.KeepaliveEnabled, - BlackcatDisabled: !cfg.Schedule.BlackcatEnabled, - GrowthDisabled: !cfg.Schedule.GrowthEnabled, - // 保号类四任务是否覆盖禁用账号(缺省 false = 禁用即跳过,保持既有行为)。 - IncludeDisabledInTasks: cfg.Schedule.IncludeDisabledInTasks, - }) - switch { - case !cfg.Schedule.CheckinEnabled: - log.Printf("签到已禁用(schedule.checkin_enabled=false)") - default: - log.Printf("签到已启用:%v 点(签到 + 余额查询解冻)", cfg.Schedule.CheckinHours) - } - switch { - case !cfg.Schedule.TravelEnabled: - log.Printf("猫猫旅行已禁用(schedule.travel_enabled=false)") - default: - log.Printf("猫猫旅行已启用:%v 点(独立排程:领养 / 派出 / 领奖)", cfg.Schedule.TravelHours) - } - switch { - case !cfg.Schedule.ActivityEnabled: - log.Printf("活跃上报已禁用(schedule.activity_enabled=false)") - default: - log.Printf("活跃上报已启用:%v 点(每日 1 次,点亮连登 + 解锁 first_buddy)", cfg.Schedule.ActivityHours) - } - if !cfg.Schedule.KeepaliveEnabled { - log.Printf("token 保活已禁用(schedule.keepalive_enabled=false)") - } else { - log.Printf("token 保活已启用:%v 点", cfg.Schedule.KeepaliveHours) - } - switch { - case !cfg.Schedule.BlackcatEnabled: - log.Printf("夜猫子已禁用(schedule.blackcat_enabled=false)") - default: - log.Printf("夜猫子已启用:%v 点(23:00–08:00 窗口 glm-5.2 对话补足)", cfg.Schedule.BlackcatHours) - } - switch { - case !cfg.Schedule.BalanceRefreshEnabled: - log.Printf("余额后台刷新已禁用(schedule.balance_refresh_enabled=false)") - case cfg.BalanceRefreshInterval > 0: - log.Printf("余额后台刷新:每 %s(签到时点照常额外刷新)", cfg.BalanceRefreshInterval) - } - if cfg.Schedule.IncludeDisabledInTasks { - log.Printf("保号任务覆盖禁用账号(schedule.include_disabled_in_tasks=true):禁用号仍签到 / 活跃 / 保活 / 刷新余额,但不参与选号") - } - - // 管理面板日志镜像:标准 log(stderr)与 chat 表格日志(stdout)双路复制进 - // 面板环形缓冲,供 /panel/api/logs 读取;控制台输出行为完全不变。 - // live 承载可热改字段(api_key/soft_rate/脱敏开关),面板保存配置时在线替换。 - live := livecfg.New(livecfg.Snapshot{ - APIKey: cfg.APIKey, - SoftCooldown: cfg.SoftRateDur, - SanitizeFingerprints: cfg.Features.SanitizeBlacklistFingerprints, - RecordClientInfo: cfg.Logging.RequestClientInfo, - }) - // 用量记录器:与 state 文件同目录,随 state_file 配置一起搬移。 - // datapath 由 state 文件路径推出,避免再加一个配置项。 - usagePath := usagePathFor(cfg.StateFile) - rec := usage.New(usagePath) - rec.Start() - defer rec.Stop() - log.Printf("[usage] 逐请求用量记录已启用: %s (%s)", usagePath, rec.Describe()) - - // 请求指标始终启用;JSONL 归档只写脱敏元数据,写盘失败不影响聊天请求。 - requestLog := reqlog.New(reqlog.Config{ - Dir: stateSibling(cfg.StateFile, "request-logs"), - Enabled: cfg.Logging.RequestArchiveEnabled, - RetentionDays: cfg.Logging.RequestRetentionDays, - MaxBytes: int64(cfg.Logging.RequestArchiveMaxMB) << 20, - }) - defer requestLog.Close() - rs := requestLog.Snapshot().Archive - if rs.Enabled { - log.Printf("[reqlog] 请求指标已启用;JSONL 归档 %s(保留 %d 天,上限 %d MiB)", - rs.Dir, cfg.Logging.RequestRetentionDays, cfg.Logging.RequestArchiveMaxMB) - } else { - log.Printf("[reqlog] 请求指标已启用;JSONL 归档已关闭") - } - - pn := panel.New(panel.Config{ - Pool: p, - Usage: rec, - RequestLog: requestLog, - Upstream: up, - Scheduler: sch, - AuthDir: cfg.AuthDir, - APIKey: cfg.APIKey, - RedisMode: redisMode, - StickyCount: sessCount, - Version: appVersion, - Live: live, - // 模型上限探测数据(scripts/probe_max_tokens.py --panel-out 写入): - // 与 state 文件同目录,缺省 data/output_probes.json。 - ProbeFile: stateSibling(cfg.StateFile, "output_probes.json"), - ConfigPath: *cfgPath, - LoadConfig: func() (any, error) { - return Load(*cfgPath) - }, - SaveConfig: func(raw []byte) ([]string, error) { - return saveConfig(raw, *cfgPath, live, p, up, sch) - }, - }) - // 成长任务队列每日自动执行(与「执行全部待办」同管线):Sequential 族零点解锁后 - // 无需手动扫描;hook 返回即启动(异步执行),已在跑时内部跳过。 - sch.SetGrowthHook(pn.RunGrowthQueueOnce) - log.SetOutput(io.MultiWriter(os.Stderr, pn.Logs())) - server.SetChatLogOutput(io.MultiWriter(os.Stdout, pn.Logs())) - - h := server.NewHandler(server.Config{ - Pool: p, - Upstream: up, - APIKey: cfg.APIKey, - Session: sessRouter, - StickyCount: sessCount, - RedisMode: redisMode, - SoftCooldown: cfg.SoftRateDur, - Panel: pn, - Live: live, - Usage: rec, - RequestLog: requestLog, - PromptMode: cfg.Prompt.Mode, - PromptText: cfg.PromptText, - // 来源记录开关经 livecfg 热生效;此处同时填静态字段,供 Live 为 nil 的 - // 裸用/测试路径拿到同一缺省值。 - RecordClientInfo: cfg.Logging.RequestClientInfo, - // handler 侧第三道闸(global realm):false(显式逃生门)时不列 global: 模型名。 - GlobalEnabled: cfg.Global.Enabled, - }) - - ctx, stop := signal.NotifyContext(context.Background(), os.Interrupt, syscall.SIGTERM) - defer stop() - go sch.Run(ctx) - sch.StartBalanceRefresh(ctx, cfg.BalanceRefreshInterval) - - // 启动即预热模型积分倍率表:倍率只在 FetchModels/FetchGlobalModelInfos 成功时 - // 填充(两者均懒触发),重启后到首次 /v1/models 或面板模型页被访问之前, - // ModelRate 恒返回空串——积分保底的目录兜底在这段空窗期内形同虚设,触底号 - // 会被当成「收费未知」放行并打穿(实测:重启后 2 分钟,97 分的账号打收费 - // 模型归零;倍率表当时尚未建立)。 - // 异步执行:不阻塞监听启动;失败仅记日志(下一轮懒触发或本轮重试仍可补上)。 - go warmModelRates(ctx, up, p) - - srv := &http.Server{ - Addr: cfg.Listen, - Handler: h, - ReadHeaderTimeout: 30 * time.Second, - // ReadTimeout 覆盖整个请求读取(含 body 上传):防慢速 body 拖死连接。 - // 请求体已无网关侧上限(max_body_mb 移除)。缺省 300s(issue #100:旧固定 - // 60s 会掐掉大上下文/文件块经反代链的慢速上传,客户端收到 - // 400 "read body: ... i/o timeout");server.read_timeout="0" 显式关闭。 - // 改动需重启进程。 - ReadTimeout: cfg.ServerReadTimeoutDur, - // IdleTimeout keep-alive 空闲连接回收:配合 chat 出站 ctx 传播防连接泄漏堆积。 - // 注意:SSE 流式响应期间连接非空闲,不受此项掐断;不设全局 WriteTimeout - // (长流式生成合法时长可达数分钟,全局 WriteTimeout 会误杀在途 SSE)。 - IdleTimeout: 120 * time.Second, - } - go func() { - <-ctx.Done() - p.Flush() // 信号触发:先落盘再做优雅停机 - shutdownCtx, cancel := context.WithTimeout(context.Background(), 5*time.Second) - defer cancel() - _ = srv.Shutdown(shutdownCtx) - }() - - log.Printf("workbuddy2api listening on %s (api_key=%v),管理面板 http://127.0.0.1%s/panel/", cfg.Listen, cfg.APIKey != "", panelListenPath(cfg.Listen)) - if err := srv.ListenAndServe(); err != nil && err != http.ErrServerClosed { - log.Fatalf("http: %v", err) - } - log.Printf("bye") -} - -// warmModelRates 启动预热各域模型积分倍率表(供积分保底的目录兜底判定)。 -// -// 为什么需要:倍率表只在 FetchModels(CN)/ FetchGlobalModelInfos(global)成功时 -// 填充,两者都是懒触发(被 /v1/models 或面板模型页访问才跑)。重启后到首次触发 -// 之间的空窗期里 ModelRate 恒返回空串,保底的目录兜底判不出收费,触底号会被 -// 当成「收费未知」放行并打穿(实测:重启后 2 分钟,97 分的账号打收费模型归零)。 -// -// 失败处理:单域失败只记 WARN(不阻塞、不致命——后续懒触发仍会补上);global 域 -// 仅在其路由开关开启时预热(逃生门关锁时按 CN 处理,无需探测)。 -func warmModelRates(ctx context.Context, up *upstream.Client, p *pool.Pool) { - // 预热不得拖住进程退出:ctx 取消(SIGINT/SIGTERM)时立刻放弃剩余域。 - if ctx.Err() != nil { - return - } - // CN:有可用 CN 账号才拉(与面板 models 同口径,避免无谓上游调用)。 - if uids := p.AvailableUIDsForRealm("cn"); len(uids) > 0 { - if a := p.AuthByUID(uids[0]); a != nil { - if _, err := up.FetchModels(a); err != nil { - log.Printf("WARN: [upstream] warm model rates (cn): %v", err) - } else { - log.Printf("[upstream] warm model rates: cn ok") - } - } - } - // global:独立目录端点(workbuddy.ai),倍率按 "global" 域键存储。 - if up.GlobalEnabled && ctx.Err() == nil { - if uids := p.AvailableUIDsForRealm("global"); len(uids) > 0 { - if a := p.AuthByUID(uids[0]); a != nil { - // FetchGlobalModelInfos 无错误返回(内部负缓存自行节流), - // 仅按结果条数判断是否拿到目录。 - if infos := up.FetchGlobalModelInfos(a); len(infos) == 0 { - log.Printf("WARN: [upstream] warm model rates (global): empty model list") - } else { - log.Printf("[upstream] warm model rates: global ok (%d models)", len(infos)) - } - } - } - } -} - -// panelListenPath 从 listen 地址提取 ":port" 形式,用于启动日志拼面板 URL -// (":7863" 或 "0.0.0.0:7863" → ":7863";异常输入原样返回)。 -func panelListenPath(listen string) string { - for i := len(listen) - 1; i >= 0; i-- { - if listen[i] == ':' { - return listen[i:] - } - } - return listen -} - -// saveConfig 面板保存配置:校验 → 落盘 → 热应用 → 返回需重启的字段列表。 -// -// 热生效范围(设计取舍): -// - api_key / cooldown.soft_rate / features.sanitize_blacklist_fingerprints → livecfg 快照 -// - pool.* → pool.SetBreaker/SetMaxInFlight/SetSoftRateMax/SetWeights/SetCostExploreInterval/SetPreferExpiring/SetCreditFloor -// - schedule.* → scheduler.Reconfigure/SetBalanceInterval/SetExpiringSoonWindow -// -// 需重启(涉及监听地址、HTTP client 超时、auth_dir 等装配期依赖): -// - listen / auth_dir / state_file / upstream.* / upstash.* / session_sticky.*(TTL 类) -// -// 落盘用"先写 tmp 再 rename"原子替换,且优先保留磁盘上的原始 JSON 结构(只改 -// 面板表单覆盖到的键),避免把用户手写的注释性字段/未知键洗掉——这里直接整体 -// 序列化校验后的配置,未知键在 json.Unmarshal 时已丢失,故先合并原始 map。 -func saveConfig(raw []byte, path string, live *livecfg.Holder, p *pool.Pool, up *upstream.Client, sch *scheduler.Scheduler) ([]string, error) { - // 1) 解析原始 JSON 为 map(保留用户手写的未知键),再叠加面板提交的键。 - oldRaw, err := os.ReadFile(path) - if err != nil { - return nil, fmt.Errorf("read current config: %w", err) - } - var cur, incoming map[string]any - if err := json.Unmarshal(oldRaw, &cur); err != nil { - cur = map[string]any{} - } - if err := json.Unmarshal(raw, &incoming); err != nil { - return nil, fmt.Errorf("parse submitted config: %w", err) - } - merged := mergeConfigMaps(cur, incoming) - - // 2) 校验(与启动同一套 Default+normalize),失败直接返回、不落盘。 - newCfg, err := ParseConfig(mergedJSON(merged)) - if err != nil { - return nil, err - } - - // 3) 落盘(原子替换)。 - out, err := json.MarshalIndent(merged, "", " ") - if err != nil { - return nil, fmt.Errorf("marshal config: %w", err) - } - tmp := path + ".tmp" - if err := os.WriteFile(tmp, out, 0o600); err != nil { - return nil, fmt.Errorf("write config: %w", err) - } - if err := os.Rename(tmp, path); err != nil { - // A single-file Docker bind mount cannot be renamed over its mount - // target (Linux returns EBUSY / "device or resource busy"). Keep the - // atomic path for regular files, but update the mounted file in place - // for this specific deployment shape. - if !errors.Is(err, syscall.EBUSY) { - return nil, fmt.Errorf("replace config: %w", err) - } - f, openErr := os.OpenFile(path, os.O_WRONLY|os.O_TRUNC, 0o600) - if openErr != nil { - _ = os.Remove(tmp) - return nil, fmt.Errorf("replace config (bind mount fallback): %w", openErr) - } - _, writeErr := f.Write(out) - if writeErr == nil { - writeErr = f.Sync() - } - closeErr := f.Close() - // 写失败时保留 tmp(挂载文件已被 O_TRUNC 破坏,tmp 里是完整新内容, - // 可手工恢复);写成功才清理。 - if writeErr != nil { - return nil, fmt.Errorf("replace config (bind mount fallback, 完整新内容保留在 %s): %w", tmp, writeErr) - } - _ = os.Remove(tmp) - if closeErr != nil { - return nil, fmt.Errorf("replace config (bind mount fallback): %w", closeErr) - } - } - - // 4) 热应用:能立即生效的字段全部应用,并列出仍需重启的字段。 - live.Store(livecfg.Snapshot{ - APIKey: newCfg.APIKey, - SoftCooldown: newCfg.SoftRateDur, - SanitizeFingerprints: newCfg.Features.SanitizeBlacklistFingerprints, - RecordClientInfo: newCfg.Logging.RequestClientInfo, - }) - up.SanitizeFingerprints.Store(newCfg.Features.SanitizeBlacklistFingerprints) - p.SetBreaker(newCfg.Pool.BreakerThreshold, newCfg.BreakerCooldownDur, newCfg.BreakerCooldownMaxD) - p.SetMaxInFlight(newCfg.Pool.MaxInFlight) - p.SetMaxInFlightGlobal(newCfg.Pool.MaxInFlightGlobal) - p.SetDegrade(newCfg.Pool.DegradeThreshold, newCfg.DegradeCooldownDur, newCfg.DegradeCooldownMaxD) - p.SetSoftRateMax(newCfg.SoftRateMaxDur) - p.SetCostExploreInterval(newCfg.CostExploreIntervalDur) // costTier 探索窗口热生效(0 关停) - p.SetCreditFloor(newCfg.Pool.CreditFloor) // 积分保底热生效(0 = 关闭) - p.SetWeights(newCfg.Pool.IdleWeightPerHour, newCfg.Pool.IdleWeightMax) - p.SetPreferExpiring(newCfg.Pool.PreferExpiring) - sch.SetExpiringSoonWindow(newCfg.ExpiringSoonDur) - sch.Reconfigure( - newCfg.Schedule.CheckinHours, newCfg.Schedule.TravelHours, - newCfg.Schedule.ActivityHours, newCfg.Schedule.KeepaliveHours, newCfg.Schedule.BlackcatHours, - newCfg.Schedule.GrowthHours, - !newCfg.Schedule.CheckinEnabled, !newCfg.Schedule.TravelEnabled, - !newCfg.Schedule.ActivityEnabled, !newCfg.Schedule.KeepaliveEnabled, !newCfg.Schedule.BlackcatEnabled, - !newCfg.Schedule.GrowthEnabled) - sch.SetBalanceInterval(newCfg.BalanceRefreshInterval) - sch.SetIncludeDisabledInTasks(newCfg.Schedule.IncludeDisabledInTasks) - - return restartRequiredFields(newCfg), nil -} - -// restartRequiredFields 返回本次改动中无法热生效、需要重启进程的字段名。 -// 恒返回完整清单中的"与当前进程装配期依赖相关"的项——面板据此提示用户。 -func restartRequiredFields(c *Config) []string { - var out []string - // 这些字段在进程内被监听地址/HTTP client/目录句柄等装配期对象捕获。 - if c.Listen != "" { - out = append(out, "listen") - } - if c.AuthDir != "" { - out = append(out, "auth_dir") - } - if c.StateFile != "" { - out = append(out, "state_file") - } - out = append(out, "upstream.timeout_seconds", "upstream.header_timeout_seconds", "upstream.idle_timeout_seconds") - // upstream.user_agent 在装配期被写进出站 client(main.go 的 up.UserAgent = ...), - // 之后不再读取——不在 livecfg 热快照里,也无法热改。此前漏列,导致面板改完 - // 显示"已保存"却不提示需要重启,用户以为没生效(issue #102 附带发现 2)。 - out = append(out, "upstream.user_agent") - if c.Upstash.URL != "" || c.Upstash.Token != "" { - out = append(out, "upstash") - } - out = append(out, "session_sticky.ttl", "session_sticky.gc_interval") - out = append(out, "logging.request_archive_enabled", "logging.request_retention_days", "logging.request_archive_max_mb") - out = append(out, "server.read_timeout") - return out -} - -// mergeConfigMaps 把 incoming 深合并进 cur(原地),返回 cur。 -// 对嵌套对象逐键覆盖而不是整体替换:面板表单只提交它管理的键, -// 未提交的兄弟键(含用户手写的未知键)保持原样。 -func mergeConfigMaps(cur, incoming map[string]any) map[string]any { - for k, v := range incoming { - if inMap, ok := v.(map[string]any); ok { - if curMap, ok := cur[k].(map[string]any); ok { - cur[k] = mergeConfigMaps(curMap, inMap) - continue - } - } - cur[k] = v - } - return cur -} - -// mergedJSON 把合并后的 map 序列化回 JSON(供 ParseConfig 校验)。 -func mergedJSON(m map[string]any) []byte { - b, err := json.Marshal(m) - if err != nil { - return []byte("{}") - } - return b -} +// main.go workbuddy2api 入口:加载配置、构建 pool、起调度器与 HTTP 服务。 +package main + +import ( + "context" + "encoding/json" + "errors" + "flag" + "fmt" + "io" + "io/fs" + "log" + "net" + "net/http" + _ "net/http/pprof" // WB2API_PPROF 打开时提供 /debug/pprof(默认无监听) + "os" + "os/signal" + "path/filepath" + "reflect" + "strings" + "sync" + "syscall" + "time" + + "github.com/misakano7545/workbuddy2api-panel/internal/alert" + "github.com/misakano7545/workbuddy2api-panel/internal/auth" + "github.com/misakano7545/workbuddy2api-panel/internal/balance" + "github.com/misakano7545/workbuddy2api-panel/internal/credithist" + "github.com/misakano7545/workbuddy2api-panel/internal/extstore" + "github.com/misakano7545/workbuddy2api-panel/internal/freemodel" + "github.com/misakano7545/workbuddy2api-panel/internal/livecfg" + "github.com/misakano7545/workbuddy2api-panel/internal/panel" + "github.com/misakano7545/workbuddy2api-panel/internal/pool" + "github.com/misakano7545/workbuddy2api-panel/internal/proxypool" + "github.com/misakano7545/workbuddy2api-panel/internal/redisstore" + "github.com/misakano7545/workbuddy2api-panel/internal/reqlog" + "github.com/misakano7545/workbuddy2api-panel/internal/safefile" + "github.com/misakano7545/workbuddy2api-panel/internal/scheduler" + "github.com/misakano7545/workbuddy2api-panel/internal/server" + "github.com/misakano7545/workbuddy2api-panel/internal/session" + "github.com/misakano7545/workbuddy2api-panel/internal/updater" + "github.com/misakano7545/workbuddy2api-panel/internal/upstream" + "github.com/misakano7545/workbuddy2api-panel/internal/usage" +) + +// appVersion 面板版本,透出到 /panel/api/overview。 +// 本地构建保持 dev。发布构建由 CI 用 -X 注入上海时间(2026.9.26.711),不跟上游 1.x。 +var appVersion = "dev" +var appRepository = "misakano7545/workbuddy2api-panel" + +// insecureKeyWarning 空 api_key = 完全不鉴权(httpauth.VerifyBearer 对空 key 恒放 +// 行),样例占位符 test_key = 人尽皆知的弱密钥;叠加非回环监听(显式配成 +// "0.0.0.0:7863" 或 ":7863")等于把网关与面板 API 暴露给整个内网/公网。返回非空告警文本供启动日志 +// 打印,安全状态返回空串。首启自动生成的随机 key 不会命中——这是给「照抄样例 / +// 显式清空」的最后提醒,不阻塞启动。 +func insecureKeyWarning(listen, apiKey string) string { + if apiKey != "" && apiKey != "test_key" { + return "" + } + host, _, err := net.SplitHostPort(listen) + if err != nil { + host = listen // 非 host:port 形态:按具名地址保守处理(继续告警) + } + switch { + case host == "", host == "0.0.0.0", host == "::": + // 空 host = 所有网卡,维持告警 + case host == "127.0.0.1", host == "::1", strings.EqualFold(host, "localhost"): + return "" // 只听回环:暴露面有限,不打扰 + } + what := "为空(网关与面板完全不鉴权)" + if apiKey != "" { + what = "为样例占位符 test_key" + } + return fmt.Sprintf("api_key %s,且监听 %s 非回环地址——对外无有效鉴权,请尽快修改配置里的 api_key", what, listen) +} + +// usagePathFor 由 state 文件路径推出用量文件路径:同目录、文件名 usage.json。 +// 这样 config 里改 state_file 时用量数据跟着走,不需要额外配置项。 +func usagePathFor(stateFile string) string { return stateSibling(stateFile, "usage.json") } + +// stateSibling 返回与 state 文件同目录的指定文件名路径(相对路径场景回落当前目录)。 +// usage.json(用量记录)与 output_probes.json(模型上限探测)共用本规则。 +func stateSibling(stateFile, name string) string { + dir := filepath.Dir(stateFile) + if dir == "" || dir == "." { + return name + } + return filepath.Join(dir, name) +} + +func main() { + if handled, err := updater.HandleSelfUpdate(os.Args); handled { + if err != nil { + log.Printf("[updater] %v", err) + os.Exit(1) + } + return + } + cfgPath := flag.String("config", "config.json", "配置文件路径(默认当前目录 config.json;不存在时自动生成推荐配置)") + flag.Parse() + // 实际生效的配置路径。必须在 flag.Parse() **之后**取值:flag.String 返回的指针 + // 在 Parse 时才写入命令行值,此前取到的是默认值拷贝,-config 自定义路径时横幅 + // 会报一份根本没读的文件。下面退回「默认+env」时清空,同理(issue #155)。 + loadedFrom := *cfgPath + + cfg, err := Load(*cfgPath) + if err != nil { + // errors.Is 才能看穿 Load 里 fmt.Errorf("%w") 的包装;os.IsNotExist 不行。 + if errors.Is(err, fs.ErrNotExist) { + // 首次运行:目录下没有配置 → 自动落一份推荐配置(含随机 api_key)再加载。 + // 双击 exe / 裸跑 docker 即开,无需先手工复制样例。 + if key, werr := WriteDefault(*cfgPath); werr == nil { + log.Printf("config %s 不存在,已生成推荐配置(api_key=%s,记录在该文件里,可自行修改)", *cfgPath, key) + cfg, err = Load(*cfgPath) + } + if err != nil { + // 生成失败(目录只读等):退回纯默认 + env(旧行为兜底),不阻塞启动。 + log.Printf("config %s not found (auto-generate failed), using defaults+env: %v", *cfgPath, err) + loadedFrom = "" + cfg, err = Load("") + } + } + if err != nil { + log.Fatalf("load config: %v", err) + } + } + + auths, err := auth.LoadDir(cfg.AuthDir) + if err != nil { + log.Fatalf("load auths: %v", err) + } + log.Printf("loaded %d account(s) from %s", len(auths), cfg.AuthDir) + + // redisstore:未配置/连接失败 → Noop(纯内存模式,一切功能照常)。 + store := redisstore.New(cfg.Upstash.URL, cfg.Upstash.Token) + + p := pool.New(cfg.StateFile) + // 停机序:先 pool.Close()(最后一次 Flush → SaveState 已提交到 store), + // 再 store.Close() 排空在途异步写(最后一笔 Redis 镜像必须写完才关连接)。 + defer func() { + p.Close() + _ = store.Close() + }() + p.SetStore(store) + p.RestoreFromSnapshot() // 择新恢复:Redis 快照比本地新才采用,否则本地优先 + p.SyncToDir(auths) // 与 auths 目录对齐:新账号加入、已删除文件账号剔除(状态保留) + + // 熔断器 + 在途上限(含 global 分档)+ 连败降权 + 闲置补偿调优(从 config 注入, + // 非正值回退默认)。 + p.SetBreaker(cfg.Pool.BreakerThreshold, cfg.BreakerCooldownDur, cfg.BreakerCooldownMaxD) + p.SetMaxInFlight(cfg.Pool.MaxInFlight) + p.SetMaxInFlightGlobal(cfg.Pool.MaxInFlightGlobal) // global 域 WAF 风控分档(P1-1) + p.SetDegrade(cfg.Pool.DegradeThreshold, cfg.DegradeCooldownDur, cfg.DegradeCooldownMaxD) + p.SetSoftRateMax(cfg.SoftRateMaxDur) // 软冷却指数退避封顶(soft_rate_max,默认 2h) + p.SetCostExploreInterval(cfg.CostExploreIntervalDur) // costTier 探索窗口(issue #136,默认 30m;0 关停) + p.SetBalanceWindow(cfg.BalanceWindowDur) // 窗口用量调度(issue #112,默认 1h;0 关停) + p.SetCreditFloor(cfg.Pool.CreditFloor) // 积分保底(默认 0 = 关闭) + p.SetCreditFloorMaxRate(cfg.Pool.CreditFloorMaxRate) // 保底兜底的目录倍率上限(0 = 严格模式) + p.SetWeights(cfg.Pool.IdleWeightPerHour, cfg.Pool.IdleWeightMax) + p.SetReserveCredits(*cfg.Pool.ReserveCredits) // 保留积分:余额低于阈值停止接单(0 = 关闭,缺省 10) + p.SetReserveCreditsByRealm(cfg.Pool.ReserveCreditsByRealm) + p.SetPreferExpiring(cfg.Pool.PreferExpiring, cfg.ExpiringSoonDur) + p.SetAccountPriority(cfg.Pool.AccountPriority) // 账号优先级/占比(issue #62):空表 = 不启用 + p.SetAccountShare(cfg.Pool.AccountShare) + // 选号策略(pool.selection_strategy):weighted 缺省 / round_robin / sequential。 + p.SetStrategy(cfg.Pool.SelectionStrategy) + + // 会话粘性路由(可配关闭)。 + var sessRouter *session.Router + redisMode := "noop" + if _, ok := store.(redisstore.Noop); !ok { + redisMode = "upstash" + } + if cfg.SessionSticky.Enabled { + sessRouter = session.New(session.Config{ + TTL: cfg.SessionTTL, + GCInterval: cfg.SessionGCInterval, + Store: store, + Available: p.AvailableUIDs, + // realm 感知闭包:带前缀模型名按 realm 过滤可用账号(跨 realm 不泄漏); + // 裸名走 cn(现状零回归)。闭包内部 resolveModel 剥前缀,再按 realm 过滤。 + AvailableForModel: realmAwareAvailableForModel(p), + }) + sessRouter.LoadFromStore() // 启动时从 Redis 恢复粘性(读操作仅此处) + sessRouter.StartGC() + defer sessRouter.StopGC() + } + sessCount := func() int { + if sessRouter != nil { + return sessRouter.Count() + } + return 0 + } + + up := upstream.New() + + // 出站 ClientHello 指纹档位:默认 node(复刻官方 Node/OpenSSL 的 JA3/JA4)。 + // 配 go 才退回 crypto/tls 原生形态——唯一用途是指纹导致握手异常时紧急回滚。 + if err := up.SetTLSFingerprint(cfg.Upstream.TLSFingerprint); err != nil { + log.Fatalf("CONFIG: %v", err) + } + if up.TLSFingerprint == upstream.TLSFingerprintNode { + log.Printf("[upstream] TLS 指纹复刻已启用(JA3 %s / JA4 %s)", + upstream.OfficialJA3MD5, upstream.OfficialJA4) + } else { + log.Printf("[upstream] TLS 指纹为原生 Go 形态(JA3/JA4 与官方客户端不一致)") + } + + // 出站 DNS(config dns_servers / WB2A_DNS):显式指定解析器,绕开系统配置。 + // 典型场景是 Android(无 /etc/resolv.conf,Go 解析器退回 [::1]:53 全域名失败) + // 与本地 DNS 被污染。未配置时保持系统解析器,行为零变化。 + if len(cfg.DNSServers) > 0 { + up.SetDNSDialer(upstream.NewDNSDialer(cfg.DNSServers)) + } + + // 积分保底的「收费」兜底判据:接上游模型目录的积分倍率表。本地实测台账无观测 + // 时用它判收费——否则「没学过」恒等于「放行」,高价新模型会把触底号一笔打穿 + // (kimi-k3-1 实案:全池无观测 → 保底全放行 → 两笔打穿并硬冷却到次日 04:00)。 + // 位于 up 装配之后:倍率表由探测下发,闭包每次调用读实时快照。 + p.SetModelRateOf(func(realm, model string) string { return up.ModelRate(realm, model) }) + // 「免费号调不通」的模型(modelTiers accessMode=exclusive):知道账号免费就不派给它。 + // 付费状态来自 billing summary 的 IsPaidUser(顺手记在 upstream 里),没观测过就放行。 + p.SetExclusiveModels(up.ModelExclusive, up.PaidUser) + // 短 RPC 总时长上限(refresh/checkin/balance/FetchModels),语义不变。 + up.HTTP.Timeout = time.Duration(cfg.Upstream.TimeoutSeconds) * time.Second + // 聊天 SSE 首字节前(响应头)上限:cfg 已 normalize(缺省回落 timeout_seconds)。 + up.HeaderTimeout = time.Duration(cfg.Upstream.HeaderTimeoutSeconds) * time.Second + if tr, ok := up.ChatHTTP.Transport.(*http.Transport); ok { + tr.ResponseHeaderTimeout = up.HeaderTimeout + } + // 聊天 SSE 流中空闲上限(S3 空闲监控读取)。 + up.IdleTimeout = time.Duration(cfg.Upstream.IdleTimeoutSeconds) * time.Second + proxies, err := proxypool.New(stateSibling(cfg.StateFile, "proxy-pool.json"), + up.HTTP.Transport.(*http.Transport), upstream.NewDNSDialer(cfg.DNSServers)) + if err != nil { + log.Fatalf("proxy pool: %v", err) + } + defer proxies.Close() + proxies.SetTLSOver(up.TLSOver) // 经代理的 HTTPS 与直连同一指纹、同一请求头顺序 + // 出口画像(国家 / 住宅或机房 / ISP):随健康探测顺手查,查不到就空着,不参与选号。 + proxies.EnableExitLookup() + up.ProxyPool = proxies + up.SanitizeFingerprints.Store(cfg.Features.SanitizeBlacklistFingerprints) + up.SanitizeBrandScope.Store(cfg.Features.SanitizeBrandScope) + up.KeepRecentRounds.Store(int64(cfg.Prompt.KeepRecentRounds)) + // 思考档位策略(thinking 节):启动装载,面板保存配置时经 saveConfig 热更新。 + up.SetEffortPolicy(effortPolicyOf(cfg)) + if cfg.Thinking.Enabled { + priority := "客户端优先(只在缺档时补默认档)" + if !cfg.Thinking.ClientPriority { + priority = "网关优先(改写客户端档位)" + if cfg.Thinking.OverrideScope == "all" { + priority = "网关优先(档位与关闭意图一起覆盖)" + } + } + log.Printf("思考档位策略:默认档 %s;%s", cfg.Thinking.DefaultEffort, priority) + } else { + log.Printf("思考档位策略已关闭(不补档、不改写客户端档位)") + } + if cfg.Features.SanitizeBlacklistFingerprints { + if cfg.Features.SanitizeBrandScope == "identity" { + log.Printf("指纹脱敏已启用;品牌词规则仅作用于 system/developer(features.sanitize_brand_scope=identity)") + } else { + log.Printf("指纹脱敏已启用;品牌词规则作用于所有消息角色(features.sanitize_brand_scope=all)") + } + } + // 出站 UA 与归属头(issue #42 + 上游同步): + // UserAgent 非空则完全覆盖;ClientVersion/CliVersion 缺省对齐官方形态; + // ClientName 非空时 chat 路径注入 X-IDE-* 四头(用量归因对齐官方桌面端)。 + up.UserAgent = cfg.Upstream.UserAgent + up.ClientVersion = cfg.Upstream.ClientVersion + up.CliVersion = cfg.Upstream.CliVersion + up.ClientName = cfg.Upstream.ClientName + up.DeviceToken = cfg.Upstream.DeviceToken + up.DeviceTokenFile = cfg.Upstream.DeviceTokenFile + up.DumpDir = cfg.Upstream.DumpDir + up.DumpRequestMax = cfg.Upstream.DumpMaxBytes + up.PassthroughIP = cfg.Upstream.PassthroughIP + // global realm 路由(config global 段):上游侧开关(第一道闸)+ base 覆盖; + // auth 侧开关(auth.SetGlobalEnabled)是第二道闸,两者同 config global.enabled。 + up.GlobalEnabled = cfg.Global.Enabled + up.ChatBaseGlobal = cfg.Global.ChatBase + up.BillingBaseGlobal = cfg.Global.BillingBase + applyCNChatBase(up, cfg) + auth.SetGlobalEnabled(cfg.Global.Enabled) + // model.json 本地缓存接线(context_length/max_output_tokens 四级查找链第 3 级): + // 数据目录与 state.json 同风格(Docker volume 持久化路径)。首次缺失/损坏自动 + // 回落仓库内嵌种子;models.dev 按需拉取成功后原子写回。 + upstream.SetModelCatalogPath(stateSibling(cfg.StateFile, "model.json")) + + // 余额采样记录器:与 state 文件同目录(路径由 state 推出,不加配置项)。 + // 采样动作挂在余额刷新之后(见 internal/scheduler),这里只管装配与落盘生命周期。 + balPath := stateSibling(cfg.StateFile, "balance_history.json") + bal := balance.New(balPath) + bal.Start() + defer bal.Stop() + log.Printf("[balance] 余额趋势采样已启用: %s 每 %v 一点(%s)", balPath, balance.Interval(), bal.Describe()) + + sch := scheduler.New(scheduler.Config{ + Pool: p, + Upstream: up, + CheckinHours: cfg.Schedule.CheckinHours, + TravelHours: cfg.Schedule.TravelHours, + ActivityHours: cfg.Schedule.ActivityHours, + KeepaliveHours: cfg.Schedule.KeepaliveHours, + GrowthHours: cfg.Schedule.GrowthHours, + // 余额采样记录器:挂在余额刷新之后(scheduler 内),nil = 不采样。 + Balance: bal, + // 快过期积分优先消耗:签到/余额刷新按此窗口分桶(issue:积分过期)。 + ExpiringSoonWindow: cfg.ExpiringSoonDur, + CheckinDisabled: !cfg.Schedule.CheckinEnabled, + TravelDisabled: !cfg.Schedule.TravelEnabled, + ActivityDisabled: !cfg.Schedule.ActivityEnabled, + WebActivityDisabled: !cfg.Schedule.WebActivityEnabled, + KeepaliveDisabled: !cfg.Schedule.KeepaliveEnabled, + GrowthDisabled: !cfg.Schedule.GrowthEnabled, + // 周期保活只刷新临期凭证(默认 7 天窗口);面板手动全量保活不受影响。 + KeepaliveRefreshWindow: cfg.KeepaliveRefreshWindowDur, + // 保号类四任务是否覆盖禁用账号(缺省 false = 禁用即跳过,保持既有行为)。 + IncludeDisabledInTasks: cfg.Schedule.IncludeDisabledInTasks, + JitterMinutes: cfg.Schedule.JitterMinutes, + // 账号级摊开(issue #45):默认 0/0 = 关闭,同一秒打全池。 + AccountSpreadMinutes: cfg.Schedule.AccountSpreadMinutes, + AccountSpreadMinGapSeconds: cfg.Schedule.AccountSpreadMinGapSeconds, + // 启动补跑去重:与 state.json 同目录,重启多次只在当天补一轮。 + RunStampFile: filepath.Join(filepath.Dir(cfg.StateFile), "task-runs.json"), + }) + switch { + case !cfg.Schedule.CheckinEnabled: + log.Printf("签到已禁用(schedule.checkin_enabled=false)") + default: + log.Printf("签到已启用:%v 点(签到 + 余额查询解冻)", cfg.Schedule.CheckinHours) + } + switch { + case !cfg.Schedule.TravelEnabled: + log.Printf("猫猫旅行已禁用(schedule.travel_enabled=false)") + default: + log.Printf("猫猫旅行已启用:%v 点(独立排程:领养 / 派出 / 领奖)", cfg.Schedule.TravelHours) + } + switch { + case !cfg.Schedule.ActivityEnabled: + log.Printf("活跃上报已禁用(schedule.activity_enabled=false)") + default: + log.Printf("活跃上报已启用:%v 点(每日 1 次,点亮连登 + 解锁 first_buddy)", cfg.Schedule.ActivityHours) + } + if !cfg.Schedule.KeepaliveEnabled { + log.Printf("token 保活已禁用(schedule.keepalive_enabled=false)") + } else { + log.Printf("token 保活已启用:%v 点", cfg.Schedule.KeepaliveHours) + } + switch { + case !cfg.Schedule.GrowthEnabled: + log.Printf("成长任务队列已禁用(schedule.growth_enabled=false)") + default: + log.Printf("成长任务队列已启用:%v 点(每日自动跑一遍任务中心待办,账号间并发 %d)", + cfg.Schedule.GrowthHours, cfg.Schedule.GrowthConcurrency) + } + if cfg.Schedule.JitterMinutes > 0 { + log.Printf("排程抖动:各任务在名义整点后 0-%d 分钟(schedule.jitter_minutes)", cfg.Schedule.JitterMinutes) + } + if cfg.Schedule.AccountSpreadMinutes > 0 { + log.Printf("账号摊开:账号遍历型任务在 %d 分钟内按账号错开,最小间隔 %d 秒(schedule.account_spread_minutes)", + cfg.Schedule.AccountSpreadMinutes, cfg.Schedule.AccountSpreadMinGapSeconds) + } + switch { + case !cfg.Schedule.BalanceRefreshEnabled: + log.Printf("余额后台刷新已禁用(schedule.balance_refresh_enabled=false)") + case cfg.BalanceRefreshInterval > 0: + log.Printf("余额后台刷新:每 %s(签到时点照常额外刷新)", cfg.BalanceRefreshInterval) + } + switch { + case !cfg.Schedule.TaskSweepEnabled: + log.Printf("补领清扫已禁用(schedule.task_sweep_enabled=false)") + case cfg.TaskSweepInterval > 0: + log.Printf("补领清扫:每 %s(只 accept 待接受的、只 claim 已达标未领的)", cfg.TaskSweepInterval) + } + if !cfg.Schedule.WindowProbeEnabled { + log.Printf("额度窗口探针已禁用(schedule.window_probe_enabled=false)") + } + if cfg.Schedule.BalanceRefreshJitterPermill > 0 { + log.Printf("周期抖动(人味化):余额刷新 ±%d‰(账号遍历同步摊开)、补领清扫 ±%d‰,不再精确固定间隔(schedule.*_jitter_permill)", + cfg.Schedule.BalanceRefreshJitterPermill, cfg.Schedule.TaskSweepJitterPermill) + } + if cfg.Schedule.IncludeDisabledInTasks { + log.Printf("保号任务覆盖禁用账号(schedule.include_disabled_in_tasks=true):禁用号仍签到 / 活跃 / 保活 / 刷新余额,但不参与选号") + } + + // 管理面板日志镜像:标准 log(stderr)与 chat 表格日志(stdout)双路复制进 + // 面板环形缓冲,供 /panel/api/logs 读取;控制台输出行为完全不变。 + // live 承载可热改字段(api_key/soft_rate/脱敏开关),面板保存配置时在线替换。 + // 模型白名单(issue #68):启动时归一化一次,快照只读持有。 + allowedModels, allowlistEnabled := livecfg.NormalizeAllowedModels(cfg.Models.Allowed) + live := livecfg.New(livecfg.Snapshot{ + APIKey: cfg.APIKey, + SoftCooldown: cfg.SoftRateDur, + SanitizeFingerprints: cfg.Features.SanitizeBlacklistFingerprints, + EmbeddingsEnabled: cfg.Features.EmbeddingsEnabled, + WatermarkStripEnabled: cfg.Features.WatermarkStripEnabled, + RecordClientInfo: cfg.Logging.RequestClientInfo, + RecordContext: cfg.Logging.RequestArchiveContext, + HiddenModels: livecfg.NormalizeHiddenModels(cfg.Models.Hidden), + // 模型白名单(issue #68):归一化集合 + 启用标志;空配置 = 不启用。 + AllowedModels: allowedModels, + AllowlistEnabled: allowlistEnabled, + ModelAliases: livecfg.NormalizeModelAliases(cfg.Models.Aliases), + // 模型降级路由表(pool.model_fallback):6004 限流时同账号改用等价模型。 + ModelFallback: cfg.Pool.ModelFallback, + // 思考档位策略镜像:面板「模型与档位」页的「网关档位」列据此显示当前生效值。 + ThinkingEnabled: cfg.Thinking.Enabled, + ThinkingDefaultEffort: cfg.Thinking.DefaultEffort, + ThinkingClientPriority: cfg.Thinking.ClientPriority, + ThinkingOverrideScope: cfg.Thinking.OverrideScope, + ThinkingModelDefaults: cfg.Thinking.ModelDefaults, + }) + // 用量记录器:与 state 文件同目录,随 state_file 配置一起搬移。 + // datapath 由 state 文件路径推出,避免再加一个配置项。 + usagePath := usagePathFor(cfg.StateFile) + rec := usage.New(usagePath) + rec.Start() + defer rec.Stop() + log.Printf("[usage] 逐请求用量记录已启用: %s (%s)", usagePath, rec.Describe()) + + // 请求指标始终启用;JSONL 归档只写脱敏元数据,写盘失败不影响聊天请求。 + requestLog := reqlog.New(reqlog.Config{ + Dir: stateSibling(cfg.StateFile, "request-logs"), + Enabled: cfg.Logging.RequestArchiveEnabled, + RetentionDays: cfg.Logging.RequestRetentionDays, + MaxBytes: int64(cfg.Logging.RequestArchiveMaxMB) << 20, + }) + defer requestLog.Close() + rs := requestLog.Snapshot().Archive + if rs.Enabled { + log.Printf("[reqlog] 请求指标已启用;JSONL 归档 %s(保留 %d 天,上限 %d MiB)", + rs.Dir, cfg.Logging.RequestRetentionDays, cfg.Logging.RequestArchiveMaxMB) + } else { + log.Printf("[reqlog] 请求指标已启用;JSONL 归档已关闭") + } + + var gw *server.Handler + // configSaveMu 串行化面板配置保存(并发两次保存会在读-改-写文件与热应用之间互踩)。 + var configSaveMu sync.Mutex + // pn 先声明再赋值:SaveConfig 闭包要在同一条语句里捕获它(:= 的作用域从语句结束才开始)。 + // 积分历史:把每次真实查到的余额与上一次比对,变动即留痕(新账号首次只建 + // 基线)。挂载在余额查询路径上(upstream 的余额观察者),签到 / 活跃上报 / + // 旅行 / 保活 / 面板手动刷新全覆盖——上游只在少数渠道落金额日志,比对余额 + // 是唯一可靠的口径。与 state/usage/request-logs 同目录,随 state_file 搬移。 + creditHist := credithist.New(stateSibling(cfg.StateFile, "credit-history.json"), 2000) + up.SetCreditObserver(creditHist.Observe) + log.Printf("[credithist] 积分历史已启用: %s", stateSibling(cfg.StateFile, "credit-history.json")) + + // 扩展层:免费模型 / 自定义模型 / 访问密钥。与 state 同目录(HF 上在存储桶卷里)。 + extStore := extstore.Open(stateSibling(cfg.StateFile, "extensions.json")) + freeClient := freemodel.New(extStore) + extSnap := extStore.Snapshot() + labels := make([]string, 0, len(extSnap.Free.Providers)) + for _, p := range extSnap.Free.Providers { + state := "off" + if p.Enabled { + state = "on" + } + labels = append(labels, p.Name+"="+state) + } + log.Printf("[extensions] 扩展配置已加载: %s(免费模型总开关=%v,渠道: %s)", + extStore.Path(), extSnap.Free.Enabled, strings.Join(labels, ", ")) + + updateManager := updater.New(appVersion, appRepository, *cfgPath, updateSettingsFrom(cfg)) + var pn *panel.Panel + pn = panel.New(panel.Config{ + Pool: p, + ProxyPool: proxies, + Usage: rec, + RequestLog: requestLog, + Upstream: up, + Scheduler: sch, + // 降级路由表:面板据此在限流提示里标注「已路由至 <等价模型>」。 + ModelFallback: func() map[string]string { return live.Load().ModelFallback }, + // 余额趋势采样记录器:nil 时该视图返回 501。 + Balance: bal, + // 后台任务的自动触发开关与成长任务排程共用热配置(schedule.growth_enabled)。 + AutoTasksEnabled: sch.GrowthEnabled, + AuthDir: cfg.AuthDir, + APIKey: cfg.APIKey, + RedisMode: redisMode, + StickyCount: sessCount, + Version: appVersion, + Updater: updateManager, + PollIntervalSec: cfg.Panel.PollIntervalSec, + Live: live, + // 模型上限探测数据(scripts/probe_max_tokens.py --panel-out 写入): + // 与 state 文件同目录,缺省 data/output_probes.json。 + ProbeFile: stateSibling(cfg.StateFile, "output_probes.json"), + ConfigPath: *cfgPath, + LoadConfig: func() (any, error) { + return Load(*cfgPath) + }, + SaveConfig: func(raw []byte) ([]string, error) { + configSaveMu.Lock() + defer configSaveMu.Unlock() + fields, err := saveConfig(raw, *cfgPath, live, p, up, sch, gw, pn, cfg) + if err != nil { + return nil, err + } + if saved, loadErr := Load(*cfgPath); loadErr == nil { + updateManager.Configure(updateSettingsFrom(saved)) + } else if loadErr != nil { + log.Printf("WARN: reload update settings: %v", loadErr) + } + return fields, nil + }, + // 积分历史账本(只读展示;写入由上面的余额观察者完成)。 + CreditHistory: creditHist, + // 扩展模型页:免登录免费模型 / 自定义模型映射 / 访问密钥。 + Extensions: extStore, + FreeModels: freeClient, + }) + // 面板运行日志全频道按天落盘(logging.panel_log_*):重启后回填、支持按区间导出。 + // 装配顺序必须在 log.SetOutput 之前——回填完再把实时输出接上,否则启动期的 + // 那几行会先入环、再被回填的历史插到前面,时间序就乱了。 + var panelLogs *panel.LogStore + if cfg.Logging.PanelLogEnabled { + panelLogs = panel.NewLogStore(stateSibling(cfg.StateFile, "panel-logs"), + cfg.Logging.PanelLogRetentionDays, cfg.Logging.PanelLogMaxMB) + if panelLogs == nil { + log.Printf("WARN: 面板日志落盘不可用(数据目录建不出来),退回纯内存环") + } else { + if err := pn.Logs().SetLogStore(panelLogs); err != nil { + log.Printf("WARN: 面板日志回填失败(不影响新日志): %v", err) + } + defer panelLogs.Close() + log.Printf("[panel] 运行日志落盘 %s(保留 %d 天,上限 %d MiB)", + panelLogs.Dir(), cfg.Logging.PanelLogRetentionDays, cfg.Logging.PanelLogMaxMB) + } + } + // 兜底:落盘关掉或不可用时,仍用任务频道那份 JSON 快照回填(旧行为)。 + if panelLogs == nil { + if err := pn.Logs().SetTaskArchive(stateSibling(cfg.StateFile, "task-logs.json")); err != nil { + log.Printf("WARN: task log archive: %v", err) + } + } + log.SetOutput(io.MultiWriter(os.Stderr, pn.Logs())) + server.SetChatLogOutput(io.MultiWriter(os.Stdout, pn.Logs())) + // 成长任务队列排程的执行体在面板(队列逻辑唯一实现):注入回调,避免 scheduler → panel 循环依赖。 + sch.SetGrowthRunner(pn.RunGrowthQueueNow) + sch.SetSweepRunner(pn.RunTaskSweepNow) + pn.SetGrowthConcurrency(cfg.Schedule.GrowthConcurrency) + + var auditLog *server.AuditLog + if cfg.Admin.AuditEnabled { + al, aerr := server.NewAuditLog(cfg.Admin.AuditFile, cfg.APIKey) + if aerr != nil { + p.Flush() // Fatal 绕过 defer:至少把池状态落盘再退,否则丢整轮运行状态 + log.Fatalf("admin audit: %v", aerr) + } + auditLog = al + log.Printf("admin audit: %s", al.Path()) + } + // MCP serverInfo.version 与面板 /status 用同一个版本串(本地构建是 dev)。 + server.BuildVersion = appVersion + gw = server.NewHandler(server.Config{ + Pool: p, + Upstream: up, + APIKey: cfg.APIKey, + Session: sessRouter, + StickyCount: sessCount, + RedisMode: redisMode, + SoftCooldown: cfg.SoftRateDur, + Panel: pn, + Live: live, + Usage: rec, + RequestLog: requestLog, + PromptMode: cfg.Prompt.Mode, + // 模型降级路由表:读 live 快照(支持面板热更,改完即生效、无需重启)。 + ModelFallback: func() map[string]string { return live.Load().ModelFallback }, + PromptText: cfg.PromptText, + // 来源记录开关经 livecfg 热生效;此处同时填静态字段,供 Live 为 nil 的 + // 裸用/测试路径拿到同一缺省值。 + RecordClientInfo: cfg.Logging.RequestClientInfo, + RecordContext: cfg.Logging.RequestArchiveContext, + // handler 侧第三道闸(global realm):false(显式逃生门)时不列 global: 模型名。 + GlobalEnabled: cfg.Global.Enabled, + // 模型黑名单原始条目;运行期以 livecfg 快照为准(热生效),此处供 + // Live 为 nil 的裸用/测试路径。 + ModelsHidden: cfg.Models.Hidden, + // 模型白名单原始条目(issue #68);同上,运行期以 livecfg 快照为准。 + ModelsAllowed: cfg.Models.Allowed, + // 模型映射原始条目(issue #30);同上,运行期以 livecfg 快照为准。 + ModelsAliases: cfg.Models.Aliases, + AdminEnabled: cfg.Admin.Enabled, + MetricsEnabled: cfg.Metrics.Enabled, + Tasks: sch, + Audit: auditLog, + BudgetLimit: cfg.Budget.DailyCreditLimit, + BurstCreditLimit: cfg.Budget.BurstCreditLimit, + CacheLowRate: cfg.Budget.CacheLowRate, + // 入站请求体 OOM 护栏 + 11140 连坐暂停(两处都只在启动时读,改完需重启)。 + MaxPayloadBytes: cfg.Server.MaxPayloadBytes, + RestrictionHold: time.Duration(cfg.Upstream.RestrictionHoldSeconds) * time.Second, + // 等上游首帧期间的 SSE 注释帧间隔(server.head_keepalive,缺省 1.5s)。 + HeadKeepalive: cfg.HeadKeepaliveDur, + // 6020/6021 渠道排队:网关内先等一轮(features.busy_retry / busy_wait_seconds)。 + BusyRetry: cfg.Features.BusyRetry, + BusyWaitMax: time.Duration(cfg.Features.BusyWaitSeconds) * time.Second, + // 扩展层:免费模型直连与自定义模型映射(访问密钥鉴权也走同一个 store)。 + Extensions: extStore, + FreeModels: freeClient, + }) + + ctx, stop := signal.NotifyContext(context.Background(), os.Interrupt, syscall.SIGTERM) + defer stop() + // 免费模型清单后台刷新(3 秒后首次,之后每 6 小时)。 + go freeClient.RunRefresh(ctx) + proxyCtx, stopProxies := context.WithCancel(ctx) + proxyDone := make(chan struct{}) + go func() { + defer close(proxyDone) + proxies.Run(proxyCtx) + }() + defer func() { stopProxies(); <-proxyDone }() + updateManager.SetRestart(stop) + go updateManager.Run(ctx) + // 账号目录热重载(issue #199):外部同步进来的 auths/*.json 不必重启进程即可入池, + // 删文件也会在连续 N 次扫描确认后出池。面板「刷新」按钮之外还提供 + // POST /panel/api/accounts/reload 给脚本用;间隔 0s 时只保留手动接口。 + pn.SetReloadConfig(cfg.ReloadIntervalDur, cfg.Accounts.ReloadDeleteConfirm) + go pn.ReloadLoop(ctx.Done()) + // 账号后台任务(taskjobs):状态与主 state 同目录,重启后自动恢复未完成作业。 + if err := pn.StartTaskJobs(ctx, stateSibling(cfg.StateFile, "task-jobs.json")); err != nil { + p.Flush() // Fatal 绕过 defer:至少把池状态落盘再退 + log.Fatalf("task jobs: %v", err) + } + defer pn.StopTaskJobs() + pn.ResumeTaskJobs() + go sch.Run(ctx) + sch.SetJitter(cfg.Schedule.BalanceRefreshJitterPermill, cfg.Schedule.TaskSweepJitterPermill) + sch.SetMakeupCardsPerRound(cfg.Schedule.MakeupCardsPerRound) + sch.StartBalanceRefresh(ctx, cfg.BalanceRefreshInterval) + sch.StartTaskSweep(ctx, cfg.TaskSweepInterval) + // 额度窗口探针:上游按首次请求起算额度窗口,429 重置时刻到了没人发请求窗口就 + // 不开始(额度空转)。到点主动发一个最小请求把起点钉住。开关见 + // schedule.window_probe_enabled(缺省开)。 + if cfg.Schedule.WindowProbeEnabled { + sch.StartModelWindowProbe(ctx) + } + if cfg.Alerting.Enabled { + mon := alert.New(alert.Config{ + Enabled: true, + WebhookURL: cfg.Alerting.WebhookURL, + Secret: cfg.Alerting.Secret, + Interval: time.Duration(cfg.Alerting.IntervalSeconds) * time.Second, + Timeout: time.Duration(cfg.Alerting.TimeoutSeconds) * time.Second, + StartupGrace: time.Duration(cfg.Alerting.StartupGraceSeconds) * time.Second, + MinHealthyCN: cfg.Alerting.MinHealthyCN, + MinHealthyGlobal: cfg.Alerting.MinHealthyGlobal, + RecoverHealthy: cfg.Alerting.RecoverHealthy, + BreakerThreshold: cfg.Alerting.BreakerThreshold, + ForTicks: cfg.Alerting.ForTicks, + ClearTicks: cfg.Alerting.ClearTicks, + SendResolve: cfg.Alerting.SendResolve, + }, alertSource{pool: p, h: gw}) + go mon.Run(ctx) + // 排程轮次结果汇总的推送出口(告警 webhook 同一条管道;未启用则只落面板日志)。 + pn.SetNotifier(mon.Notify) + log.Printf("alerting: webhook on, every %ds", cfg.Alerting.IntervalSeconds) + // 上游目录改版监控也走这条管道(未启用告警时只写日志,见下方 watchdog 段)。 + if cfg.Watchdog.Enabled { + go gw.WatchCatalog(ctx, time.Duration(cfg.Watchdog.IntervalSeconds)*time.Second, mon.Notify) + log.Printf("watchdog: 上游目录监控开,每 %ds", cfg.Watchdog.IntervalSeconds) + } + } else if cfg.Watchdog.Enabled { + // 没有 webhook 也要能开:变化只写日志(面板任务日志里能翻到)。 + go gw.WatchCatalog(ctx, time.Duration(cfg.Watchdog.IntervalSeconds)*time.Second, nil) + log.Printf("watchdog: 上游目录监控开(未配置 alerting,仅写日志),每 %ds", cfg.Watchdog.IntervalSeconds) + } + + // 启动即预热模型积分倍率表:倍率只在 FetchModels/FetchGlobalModelInfos 成功时 + // 填充(两者均懒触发),重启后到首次 /v1/models 或面板模型页被访问之前, + // ModelRate 恒返回空串——积分保底的目录兜底在这段空窗期内形同虚设,触底号 + // 会被当成「收费未知」放行并打穿(实测:重启后 2 分钟,97 分的账号打收费 + // 模型归零;倍率表当时尚未建立)。 + // 异步执行:不阻塞监听启动;失败仅记日志(下一轮懒触发或本轮重试仍可补上)。 + go warmModelRates(ctx, up, p) + + // 诊断用:WB2API_PPROF=127.0.0.1:6060 时另起一个只跑 pprof 的监听。 + // 默认不开启(不设环境变量就完全没有这个监听),供「并发一高就降速」这类 + // 只能靠真实负载定位的 CPU 问题取 profile(取完即关容器,不常驻生产)。 + if addr := os.Getenv("WB2API_PPROF"); addr != "" { + go func() { + log.Printf("[pprof] 诊断监听开启 %s(CPU: /debug/pprof/profile?seconds=30)", addr) + if err := http.ListenAndServe(addr, nil); err != nil { + log.Printf("WARN: [pprof] 监听失败 %v", err) + } + }() + } + + srv := &http.Server{ + Addr: cfg.Listen, + Handler: gw, + ReadHeaderTimeout: 30 * time.Second, + // ReadTimeout 覆盖整个请求读取(含 body 上传):防慢速 body 拖死连接。 + // 请求体已无网关侧上限(max_body_mb 移除)。缺省 300s(issue #100:旧固定 + // 60s 会掐掉大上下文/文件块经反代链的慢速上传,客户端收到 + // 400 "read body: ... i/o timeout");server.read_timeout="0" 显式关闭。 + // 改动需重启进程。 + ReadTimeout: cfg.ServerReadTimeoutDur, + // IdleTimeout keep-alive 空闲连接回收:配合 chat 出站 ctx 传播防连接泄漏堆积。 + // 注意:SSE 流式响应期间连接非空闲,不受此项掐断;不设全局 WriteTimeout + // (长流式生成合法时长可达数分钟,全局 WriteTimeout 会误杀在途 SSE)。 + IdleTimeout: 120 * time.Second, + } + shutdownDone := make(chan struct{}) + go func() { + defer close(shutdownDone) + <-ctx.Done() + p.Flush() // 信号触发:先落盘再做优雅停机 + // 在途请求排干窗口可配(server.shutdown_timeout,缺省 30s):长流式 SSE + // 合法时长可达分钟级,固定 5s 必然把在途请求掐成连接重置;超时不再静默。 + shutdownTimeout := cfg.ShutdownTimeoutDur + if shutdownTimeout <= 0 { + shutdownTimeout = 5 * time.Second + } + shutdownCtx, cancel := context.WithTimeout(context.Background(), shutdownTimeout) + defer cancel() + if err := srv.Shutdown(shutdownCtx); err != nil { + log.Printf("WARN: 优雅关停未在 %s 内完成,在途请求被放弃: %v", shutdownTimeout, err) + } + }() + + if warn := insecureKeyWarning(cfg.Listen, cfg.APIKey); warn != "" { + log.Printf("WARN: %s", warn) + } + log.Print(listenBanner(cfg.Listen, loadedFrom, cfg.APIKey)) + if err := srv.ListenAndServe(); err != nil && err != http.ErrServerClosed { + p.Flush() // 监听失败时信号路径不会跑:这里同样兜底落盘再退 + log.Fatalf("http: %v", err) + } + if ctx.Err() != nil { + <-shutdownDone + } + log.Printf("bye") +} + +// warmModelRates 启动预热各域模型积分倍率表(供积分保底的目录兜底判定)。 +// +// 为什么需要:倍率表只在 FetchModels(CN)/ FetchGlobalModelInfos(global)成功时 +// 填充,两者都是懒触发(被 /v1/models 或面板模型页访问才跑)。重启后到首次触发 +// 之间的空窗期里 ModelRate 恒返回空串,保底的目录兜底判不出收费,触底号会被 +// 当成「收费未知」放行并打穿(实测:重启后 2 分钟,97 分的账号打收费模型归零)。 +// +// 失败处理:单域失败只记 WARN(不阻塞、不致命——后续懒触发仍会补上);global 域 +// 仅在其路由开关开启时预热(逃生门关锁时按 CN 处理,无需探测)。 +func warmModelRates(ctx context.Context, up *upstream.Client, p *pool.Pool) { + // 预热不得拖住进程退出:ctx 取消(SIGINT/SIGTERM)时立刻放弃剩余域。 + if ctx.Err() != nil { + return + } + // CN:有可用 CN 账号才拉(与面板 models 同口径,避免无谓上游调用)。 + if uids := p.AvailableUIDsForRealm("cn"); len(uids) > 0 { + if a := p.AuthByUID(uids[0]); a != nil { + if _, err := up.FetchModels(a); err != nil { + log.Printf("WARN: [upstream] warm model rates (cn): %v", err) + } else { + log.Printf("[upstream] warm model rates: cn ok") + } + } + } + // global:独立目录端点(workbuddy.ai),倍率按 "global" 域键存储。 + if up.GlobalEnabled && ctx.Err() == nil { + if uids := p.AvailableUIDsForRealm("global"); len(uids) > 0 { + if a := p.AuthByUID(uids[0]); a != nil { + // FetchGlobalModelInfos 无错误返回(内部负缓存自行节流), + // 仅按结果条数判断是否拿到目录。 + if infos := up.FetchGlobalModelInfos(a); len(infos) == 0 { + log.Printf("WARN: [upstream] warm model rates (global): empty model list") + } else { + log.Printf("[upstream] warm model rates: global ok (%d models)", len(infos)) + } + } + } + } +} + +// listenBanner 组装启动横幅。api_key 的来源必须写明(issue #155:改了 config.json 却不 +// 生效,旧日志只写 api_key=true,看不出是 WB2A_API_KEY 覆盖了文件还是改错了文件), +// 密钥本身只出掩码。path 传「实际加载的那份」,退回默认时传空。 +func listenBanner(listen, path, key string) string { + return fmt.Sprintf("workbuddy2api listening on %s (api_key=%s, 来源 %s),管理面板 http://127.0.0.1%s/panel/", + listen, maskSecret(key), apiKeySource(path), panelListenPath(listen)) +} + +// apiKeySource 报生效的 api_key 来自哪里,顺序同 applyEnv:env 非空即覆盖文件。 +func apiKeySource(path string) string { + if os.Getenv("WB2A_API_KEY") != "" { + return "环境变量 WB2A_API_KEY" + } + if path == "" { + return "内置默认值" + } + return "配置文件 " + path +} + +// maskSecret 只留首尾各两位便于对号入座;不足 8 位或未设置则整条隐去。 +func maskSecret(s string) string { + if s == "" { + return "(未设置)" + } + r := []rune(s) + if len(r) < 8 { + return strings.Repeat("*", len(r)) + } + return string(r[:2]) + strings.Repeat("*", len(r)-4) + string(r[len(r)-2:]) +} + +// panelListenPath 从 listen 地址提取 ":port" 形式,用于启动日志拼面板 URL +// (":7863" 或 "0.0.0.0:7863" → ":7863";异常输入原样返回)。 +func panelListenPath(listen string) string { + for i := len(listen) - 1; i >= 0; i-- { + if listen[i] == ':' { + return listen[i:] + } + } + return listen +} + +// saveConfig 面板保存配置:校验 → 落盘 → 热应用 → 返回需重启的字段列表。 +// +// 热生效范围(设计取舍): +// - api_key / cooldown.soft_rate / features.sanitize_blacklist_fingerprints → livecfg 快照 +// - pool.* → pool.SetBreaker/SetMaxInFlight/SetSoftRateMax/SetWeights/SetCostExploreInterval/SetPreferExpiring(含快过期窗口)/SetAccountPriority/SetAccountShare/SetCreditFloor +// - schedule.* → scheduler.Reconfigure/SetBalanceInterval/SetExpiringSoonWindow +// +// 需重启(涉及监听地址、HTTP client 超时、auth_dir 等装配期依赖): +// - listen / auth_dir / state_file / upstream.* / upstash.* / session_sticky.*(TTL 类) +// +// 落盘用"先写 tmp 再 rename"原子替换,且优先保留磁盘上的原始 JSON 结构(只改 +// 面板表单覆盖到的键),避免把用户手写的注释性字段/未知键洗掉——这里直接整体 +// 序列化校验后的配置,未知键在 json.Unmarshal 时已丢失,故先合并原始 map。 +// writeConfigInPlace 原地重写配置(O_TRUNC),给两种「原子替换做不到」的部署形态复用: +// 单文件 bind mount 不能被 rename 覆盖(EBUSY);配置目录不可写但文件可写(EACCES, +// Docker 以 PUID 运行而 /app 属主是镜像内的 app,见 issue #134)。代价是失去原子性: +// 写失败时文件可能只剩半截 —— 这两种形态下本来也没有可用 tmp 的目录。 +func writeConfigInPlace(path string, out []byte) error { + f, err := os.OpenFile(path, os.O_WRONLY|os.O_TRUNC, 0o600) + if err != nil { + return err + } + _, werr := f.Write(out) + if werr == nil { + werr = f.Sync() + } + if cerr := f.Close(); werr == nil { + werr = cerr + } + return werr +} + +// effortPolicyOf 把 config thinking 节转成 upstream 运行时策略。nil 配置/ +// 未启用时返回的策略由 Client.SetEffortPolicy 统一处理(Enabled=false 即不生效)。 +func effortPolicyOf(cfg *Config) *upstream.EffortPolicy { + if cfg == nil { + return nil + } + return &upstream.EffortPolicy{ + Enabled: cfg.Thinking.Enabled, + DefaultEffort: cfg.Thinking.DefaultEffort, + ClientPriority: cfg.Thinking.ClientPriority, + OverrideScope: cfg.Thinking.OverrideScope, + ModelDefaults: cfg.Thinking.ModelDefaults, + } +} + +// updateSettingsFrom 把 config 的 update 段翻成 updater.Settings(issue #198)。 +// +// 单独抽成函数是因为「启动装配」与「配置保存后热更新」两处必须用同一口 IO—— +// 各写一份字面量时,新增字段必然只接一处(热更新丢了 proxy/mirror,面板看着 +// 保存成功、实际还是旧通道)。 +// +// proxy_from_env 在 config 里是 *bool:JSON 缺键 = 未表态 → 沿用环境变量(历史 +// 行为,也是绝大多数部署的实际形态);显式 false 才完全不读环境。 +func updateSettingsFrom(u *Config) updater.Settings { + fromEnv := true + if u.Update.ProxyFromEnv != nil { + fromEnv = *u.Update.ProxyFromEnv + } + return updater.Settings{ + AutoEnabled: u.Update.AutoEnabled, + AutoTime: u.Update.AutoTime, + Proxy: u.Update.Proxy, + ProxyFromEnv: fromEnv, + Mirror: u.Update.Mirror, + } +} + +func saveConfig(raw []byte, path string, live *livecfg.Holder, p *pool.Pool, up *upstream.Client, sch *scheduler.Scheduler, gw *server.Handler, pn *panel.Panel, running ...*Config) ([]string, error) { + // 1) 解析原始 JSON 为 map(保留用户手写的未知键),再叠加面板提交的键。 + oldRaw, err := os.ReadFile(path) + if err != nil { + return nil, fmt.Errorf("read current config: %w", err) + } + // 重启清单的比较基线:优先用「运行中配置」(含 env 覆盖与启动归一化); + // 未传入(测试/旧调用)时退化为磁盘旧值。见 restartRequiredFields。 + previous, err := ParseConfig(oldRaw) + if err != nil { + return nil, fmt.Errorf("parse current config: %w", err) + } + baseline := previous + if len(running) > 0 && running[0] != nil { + baseline = running[0] + } + var cur, incoming map[string]any + if err := json.Unmarshal(oldRaw, &cur); err != nil { + cur = map[string]any{} + } + if err := json.Unmarshal(raw, &incoming); err != nil { + return nil, fmt.Errorf("parse submitted config: %w", err) + } + merged := mergeConfigMaps(cur, incoming) + + // 2) 校验(与启动同一套 Default+normalize),失败直接返回、不落盘。 + newCfg, err := ParseConfig(mergedJSON(merged)) + if err != nil { + return nil, err + } + // 环境变量覆盖与启动同优先级:保存路径同样应用(否则 env 托管字段会被文件值 + // 抢班——面板显示 env 值、运行却按文件值)。移植上游 PR #104。 + applyEnv(newCfg) + if err := newCfg.normalize(); err != nil { + return nil, err + } + + // 3) 落盘(原子替换)。 + out, err := json.MarshalIndent(merged, "", " ") + if err != nil { + return nil, fmt.Errorf("marshal config: %w", err) + } + // safefile:tmp fsync 后才 rename,并把上一份有效配置留成 config.json.bak + // —— 掉电把 config.json 留成半截时,下次启动能捡回上一份。 + if err := safefile.WriteKeep(path, out, 0o600); err != nil { + switch { + case errors.Is(err, fs.ErrPermission): + // 配置所在目录不可写:Docker 里 /app 属主是镜像内的 app(10001),而 compose 让 + // 容器以 PUID(如 1000) 运行 —— 挂载进去的 config.json 可写、目录不行,于是原子 + // 替换连 tmp 都建不出来(issue #134:write config: open /app/config.json.tmp: + // permission denied)。文件本身可写就退回原地重写,不再要求目录可写。 + if inPlaceErr := writeConfigInPlace(path, out); inPlaceErr != nil { + return nil, fmt.Errorf("write config (目录不可写,原地重写也失败): %w", inPlaceErr) + } + case errors.Is(err, syscall.EBUSY): + // A single-file Docker bind mount cannot be renamed over its mount + // target (Linux returns EBUSY / "device or resource busy"). Keep the + // atomic path for regular files, but update the mounted file in place + // for this specific deployment shape. + if inPlaceErr := writeConfigInPlace(path, out); inPlaceErr != nil { + return nil, fmt.Errorf("replace config (bind mount fallback): %w", inPlaceErr) + } + default: + return nil, fmt.Errorf("write config: %w", err) + } + } + + // 4) 热应用:能立即生效的字段全部应用,并列出仍需重启的字段。 + // 白名单同步重建(issue #68):面板保存 models.allowed 后即时生效。 + newAllowedModels, newAllowlistEnabled := livecfg.NormalizeAllowedModels(newCfg.Models.Allowed) + live.Store(livecfg.Snapshot{ + APIKey: newCfg.APIKey, + SoftCooldown: newCfg.SoftRateDur, + SanitizeFingerprints: newCfg.Features.SanitizeBlacklistFingerprints, + EmbeddingsEnabled: newCfg.Features.EmbeddingsEnabled, + WatermarkStripEnabled: newCfg.Features.WatermarkStripEnabled, + RecordClientInfo: newCfg.Logging.RequestClientInfo, + RecordContext: newCfg.Logging.RequestArchiveContext, + HiddenModels: livecfg.NormalizeHiddenModels(newCfg.Models.Hidden), + // 白名单热生效:与 HiddenModels 同一条快照重建通路(issue #68)。 + AllowedModels: newAllowedModels, + AllowlistEnabled: newAllowlistEnabled, + ModelAliases: livecfg.NormalizeModelAliases(newCfg.Models.Aliases), + // 思考档位策略镜像:与 up.SetEffortPolicy 同批热更新,面板立即回显新生效值。 + ThinkingEnabled: newCfg.Thinking.Enabled, + ThinkingDefaultEffort: newCfg.Thinking.DefaultEffort, + ThinkingClientPriority: newCfg.Thinking.ClientPriority, + ThinkingOverrideScope: newCfg.Thinking.OverrideScope, + ThinkingModelDefaults: newCfg.Thinking.ModelDefaults, + ModelFallback: newCfg.Pool.ModelFallback, + }) + up.SanitizeFingerprints.Store(newCfg.Features.SanitizeBlacklistFingerprints) + up.SanitizeBrandScope.Store(newCfg.Features.SanitizeBrandScope) + up.KeepRecentRounds.Store(int64(newCfg.Prompt.KeepRecentRounds)) + // 思考档位策略热生效:改默认档 / 切换客户端优先或作用域后,下一次 chat 即按新策略。 + up.SetEffortPolicy(effortPolicyOf(newCfg)) + p.SetBreaker(newCfg.Pool.BreakerThreshold, newCfg.BreakerCooldownDur, newCfg.BreakerCooldownMaxD) + p.SetMaxInFlight(newCfg.Pool.MaxInFlight) + p.SetMaxInFlightGlobal(newCfg.Pool.MaxInFlightGlobal) + p.SetDegrade(newCfg.Pool.DegradeThreshold, newCfg.DegradeCooldownDur, newCfg.DegradeCooldownMaxD) + p.SetSoftRateMax(newCfg.SoftRateMaxDur) + p.SetCostExploreInterval(newCfg.CostExploreIntervalDur) // costTier 探索窗口热生效(0 关停) + p.SetBalanceWindow(newCfg.BalanceWindowDur) // 窗口用量调度热生效(0 关停) + p.SetCreditFloor(newCfg.Pool.CreditFloor) // 积分保底热生效(0 = 关闭) + p.SetCreditFloorMaxRate(newCfg.Pool.CreditFloorMaxRate) // 保底倍率上限热生效(0 = 严格模式) + p.SetWeights(newCfg.Pool.IdleWeightPerHour, newCfg.Pool.IdleWeightMax) + p.SetPreferExpiring(newCfg.Pool.PreferExpiring, newCfg.ExpiringSoonDur) + sch.SetExpiringSoonWindow(newCfg.ExpiringSoonDur) + sch.SetKeepaliveRefreshWindow(newCfg.KeepaliveRefreshWindowDur) + p.SetReserveCredits(*newCfg.Pool.ReserveCredits) // 保留积分热生效(0 = 关闭,缺省 10) + p.SetReserveCreditsByRealm(newCfg.Pool.ReserveCreditsByRealm) // 按域覆盖热生效(issue #147) + p.SetAccountPriority(newCfg.Pool.AccountPriority) // 账号优先级/占比热生效(issue #62) + p.SetAccountShare(newCfg.Pool.AccountShare) + p.SetStrategy(newCfg.Pool.SelectionStrategy) // 选号策略热生效 + sch.Reconfigure(scheduler.ScheduleParams{ + CheckinHours: newCfg.Schedule.CheckinHours, + TravelHours: newCfg.Schedule.TravelHours, + ActivityHours: newCfg.Schedule.ActivityHours, + KeepaliveHours: newCfg.Schedule.KeepaliveHours, + GrowthHours: newCfg.Schedule.GrowthHours, + + CheckinDisabled: !newCfg.Schedule.CheckinEnabled, + TravelDisabled: !newCfg.Schedule.TravelEnabled, + ActivityDisabled: !newCfg.Schedule.ActivityEnabled, + WebActivityDisabled: !newCfg.Schedule.WebActivityEnabled, + KeepaliveDisabled: !newCfg.Schedule.KeepaliveEnabled, + GrowthDisabled: !newCfg.Schedule.GrowthEnabled, + IncludeDisabledInTasks: newCfg.Schedule.IncludeDisabledInTasks, + + JitterMinutes: newCfg.Schedule.JitterMinutes, + AccountSpreadMinutes: newCfg.Schedule.AccountSpreadMinutes, + AccountSpreadMinGapSeconds: newCfg.Schedule.AccountSpreadMinGapSeconds, + }) + sch.SetBalanceInterval(newCfg.BalanceRefreshInterval) + sch.SetTaskSweepInterval(newCfg.TaskSweepInterval) + sch.SetJitter(newCfg.Schedule.BalanceRefreshJitterPermill, newCfg.Schedule.TaskSweepJitterPermill) + sch.SetMakeupCardsPerRound(newCfg.Schedule.MakeupCardsPerRound) + if pn != nil { + pn.SetGrowthConcurrency(newCfg.Schedule.GrowthConcurrency) // 排程轮次并发热生效 + } + if gw != nil { + gw.SetBudgetLimit(newCfg.Budget.DailyCreditLimit) + gw.SetBudgetGuards(newCfg.Budget.BurstCreditLimit, newCfg.Budget.CacheLowRate) + } + + return restartRequiredFields(baseline, newCfg), nil +} + +// applyCNChatBase 把 config cn.chat_base / cn.billing_base 装配进上游 client; +// 空则保留内置默认,老配置(无 cn 段)行为不变。 +func applyCNChatBase(up *upstream.Client, cfg *Config) { + if cfg.CN.ChatBase != "" { + up.ChatBaseCN = cfg.CN.ChatBase + } + if cfg.CN.BillingBase != "" { + up.BillingBaseCN = cfg.CN.BillingBase + } +} + +// restartRequiredFields 比较运行中装配值与新配置(有运行配置时以它为准,否则退化 +// 为磁盘旧值),只报告「确实变化且无法热生效」的字段——第二次保存不再重复携带上 +// 一处的待重启项、改回原值即自动清除(无独立的 pending 集合)。移植上游 PR #104; +// 字段集保留本 fork 自有项(admin/metrics/alerting 整块)。 +func restartRequiredFields(current, next *Config) []string { + var out []string + changed := func(name string, before, after any) { + if !reflect.DeepEqual(before, after) { + out = append(out, name) + } + } + changed("listen", current.Listen, next.Listen) + changed("auth_dir", current.AuthDir, next.AuthDir) + changed("state_file", current.StateFile, next.StateFile) + changed("upstream.timeout_seconds", current.Upstream.TimeoutSeconds, next.Upstream.TimeoutSeconds) + changed("upstream.header_timeout_seconds", current.Upstream.HeaderTimeoutSeconds, next.Upstream.HeaderTimeoutSeconds) + changed("upstream.idle_timeout_seconds", current.Upstream.IdleTimeoutSeconds, next.Upstream.IdleTimeoutSeconds) + changed("upstream.user_agent", current.Upstream.UserAgent, next.Upstream.UserAgent) + changed("upstream.client_version", current.Upstream.ClientVersion, next.Upstream.ClientVersion) + changed("upstream.cli_version", current.Upstream.CliVersion, next.Upstream.CliVersion) + changed("upstream.client_name", current.Upstream.ClientName, next.Upstream.ClientName) + changed("upstream.device_token", current.Upstream.DeviceToken, next.Upstream.DeviceToken) + changed("upstream.device_token_file", current.Upstream.DeviceTokenFile, next.Upstream.DeviceTokenFile) + changed("upstream.passthrough_ip", current.Upstream.PassthroughIP, next.Upstream.PassthroughIP) + // cn.chat_base / cn.billing_base 同样只在装配期写进上游 client(请求路径并发读取,不做热改)。 + changed("cn.chat_base", current.CN.ChatBase, next.CN.ChatBase) + changed("cn.billing_base", current.CN.BillingBase, next.CN.BillingBase) + changed("global.enabled", current.Global.Enabled, next.Global.Enabled) + changed("global.chat_base", current.Global.ChatBase, next.Global.ChatBase) + changed("global.billing_base", current.Global.BillingBase, next.Global.BillingBase) + changed("prompt.mode", current.Prompt.Mode, next.Prompt.Mode) + changed("prompt.file", current.Prompt.File, next.Prompt.File) + changed("prompt.text", current.PromptText, next.PromptText) + changed("upstash.url", current.Upstash.URL, next.Upstash.URL) + changed("upstash.token", current.Upstash.Token, next.Upstash.Token) + changed("session_sticky.enabled", current.SessionSticky.Enabled, next.SessionSticky.Enabled) + changed("session_sticky.ttl", current.SessionTTL, next.SessionTTL) + changed("session_sticky.gc_interval", current.SessionGCInterval, next.SessionGCInterval) + changed("admin", current.Admin, next.Admin) + changed("metrics", current.Metrics, next.Metrics) + changed("alerting", current.Alerting, next.Alerting) + changed("logging.request_archive_enabled", current.Logging.RequestArchiveEnabled, next.Logging.RequestArchiveEnabled) + changed("logging.request_retention_days", current.Logging.RequestRetentionDays, next.Logging.RequestRetentionDays) + changed("logging.request_archive_max_mb", current.Logging.RequestArchiveMaxMB, next.Logging.RequestArchiveMaxMB) + changed("server.read_timeout", current.Server.ReadTimeout, next.Server.ReadTimeout) + changed("server.shutdown_timeout", current.Server.ShutdownTimeout, next.Server.ShutdownTimeout) + return out +} + +// mergeConfigMaps 把 incoming 深合并进 cur(原地),返回 cur。 +// 对嵌套对象逐键覆盖而不是整体替换:面板表单只提交它管理的键, +// 未提交的兄弟键(含用户手写的未知键)保持原样。 +func mergeConfigMaps(cur, incoming map[string]any) map[string]any { + for k, v := range incoming { + if inMap, ok := v.(map[string]any); ok { + if curMap, ok := cur[k].(map[string]any); ok { + cur[k] = mergeConfigMaps(curMap, inMap) + continue + } + } + cur[k] = v + } + return cur +} + +// mergedJSON 把合并后的 map 序列化回 JSON(供 ParseConfig 校验)。 +func mergedJSON(m map[string]any) []byte { + b, err := json.Marshal(m) + if err != nil { + return []byte("{}") + } + return b +} diff --git a/cmd/server/upstream_port_config_test.go b/cmd/server/upstream_port_config_test.go new file mode 100644 index 0000000000000000000000000000000000000000..93523233c0f67de84a7c57d029698ae7af743e8b --- /dev/null +++ b/cmd/server/upstream_port_config_test.go @@ -0,0 +1,21 @@ +package main + +import "testing" + +func TestBudgetAndJitterRejectBadValues(t *testing.T) { + c := Default() + c.Budget.DailyCreditLimit = -1 + if err := c.normalize(); err == nil { + t.Fatal("negative budget should fail") + } + c = Default() + c.Schedule.JitterMinutes = 1441 + if err := c.normalize(); err == nil { + t.Fatal("jitter over a day should fail") + } + c = Default() + c.Alerting.Enabled = true + if err := c.normalize(); err == nil { + t.Fatal("alerting without webhook should fail") + } +} diff --git a/cmd/server/wiring.go b/cmd/server/wiring.go index 1d1495d536c2b6339504c120e07827b45348e4fc..27c88aada471e87938eb81799e30c205c53a7a94 100644 --- a/cmd/server/wiring.go +++ b/cmd/server/wiring.go @@ -1,24 +1,40 @@ -package main - -import ( - "github.com/linguo2625469/workbuddy2api-panel/internal/pool" - "github.com/linguo2625469/workbuddy2api-panel/internal/server" -) - -// realmAwareAvailableForModel 构造会话粘性路由按模型可用口径的 realm 感知闭包。 -// -// 粘性分配的模型名可能带 realm 前缀("global:gpt-5.4" / "cn:glm-5.2"):必须按前缀剥出 -// realm + bareModel,再交给分池选号域过滤——否则裸名取池子全集,global 号会被粘性分配给 -// CN 前缀请求(跨 realm 泄漏)。裸名/显式 cn → cn 集合;global: → global 集合。 -// -// realm 为空串时 pool.WeightedAvailableUIDsForModelRealm 退化为现状 -// (AvailableUIDsForModel),老调用(无前缀模型名)语义零改动。 -// -// 返回列表可能对快过期账号重复同一 UID,作为虚拟实例权重;会话哈希分配无需感知 -// 权重细节,已有绑定的快路径仍直接返回原账号,不做迁移。 -func realmAwareAvailableForModel(p *pool.Pool) func(model string) []string { - return func(model string) []string { - realm, bare := server.ResolveModel(model) - return p.WeightedAvailableUIDsForModelRealm(bare, realm) - } -} +package main + +import ( + "github.com/misakano7545/workbuddy2api-panel/internal/alert" + "github.com/misakano7545/workbuddy2api-panel/internal/pool" + "github.com/misakano7545/workbuddy2api-panel/internal/server" +) + +// realmAwareAvailableForModel 构造会话粘性路由按模型可用口径的 realm 感知闭包。 +// +// 粘性分配的模型名可能带 realm 前缀("global:gpt-5.4" / "cn:glm-5.2"):必须按前缀剥出 +// realm + bareModel,再交给分池选号域过滤——否则裸名取池子全集,global 号会被粘性分配给 +// CN 前缀请求(跨 realm 泄漏)。裸名/显式 cn → cn 集合;global: → global 集合。 +// +// realm 为空串时 pool.WeightedAvailableUIDsForModelRealm 退化为现状 +// (AvailableUIDsForModel),老调用(无前缀模型名)语义零改动。 +// +// 返回列表可能对快过期账号重复同一 UID,作为虚拟实例权重;会话哈希分配无需感知 +// 权重细节,已有绑定的快路径仍直接返回原账号,不做迁移。 +func realmAwareAvailableForModel(p *pool.Pool) func(model string) []string { + return func(model string) []string { + realm, bare := server.ResolveModel(model) + return p.WeightedAvailableUIDsForModelRealm(bare, realm) + } +} + +type alertSource struct { + pool *pool.Pool + h *server.Handler +} + +func (s alertSource) Health(realm string) alert.Health { + h := s.pool.RealmHealth(realm) + return alert.Health{ + Total: h.Total, Healthy: h.Healthy, Cooling: h.Cooling, Disabled: h.Disabled, + Breaker: h.Breaker, Degraded: h.Degraded, InFlight: h.InFlight, + } +} + +func (s alertSource) WAFActive() bool { return s.h.WAFActive() } diff --git a/cmd/signin/main.go b/cmd/signin/main.go index fad0eef1fb7b1c6b820a45a190d867ace6ca9e81..0b879e09d0040d78c6530e79361ce86497aaaff1 100644 --- a/cmd/signin/main.go +++ b/cmd/signin/main.go @@ -1,140 +1,143 @@ -// signin 一次性批量签到工具:遍历 ./auths/workbuddy-*.json 全部账号, -// 自动 RefreshToken(过期时),逐个调 daily-checkin,顺手查余额。 -package main - -import ( - "fmt" - "log" - "os" - "path/filepath" - "sort" - "strings" - - "github.com/linguo2625469/workbuddy2api-panel/internal/auth" - "github.com/linguo2625469/workbuddy2api-panel/internal/upstream" -) - -type row struct { - file string - uid string - nick string - status string // OK | ALREADY | FAIL | AUTH_INVALID | LOAD_ERR - detail string - remain int64 - hasQuota bool -} - -func main() { - dir := "auths" - if len(os.Args) > 1 { - dir = os.Args[1] - } - files, err := filepath.Glob(filepath.Join(dir, "workbuddy-*.json")) - if err != nil || len(files) == 0 { - fmt.Fprintf(os.Stderr, "no auth files in %s\n", dir) - os.Exit(1) - } - sort.Strings(files) - up := upstream.New() - - var rows []row - okN, alreadyN, failN := 0, 0, 0 - for _, f := range files { - r := row{file: filepath.Base(f)} - raw, err := os.ReadFile(f) - if err != nil { - r.status, r.detail = "LOAD_ERR", err.Error() - rows = append(rows, r) - failN++ - continue - } - a, err := auth.Parse(raw) - if err != nil { - r.status, r.detail = "LOAD_ERR", err.Error() - rows = append(rows, r) - failN++ - continue - } - a.FilePath = f - r.uid, r.nick = a.UID, a.Nickname - - // refresh 过期 token - if a.NeedsRefresh(2 * 3600) { - if err := up.RefreshToken(a); err != nil { - if ue, ok := err.(*upstream.Error); ok && ue.Kind == upstream.ErrSessionDead { - r.status = "AUTH_INVALID" - } else { - r.status = "FAIL" - } - r.detail = "refresh: " + short(err.Error()) - rows = append(rows, r) - failN++ - continue - } - // refresh 后写回文件(权限问题已修复);落盘失败必须暴露,否则重启回旧 token - if err := a.SaveAtomic(); err != nil { - log.Printf("signin %s save: %v", a.UID, err) - } - } - - err = up.DailyCheckin(a) - switch { - case err == nil: - r.status = "OK" - okN++ - default: - // DailyCheckin 已签到返回 code!=0 错误 - if isAlready(err.Error()) { - r.status = "ALREADY" - r.detail = short(err.Error()) - alreadyN++ - } else { - r.status = "FAIL" - r.detail = short(err.Error()) - failN++ - } - } - // 顺手查余额 - if remain, _, qerr := up.UserResource(a); qerr == nil { - r.remain, r.hasQuota = remain, true - } - rows = append(rows, r) - } - - // 报告 - fmt.Printf("uid | nick | status | remain | detail\n") - fmt.Printf("-------------------------------------+-------------+--------------+--------+------------------------------\n") - for _, r := range rows { - remain := "-" - if r.hasQuota { - remain = fmt.Sprintf("%d", r.remain) - } - fmt.Printf("%-36s | %-11s | %-12s | %-6s | %s\n", - trunc(r.uid, 36), trunc(r.nick, 11), r.status, remain, r.detail) - } - fmt.Printf("\ntotal=%d ok=%d already=%d fail=%d\n", len(rows), okN, alreadyN, failN) -} - -// 已签判定:code 非 0 且含 "已签到"/"already"/"checkin" 等字样 -func isAlready(msg string) bool { - s := strings.ToLower(msg) - return strings.Contains(s, "已签到") || - strings.Contains(s, "already") || - strings.Contains(s, "checkin") || - strings.Contains(s, "code=400") -} - -func trunc(s string, n int) string { - if len(s) > n { - return s[:n] - } - return s -} - -func short(s string) string { - s = strings.ReplaceAll(s, "\n", " ") - if len(s) > 60 { - return s[:60] - } - return s -} +// signin 一次性批量签到工具:遍历 ./auths/workbuddy-*.json 全部账号, +// 自动 RefreshToken(过期时),逐个调 daily-checkin,顺手查余额。 +package main + +import ( + "fmt" + "log" + "os" + "path/filepath" + "sort" + "strings" + "time" + + "github.com/misakano7545/workbuddy2api-panel/internal/auth" + "github.com/misakano7545/workbuddy2api-panel/internal/upstream" +) + +type row struct { + file string + uid string + nick string + status string // OK | ALREADY | FAIL | AUTH_INVALID | LOAD_ERR + detail string + remain int64 + hasQuota bool +} + +func main() { + dir := "auths" + if len(os.Args) > 1 { + dir = os.Args[1] + } + files, err := filepath.Glob(filepath.Join(dir, "workbuddy-*.json")) + if err != nil || len(files) == 0 { + fmt.Fprintf(os.Stderr, "no auth files in %s\n", dir) + os.Exit(1) + } + sort.Strings(files) + up := upstream.New() + + var rows []row + okN, alreadyN, failN := 0, 0, 0 + for _, f := range files { + r := row{file: filepath.Base(f)} + raw, err := os.ReadFile(f) + if err != nil { + r.status, r.detail = "LOAD_ERR", err.Error() + rows = append(rows, r) + failN++ + continue + } + a, err := auth.Parse(raw) + if err != nil { + r.status, r.detail = "LOAD_ERR", err.Error() + rows = append(rows, r) + failN++ + continue + } + a.FilePath = f + r.uid, r.nick = a.UID, a.Nickname + + // refresh 过期 token + if a.NeedsRefresh(2 * time.Hour) { + if err := up.RefreshTokenIfNeeded(a, 2*time.Hour); err != nil { + if ue, ok := err.(*upstream.Error); ok && ue.Kind == upstream.ErrSessionDead { + r.status = "AUTH_INVALID" + } else { + r.status = "FAIL" + } + r.detail = "refresh: " + short(err.Error()) + rows = append(rows, r) + failN++ + continue + } + // refresh 后写回文件(权限问题已修复);落盘失败必须暴露,否则重启回旧 token + if err := a.SaveAtomicRetry(); err != nil { + log.Printf("signin %s save: %v", a.UID, err) + } + } + + err = up.DailyCheckin(a) + switch { + case err == nil: + r.status = "OK" + okN++ + default: + // DailyCheckin 已签到返回 code!=0 错误 + if isAlready(err.Error()) { + r.status = "ALREADY" + r.detail = short(err.Error()) + alreadyN++ + } else { + r.status = "FAIL" + r.detail = short(err.Error()) + failN++ + } + } + // 顺手查余额 + if remain, _, qerr := up.UserResource(a); qerr == nil { + r.remain, r.hasQuota = remain, true + } + rows = append(rows, r) + } + + // 报告 + fmt.Printf("uid | nick | status | remain | detail\n") + fmt.Printf("-------------------------------------+-------------+--------------+--------+------------------------------\n") + for _, r := range rows { + remain := "-" + if r.hasQuota { + remain = fmt.Sprintf("%d", r.remain) + } + fmt.Printf("%-36s | %-11s | %-12s | %-6s | %s\n", + trunc(r.uid, 36), trunc(r.nick, 11), r.status, remain, r.detail) + } + fmt.Printf("\ntotal=%d ok=%d already=%d fail=%d\n", len(rows), okN, alreadyN, failN) +} + +// isAlready 已签到幂等判定。判据必须窄:上游业务错误统一是 HTTP 400 + code=%d +// msg=%s——早期版本宽匹配 "code=400" 甚至裸 "checkin",任何 400(参数缺失/风控/ +// 活动未开启)都会被误判成 ALREADY,把真实失败静默掩盖成「已签到」。实测幂等码 +// 是 code=10001(「今天已签到」),与文案判定并列兜底。 +func isAlready(msg string) bool { + s := strings.ToLower(msg) + return strings.Contains(s, "已签到") || + strings.Contains(s, "already") || + strings.Contains(s, "code=10001") +} + +func trunc(s string, n int) string { + if len(s) > n { + return s[:n] + } + return s +} + +func short(s string) string { + s = strings.ReplaceAll(s, "\n", " ") + if len(s) > 60 { + return s[:60] + } + return s +} diff --git a/cmd/signin/main_test.go b/cmd/signin/main_test.go new file mode 100644 index 0000000000000000000000000000000000000000..c4f721b5efff2cd5e103e16054b03e5e0cf188ae --- /dev/null +++ b/cmd/signin/main_test.go @@ -0,0 +1,31 @@ +package main + +import "testing" + +// TestIsAlreadyNarrowMatching 已签到判定必须窄匹配:上游业务错误统一是 +// HTTP 400 + code=%d,宽匹配 code=400 / 裸 "checkin" 会把参数缺失、风控、 +// 「活动未开启」等真实失败全部误判成 ALREADY,静默掩盖失败。 +func TestIsAlreadyNarrowMatching(t *testing.T) { + already := []string{ + "upstream error: code=10001 今天已签到", + "code=10001 msg=already checked in today", + "今日已签到,明天再来吧", + "already claimed", + } + for _, m := range already { + if !isAlready(m) { + t.Errorf("isAlready(%q) = false, want true", m) + } + } + failures := []string{ + "upstream error: code=400 msg=活动未开启", // 400 但非幂等码 + "upstream error: code=400 msg=request illegal", // 风控/参数错误 + "checkin activity not started", // 裸 checkin 字样不再误判 + "http 500", + } + for _, m := range failures { + if isAlready(m) { + t.Errorf("isAlready(%q) = true, want false(真实失败被误判成已签到)", m) + } + } +} diff --git a/cmd/sync/main.go b/cmd/sync/main.go index 760be2578fea83b848ab5c450f6d079808c9bdfb..f798cf490c1edff69998f324056939f9dcfa4603 100644 --- a/cmd/sync/main.go +++ b/cmd/sync/main.go @@ -25,7 +25,7 @@ import ( "syscall" "time" - "github.com/linguo2625469/workbuddy2api-panel/internal/syncer" + "github.com/misakano7545/workbuddy2api-panel/internal/syncer" ) // 退出码:0 一切就绪/已对齐;1 出错;2 有差异但未应用(status 模式,供脚本判分支)。 diff --git a/cmd/trial/classify_test.go b/cmd/trial/classify_test.go new file mode 100644 index 0000000000000000000000000000000000000000..5dbb45d9ad0171302cb97a7d585ca9f83cdb3cd0 --- /dev/null +++ b/cmd/trial/classify_test.go @@ -0,0 +1,21 @@ +package main + +import ( + "errors" + "testing" +) + +// TestClassifyTrial 领取结果三态分类(纯函数,注释一直声称「供测试直接断言」, +// 此前没有这个测试)。 +func TestClassifyTrial(t *testing.T) { + if st, msg := classifyTrial(true, nil); st != trialOK || msg != "trial granted" { + t.Errorf("claimed: %q %q", st, msg) + } + if st, _ := classifyTrial(false, nil); st != trialAlready { + t.Errorf("idempotent: %q", st) + } + wrapped := errors.New("code=14051 already claimed") + if st, msg := classifyTrial(false, wrapped); st != trialFailed || msg != wrapped.Error() { + t.Errorf("error: %q %q", st, msg) + } +} diff --git a/cmd/trial/main.go b/cmd/trial/main.go index 10aaf9370e77b55121efc09ae0252a759be1f95e..2e11737edc3ce7c0e0cd753427113087918808f1 100644 --- a/cmd/trial/main.go +++ b/cmd/trial/main.go @@ -1,133 +1,133 @@ -// trial 一次性批量领取 global trial 加油包:遍历 auths 下全部账号, -// 仅对 global 账号执行 /billing/ide/trial(CN 无此端点,明确提示不适用)。 -// -// 用法: -// -// # 本地:在项目根目录(需 config.json + auths/ + data/)直接 run -// go run ./cmd/trial -// -// # 容器内:先 cp 进去再 exec -// docker cp trial workbuddy2api:/tmp/trial -// docker exec -w /app workbuddy2api /tmp/trial -// -// 结果逐账号输出到 stdout: -// -// uid | nick | status | detail -// ----+------+--------+------- -// ... | GLOBAL | OK | trial granted -// ... | GLOBAL | ALREADY | 已领取过(幂等,不算失败) -// ... | CN | N/A | not applicable -package main - -import ( - "fmt" - "os" - "path/filepath" - "sort" - - "github.com/linguo2625469/workbuddy2api-panel/internal/auth" - "github.com/linguo2625469/workbuddy2api-panel/internal/upstream" -) - -// classifyTrial 归一化 ClaimTrial 结果(纯函数,供 main 循环与测试直接断言): -// err → FAIL;claimed → OK;否则(幂等码已领)→ ALREADY。 -func classifyTrial(claimed bool, err error) (trialStatus, string) { - switch { - case err != nil: - return trialFailed, err.Error() - case claimed: - return trialOK, "trial granted" - default: - return trialAlready, "already claimed (idempotent)" - } -} - -// trialStatus 单账号 trial 领取结果状态。 -type trialStatus string - -const ( - trialOK trialStatus = "OK" - trialAlready trialStatus = "ALREADY" - trialNotApp trialStatus = "N/A" // CN 账号不适用 - trialFailed trialStatus = "FAIL" -) - -type trialRow struct { - uid string - nick string - status trialStatus - detail string -} - -func main() { - authDir := "auths" - if len(os.Args) > 1 { - authDir = os.Args[1] - } - files, err := filepath.Glob(filepath.Join(authDir, "workbuddy-*.json")) - if err != nil || len(files) == 0 { - fmt.Fprintf(os.Stderr, "no auth files in %s\n", authDir) - os.Exit(1) - } - sort.Strings(files) - - up := upstream.New() - // trial 是 global 专属端点:必须开启 global realm 路由,否则 upstream.New() 的 - // GlobalEnabled 零值 false 会把请求路由到 CN base(codebuddy.cn)而必然失败。 - up.GlobalEnabled = true - var rows []trialRow - for _, f := range files { - r := trialRow{uid: filepath.Base(f)} - raw, err := os.ReadFile(f) - if err != nil { - r.status, r.detail = trialFailed, "load: "+err.Error() - rows = append(rows, r) - continue - } - a, err := auth.Parse(raw) - if err != nil { - r.status, r.detail = trialFailed, "parse: "+err.Error() - rows = append(rows, r) - continue - } - a.FilePath = f - r.uid, r.nick = a.UID, a.Nickname - - // 仅 global 账号适用:CN 明确提示不适用,不发任何请求。 - if !a.IsGlobal() { - r.status, r.detail = trialNotApp, "CN account not applicable" - rows = append(rows, r) - continue - } - - r.status, r.detail = classifyTrial(up.ClaimTrial(a)) - rows = append(rows, r) - } - - var okN, alreadyN, notAppN, failN int - fmt.Printf("uid | nick | status | detail\n") - fmt.Printf("-------------------------------------+-------------+---------+------------------------------\n") - for _, r := range rows { - fmt.Printf("%-36s | %-11s | %-7s | %s\n", - trunc(r.uid, 36), trunc(r.nick, 11), r.status, r.detail) - switch r.status { - case trialOK: - okN++ - case trialAlready: - alreadyN++ - case trialNotApp: - notAppN++ - default: - failN++ - } - } - fmt.Printf("\ntotal=%d ok=%d already=%d na=%d fail=%d\n", - len(rows), okN, alreadyN, notAppN, failN) -} - -func trunc(s string, n int) string { - if len(s) > n { - return s[:n] - } - return s -} +// trial 一次性批量领取 global trial 加油包:遍历 auths 下全部账号, +// 仅对 global 账号执行 /billing/ide/trial(CN 无此端点,明确提示不适用)。 +// +// 用法: +// +// # 本地:在项目根目录(需 config.json + auths/ + data/)直接 run +// go run ./cmd/trial +// +// # 容器内:先 cp 进去再 exec +// docker cp trial workbuddy2api:/tmp/trial +// docker exec -w /app workbuddy2api /tmp/trial +// +// 结果逐账号输出到 stdout: +// +// uid | nick | status | detail +// ----+------+--------+------- +// ... | GLOBAL | OK | trial granted +// ... | GLOBAL | ALREADY | 已领取过(幂等,不算失败) +// ... | CN | N/A | not applicable +package main + +import ( + "fmt" + "os" + "path/filepath" + "sort" + + "github.com/misakano7545/workbuddy2api-panel/internal/auth" + "github.com/misakano7545/workbuddy2api-panel/internal/upstream" +) + +// classifyTrial 归一化 ClaimTrial 结果(纯函数,供 main 循环与测试直接断言): +// err → FAIL;claimed → OK;否则(幂等码已领)→ ALREADY。 +func classifyTrial(claimed bool, err error) (trialStatus, string) { + switch { + case err != nil: + return trialFailed, err.Error() + case claimed: + return trialOK, "trial granted" + default: + return trialAlready, "already claimed (idempotent)" + } +} + +// trialStatus 单账号 trial 领取结果状态。 +type trialStatus string + +const ( + trialOK trialStatus = "OK" + trialAlready trialStatus = "ALREADY" + trialNotApp trialStatus = "N/A" // CN 账号不适用 + trialFailed trialStatus = "FAIL" +) + +type trialRow struct { + uid string + nick string + status trialStatus + detail string +} + +func main() { + authDir := "auths" + if len(os.Args) > 1 { + authDir = os.Args[1] + } + files, err := filepath.Glob(filepath.Join(authDir, "workbuddy-*.json")) + if err != nil || len(files) == 0 { + fmt.Fprintf(os.Stderr, "no auth files in %s\n", authDir) + os.Exit(1) + } + sort.Strings(files) + + up := upstream.New() + // trial 是 global 专属端点:必须开启 global realm 路由,否则 upstream.New() 的 + // GlobalEnabled 零值 false 会把请求路由到 CN base(codebuddy.cn)而必然失败。 + up.GlobalEnabled = true + var rows []trialRow + for _, f := range files { + r := trialRow{uid: filepath.Base(f)} + raw, err := os.ReadFile(f) + if err != nil { + r.status, r.detail = trialFailed, "load: "+err.Error() + rows = append(rows, r) + continue + } + a, err := auth.Parse(raw) + if err != nil { + r.status, r.detail = trialFailed, "parse: "+err.Error() + rows = append(rows, r) + continue + } + a.FilePath = f + r.uid, r.nick = a.UID, a.Nickname + + // 仅 global 账号适用:CN 明确提示不适用,不发任何请求。 + if !a.IsGlobal() { + r.status, r.detail = trialNotApp, "CN account not applicable" + rows = append(rows, r) + continue + } + + r.status, r.detail = classifyTrial(up.ClaimTrial(a)) + rows = append(rows, r) + } + + var okN, alreadyN, notAppN, failN int + fmt.Printf("uid | nick | status | detail\n") + fmt.Printf("-------------------------------------+-------------+---------+------------------------------\n") + for _, r := range rows { + fmt.Printf("%-36s | %-11s | %-7s | %s\n", + trunc(r.uid, 36), trunc(r.nick, 11), r.status, r.detail) + switch r.status { + case trialOK: + okN++ + case trialAlready: + alreadyN++ + case trialNotApp: + notAppN++ + default: + failN++ + } + } + fmt.Printf("\ntotal=%d ok=%d already=%d na=%d fail=%d\n", + len(rows), okN, alreadyN, notAppN, failN) +} + +func trunc(s string, n int) string { + if len(s) > n { + return s[:n] + } + return s +} diff --git a/config.default.json b/config.default.json index c2163f4a3603302ca056676d726b146930b4763c..a3246c84c8605e17ac61c8f8e8f1ebc43e90bd14 100644 --- a/config.default.json +++ b/config.default.json @@ -1,102 +1,154 @@ -{ - "listen": ":7861", - "api_key": "", - "auth_dir": "/app/storage/auths", - "state_file": "/app/storage/data/state.json", - "server": { - "read_timeout": "300s" - }, - "panel": { - "package_detail_limit": 5 - }, - "logging": { - "request_archive_enabled": true, - "request_retention_days": 7, - "request_archive_max_mb": 100, - "request_client_info": true - }, - "cooldown": { - "soft_rate": "600s", - "soft_rate_max": "2h" - }, - "schedule": { - "checkin_hours": [ - 9, - 21 - ], - "travel_hours": [ - 9, - 21 - ], - "activity_hours": [ - 10 - ], - "keepalive_hours": [ - 22 - ], - "blackcat_hours": [ - 23 - ], - "growth_hours": [ - 1 - ], - "checkin_enabled": true, - "travel_enabled": true, - "activity_enabled": true, - "keepalive_enabled": true, - "blackcat_enabled": true, - "growth_enabled": true, - "balance_refresh_enabled": true, - "balance_refresh_minutes": 5, - "include_disabled_in_tasks": false - }, - "global": { - "enabled": true, - "chat_base": "", - "billing_base": "" - }, - "upstream": { - "timeout_seconds": 120, - "header_timeout_seconds": 120, - "idle_timeout_seconds": 300, - "user_agent": "", - "client_version": "", - "cli_version": "", - "client_name": "", - "device_token": "", - "device_token_file": "", - "passthrough_ip": false - }, - "features": { - "sanitize_blacklist_fingerprints": true - }, - "prompt": { - "mode": "passthrough", - "file": "" - }, - "upstash": { - "url": "", - "token": "" - }, - "pool": { - "max_in_flight": 3, - "max_in_flight_global": 2, - "breaker_threshold": 3, - "breaker_cooldown": "30m", - "breaker_cooldown_max": "6h", - "degrade_threshold": 5, - "degrade_cooldown": "10m", - "degrade_cooldown_max": "2h", - "idle_weight_per_hour": 0.5, - "idle_weight_max": 5, - "prefer_expiring": true, - "expiring_soon": "168h", - "cost_explore_interval": "30m", - "credit_floor": 0 - }, - "session_sticky": { - "enabled": true, - "ttl": "30m", - "gc_interval": "5m" - } -} +{ + "listen": ":7861", + "api_key": "", + "auth_dir": "/app/storage/auths", + "state_file": "/app/storage/data/state.json", + "dns_servers": [], + "server": { + "read_timeout": "300s" + }, + "panel": { + "package_detail_limit": 5 + }, + "logging": { + "request_archive_enabled": true, + "request_retention_days": 7, + "request_archive_max_mb": 100, + "request_client_info": true + }, + "cooldown": { + "soft_rate": "600s", + "soft_rate_max": "2h" + }, + "schedule": { + "checkin_hours": [ + 9, + 21 + ], + "travel_hours": [ + 9, + 21 + ], + "activity_hours": [ + 10 + ], + "keepalive_hours": [ + 22 + ], + "keepalive_refresh_window": "168h", + "growth_hours": [ + 11 + ], + "checkin_enabled": true, + "travel_enabled": true, + "activity_enabled": true, + "keepalive_enabled": true, + "growth_enabled": true, + "growth_concurrency": 1, + "jitter_minutes": 0, + "account_spread_minutes": 0, + "account_spread_min_gap_seconds": 0, + "balance_refresh_enabled": true, + "balance_refresh_minutes": 5, + "include_disabled_in_tasks": false + }, + "global": { + "enabled": true, + "chat_base": "", + "billing_base": "" + }, + "cn": { + "chat_base": "" + }, + "upstream": { + "timeout_seconds": 120, + "header_timeout_seconds": 120, + "idle_timeout_seconds": 300, + "user_agent": "", + "client_version": "", + "cli_version": "", + "client_name": "", + "device_token": "", + "device_token_file": "", + "passthrough_ip": false, + "dump_dir": "", + "dump_max_bytes": 0 + }, + "features": { + "sanitize_blacklist_fingerprints": true, + "sanitize_brand_scope": "all" + }, + "models": { + "_comment": "hidden: 不对外暴露的模型黑名单。裸名=两域都藏;\"cn:xxx\"/\"global:xxx\"=只藏该域。/v1/models 列表过滤 + chat 点名拒绝,面板保存后热生效。", + "hidden": [] + }, + "prompt": { + "mode": "passthrough", + "file": "" + }, + "upstash": { + "url": "", + "token": "" + }, + "pool": { + "max_in_flight": 3, + "max_in_flight_global": 2, + "breaker_threshold": 3, + "breaker_cooldown": "30m", + "breaker_cooldown_max": "6h", + "degrade_threshold": 5, + "degrade_cooldown": "10m", + "degrade_cooldown_max": "2h", + "idle_weight_per_hour": 0.5, + "idle_weight_max": 5.0, + "prefer_expiring": true, + "expiring_soon": "168h", + "account_priority": {}, + "account_share": {}, + "cost_explore_interval": "30m", + "credit_floor": 0, + "reserve_credits": 10, + "model_fallback": {} + }, + "session_sticky": { + "enabled": true, + "ttl": "30m", + "gc_interval": "5m" + }, + "admin": { + "enabled": false, + "audit_enabled": false, + "audit_file": "./data/admin_audit.log" + }, + "metrics": { + "enabled": false + }, + "budget": { + "daily_credit_limit": 0, + "burst_credit_limit": 0, + "cache_low_rate": 0 + }, + "alerting": { + "enabled": false, + "webhook_url": "", + "min_healthy_cn": 1, + "min_healthy_global": 0 + }, + "sync": { + "bucket": "", + "token": "", + "token_file": "", + "endpoint": "https://huggingface.co", + "auth_dir": "", + "data_dir": "", + "include_data": [], + "writer": "auto", + "hf_bin": "hf", + "relay_url": "", + "relay_key": "", + "restart_space": "", + "ca_bundle": "", + "timeout": "60s", + "insecure_skip_verify": false + } +} diff --git a/config.example.json b/config.example.json index 1324486909af0e331e0c377bd99d31439163f17f..f6fb0c34f0d8ea8d74458df4d966ec7ef56abfa6 100644 --- a/config.example.json +++ b/config.example.json @@ -1,105 +1,206 @@ -{ - "listen": ":7863", - "api_key": "test_key", - "auth_dir": "./auths", - "state_file": "./data/state.json", - "server": { - "read_timeout": "300s" - }, - "panel": { - "package_detail_limit": 5 - }, - "logging": { - "request_archive_enabled": true, - "request_retention_days": 7, - "request_archive_max_mb": 100, - "request_client_info": true - }, - "cooldown": { - "soft_rate": "600s", - "soft_rate_max": "2h" - }, - "schedule": { - "checkin_hours": [9, 21], - "growth_hours": [1], - "travel_hours": [9, 21], - "activity_hours": [10], - "keepalive_hours": [22], - "blackcat_hours": [23], - "checkin_enabled": true, - "growth_enabled": true, - "travel_enabled": true, - "activity_enabled": true, - "keepalive_enabled": true, - "blackcat_enabled": true, - "balance_refresh_enabled": true, - "balance_refresh_minutes": 5, - "include_disabled_in_tasks": false - }, - "global": { - "enabled": true, - "chat_base": "", - "billing_base": "" - }, - "upstream": { - "timeout_seconds": 120, - "header_timeout_seconds": 120, - "idle_timeout_seconds": 300, - "user_agent": "", - "client_version": "", - "cli_version": "", - "client_name": "", - "device_token": "", - "device_token_file": "", - "passthrough_ip": false - }, - "features": { - "sanitize_blacklist_fingerprints": true - }, - "prompt": { - "mode": "passthrough", - "file": "" - }, - "upstash": { - "url": "", - "token": "" - }, - "pool": { - "max_in_flight": 3, - "max_in_flight_global": 2, - "breaker_threshold": 3, - "breaker_cooldown": "30m", - "breaker_cooldown_max": "6h", - "degrade_threshold": 5, - "degrade_cooldown": "10m", - "degrade_cooldown_max": "2h", - "idle_weight_per_hour": 0.5, - "idle_weight_max": 5.0, - "prefer_expiring": true, - "expiring_soon": "168h", - "cost_explore_interval": "30m", - "credit_floor": 100 - }, - "session_sticky": { - "enabled": true, - "ttl": "30m", - "gc_interval": "5m" - }, - "sync": { - "bucket": "", - "token": "", - "token_file": "", - "endpoint": "https://huggingface.co", - "auth_dir": "", - "data_dir": "", - "include_data": [], - "writer": "auto", - "hf_bin": "hf", - "relay_url": "", - "relay_key": "", - "restart_space": "", - "ca_bundle": "", - "timeout": "60s", - "insecure_skip_verify": false - } -} +{ + "listen": "127.0.0.1:7863", + "api_key": "test_key", + "auth_dir": "./auths", + "state_file": "./data/state.json", + "dns_servers": [], + "server": { + "read_timeout": "300s", + "shutdown_timeout": "30s", + "max_payload_bytes": 67108864 + }, + "panel": { + "package_detail_limit": 5, + "poll_interval_sec": 0 + }, + "update": { + "auto_enabled": false, + "auto_time": "04:00", + "_proxy_comment": "更新走哪个出口(issue #198)。空 = 不显式设置。支持 http:// https:// socks5://。典型场景:api.github.com 通、但 release-assets.githubusercontent.com 被出站拦住(群晖/NAS/内网),此时填 socks5://127.0.0.1:1080 之类即可。可热生效,不用重启。", + "proxy": "", + "_proxy_from_env_comment": "是否沿用进程环境变量里的 HTTP_PROXY/HTTPS_PROXY(缺省 true,保持历史行为)。显式 false 则完全不读环境,只认上面的 proxy。", + "proxy_from_env": true, + "_mirror_comment": "资产下载镜像前缀(issue #198),如 https://ghfast.top/ 。只作用于资产下载:Release 元数据(tag/digest/size)永远直连 api.github.com,落盘后照旧校验 sha256——镜像只能搬字节,改不了「应该是什么」。空 = 直连。", + "mirror": "" + }, + "accounts": { + "_comment": "账号目录热重载(issue #199):外部脚本/另一台机器往 auths/ 同步文件,不必重启进程即可入池;删文件在连续 N 次扫描确认后出池。", + "reload_interval": "10s", + "_reload_interval_comment": "轮询间隔;\"0s\" = 关闭轮询(手动接口 POST /panel/api/accounts/reload 仍可用)。", + "reload_delete_confirm": 2, + "_reload_delete_confirm_comment": "文件消失后要连续几轮扫描确认才移出账号池。半写文件、临时移走文件都只让账号「这一轮看不见」;剔除会写进 state.json 且下次启动不复活,所以要连续确认。1 = 立即删(不建议)。" + }, + "logging": { + "request_archive_enabled": true, + "request_retention_days": 7, + "request_archive_max_mb": 100, + "request_client_info": true, + "request_archive_context": false, + "panel_log_enabled": true, + "panel_log_retention_days": 7, + "panel_log_max_mb": 50 + }, + "cooldown": { + "soft_rate": "600s", + "soft_rate_max": "2h" + }, + "schedule": { + "checkin_hours": [ + 9, + 21 + ], + "travel_hours": [ + 9, + 21 + ], + "activity_hours": [ + 10 + ], + "web_activity_enabled": false, + "keepalive_hours": [ + 22 + ], + "keepalive_refresh_window": "168h", + "growth_hours": [ + 11 + ], + "checkin_enabled": true, + "travel_enabled": true, + "activity_enabled": true, + "keepalive_enabled": true, + "growth_enabled": true, + "growth_concurrency": 1, + "jitter_minutes": 0, + "account_spread_minutes": 0, + "account_spread_min_gap_seconds": 0, + "balance_refresh_enabled": true, + "balance_refresh_minutes": 5, + "include_disabled_in_tasks": false, + "balance_refresh_jitter_permill": 0, + "task_sweep_jitter_permill": 0, + "makeup_cards_per_round": 0, + "window_probe_enabled": true + }, + "global": { + "enabled": true, + "chat_base": "", + "billing_base": "" + }, + "cn": { + "chat_base": "" + }, + "upstream": { + "timeout_seconds": 120, + "tls_fingerprint": "node", + "header_timeout_seconds": 120, + "idle_timeout_seconds": 300, + "user_agent": "", + "client_version": "", + "cli_version": "", + "client_name": "", + "device_token": "", + "device_token_file": "", + "passthrough_ip": false, + "dump_dir": "", + "dump_max_bytes": 0, + "restriction_hold_seconds": 1800 + }, + "features": { + "sanitize_blacklist_fingerprints": true, + "sanitize_brand_scope": "all", + "embeddings_enabled": false, + "busy_retry": true, + "busy_wait_seconds": 60, + "watermark_strip_enabled": false + }, + "models": { + "_comment": "hidden: 不对外暴露的模型黑名单。裸名=两域都藏;\"cn:xxx\"/\"global:xxx\"=只藏该域。/v1/models 列表过滤 + chat 点名拒绝,面板保存后热生效。allowed: 模型白名单(issue #68),条目语法同 hidden;空数组 = 不启用(默认放行全部);非空时仅白名单内模型可列出与调用,与 hidden 共存取交集。", + "hidden": [], + "allowed": [] + }, + "thinking": { + "_comment": "网关思考档位策略。enabled=false 完全不碰档位;client_priority=true 客户端优先:客户端传了档位就照单全收(含关闭思考),只在缺档时补 default_effort;false 网关优先,按 override_scope 改写客户端档位(level=只改档位、尊重客户端关闭思考;all=连关闭也改写为开启)。default_effort 缺省 high:max 取模型支持的最高档,但思考与正文共用一份输出额度,max 会把预算烧在思考上、正文只剩半句(实测 max 正文 1906 token vs high 3236 token),只有确实要最深推理时才改回 max。也可写 xhigh/medium/low/minimal(模型不支持时落到不高于它的最高支持档)。model_defaults 按模型覆盖目标档:\"cn:xxx\"/\"global:xxx\" 精确到域,裸名两域共用;\"inherit\" 表示不覆盖。面板「模型与档位」页每行的「网关档位」下拉直接写本表(域精确键),配置页仅保留总开关与优先级三选一;保存后热生效。", + "enabled": true, + "default_effort": "high", + "client_priority": true, + "override_scope": "level", + "model_defaults": {} + }, + "prompt": { + "mode": "passthrough", + "file": "", + "keep_recent_rounds": 0 + }, + "upstash": { + "url": "", + "token": "" + }, + "pool": { + "max_in_flight": 3, + "max_in_flight_global": 2, + "breaker_threshold": 3, + "breaker_cooldown": "30m", + "breaker_cooldown_max": "6h", + "degrade_threshold": 5, + "degrade_cooldown": "10m", + "degrade_cooldown_max": "2h", + "selection_strategy": "weighted", + "idle_weight_per_hour": 0.5, + "idle_weight_max": 5.0, + "prefer_expiring": true, + "expiring_soon": "168h", + "account_priority": {}, + "account_share": {}, + "cost_explore_interval": "30m", + "balance_window": "1h", + "credit_floor": 100, + "reserve_credits": 10, + "model_fallback": {} + }, + "session_sticky": { + "enabled": true, + "ttl": "30m", + "gc_interval": "5m" + }, + "admin": { + "enabled": false, + "audit_enabled": false, + "audit_file": "./data/admin_audit.log" + }, + "metrics": { + "enabled": false + }, + "budget": { + "daily_credit_limit": 0, + "burst_credit_limit": 0, + "cache_low_rate": 0 + }, + "alerting": { + "enabled": false, + "webhook_url": "", + "min_healthy_cn": 1, + "min_healthy_global": 0 + }, + "watchdog": { + "_comment": "上游目录改版监控:定期对 /v1/models 结果取指纹,模型新增/下线或能力字段变动时经 alerting.webhook_url 通知。默认关闭——只在想第一时间知道上游改了目录时开。", + "enabled": false, + "interval_seconds": 3600 + }, + "sync": { + "bucket": "", + "token": "", + "token_file": "", + "endpoint": "https://huggingface.co", + "auth_dir": "", + "data_dir": "", + "include_data": [], + "writer": "auto", + "hf_bin": "hf", + "relay_url": "", + "relay_key": "", + "restart_space": "", + "ca_bundle": "", + "timeout": "60s", + "insecure_skip_verify": false + } +} diff --git a/credit.sh b/credit.sh old mode 100644 new mode 100755 index a1fddf5983568f1c93e234bfc64cc4ef49b6cdd4..ae0e085ceab21398e110fb317c3e6dbbd59be704 --- a/credit.sh +++ b/credit.sh @@ -1,14 +1,14 @@ -#!/usr/bin/env bash -# credit.sh — WorkBuddy 积分日报(默认美化输出) -# -# 用法: -# ./credit.sh # 人类可读日报 -# ./credit.sh -json # 原始 JSON -# -# 二进制升级: go build -o credit ./cmd/credit -set -euo pipefail -cd "$(dirname "$0")" -if [[ "${1:-}" == "-json" ]]; then - exec ./credit -fi -exec ./credit -pretty +#!/usr/bin/env bash +# credit.sh — WorkBuddy 积分日报(默认美化输出) +# +# 用法: +# ./credit.sh # 人类可读日报 +# ./credit.sh -json # 原始 JSON +# +# 二进制升级: go build -o credit ./cmd/credit +set -euo pipefail +cd "$(dirname "$0")" +if [[ "${1:-}" == "-json" ]]; then + exec ./credit +fi +exec ./credit -pretty diff --git a/docker-compose.yml b/docker-compose.yml index 33c59f221337e292529705d0dd7dc79873a32aa7..d60ba24a77c723a9738a01add4f83d48248d8490 100644 --- a/docker-compose.yml +++ b/docker-compose.yml @@ -1,15 +1,15 @@ -# 本地 / 自建服务器跑法(不用 HF 时)。HF Spaces 上不需要这个文件。 -services: - wb2api: - build: . - container_name: workbuddy2api - restart: unless-stopped - environment: - - TZ=Asia/Shanghai - ports: - - "7861:7861" - volumes: - # 一个目录装下全部持久化状态,和 HF 上挂桶的布局保持一致: - # storage/config.json、storage/auths/、storage/data/ - - ./storage:/app/storage - - ./storage/config.json:/app/config.json +# 本地 / 自建服务器跑法(不用 HF 时)。HF Spaces 上不需要这个文件。 +services: + wb2api: + build: . + container_name: workbuddy2api + restart: unless-stopped + environment: + - TZ=Asia/Shanghai + ports: + - "7861:7861" + volumes: + # 一个目录装下全部持久化状态,和 HF 上挂桶的布局保持一致: + # storage/config.json、storage/auths/、storage/data/ + - ./storage:/app/storage + - ./storage/config.json:/app/config.json diff --git a/docker-entrypoint.sh b/docker-entrypoint.sh index 1066b545a135ed102638988a7541ffb0d24e133c..589dec2d80eea3a94a9dcac688b1d1d550e6758f 100644 --- a/docker-entrypoint.sh +++ b/docker-entrypoint.sh @@ -1,69 +1,70 @@ -#!/bin/sh -# WorkBuddy2API Panel — Hugging Face Spaces 入口脚本 -# -# 持久化模型: -# HF Storage Bucket(私有) -> 挂载到容器 /app/storage -# /app/storage/config.json 运行配置(含 api_key,私有卷上,不进公开仓库) -# /app/storage/auths/*.json 账号凭证 -# /app/storage/data/*.json 水位/用量/模型探测/请求归档 -# -# 容器根文件系统是 ephemeral 的:重启、休眠唤醒、重新构建都会重置。 -# 所以配置和账号必须待在卷上,否则每次重启都要重新登录账号。 -set -eu - -PERSIST="${WB2A_PERSIST_DIR:-/app/storage}" -TEMPLATE=/app/config.json -CFG="$TEMPLATE" - -echo "[entrypoint] boot at $(date -u '+%Y-%m-%dT%H:%M:%SZ')" - -if [ -d "$PERSIST" ]; then - echo "[entrypoint] persistent volume detected at $PERSIST" - mkdir -p "$PERSIST/auths" "$PERSIST/data" - - # 落盘自检:程序全部走「写 .tmp 再 rename」,rename 不可用的话持久化是假的 - if echo probe > "$PERSIST/.wb2a-write-probe" 2>/dev/null \ - && mv "$PERSIST/.wb2a-write-probe" "$PERSIST/.wb2a-rename-probe" 2>/dev/null \ - && rm -f "$PERSIST/.wb2a-rename-probe"; then - echo "[entrypoint] storage self-test: write+rename OK" - else - echo "[entrypoint] storage self-test: FAILED — write or rename unsupported on $PERSIST" >&2 - rm -f "$PERSIST/.wb2a-write-probe" "$PERSIST/.wb2a-rename-probe" 2>/dev/null || true - fi - - if [ ! -f "$PERSIST/config.json" ]; then - if [ -f "$TEMPLATE" ]; then - echo "[entrypoint] no config.json on the volume -> seeding from image template" - cp "$TEMPLATE" "$PERSIST/config.json" - else - echo "[entrypoint] no config.json on the volume and no image template" >&2 - fi - fi - [ -f "$PERSIST/config.json" ] && CFG="$PERSIST/config.json" -else - echo "[entrypoint] WARNING: no persistent volume at $PERSIST — everything written will be LOST on restart" >&2 - mkdir -p /app/auths /app/data -fi - -# 安全闸门:api_key 为空 == 完全不鉴权(httpauth.VerifyBearer 语义)。 -# 空间是公网可达的,绝不允许以裸奔状态启动。 -if [ -n "${WB2A_API_KEY:-}" ]; then - echo "[entrypoint] api_key supplied via WB2A_API_KEY env" -else - KEY=$(python3 -c 'import json,sys -try: - print(json.load(open(sys.argv[1])).get("api_key") or "") -except Exception: - print("")' "$CFG" 2>/dev/null || true) - if [ -z "$KEY" ]; then - echo "[entrypoint] FATAL: api_key is empty in $CFG and WB2A_API_KEY is not set." >&2 - echo "[entrypoint] Refusing to start: an empty api_key disables authentication on a public Space." >&2 - echo "[entrypoint] Fix: write a config.json containing an api_key onto the bucket, or set the WB2A_API_KEY secret." >&2 - exit 1 - fi - echo "[entrypoint] api_key loaded from config file" -fi - -echo "[entrypoint] config: $CFG" -echo "[entrypoint] auth_dir: $(dirname "$CFG")/auths (see config)" -exec /app/wb2api -config "$CFG" +#!/bin/sh +# WorkBuddy2API Panel — Hugging Face Spaces 入口脚本 +# +# 持久化模型: +# HF Storage Bucket(私有) -> 挂载到容器 /app/storage +# /app/storage/config.json 运行配置(含 api_key,私有卷上,不进公开仓库) +# /app/storage/auths/*.json 账号凭证 +# /app/storage/data/*.json 水位/用量/模型探测/请求归档 +# /app/storage/data/extensions.json 免费模型 / 自定义模型 / 访问密钥 +# +# 容器根文件系统是 ephemeral 的:重启、休眠唤醒、重新构建都会重置。 +# 所以配置和账号必须待在卷上,否则每次重启都要重新登录账号。 +set -eu + +PERSIST="${WB2A_PERSIST_DIR:-/app/storage}" +TEMPLATE=/app/config.json +CFG="$TEMPLATE" + +echo "[entrypoint] boot at $(date -u '+%Y-%m-%dT%H:%M:%SZ')" + +if [ -d "$PERSIST" ]; then + echo "[entrypoint] persistent volume detected at $PERSIST" + mkdir -p "$PERSIST/auths" "$PERSIST/data" + + # 落盘自检:程序全部走「写 .tmp 再 rename」,rename 不可用的话持久化是假的 + if echo probe > "$PERSIST/.wb2a-write-probe" 2>/dev/null \ + && mv "$PERSIST/.wb2a-write-probe" "$PERSIST/.wb2a-rename-probe" 2>/dev/null \ + && rm -f "$PERSIST/.wb2a-rename-probe"; then + echo "[entrypoint] storage self-test: write+rename OK" + else + echo "[entrypoint] storage self-test: FAILED — write or rename unsupported on $PERSIST" >&2 + rm -f "$PERSIST/.wb2a-write-probe" "$PERSIST/.wb2a-rename-probe" 2>/dev/null || true + fi + + if [ ! -f "$PERSIST/config.json" ]; then + if [ -f "$TEMPLATE" ]; then + echo "[entrypoint] no config.json on the volume -> seeding from image template" + cp "$TEMPLATE" "$PERSIST/config.json" + else + echo "[entrypoint] no config.json on the volume and no image template" >&2 + fi + fi + [ -f "$PERSIST/config.json" ] && CFG="$PERSIST/config.json" +else + echo "[entrypoint] WARNING: no persistent volume at $PERSIST — everything written will be LOST on restart" >&2 + mkdir -p /app/auths /app/data +fi + +# 安全闸门:api_key 为空 == 完全不鉴权(httpauth.VerifyBearer 语义)。 +# 空间是公网可达的,绝不允许以裸奔状态启动。 +if [ -n "${WB2A_API_KEY:-}" ]; then + echo "[entrypoint] api_key supplied via WB2A_API_KEY env" +else + KEY=$(python3 -c 'import json,sys +try: + print(json.load(open(sys.argv[1])).get("api_key") or "") +except Exception: + print("")' "$CFG" 2>/dev/null || true) + if [ -z "$KEY" ]; then + echo "[entrypoint] FATAL: api_key is empty in $CFG and WB2A_API_KEY is not set." >&2 + echo "[entrypoint] Refusing to start: an empty api_key disables authentication on a public Space." >&2 + echo "[entrypoint] Fix: write a config.json containing an api_key onto the bucket, or set the WB2A_API_KEY secret." >&2 + exit 1 + fi + echo "[entrypoint] api_key loaded from config file" +fi + +echo "[entrypoint] config: $CFG" +echo "[entrypoint] auth_dir: $(dirname "$CFG")/auths (see config)" +exec /app/wb2api -config "$CFG" diff --git a/go.mod b/go.mod index b15e48404bd47125c67b4538423322c8b1ccbad6..4b0bf1667cd471bedda484095e5a94cdf3f5c80a 100644 --- a/go.mod +++ b/go.mod @@ -1,11 +1,19 @@ -module github.com/linguo2625469/workbuddy2api-panel - -go 1.22.5 - -require ( - github.com/cespare/xxhash/v2 v2.3.0 // indirect - github.com/dgryski/go-rendezvous v0.0.0-20200823014737-9f7001d12a5f // indirect - github.com/redis/go-redis/v9 v9.18.0 // indirect - go.uber.org/atomic v1.11.0 // indirect - golang.org/x/sys v0.30.0 // indirect -) +module github.com/misakano7545/workbuddy2api-panel + +go 1.26.10 + +require ( + github.com/andybalholm/brotli v1.2.7 + github.com/redis/go-redis/v9 v9.18.0 + github.com/refraction-networking/utls v1.8.2 + golang.org/x/net v0.52.0 + golang.org/x/sys v0.42.0 +) + +require ( + github.com/cespare/xxhash/v2 v2.3.0 // indirect + github.com/dgryski/go-rendezvous v0.0.0-20200823014737-9f7001d12a5f // indirect + github.com/klauspost/compress v1.20.2 // indirect + go.uber.org/atomic v1.11.0 // indirect + golang.org/x/crypto v0.49.0 // indirect +) diff --git a/go.sum b/go.sum index d460412d4c891b643ebb8c4232f334234fff1520..bfddb468ba4032373d475bff0460bbfce60e05af 100644 --- a/go.sum +++ b/go.sum @@ -1,12 +1,36 @@ -github.com/cespare/xxhash/v2 v2.3.0 h1:UL815xU9SqsFlibzuggzjXhog7bL6oX9BbNZnL2UFvs= -github.com/cespare/xxhash/v2 v2.3.0/go.mod h1:VGX0DQ3Q6kWi7AoAeZDth3/j3BFtOZR5XLFGgcrjCOs= -github.com/dgryski/go-rendezvous v0.0.0-20200823014737-9f7001d12a5f h1:lO4WD4F/rVNCu3HqELle0jiPLLBs70cWOduZpkS1E78= -github.com/dgryski/go-rendezvous v0.0.0-20200823014737-9f7001d12a5f/go.mod h1:cuUVRXasLTGF7a8hSLbxyZXjz+1KgoB3wDUb6vlszIc= -github.com/redis/go-redis/v9 v9.18.0 h1:pMkxYPkEbMPwRdenAzUNyFNrDgHx9U+DrBabWNfSRQs= -github.com/redis/go-redis/v9 v9.18.0/go.mod h1:k3ufPphLU5YXwNTUcCRXGxUoF1fqxnhFQmscfkCoDA0= -github.com/redis/go-redis/v9 v9.22.0 h1:laDvpYXTJtZLloinw1fA5Kqd6HAEH2XKxOkG/PDq2F0= -github.com/redis/go-redis/v9 v9.22.0/go.mod h1:y2g0Wj8rQvuK0ELM+oxSudcLtC09JScs98I/X9gRWY4= -go.uber.org/atomic v1.11.0 h1:ZvwS0R+56ePWxUNi+Atn9dWONBPp/AUETXlHW0DxSjE= -go.uber.org/atomic v1.11.0/go.mod h1:LUxbIzbOniOlMKjJjyPfpl4v+PKK2cNJn91OQbhoJI0= -golang.org/x/sys v0.30.0 h1:QjkSwP/36a20jFYWkSue1YwXzLmsV5Gfq7Eiy72C1uc= -golang.org/x/sys v0.30.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA= +github.com/andybalholm/brotli v1.2.7 h1:UgafRPGMam5ySHfRkhthMqOFA6IFoeF3D7mWIDLjG5A= +github.com/andybalholm/brotli v1.2.7/go.mod h1:rzTDkvFWvIrjDXZHkuS16NPggd91W3kUSvPlQ1pLaKY= +github.com/bsm/ginkgo/v2 v2.12.0 h1:Ny8MWAHyOepLGlLKYmXG4IEkioBysk6GpaRTLC8zwWs= +github.com/bsm/ginkgo/v2 v2.12.0/go.mod h1:SwYbGRRDovPVboqFv0tPTcG1sN61LM1Z4ARdbAV9g4c= +github.com/bsm/gomega v1.27.10 h1:yeMWxP2pV2fG3FgAODIY8EiRE3dy0aeFYt4l7wh6yKA= +github.com/bsm/gomega v1.27.10/go.mod h1:JyEr/xRbxbtgWNi8tIEVPUYZ5Dzef52k01W3YH0H+O0= +github.com/cespare/xxhash/v2 v2.3.0 h1:UL815xU9SqsFlibzuggzjXhog7bL6oX9BbNZnL2UFvs= +github.com/cespare/xxhash/v2 v2.3.0/go.mod h1:VGX0DQ3Q6kWi7AoAeZDth3/j3BFtOZR5XLFGgcrjCOs= +github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c= +github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= +github.com/dgryski/go-rendezvous v0.0.0-20200823014737-9f7001d12a5f h1:lO4WD4F/rVNCu3HqELle0jiPLLBs70cWOduZpkS1E78= +github.com/dgryski/go-rendezvous v0.0.0-20200823014737-9f7001d12a5f/go.mod h1:cuUVRXasLTGF7a8hSLbxyZXjz+1KgoB3wDUb6vlszIc= +github.com/klauspost/compress v1.20.2 h1:v5tiZvm1KGLyg5d5oXdXe3lsSPrbEUiKoXGia//I7Qo= +github.com/klauspost/compress v1.20.2/go.mod h1:LUdAzn7YLVvxLpc7y3V1m40wESHTgc1422pwwBSKYuI= +github.com/klauspost/cpuid/v2 v2.0.9 h1:lgaqFMSdTdQYdZ04uHyN2d/eKdOMyi2YLSvlQIBFYa4= +github.com/klauspost/cpuid/v2 v2.0.9/go.mod h1:FInQzS24/EEf25PyTYn52gqo7WaD8xa0213Md/qVLRg= +github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM= +github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4= +github.com/redis/go-redis/v9 v9.18.0 h1:pMkxYPkEbMPwRdenAzUNyFNrDgHx9U+DrBabWNfSRQs= +github.com/redis/go-redis/v9 v9.18.0/go.mod h1:k3ufPphLU5YXwNTUcCRXGxUoF1fqxnhFQmscfkCoDA0= +github.com/refraction-networking/utls v1.8.2 h1:j4Q1gJj0xngdeH+Ox/qND11aEfhpgoEvV+S9iJ2IdQo= +github.com/refraction-networking/utls v1.8.2/go.mod h1:jkSOEkLqn+S/jtpEHPOsVv/4V4EVnelwbMQl4vCWXAM= +github.com/stretchr/testify v1.3.0 h1:TivCn/peBQ7UY8ooIcPgZFpTNSz0Q2U6UrFlUfqbe0Q= +github.com/stretchr/testify v1.3.0/go.mod h1:M5WIy9Dh21IEIfnGCwXGc5bZfKNJtfHm1UVUgZn+9EI= +github.com/xyproto/randomstring v1.0.5 h1:YtlWPoRdgMu3NZtP45drfy1GKoojuR7hmRcnhZqKjWU= +github.com/xyproto/randomstring v1.0.5/go.mod h1:rgmS5DeNXLivK7YprL0pY+lTuhNQW3iGxZ18UQApw/E= +github.com/zeebo/xxh3 v1.0.2 h1:xZmwmqxHZA8AI603jOQ0tMqmBr9lPeFwGg6d+xy9DC0= +github.com/zeebo/xxh3 v1.0.2/go.mod h1:5NWz9Sef7zIDm2JHfFlcQvNekmcEl9ekUZQQKCYaDcA= +go.uber.org/atomic v1.11.0 h1:ZvwS0R+56ePWxUNi+Atn9dWONBPp/AUETXlHW0DxSjE= +go.uber.org/atomic v1.11.0/go.mod h1:LUxbIzbOniOlMKjJjyPfpl4v+PKK2cNJn91OQbhoJI0= +golang.org/x/crypto v0.49.0 h1:+Ng2ULVvLHnJ/ZFEq4KdcDd/cfjrrjjNSXNzxg0Y4U4= +golang.org/x/crypto v0.49.0/go.mod h1:ErX4dUh2UM+CFYiXZRTcMpEcN8b/1gxEuv3nODoYtCA= +golang.org/x/net v0.52.0 h1:He/TN1l0e4mmR3QqHMT2Xab3Aj3L9qjbhRm78/6jrW0= +golang.org/x/net v0.52.0/go.mod h1:R1MAz7uMZxVMualyPXb+VaqGSa3LIaUqk0eEt3w36Sw= +golang.org/x/sys v0.42.0 h1:omrd2nAlyT5ESRdCLYdm3+fMfNFE/+Rf4bDIQImRJeo= +golang.org/x/sys v0.42.0/go.mod h1:4GL1E5IUh+htKOUEOaiffhrAeqysfVGipDYzABqnCmw= diff --git a/internal/alert/alert.go b/internal/alert/alert.go new file mode 100644 index 0000000000000000000000000000000000000000..d5ec0b48f77ba7fa353488c36839f3ab06449f4a --- /dev/null +++ b/internal/alert/alert.go @@ -0,0 +1,366 @@ +// Package alert 账号池可用性阈值告警。Enabled=false 时 Run 直接返回。 +package alert + +import ( + "bytes" + "context" + "crypto/hmac" + "crypto/sha256" + "encoding/hex" + "encoding/json" + "fmt" + "io" + "log" + "net/http" + "sync" + "time" +) + +const ( + defaultInterval = 30 * time.Second + defaultTimeout = 5 * time.Second + defaultForTicks = 2 + defaultClearTicks = 2 + defaultStartupGrace = 30 * time.Second + defaultRecover = 1 + defaultServiceName = "workbuddy2api" +) + +type Health struct { + Total, Healthy, Cooling, Disabled, Breaker, Degraded, InFlight int +} + +type Source interface { + Health(realm string) Health + WAFActive() bool +} + +type Config struct { + Enabled bool + WebhookURL string + Secret string + Interval time.Duration + Timeout time.Duration + StartupGrace time.Duration + MinHealthyCN int + MinHealthyGlobal int + RecoverHealthy int + BreakerThreshold int + ForTicks int + ClearTicks int + SendResolve bool + ServiceName string +} + +func (c *Config) normalize() { + if c.Interval <= 0 { + c.Interval = defaultInterval + } + if c.Timeout <= 0 { + c.Timeout = defaultTimeout + } + if c.StartupGrace <= 0 { + c.StartupGrace = defaultStartupGrace + } + if c.ForTicks <= 0 { + c.ForTicks = defaultForTicks + } + if c.ClearTicks <= 0 { + c.ClearTicks = defaultClearTicks + } + if c.RecoverHealthy <= 0 { + c.RecoverHealthy = defaultRecover + } + if c.ServiceName == "" { + c.ServiceName = defaultServiceName + } +} + +type ruleState int + +const ( + stateOK ruleState = iota + statePending + stateFiring +) + +type rule struct { + id, severity, realm string + sample func(Source) (value float64, bad, recovered bool, threshold float64, msg string) + state ruleState + badTicks int + clearCount int + since time.Time +} + +type event int + +const ( + eventNone event = iota + eventAlert + eventResolve +) + +func (r *rule) step(now time.Time, src Source, forTicks, clearTicks int) (event, float64, float64, string) { + v, bad, recovered, th, msg := r.sample(src) + switch r.state { + case stateOK: + if !bad { + return eventNone, 0, 0, "" + } + r.state = statePending + r.badTicks = 0 + fallthrough + case statePending: + if !bad { + r.state = stateOK + r.badTicks = 0 + return eventNone, 0, 0, "" + } + r.badTicks++ + if r.badTicks >= forTicks { + r.state = stateFiring + r.since = now + r.clearCount = 0 + return eventAlert, v, th, msg + } + case stateFiring: + if recovered { + r.clearCount++ + if r.clearCount >= clearTicks { + r.state = stateOK + r.badTicks = 0 + r.clearCount = 0 + return eventResolve, v, th, msg + } + } else { + r.clearCount = 0 + } + } + return eventNone, 0, 0, "" +} + +func newRules(cfg Config) []*rule { + var rs []*rule + for _, rc := range []struct { + realm string + min int + }{{"cn", cfg.MinHealthyCN}, {"global", cfg.MinHealthyGlobal}} { + if rc.min <= 0 { + continue + } + realm, min := rc.realm, rc.min + rs = append(rs, &rule{ + id: "realm_healthy_low", severity: "critical", realm: realm, + sample: func(src Source) (float64, bool, bool, float64, string) { + v := float64(src.Health(realm).Healthy) + bad := v < float64(min) + return v, bad, v >= float64(cfg.RecoverHealthy), float64(min), + fmt.Sprintf("%s realm healthy accounts (%d) below threshold (%d)", realm, int(v), min) + }, + }) + } + if cfg.BreakerThreshold > 0 { + th := cfg.BreakerThreshold + rs = append(rs, &rule{ + id: "breaker_high", severity: "warning", + sample: func(src Source) (float64, bool, bool, float64, string) { + v := float64(src.Health("cn").Breaker + src.Health("global").Breaker) + return v, v >= float64(th), v < float64(th), float64(th), + fmt.Sprintf("accounts in circuit-breaker (%d) reached threshold (%d)", int(v), th) + }, + }) + } + rs = append(rs, &rule{ + id: "waf_ip_block", severity: "warning", + sample: func(src Source) (float64, bool, bool, float64, string) { + active := src.WAFActive() + v := 0.0 + if active { + v = 1 + } + return v, active, !active, 1, "IP-level WAF block is active" + }, + }) + return rs +} + +type Snapshot struct { + CN RealmSnapshot `json:"cn"` + Global RealmSnapshot `json:"global"` + WAFActive bool `json:"waf_active"` +} + +type RealmSnapshot struct { + Total int `json:"total"` + Healthy int `json:"healthy"` + Cooling int `json:"cooling"` + Disabled int `json:"disabled"` + Breaker int `json:"breaker"` + // Degraded 连败降权中的账号数。alert.Health 一直有这个观测,但快照转换时 + // 被丢弃——webhook 接收方永远看不到「有一批号在连败降权」,只能等它恶化成 + // healthy 不足才被 realm_healthy_low 告警。 + Degraded int `json:"degraded"` + InFlight int `json:"in_flight"` +} + +type Payload struct { + Version int `json:"version"` + Event string `json:"event"` + Service string `json:"service"` + Rule string `json:"rule"` + Severity string `json:"severity"` + Realm string `json:"realm,omitempty"` + Value float64 `json:"value"` + Threshold float64 `json:"threshold"` + Message string `json:"message"` + Since time.Time `json:"since"` + FiredAt time.Time `json:"fired_at"` + Snapshot Snapshot `json:"snapshot"` +} + +type Monitor struct { + cfg Config + src Source + rules []*rule + client *http.Client + startedAt time.Time + mu sync.Mutex + stop chan struct{} + stopOnce sync.Once +} + +func New(cfg Config, src Source) *Monitor { + cfg.normalize() + return &Monitor{ + cfg: cfg, src: src, rules: newRules(cfg), startedAt: time.Now(), + client: &http.Client{ + Timeout: cfg.Timeout, + CheckRedirect: func(req *http.Request, via []*http.Request) error { + if len(via) >= 2 { + return fmt.Errorf("too many redirects") + } + if req.URL.Host != via[0].URL.Host { + return fmt.Errorf("cross-host redirect refused") + } + return nil + }, + }, + } +} + +func (m *Monitor) Run(ctx context.Context) { + if !m.cfg.Enabled || m.src == nil { + return + } + m.mu.Lock() + if m.stop != nil { + m.mu.Unlock() + return + } + stop := make(chan struct{}) + m.stop = stop + m.mu.Unlock() + t := time.NewTicker(m.cfg.Interval) + defer t.Stop() + m.Tick(time.Now()) + for { + select { + case <-ctx.Done(): + return + case <-stop: + return + case <-t.C: + m.Tick(time.Now()) + } + } +} + +func (m *Monitor) Stop() { + m.stopOnce.Do(func() { + m.mu.Lock() + defer m.mu.Unlock() + if m.stop != nil { + close(m.stop) + m.stop = nil + } + }) +} + +func (m *Monitor) Tick(now time.Time) { + if !m.cfg.Enabled || m.src == nil { + return + } + if now.Sub(m.startedAt) < m.cfg.StartupGrace { + return + } + for _, r := range m.rules { + ev, value, threshold, msg := r.step(now, m.src, m.cfg.ForTicks, m.cfg.ClearTicks) + switch ev { + case eventAlert: + m.send("alert", r, now, value, threshold, msg) + case eventResolve: + if m.cfg.SendResolve { + m.send("resolve", r, now, value, threshold, msg) + } + } + } +} + +func (m *Monitor) snapshot() Snapshot { + to := func(h Health) RealmSnapshot { + return RealmSnapshot{Total: h.Total, Healthy: h.Healthy, Cooling: h.Cooling, Disabled: h.Disabled, Breaker: h.Breaker, Degraded: h.Degraded, InFlight: h.InFlight} + } + return Snapshot{CN: to(m.src.Health("cn")), Global: to(m.src.Health("global")), WAFActive: m.src.WAFActive()} +} + +func (m *Monitor) send(eventName string, r *rule, now time.Time, value, threshold float64, msg string) { + m.post(Payload{ + Version: 1, Event: eventName, Service: m.cfg.ServiceName, Rule: r.id, Severity: r.severity, + Realm: r.realm, Value: value, Threshold: threshold, Message: msg, Since: r.since, FiredAt: now, + Snapshot: m.snapshot(), + }, r.id) +} + +// Notify 推送一条通知(无阈值语义的事件型消息,如排程轮次结果汇总)。 +// 未启用或无 webhook 时静默——通知是旁路,不该影响调用方主流程。 +func (m *Monitor) Notify(message string) { + if !m.cfg.Enabled || m.cfg.WebhookURL == "" { + return + } + m.post(Payload{ + Version: 1, Event: "notify", Service: m.cfg.ServiceName, Severity: "info", + Message: message, FiredAt: time.Now(), Snapshot: m.snapshot(), + }, "notify") +} + +// post 发 payload 到 webhook(HMAC 签名同规则事件;失败只记日志,不重试)。 +func (m *Monitor) post(p Payload, tag string) { + body, err := json.Marshal(p) + if err != nil { + log.Printf("WARN: [alert] marshal payload rule=%s: %v", tag, err) + return + } + req, err := http.NewRequest(http.MethodPost, m.cfg.WebhookURL, bytes.NewReader(body)) + if err != nil { + log.Printf("WARN: [alert] build request rule=%s: %v", tag, err) + return + } + req.Header.Set("Content-Type", "application/json") + req.Header.Set("User-Agent", "workbuddy2api-alert/1") + if m.cfg.Secret != "" { + mac := hmac.New(sha256.New, []byte(m.cfg.Secret)) + mac.Write(body) + req.Header.Set("X-WB2A-Signature", "sha256="+hex.EncodeToString(mac.Sum(nil))) + } + resp, err := m.client.Do(req) + if err != nil { + log.Printf("WARN: [alert] webhook post failed rule=%s: %v", tag, err) + return + } + _, _ = io.Copy(io.Discard, io.LimitReader(resp.Body, 4<<10)) + _ = resp.Body.Close() + if resp.StatusCode < 200 || resp.StatusCode > 299 { + log.Printf("WARN: [alert] webhook returned %d rule=%s", resp.StatusCode, tag) + } +} diff --git a/internal/alert/alert_test.go b/internal/alert/alert_test.go new file mode 100644 index 0000000000000000000000000000000000000000..db610f32f98a9cac0876e01ef4e03fd1b714a7a5 --- /dev/null +++ b/internal/alert/alert_test.go @@ -0,0 +1,80 @@ +package alert + +import ( + "crypto/hmac" + "crypto/sha256" + "encoding/hex" + "io" + "net/http" + "net/http/httptest" + "strings" + "testing" + "time" +) + +type fakeSrc struct{ healthy int } + +func (f fakeSrc) Health(realm string) Health { + if realm == "cn" { + return Health{Total: 2, Healthy: f.healthy} + } + return Health{} +} +func (f fakeSrc) WAFActive() bool { return false } + +func TestAlertFiresOnce(t *testing.T) { + var n int + var gotSig string + srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { + n++ + body, _ := io.ReadAll(r.Body) + gotSig = r.Header.Get("X-WB2A-Signature") + mac := hmac.New(sha256.New, []byte("s3")) + mac.Write(body) + want := "sha256=" + hex.EncodeToString(mac.Sum(nil)) + if gotSig != want { + t.Errorf("sig %s want %s", gotSig, want) + } + w.WriteHeader(204) + })) + defer srv.Close() + m := New(Config{ + Enabled: true, WebhookURL: srv.URL, Secret: "s3", + StartupGrace: time.Nanosecond, ForTicks: 1, ClearTicks: 1, + MinHealthyCN: 1, Interval: time.Hour, Timeout: time.Second, + }, fakeSrc{}) + now := m.startedAt.Add(time.Second) + m.Tick(now) + m.Tick(now.Add(time.Second)) + if n != 1 { + t.Fatalf("posts=%d want 1 (edge trigger, no repeat)", n) + } +} + +// TestNotifyPosts 汇总通知走同一条 webhook 管道:enabled + URL 才发;关闭时静默。 +func TestNotifyPosts(t *testing.T) { + var n int + var got string + var sig string + srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { + n++ + body, _ := io.ReadAll(r.Body) + got, sig = string(body), r.Header.Get("X-WB2A-Signature") + w.WriteHeader(204) + })) + defer srv.Close() + m := New(Config{Enabled: true, WebhookURL: srv.URL, Secret: "s3", Interval: time.Hour, Timeout: time.Second}, fakeSrc{}) + m.Notify("growth 队列 第 1 轮 2 项:完成 2 / 跳过 0 / 失败 0") + if n != 1 || !strings.Contains(got, `"event":"notify"`) || !strings.Contains(got, "growth 队列 第 1 轮") { + t.Fatalf("posts=%d body=%s want 1 条 event=notify", n, got) + } + mac := hmac.New(sha256.New, []byte("s3")) + mac.Write([]byte(got)) + if want := "sha256=" + hex.EncodeToString(mac.Sum(nil)); sig != want { + t.Fatalf("sig %s want %s", sig, want) + } + New(Config{Interval: time.Hour, Timeout: time.Second}, fakeSrc{}).Notify("x") // 未启用:静默不 panic + if n != 1 { + t.Fatalf("posts=%d want 1(未启用不应发)", n) + } +} diff --git a/internal/auth/apikey_test.go b/internal/auth/apikey_test.go new file mode 100644 index 0000000000000000000000000000000000000000..70210d0e1a67fd4d177e1d6b34b62cd2a4c16c2e --- /dev/null +++ b/internal/auth/apikey_test.go @@ -0,0 +1,144 @@ +package auth + +import ( + "os" + "testing" + "time" +) + +// TestIsAPIKey 静态 API Key 判定:只看 accessToken 前缀(ck_/pt_)。 +// +// 为什么必须在前缀上判:auth 文件不持久化 tokenType(refresh 只认 OAuth 设备流, +// 静态 Key 无法刷新),前缀是落盘形态里唯一稳定、跨进程一致的判据。误判两个方向 +// 都有实代价:判成普通号 → 每日对签到/成长端点空发请求、refresh 必然失败把好号冷却; +// 判太宽(比如把 ck 之后的任意串都算)→ 真实 OAuth token 被当成 Key,额度查询走错端点。 +func TestIsAPIKey(t *testing.T) { + cases := []struct { + name string + token string + want bool + }{ + {"ck_ 前缀(CodeBuddy 控制台签发)", "ck_abcd1234.secretpart", true}, + {"pt_ 前缀(官方 CLI 形态)", "pt_abcd1234.secretpart", true}, + {"裸 ck 无下划线", "ckabcd1234", false}, + {"大写前缀", "CK_abcd1234", false}, + {"JWT 形式 OAuth token", "eyJhbGciOiJSUzI1NiJ9.eyJ1aWQiOiJ1MSJ9.sig", false}, + {"空 token", "", false}, + {"前缀在中间", "Bearer ck_abcd", false}, + } + for _, c := range cases { + t.Run(c.name, func(t *testing.T) { + a := &Auth{UID: "u1", AccessToken: c.token} + if got := a.IsAPIKey(); got != c.want { + t.Fatalf("token=%q IsAPIKey()=%v want %v", c.token, got, c.want) + } + }) + } + + // nil 接收者不得 panic:panel 侧会用临时 Auth 走判定,防御路径也可能传 nil。 + var nilAuth *Auth + if nilAuth.IsAPIKey() { + t.Fatal("nil Auth 不该被判为 API Key") + } +} + +// TestUsesEnterpriseBilling 额度查询分流判据:企业版与静态 API Key 都要走企业口径, +// 因为个人 get-user-resource 对二者恒返回空 Accounts。若这里的判据漏了 API Key, +// 静态 Key 账号的余额会恒为 0,积分保底把它当成耗尽号挡出选号。 +func TestUsesEnterpriseBilling(t *testing.T) { + cases := []struct { + name string + a *Auth + want bool + }{ + {"个人 OAuth 号", &Auth{UID: "u1", AccessToken: "eyJ.x.y"}, false}, + {"企业版", &Auth{UID: "u1", AccessToken: "eyJ.x.y", EnterpriseID: "fn7x"}, true}, + {"静态 API Key", &Auth{UID: "u1", AccessToken: "ck_abc.def"}, true}, + {"企业版 + API Key", &Auth{UID: "u1", AccessToken: "pt_abc.def", EnterpriseID: "fn7x"}, true}, + } + for _, c := range cases { + t.Run(c.name, func(t *testing.T) { + if got := c.a.UsesEnterpriseBilling(); got != c.want { + t.Fatalf("UsesEnterpriseBilling()=%v want %v", got, c.want) + } + }) + } +} + +// TestSupportsPersonalGrowth 个人成长体系门控:企业版与静态 API Key 都不具备, +// scheduler 五类任务与 panel 成长入口据此跳过(否则每日空发一堆注定失败的请求)。 +func TestSupportsPersonalGrowth(t *testing.T) { + cases := []struct { + name string + a *Auth + want bool + }{ + {"个人号", &Auth{UID: "u1", AccessToken: "eyJ.x.y"}, true}, + {"企业版", &Auth{UID: "u1", AccessToken: "eyJ.x.y", EnterpriseID: "fn7x"}, false}, + {"静态 API Key", &Auth{UID: "u1", AccessToken: "ck_abc.def"}, false}, + } + for _, c := range cases { + t.Run(c.name, func(t *testing.T) { + if got := c.a.SupportsPersonalGrowth(); got != c.want { + t.Fatalf("SupportsPersonalGrowth()=%v want %v", got, c.want) + } + // 执行类门控与读类门控在本项目当前口径下必须一致(两者分开命名只为将来 + // 出现「读得见、记不上账」的账号类型时能单独改一处)。 + if got := c.a.SupportsPersonalEndpoints(); got != c.want { + t.Fatalf("SupportsPersonalEndpoints()=%v want %v(应与 SupportsPersonalGrowth 同口径)", got, c.want) + } + }) + } +} + +// TestNeedsRefreshAPIAKeyNever 静态 API Key 永不刷新。 +// +// 这是整个接入里最容易踩的一处:Key 没有 expiresAt,若 NeedsRefresh 按「无过期即 +// 需刷新」返回 true,请求路径会在每次发请求前先打 refresh 端点——而 refresh 只认 +// OAuth 设备流,必然失败,于是这个完全健康的号会被当成坏号冷却/轮换。 +func TestNeedsRefreshAPIAKeyNever(t *testing.T) { + a := &Auth{UID: "u1", AccessToken: "ck_abc.def"} // ExpiresAt 零值 + if a.NeedsRefresh(time.Hour) { + t.Fatal("静态 API Key 不该需要刷新(refresh 端点只认 OAuth 设备流)") + } + if a.NeedsRefresh(0) { + t.Fatal("静态 API Key 在任何窗口下都不该需要刷新") + } + + // 反例:普通 OAuth 号无 expiresAt 时仍要刷新(既有语义不能被这次改动带偏)。 + b := &Auth{UID: "u2", AccessToken: "eyJ.x.y"} + if !b.NeedsRefresh(time.Hour) { + t.Fatal("无 expiresAt 的 OAuth 账号仍应需要刷新") + } +} + +// TestAPIKeySavedAndReloaded 静态 Key 落盘/重载后判定不变:前缀判据只看 token 本身, +// 不依赖 Parse 时补齐的任何字段——否则重启后账号会「变回」普通号。 +func TestAPIKeySavedAndReloaded(t *testing.T) { + dir := t.TempDir() + orig := &Auth{UID: "apikey-abc", AccessToken: "ck_abc.secret", Nickname: "key-1"} + orig.FilePath = dir + "/workbuddy-apikey-abc.json" + if _, realm := orig.BackfillRealm(); realm == "" { + t.Fatal("realm 应被补全(静态 Key 恒 CN)") + } + if err := orig.SaveAtomic(); err != nil { + t.Fatalf("save: %v", err) + } + raw, err := os.ReadFile(orig.FilePath) + if err != nil { + t.Fatalf("read: %v", err) + } + parsed, err := Parse(raw) + if err != nil { + t.Fatalf("parse: %v", err) + } + if !parsed.IsAPIKey() { + t.Fatalf("重载后应仍判为 API Key:%+v", parsed) + } + if parsed.RefreshTokenValue() != "" { + t.Fatalf("静态 Key 不该带 refreshToken:%q", parsed.RefreshTokenValue()) + } + if parsed.NeedsRefresh(time.Hour) { + t.Fatal("重载后仍不该需要刷新") + } +} diff --git a/internal/auth/auth.go b/internal/auth/auth.go index 6a94d7d4fdf2b06ce4a09ae52888ee16121bac12..cc47aee70f6186ea1539f7155a196c77f9788bc5 100644 --- a/internal/auth/auth.go +++ b/internal/auth/auth.go @@ -1,378 +1,628 @@ -// Package auth 解析 WorkBuddy auth 文件(嵌套形/扁平形双形态), -// 提供 refresh 后的原子写回。 -package auth - -import ( - "encoding/json" - "errors" - "fmt" - "io/fs" - "log" - "os" - "path/filepath" - "strings" - "sync" - "sync/atomic" - "time" - - "github.com/linguo2625469/workbuddy2api-panel/internal/logfmt" -) - -// Auth 是归一化后的账号凭证(来源可以是插件 OAuth 嵌套形或手写扁平形)。 -type Auth struct { - // mu 串行化 RefreshToken 写与 SaveAtomic 读,防止并发写回半更新 token。 - mu sync.Mutex - - AccessToken string - RefreshToken string - ExpiresAt int64 // Unix 秒 - Domain string - // realm 账号域("cn" / "global"),落盘于 auth.realm(嵌套形)或顶层 realm(扁平形)。 - // 空 = 缺省:Realm() 按 domain 后缀回落,最终恒非空。 - // - // 命名注记:Go 不允许字段与方法同名,持久化字段用未导出 realm,计算访问器用 - // 导出的 Realm()(跨包调用全部走方法)。Parse/SaveAtomic/login 在包内读写字段。 - realm string - UID string - EnterpriseID string - Nickname string - FilePath string // 来源文件;refresh 后原子写回此处 - - // DeviceToken 设备风控 Token(X-Device-Token 头),来源 auth 文件的 device_token 键。 - // 缺省为空 = 不注入该头(容器内无桌面端 Turing SDK 的常见部署)。 - // 手写扁平形 auth 文件可直接写 "device_token": "...";插件 OAuth 嵌套形 - // 顶层 device_token 也会被解析(与桌面端共用状态文件的部署方式)。 - DeviceToken string -} - -// Lock 供同进程内其他包(upstream.RefreshToken)在改写 Auth 字段期间加锁。 -func (a *Auth) Lock() { a.mu.Lock() } - -// Unlock 释放 a.Lock 获取的锁。 -func (a *Auth) Unlock() { a.mu.Unlock() } - -// AccessTokenValue 加锁读取 AccessToken(出站请求头一律经此取值,勿直读字段)。 -// -// 为什么必须加锁:RefreshToken 在 a.mu 内改写 AccessToken/RefreshToken/Domain/ExpiresAt -// (client.go「第 2 段(锁内):校验快照一致后写回」),而所有出站请求头构造 -// (ChatHeaders / BillingHeaders / fetchEnterpriseModels / fetchV3Models / -// global_models)与调度器的 token 检查都在锁外直读这些字段。生产上两侧真会并发: -// Scheduler.RunKeepaliveNow 定时对**每个**非禁用账号刷新(与是否有在途请求无关), -// 而 handler 正基于**同一个** *auth.Auth 指针构造请求头(Pool.AuthByUID/List 返回的 -// 就是池内同一个对象)。无同步直读构成数据竞争(go test -race 实证)。 -func (a *Auth) AccessTokenValue() string { - if a == nil { - return "" - } - a.mu.Lock() - defer a.mu.Unlock() - return a.AccessToken -} - -// DomainValue 加锁读取 Domain(同 AccessTokenValue:RefreshToken 在锁内改写它)。 -func (a *Auth) DomainValue() string { - if a == nil { - return "" - } - a.mu.Lock() - defer a.mu.Unlock() - return a.Domain -} - -// RefreshTokenValue 加锁读取 RefreshToken(同 AccessTokenValue:RefreshToken 在锁内 -// 改写它)。调度器的「有无凭证」前置守卫(checkin/keepalive/travel 的 -// `a.RefreshToken == ""`)必须经此取值,勿直读字段。 -func (a *Auth) RefreshTokenValue() string { - if a == nil { - return "" - } - a.mu.Lock() - defer a.mu.Unlock() - return a.RefreshToken -} - -// globalEnabled 全局开关:global realm 是否路由(D5 双保险)。 -// 默认开启(与 config global.enabled 缺省 true 一致):Realm() 正常按显式 realm/ -// domain 判定 global/cn。显式 SetGlobalEnabled(false)(config "enabled": false)关闭 -// → 逃生门:纯 CN 部署,即便 auth 文件写了 realm=global 或 domain 为 .workbuddy.ai -// 也恒判 cn——「关了才锁死」的单一闸口集中收敛在 Realm()/IsGlobal() 里。 -var globalEnabled atomic.Bool - -func init() { globalEnabled.Store(true) } - -// SetGlobalEnabled 注入 global realm 路由开关(false = 锁死纯 CN,逃生门)。 -func SetGlobalEnabled(enabled bool) { globalEnabled.Store(enabled) } - -// GlobalEnabled 报告 global realm 路由开关当前状态(测试/运维观测)。 -func GlobalEnabled() bool { return globalEnabled.Load() } - -// Realm 返回账号的归一化域:显式 Realm=="global" 或 domain 后缀 .workbuddy.ai → "global", -// 否则 "cn"。显式 global 优先于 domain 回落(D1)。 -// 全局开关 SetGlobalEnabled(false) 时恒 "cn"(逃生门:纯 CN 锁定,不影响默认行为)。 -// 空 realm + 空 domain → "cn"(老 CN 凭证零回归)。 -func (a *Auth) Realm() string { - a.mu.Lock() - defer a.mu.Unlock() - return a.realmLocked() -} - -// realmLocked Realm 的无锁内部实现:仅限**已持 a.mu** 的调用方使用(sync.Mutex 不可重入, -// 锁内再调 Realm() 会自锁)。realm 由 BackfillRealm 改写、Domain 由 RefreshToken 在锁内 -// 改写,故读取必须与写方同锁(理由见 AccessTokenValue 注释)。 -func (a *Auth) realmLocked() string { - if !globalEnabled.Load() { - return "cn" - } - if strings.TrimSpace(a.realm) == "global" || isGlobalDomain(a.Domain) { - return "global" - } - return "cn" -} - -// ResolveRealm 归一化 realm(cn/global):显式非空优先,否则按原始 domain 推断 -// (isGlobalDomain)。不受逃生门影响(逃生门是路由锁,不应影响标识判定); -// domain 也为空 → "cn"(老 CN 凭证零回归)。 -func ResolveRealm(explicit, domain string) string { - if r := strings.TrimSpace(explicit); r != "" { - return r - } - if isGlobalDomain(domain) { - return "global" - } - return "cn" -} - -// BackfillRealm 为缺省 realm 标识的账号持久化补标识:a.realm 为空时按「原始 domain 推断」 -// 写回(cn/global),返回 (是否有变更, 归一化后的 realm)。已有标识不动(幂等)。 -// -// 注意用 isGlobalDomain(a.Domain) 直接推断,而非 Realm()——Realm() 在逃生门 -// (SetGlobalEnabled(false))下恒降级 cn,把 global 账号写死成 cn 会永久污染凭证 -// (逃生门是纯 CN 部署的临时锁,不应改写落盘数据)。domain 也为空时写 "cn"(老 CN 凭证)。 -func (a *Auth) BackfillRealm() (bool, string) { - a.mu.Lock() - defer a.mu.Unlock() - if strings.TrimSpace(a.realm) != "" { - return false, a.realm - } - r := ResolveRealm("", a.Domain) - a.realm = r - return true, r -} - -// RealmStored 直读持久化的 realm 标识(可能为空 = 未 backfill 的旧文件,Realm() 会 fallback)。 -func (a *Auth) RealmStored() string { - a.mu.Lock() - defer a.mu.Unlock() - return a.realm -} - -// BackfillRealmFor 显式写入 realm 标识(包外登录路径使用:panel login 已知用户选了 -// global,直接落盘 realm=global,不依赖 domain 后缀推断)。realm 需为 cn/global, -// 非法值报错(防写脏)。返回是否发生变更。 -func BackfillRealmFor(a *Auth, realm string) (bool, error) { - if a == nil { - return false, fmt.Errorf("nil auth") - } - switch strings.TrimSpace(realm) { - case "cn", "global": - default: - return false, fmt.Errorf("realm must be cn/global, got %q", realm) - } - a.mu.Lock() - defer a.mu.Unlock() - if a.realm == realm { - return false, nil - } - a.realm = realm - return true, nil -} - -// IsGlobal 报告账号是否属于 global realm(= Realm() == "global")。 -func (a *Auth) IsGlobal() bool { return a.Realm() == "global" } - -// isGlobalDomain 判定 domain 是否指向 www.workbuddy.ai 家族。 -// 同时接受裸域 workbuddy.ai 与任意子域(HasSuffix("www.workbuddy.ai") 或裸域本身)。 -func isGlobalDomain(d string) bool { - d = strings.ToLower(strings.TrimSpace(d)) - return d == "workbuddy.ai" || strings.HasSuffix(d, ".workbuddy.ai") -} - -// NeedsRefresh 报告 token 是否将在 within 内过期(或已过期/无 expiry)。 -func (a *Auth) NeedsRefresh(within time.Duration) bool { - a.mu.Lock() - defer a.mu.Unlock() - if a.ExpiresAt <= 0 { - return true - } - return time.Now().Add(within).Unix() >= a.ExpiresAt -} - -// Parse 兼容两种磁盘形态: -// -// 嵌套形 {"auth":{...},"account":{...}} (插件 OAuth 输出) -// 扁平形 {"accessToken":...,"uid":...} (手写/旧版) -func Parse(raw []byte) (*Auth, error) { - if len(raw) == 0 { - return nil, fmt.Errorf("empty auth storage") - } - var probe map[string]json.RawMessage - if err := json.Unmarshal(raw, &probe); err != nil { - return nil, fmt.Errorf("storage_parse_error: %w", err) - } - var a Auth - if _, nested := probe["auth"]; nested { - var n struct { - Auth struct { - AccessToken string `json:"accessToken"` - RefreshToken string `json:"refreshToken"` - ExpiresAt int64 `json:"expiresAt"` - Domain string `json:"domain"` - Realm string `json:"realm"` - } `json:"auth"` - Account struct { - UID string `json:"uid"` - EnterpriseID string `json:"enterpriseId"` - Nickname string `json:"nickname"` - } `json:"account"` - // DeviceToken 顶层 device_token(嵌套形与扁平形共用;手写时无需嵌进 auth 对象)。 - DeviceToken string `json:"device_token"` - } - if err := json.Unmarshal(raw, &n); err != nil { - return nil, fmt.Errorf("storage_parse_error: %w", err) - } - a = Auth{ - AccessToken: n.Auth.AccessToken, - RefreshToken: n.Auth.RefreshToken, - ExpiresAt: n.Auth.ExpiresAt, - Domain: n.Auth.Domain, - realm: n.Auth.Realm, - UID: n.Account.UID, - EnterpriseID: n.Account.EnterpriseID, - Nickname: n.Account.Nickname, - DeviceToken: n.DeviceToken, - } - } else { - var f struct { - AccessToken string `json:"accessToken"` - RefreshToken string `json:"refreshToken"` - ExpiresAt int64 `json:"expiresAt"` - Domain string `json:"domain"` - Realm string `json:"realm"` - UID string `json:"uid"` - EnterpriseID string `json:"enterpriseId"` - Nickname string `json:"nickname"` - DeviceToken string `json:"device_token"` - } - if err := json.Unmarshal(raw, &f); err != nil { - return nil, fmt.Errorf("storage_parse_error: %w", err) - } - a = Auth{ - AccessToken: f.AccessToken, - RefreshToken: f.RefreshToken, - ExpiresAt: f.ExpiresAt, - Domain: f.Domain, - realm: f.Realm, - UID: f.UID, - EnterpriseID: f.EnterpriseID, - Nickname: f.Nickname, - DeviceToken: f.DeviceToken, - } - } - if strings.TrimSpace(a.AccessToken) == "" { - return nil, fmt.Errorf("parse_error: missing accessToken") - } - return &a, nil -} - -// SaveAtomic 以嵌套形原子写回 FilePath(tmp + rename),保持嵌套形(插件可读)格式。 -// 全程持 a.mu:防止与 RefreshToken 修改 token 字段并发,杜绝写回半更新。 -// 防御:accessToken 为空时拒绝写回,避免误用空凭证覆盖有效文件。 -func (a *Auth) SaveAtomic() error { - a.mu.Lock() - defer a.mu.Unlock() - if strings.TrimSpace(a.AccessToken) == "" { - return fmt.Errorf("save refused: empty accessToken (uid=%s)", a.UID) - } - if a.FilePath == "" { - return fmt.Errorf("no FilePath set") - } - doc := map[string]any{ - "auth": map[string]any{ - "accessToken": a.AccessToken, - "refreshToken": a.RefreshToken, - "expiresAt": a.ExpiresAt, - "domain": a.Domain, - "realm": a.realm, - }, - "account": map[string]any{ - "uid": a.UID, - "enterpriseId": a.EnterpriseID, - "nickname": a.Nickname, - }, - } - // DeviceToken 非空才写回顶层 device_token:避免在无该字段的旧文件里引入空键 - // (保持与插件 OAuth 输出形状一致,插件读取忽略未知键)。 - if a.DeviceToken != "" { - doc["device_token"] = a.DeviceToken - } - raw, err := json.MarshalIndent(doc, "", " ") - if err != nil { - return err - } - tmp := a.FilePath + ".tmp" - if err := os.WriteFile(tmp, raw, 0o600); err != nil { - // Docker bind-mount 权限问题的典型现场:容器内 app 用户(uid 10001) - // 对宿主机挂载目录无写权限。给出可操作指引而不是裸 syscall 错误。 - msg := fmt.Sprintf("写入 %s 失败: %v", tmp, err) - if errors.Is(err, fs.ErrPermission) { - msg += "\n(Docker 部署:容器内用户对宿主机挂载目录无写权限。解法任选:" + - "1) 以本机 uid 运行容器:PUID=$(id -u) PGID=$(id -g) docker compose up -d;" + - "2) sudo chown -R 10001:10001 ./auths ./data ./config.json;" + - "3) compose 设 user: \"0:0\" 以 root 运行)" - } - return errors.New(msg) - } - return os.Rename(tmp, a.FilePath) -} - -// LoadDir 扫描并解析 dir 下 workbuddy*.json;解析失败的文件静默跳过(启动日志由调用方统计)。 -// 顺带做 realm 标识存量迁移:对空 realm 的 auth 自动 backfill(原始 domain 推断)并 SaveAtomic -// 落盘,一次性把旧文件补上 realm 键。单个文件写失败不阻断启动(log WARN 继续), -// 避免历史 auth 目录个别文件不可写时整个服务起不来。 -func LoadDir(dir string) ([]*Auth, error) { - files, err := filepath.Glob(filepath.Join(dir, "workbuddy*.json")) - if err != nil { - return nil, err - } - // seenUID 重复 UID 检测:同 UID 出现在多个文件时(双 realm 同名 UID 概率近零) - // 打 WARN 告警含两文件路径,由「后载入者胜出」保持现状行为(不改变加载结果)。 - seenUID := make(map[string]string, len(files)) - var out []*Auth - for _, f := range files { - raw, err := os.ReadFile(f) - if err != nil { - continue - } - a, err := Parse(raw) - if err != nil { - continue - } - a.FilePath = f - if prev, ok := seenUID[a.UID]; ok { - log.Printf("WARN: uid %s duplicated across %s and %s — 后者覆盖(不同 realm 同名 UID?)", - logfmt.Label(a.UID, a.Nickname), prev, f) - } - seenUID[a.UID] = f - if a.RealmStored() == "" { - if changed, r := a.BackfillRealm(); changed { - if err := a.SaveAtomic(); err != nil { - log.Printf("WARN: auth %s realm backfill save: %v", logfmt.Label(a.UID, a.Nickname), err) - } else if r == "global" { - log.Printf("auth %s 存量迁移: 补 realm=global(domain=%s)", logfmt.Label(a.UID, a.Nickname), a.Domain) - } - } - } - out = append(out, a) - } - return out, nil -} +// Package auth 解析 WorkBuddy auth 文件(嵌套形/扁平形双形态), +// 提供 refresh 后的原子写回。 +package auth + +import ( + "encoding/base64" + "encoding/json" + "errors" + "fmt" + "io/fs" + "log" + "os" + "path/filepath" + "sort" + "strings" + "sync" + "sync/atomic" + "time" + + "github.com/misakano7545/workbuddy2api-panel/internal/logfmt" + "github.com/misakano7545/workbuddy2api-panel/internal/safefile" +) + +// Auth 是归一化后的账号凭证(来源可以是插件 OAuth 嵌套形或手写扁平形)。 +type Auth struct { + // mu 串行化 RefreshToken 写与 SaveAtomic 读,防止并发写回半更新 token。 + mu sync.Mutex + + AccessToken string + RefreshToken string + ExpiresAt int64 // Unix 秒 + Domain string + // realm 账号域("cn" / "global"),落盘于 auth.realm(嵌套形)或顶层 realm(扁平形)。 + // 空 = 缺省:Realm() 按 domain 后缀回落,最终恒非空。 + // + // 命名注记:Go 不允许字段与方法同名,持久化字段用未导出 realm,计算访问器用 + // 导出的 Realm()(跨包调用全部走方法)。Parse/SaveAtomic/login 在包内读写字段。 + realm string + UID string + EnterpriseID string + Nickname string + FilePath string // 来源文件;refresh 后原子写回此处 + + // DeviceToken 设备风控 Token(X-Device-Token 头),来源 auth 文件的 device_token 键。 + // 缺省为空 = 不注入该头(容器内无桌面端 Turing SDK 的常见部署)。 + // 手写扁平形 auth 文件可直接写 "device_token": "...";插件 OAuth 嵌套形 + // 顶层 device_token 也会被解析(与桌面端共用状态文件的部署方式)。 + DeviceToken string + + // wbSealed 源文件里原本是 $wbEncrypted 信封的字段("auth.accessToken" 形态): + // SaveAtomic 回写时必须逐个复原成信封,否则刷新后的 token 会以明文覆盖掉 + // 桌面端的加密文件。nil = 来源文件没加密。 + wbSealed map[string]bool +} + +// Lock 供同进程内其他包(upstream.RefreshToken)在改写 Auth 字段期间加锁。 +func (a *Auth) Lock() { a.mu.Lock() } + +// Unlock 释放 a.Lock 获取的锁。 +func (a *Auth) Unlock() { a.mu.Unlock() } + +// AccessTokenValue 加锁读取 AccessToken(出站请求头一律经此取值,勿直读字段)。 +// +// 为什么必须加锁:RefreshToken 在 a.mu 内改写 AccessToken/RefreshToken/Domain/ExpiresAt +// (client.go「第 2 段(锁内):校验快照一致后写回」),而所有出站请求头构造 +// (ChatHeaders / BillingHeaders / fetchEnterpriseModels / fetchV3Models / +// global_models)与调度器的 token 检查都在锁外直读这些字段。生产上两侧真会并发: +// Scheduler.RunKeepaliveNow 定时对**每个**非禁用账号刷新(与是否有在途请求无关), +// 而 handler 正基于**同一个** *auth.Auth 指针构造请求头(Pool.AuthByUID/List 返回的 +// 就是池内同一个对象)。无同步直读构成数据竞争(go test -race 实证)。 +func (a *Auth) AccessTokenValue() string { + if a == nil { + return "" + } + a.mu.Lock() + defer a.mu.Unlock() + return a.AccessToken +} + +// DomainValue 加锁读取 Domain(同 AccessTokenValue:RefreshToken 在锁内改写它)。 +func (a *Auth) DomainValue() string { + if a == nil { + return "" + } + a.mu.Lock() + defer a.mu.Unlock() + return a.Domain +} + +// RefreshTokenValue 加锁读取 RefreshToken(同 AccessTokenValue:RefreshToken 在锁内 +// 改写它)。调度器的「有无凭证」前置守卫(checkin/keepalive/travel 的 +// `a.RefreshToken == ""`)必须经此取值,勿直读字段。 +func (a *Auth) RefreshTokenValue() string { + if a == nil { + return "" + } + a.mu.Lock() + defer a.mu.Unlock() + return a.RefreshToken +} + +// globalEnabled 全局开关:global realm 是否路由(D5 双保险)。 +// 默认开启(与 config global.enabled 缺省 true 一致):Realm() 正常按显式 realm/ +// domain 判定 global/cn。显式 SetGlobalEnabled(false)(config "enabled": false)关闭 +// → 逃生门:纯 CN 部署,即便 auth 文件写了 realm=global 或 domain 为 .workbuddy.ai +// 也恒判 cn——「关了才锁死」的单一闸口集中收敛在 Realm()/IsGlobal() 里。 +var globalEnabled atomic.Bool + +func init() { globalEnabled.Store(true) } + +// SetGlobalEnabled 注入 global realm 路由开关(false = 锁死纯 CN,逃生门)。 +func SetGlobalEnabled(enabled bool) { globalEnabled.Store(enabled) } + +// GlobalEnabled 报告 global realm 路由开关当前状态(测试/运维观测)。 +func GlobalEnabled() bool { return globalEnabled.Load() } + +// Realm 返回账号的归一化域:显式 Realm=="global" 或 domain 后缀 .workbuddy.ai → "global", +// 否则 "cn"。显式 global 优先于 domain 回落(D1)。 +// 全局开关 SetGlobalEnabled(false) 时恒 "cn"(逃生门:纯 CN 锁定,不影响默认行为)。 +// 空 realm + 空 domain → "cn"(老 CN 凭证零回归)。 +func (a *Auth) Realm() string { + a.mu.Lock() + defer a.mu.Unlock() + return a.realmLocked() +} + +// realmLocked Realm 的无锁内部实现:仅限**已持 a.mu** 的调用方使用(sync.Mutex 不可重入, +// 锁内再调 Realm() 会自锁)。realm 由 BackfillRealm 改写、Domain 由 RefreshToken 在锁内 +// 改写,故读取必须与写方同锁(理由见 AccessTokenValue 注释)。 +func (a *Auth) realmLocked() string { + if !globalEnabled.Load() { + return "cn" + } + if strings.TrimSpace(a.realm) == "global" || isGlobalDomain(a.Domain) { + return "global" + } + return "cn" +} + +// ResolveRealm 归一化 realm(cn/global):显式非空优先,否则按原始 domain 推断 +// (isGlobalDomain)。不受逃生门影响(逃生门是路由锁,不应影响标识判定); +// domain 也为空 → "cn"(老 CN 凭证零回归)。 +func ResolveRealm(explicit, domain string) string { + if r := strings.TrimSpace(explicit); r != "" { + return r + } + if isGlobalDomain(domain) { + return "global" + } + return "cn" +} + +// BackfillRealm 为缺省 realm 标识的账号持久化补标识:a.realm 为空时按「原始 domain 推断」 +// 写回(cn/global),返回 (是否有变更, 归一化后的 realm)。已有标识不动(幂等)。 +// +// 注意用 isGlobalDomain(a.Domain) 直接推断,而非 Realm()——Realm() 在逃生门 +// (SetGlobalEnabled(false))下恒降级 cn,把 global 账号写死成 cn 会永久污染凭证 +// (逃生门是纯 CN 部署的临时锁,不应改写落盘数据)。domain 也为空时写 "cn"(老 CN 凭证)。 +func (a *Auth) BackfillRealm() (bool, string) { + a.mu.Lock() + defer a.mu.Unlock() + if strings.TrimSpace(a.realm) != "" { + return false, a.realm + } + r := ResolveRealm("", a.Domain) + a.realm = r + return true, r +} + +// RealmStored 直读持久化的 realm 标识(可能为空 = 未 backfill 的旧文件,Realm() 会 fallback)。 +func (a *Auth) RealmStored() string { + a.mu.Lock() + defer a.mu.Unlock() + return a.realm +} + +// BackfillRealmFor 显式写入 realm 标识(包外登录路径使用:panel login 已知用户选了 +// global,直接落盘 realm=global,不依赖 domain 后缀推断)。realm 需为 cn/global, +// 非法值报错(防写脏)。返回是否发生变更。 +func BackfillRealmFor(a *Auth, realm string) (bool, error) { + if a == nil { + return false, fmt.Errorf("nil auth") + } + switch strings.TrimSpace(realm) { + case "cn", "global": + default: + return false, fmt.Errorf("realm must be cn/global, got %q", realm) + } + a.mu.Lock() + defer a.mu.Unlock() + if a.realm == realm { + return false, nil + } + a.realm = realm + return true, nil +} + +// IsGlobal 报告账号是否属于 global realm(= Realm() == "global")。 +func (a *Auth) IsGlobal() bool { return a.Realm() == "global" } + +// IsEnterprise 报告账号是否为企业版(auth 文件带非空 enterpriseId)。 +// +// 企业版**没有个人成长体系**:签到 / 成长任务 / 连登管家 / 猫猫旅行 / 夜猫子 +// 在上游一律被拒——实测(2026-10-07,同一时刻 A/B 对照): +// - POST /v2/billing/meter/daily-checkin → 400 code 10001「企业账号不支持该操作」 +// - POST /billing/meter/claim-gift / claim-compensation → 400 code 10001 同上 +// - GET /activity/growth/{streak,buddy/info,heatmap,lottery/summary} +// 与 GET /v2/activity/growth/tasks → 403「growth system is only available for personal users」 +// +// 因此引用处(scheduler 五类任务 + panel 成长任务/签到入口)必须与 IsGlobal 门控 +// 并列跳过,避免每日对注定失败的端点空发请求、面板按钮必然报错。 +// +// 不受影响的能力:选号派发、保活(token 刷新)、额度查询(企业额度改走 +// /v2/billing/meter/get-enterprise-user-usage,见 upstream.enterpriseResource)。 +// +// 直读字段(EnterpriseID 自 Parse 后不再改写,与 upstream 读取方式一致), +// 无需加锁——Realm() 加锁是因为 realm/Domain 会被 RefreshToken 在锁内改写。 +func (a *Auth) IsEnterprise() bool { return strings.TrimSpace(a.EnterpriseID) != "" } + +// apiTokenPrefixes 静态 API Key 的前缀集合:ck_(CodeBuddy 控制台签发)与 +// pt_(官方 CLI @tencent-ai/codebuddy-code 另有该前缀)。 +// +// 官方 CLI 的判据是 tokenType === "ApiKey" 且 token 以这两个前缀之一开头;auth +// 文件不持久化 tokenType(refresh 只认 OAuth 设备流,静态 Key 无法刷新),前缀是 +// 落盘形态里唯一稳定、跨进程一致的判据。 +var apiTokenPrefixes = []string{"ck_", "pt_"} + +// isAPIKeyToken 判 token 是否以静态 API Key 前缀开头。 +func isAPIKeyToken(at string) bool { + for _, p := range apiTokenPrefixes { + if strings.HasPrefix(at, p) { + return true + } + } + return false +} + +// isAPIKeyLocked IsAPIKey 的无锁内部实现:仅限**已持 a.mu** 的调用方使用 +// (sync.Mutex 不可重入,锁内再调 AccessTokenValue 会自锁)。 +func (a *Auth) isAPIKeyLocked() bool { return isAPIKeyToken(a.AccessToken) } + +// IsAPIKey 报告账号是否为静态 API Key 账号(AccessToken 以 ck_/pt_ 开头)。 +// +// 静态 Key 直接可用(Authorization: Bearer ,官方 CLI 同时发 X-API-Key), +// 但它**没有**个人账号身份:签到 / 成长任务 / 连登 / 旅行 / 夜猫子一律不适用, +// 额度只能走企业口径端点(个人 get-user-resource 对静态 Key 返回空 Accounts), +// 见 UsesEnterpriseBilling。 +// +// 经 AccessTokenValue() 加锁读取:RefreshToken 会在锁内改写 AccessToken。 +func (a *Auth) IsAPIKey() bool { + if a == nil { + return false + } + return isAPIKeyToken(a.AccessTokenValue()) +} + +// UsesEnterpriseBilling 报告账号的额度查询是否该走企业口径端点 +// (/v2/billing/meter/get-enterprise-user-usage)。 +// +// 企业版与静态 API Key 账号同属此列:个人 get-user-resource 对二者均返回空 +// Accounts(企业账号无个人资源包;静态 Key 无个人账号身份),额度必须走企业口径, +// 否则余额恒为 0 → 积分保底把可用号当成耗尽号挡掉。 +func (a *Auth) UsesEnterpriseBilling() bool { return a.IsEnterprise() || a.IsAPIKey() } + +// TokenSource 从 AccessToken 的 JWT payload 里读 token_source 声明(官方客户端用它 +// 填出站 X-Auth-Method 与 X-Userinfo.token_source)。非 JWT / 无该声明 / 解码失败一律 +// 返回空串——空表示「这个账号没有该维度」,调用方随之不发对应头(不伪造)。 +// +// 每次现解码而不缓存:RefreshToken 会整体换发 token,token_source 可能随重新授权翻转。 +// 成本是一次 base64 + 小 JSON,相对一次上游请求可忽略。 +func (a *Auth) TokenSource() string { + if a == nil { + return "" + } + return jwtClaim(a.AccessTokenValue(), "token_source") +} + +// IdSource 从 AccessToken 的 JWT payload 里读 `id_source` 声明(官方客户端据此填 +// 出站 X-Id-Source 头与 X-Userinfo.id_source 段)。 +// +// 与 TokenSource 的差别很重要:token_source 描述「这次授权走了哪条流程」(企业切换等, +// 个人号也有),id_source 描述「身份来源」——两者在真机 runIdentityHeaders() 里是 +// 各自独立触发的条件维度。同样现解码不缓存:换发 token 后声明可能变。 +func (a *Auth) IdSource() string { + if a == nil { + return "" + } + return jwtClaim(a.AccessTokenValue(), "id_source") +} + +// jwtClaim 解出 JWT payload 里的指定字符串声明;非 JWT / 解码失败返回空。 +// 先按无填充 base64url 解(JWT 标准),失败再试带填充形态(兼容非标准签发方)。 +func jwtClaim(token, name string) string { + parts := strings.Split(token, ".") + if len(parts) < 2 { + return "" + } + raw, err := base64.RawURLEncoding.DecodeString(parts[1]) + if err != nil { + if raw, err = base64.URLEncoding.DecodeString(parts[1]); err != nil { + return "" + } + } + var payload map[string]any + if json.Unmarshal(raw, &payload) != nil { + return "" + } + v, _ := payload[name].(string) + return strings.TrimSpace(v) +} + +// SupportsPersonalGrowth 报告账号是否具备个人成长体系(签到 / 成长任务 / 连登管家 / +// 猫猫旅行 / 夜猫子)。企业版与静态 API Key 都没有该体系: +// - 企业版:上游一律拒绝(400 code 10001 / 403 growth-only,见 IsEnterprise); +// - 静态 API Key:根本没有个人账号身份。 +// +// scheduler 各任务与 panel 成长入口统一用本方法门控,避免对注定失败的端点空发请求、 +// 把本可正常对话的号攒出一串上游报错。 +func (a *Auth) SupportsPersonalGrowth() bool { return !a.IsEnterprise() && !a.IsAPIKey() } + +// SupportsPersonalEndpoints 报告账号是否可调用「签到 / 任务列表」这类显式报错的个人端点。 +// 与 SupportsPersonalGrowth(执行类门控)刻意分开命名:两者当前的判据相同,但语义不同 +// ——将来若某类账号「读得到、记不上账」,只需改这一处而不影响执行类门控。 +func (a *Auth) SupportsPersonalEndpoints() bool { return !a.IsEnterprise() && !a.IsAPIKey() } + +// 不要再用 AccessToken 的 token_source=enterprise_switch 判定「企业上下文」: +// 实测两个只带该章的**个人版**号(enterpriseId 空)成长任务全部 claimed、行为事件 +// 照常计分——该章只记本次授权走了哪条流程。企业形态一律以 enterpriseId 为准。 + +// isGlobalDomain 判定 domain 是否指向 www.workbuddy.ai 家族。 +// 同时接受裸域 workbuddy.ai 与任意子域(HasSuffix("www.workbuddy.ai") 或裸域本身)。 +func isGlobalDomain(d string) bool { + d = strings.ToLower(strings.TrimSpace(d)) + if d == "workbuddy.ai" || strings.HasSuffix(d, ".workbuddy.ai") { + return true + } + // 官方 CLI 国际站域(product.json externalDomain: www.codebuddy.ai)。与 workbuddy.ai + // 同后端不同主机名,但 domain 落盘值不同,不认它会把国际站账号误判成 cn + // (显式 realm 键可兜住面板登录的账号,手写 auth 文件则直接错域路由)。 + return d == "codebuddy.ai" || strings.HasSuffix(d, ".codebuddy.ai") +} + +// NeedsRefresh 报告 token 是否将在 within 内过期(或已过期/无 expiry)。 +func (a *Auth) NeedsRefresh(within time.Duration) bool { + a.mu.Lock() + defer a.mu.Unlock() + // 静态 API Key 永不刷新(refresh 端点只认 OAuth 设备流):恒 false,否则请求 + // 路径会先 refresh、失败后把该号当坏号冷却换号——Key 本身是好的。 + if a.isAPIKeyLocked() { + return false + } + if a.ExpiresAt <= 0 { + return true + } + return time.Now().Add(within).Unix() >= a.ExpiresAt +} + +// Parse 兼容两种磁盘形态: +// +// 嵌套形 {"auth":{...},"account":{...}} (插件 OAuth 输出) +// 扁平形 {"accessToken":...,"uid":...} (手写/旧版) +func Parse(raw []byte) (*Auth, error) { + if len(raw) == 0 { + return nil, fmt.Errorf("empty auth storage") + } + // 新版桌面端把 auth 字段换成 $wbEncrypted 信封(见 wbencrypted.go)。 + // 解密后再按原两形态解析;未加密文件原样返回,不吃这条路径。 + dec, sealed, err := decryptWBEncrypted(raw) + if err != nil { + return nil, err + } + raw = dec + var probe map[string]json.RawMessage + if err := json.Unmarshal(raw, &probe); err != nil { + return nil, fmt.Errorf("storage_parse_error: %w", err) + } + var a Auth + if _, nested := probe["auth"]; nested { + var n struct { + Auth struct { + AccessToken string `json:"accessToken"` + RefreshToken string `json:"refreshToken"` + ExpiresAt int64 `json:"expiresAt"` + Domain string `json:"domain"` + Realm string `json:"realm"` + } `json:"auth"` + Account struct { + UID string `json:"uid"` + EnterpriseID string `json:"enterpriseId"` + Nickname string `json:"nickname"` + } `json:"account"` + // DeviceToken 顶层 device_token(嵌套形与扁平形共用;手写时无需嵌进 auth 对象)。 + DeviceToken string `json:"device_token"` + } + if err := json.Unmarshal(raw, &n); err != nil { + return nil, fmt.Errorf("storage_parse_error: %w", err) + } + a = Auth{ + AccessToken: n.Auth.AccessToken, + RefreshToken: n.Auth.RefreshToken, + ExpiresAt: n.Auth.ExpiresAt, + Domain: n.Auth.Domain, + realm: n.Auth.Realm, + UID: n.Account.UID, + EnterpriseID: n.Account.EnterpriseID, + Nickname: n.Account.Nickname, + DeviceToken: n.DeviceToken, + } + } else { + var f struct { + AccessToken string `json:"accessToken"` + RefreshToken string `json:"refreshToken"` + ExpiresAt int64 `json:"expiresAt"` + Domain string `json:"domain"` + Realm string `json:"realm"` + UID string `json:"uid"` + EnterpriseID string `json:"enterpriseId"` + Nickname string `json:"nickname"` + DeviceToken string `json:"device_token"` + } + if err := json.Unmarshal(raw, &f); err != nil { + return nil, fmt.Errorf("storage_parse_error: %w", err) + } + a = Auth{ + AccessToken: f.AccessToken, + RefreshToken: f.RefreshToken, + ExpiresAt: f.ExpiresAt, + Domain: f.Domain, + realm: f.Realm, + UID: f.UID, + EnterpriseID: f.EnterpriseID, + Nickname: f.Nickname, + DeviceToken: f.DeviceToken, + } + } + if strings.TrimSpace(a.AccessToken) == "" { + return nil, fmt.Errorf("parse_error: missing accessToken") + } + a.ExpiresAt = normalizeExpiresAt(a.ExpiresAt) + a.wbSealed = sealed + return &a, nil +} + +// expiresAtMillisThreshold 区分「秒」与「毫秒」时间戳的分界(1e11)。 +// +// 单位到 1e11 秒已是公元 5138 年,真实凭证不可能;而 1e11 毫秒 = 1973 年, +// 毫秒制当前值(~1.8e12)远在其上。阈值取在两者之间不会误判任一侧。 +const expiresAtMillisThreshold = 100_000_000_000 + +// normalizeExpiresAt 把上游凭据的 expiresAt 归一到 Unix 秒。 +// +// 为什么需要:官方 CodeBuddy CLI 的凭据文件 +// (%LOCALAPPDATA%\CodeBuddyExtension\Data\Public\auth\*.info)写的是**毫秒** +// (实测 1795254516410),而本仓与旧插件 OAuth 落盘的是**秒**。直接按秒解释毫秒 +// 会把到期时间推到公元 58800 年 → NeedsRefresh 恒 false → token 永不刷新 → +// 到期后账号静默失效(表现为「用了一个月突然全部 401」)。导入官方凭据是本仓 +// 支持的用法,所以解析入口必须归一,而不是靠使用者手改文件。 +func normalizeExpiresAt(v int64) int64 { + if v > expiresAtMillisThreshold { + return v / 1000 + } + return v +} + +// SaveAtomic 以嵌套形原子写回 FilePath(tmp + rename),保持嵌套形(插件可读)格式。 +// 全程持 a.mu:防止与 RefreshToken 修改 token 字段并发,杜绝写回半更新。 +// 防御:accessToken 为空时拒绝写回,避免误用空凭证覆盖有效文件。 +func (a *Auth) SaveAtomic() error { + a.mu.Lock() + defer a.mu.Unlock() + if strings.TrimSpace(a.AccessToken) == "" { + return fmt.Errorf("save refused: empty accessToken (uid=%s)", a.UID) + } + if a.FilePath == "" { + return fmt.Errorf("no FilePath set") + } + doc := map[string]any{ + "auth": map[string]any{ + "accessToken": a.AccessToken, + "refreshToken": a.RefreshToken, + "expiresAt": a.ExpiresAt, + "domain": a.Domain, + "realm": a.realm, + }, + "account": map[string]any{ + "uid": a.UID, + "enterpriseId": a.EnterpriseID, + "nickname": a.Nickname, + }, + } + // DeviceToken 非空才写回顶层 device_token:避免在无该字段的旧文件里引入空键 + // (保持与插件 OAuth 输出形状一致,插件读取忽略未知键)。 + if a.DeviceToken != "" { + doc["device_token"] = a.DeviceToken + } + // 来源文件加密的,回写也保持加密:按读入时的信封清单复原(见 sealForSave)。 + // 封装失败就拒绝落盘——明文降级覆盖加密文件比写不进去更糟。 + if err := sealForSave(doc, a.wbSealed); err != nil { + return err + } + raw, err := json.MarshalIndent(doc, "", " ") + if err != nil { + return err + } + // 落盘走 safefile:tmp fsync 后才 rename(掉电不会留下长度正确、内容全 0 的 + // 凭证文件),并把上一份有效内容留成 .bak —— LoadDir 读到坏文件时用它。 + if err := safefile.WriteKeep(a.FilePath, raw, 0o600); err != nil { + // Docker bind-mount 权限问题的典型现场:容器内 app 用户(uid 10001) + // 对宿主机挂载目录无写权限。给出可操作指引而不是裸 syscall 错误。 + msg := fmt.Sprintf("写入 %s 失败: %v", a.FilePath, err) + if errors.Is(err, fs.ErrPermission) { + msg += "\n(Docker 部署:容器内用户对宿主机挂载目录无写权限。解法任选:" + + "1) 以本机 uid 运行容器:PUID=$(id -u) PGID=$(id -g) docker compose up -d;" + + "2) sudo chown -R 10001:10001 ./auths ./data ./config.json;" + + "3) compose 设 user: \"0:0\" 以 root 运行)" + } + return errors.New(msg) + } + return nil +} + +// SaveAtomicRetry 在 SaveAtomic 基础上做有界重试(0/100ms/300ms)。 +// +// 为什么需要:refresh 成功后上游已经轮换了 RT,新 token 只在内存里;如果这一次 +// 落盘失败(磁盘瞬时满、bind-mount 抖动),进程重启会拿旧 RT 去刷新——旧 RT 可能 +// 已被消费,账号直接进入「需要重新登录」。重试把瞬时失败挡掉;仍失败由调用方 +// 打 ERR(错误汇总可见),至少不让问题静默。 +func (a *Auth) SaveAtomicRetry() error { + var err error + for i, delay := range []time.Duration{0, 100 * time.Millisecond, 300 * time.Millisecond} { + if i > 0 { + time.Sleep(delay) + } + if err = a.SaveAtomic(); err == nil { + return nil + } + } + return err +} + +// LoadReport 一次账号目录扫描的结果。 +// +// Errors 非空表示「本次有文件读不动/解析不了」:账号可能**还在**,只是这一轮看不见。 +// 热重载必须据此放弃删除(见 panel/reload.go)——半写文件被当成「文件已删」会把 +// 在池账号踢掉,而且剔除结果会持久化,下次启动也不复活。 +type LoadReport struct { + Auths []*Auth + Files int + ParseError []string // "文件名: 原因",已按文件粒度去重 +} + +// LoadDir 扫描并解析 dir 下 workbuddy*.json;解析失败的文件静默跳过(启动日志由调用方统计)。 +// 顺带做 realm 标识存量迁移:对空 realm 的 auth 自动 backfill(原始 domain 推断)并 SaveAtomic +// 落盘,一次性把旧文件补上 realm 键。单个文件写失败不阻断启动(log WARN 继续), +// 避免历史 auth 目录个别文件不可写时整个服务起不来。 +func LoadDir(dir string) ([]*Auth, error) { + r, err := LoadDirReport(dir) + if err != nil { + return nil, err + } + return r.Auths, nil +} + +// LoadDirReport 同 LoadDir,另外回报文件数与解析失败的条目(热重载用来判断能否删号)。 +func LoadDirReport(dir string) (LoadReport, error) { + files, err := filepath.Glob(filepath.Join(dir, "workbuddy*.json")) + if err != nil { + return LoadReport{}, err + } + report := LoadReport{Files: len(files)} + // 按 mtime 升序:同一个号的轮转备份并存时(客户端会写 ....info), + // 池里「后载入者胜出」才等于「最新凭证胜出」。不排序的话 glob 顺序(字典序)可能让 + // 陈旧备份胜出——那账号在面板上表现为 token 失效。取不到 mtime 的文件排最前(先被覆盖)。 + sort.SliceStable(files, func(i, j int) bool { + fi, erri := os.Stat(files[i]) + fj, errj := os.Stat(files[j]) + if erri != nil || errj != nil { + return erri != nil && errj == nil + } + return fi.ModTime().Before(fj.ModTime()) + }) + // seenUID 重复 UID 检测:同一个号的**个人版与企业版 uid 完全相同**(企业版只是 + // type→ultimate + 多一个 enterpriseId,实测如此),两份凭证在池里只有一个槽位, + // 后载入者胜出。这里打 WARN 并点出两个文件与各自 enterpriseId——否则用户只看到 + // 「我导了两个号,面板只有一个」。 + type dupUID struct{ file, eid string } + seenUID := make(map[string]dupUID, len(files)) + var out []*Auth + for _, f := range files { + // 坏文件不再静默跳过:safefile.Read 在正文损坏时回退到 .bak(掉电留下的 + // 全 0 文件因此还能救回账号),两边都坏才放弃,并且说清是哪个文件、坏在哪 + // ——「账号凭空少了一个」比多打一行 ERROR 难查得多。 + raw, err := safefile.Read(f, func(b []byte) bool { + _, perr := Parse(b) + return perr == nil + }) + if err != nil { + log.Printf("ERROR: auth 文件 %s 无法读取: %v —— 该账号本次不在池里,修好文件或重新登录", f, err) + report.ParseError = append(report.ParseError, filepath.Base(f)+": "+err.Error()) + continue + } + a, err := Parse(raw) + if err != nil { + log.Printf("ERROR: auth 文件 %s 解析失败: %v —— 该账号本次不在池里", f, err) + report.ParseError = append(report.ParseError, filepath.Base(f)+": "+err.Error()) + continue + } + a.FilePath = f + if prev, ok := seenUID[a.UID]; ok { + log.Printf("WARN: uid %s 在 %s(enterpriseId=%q)与 %s(enterpriseId=%q)重复 —— "+ + "同一账号的个人版/企业版 uid 相同,池里只保留后载入的一份;不用的那份删掉", + logfmt.Label(a.UID, a.Nickname), prev.file, prev.eid, f, a.EnterpriseID) + } + seenUID[a.UID] = dupUID{file: f, eid: a.EnterpriseID} + if a.RealmStored() == "" { + if changed, r := a.BackfillRealm(); changed { + if err := a.SaveAtomic(); err != nil { + log.Printf("WARN: auth %s realm backfill save: %v", logfmt.Label(a.UID, a.Nickname), err) + } else if r == "global" { + log.Printf("auth %s 存量迁移: 补 realm=global(domain=%s)", logfmt.Label(a.UID, a.Nickname), a.Domain) + } + } + } + out = append(out, a) + } + report.Auths = out + return report, nil +} diff --git a/internal/auth/auth_test.go b/internal/auth/auth_test.go index fa47c123b4325a3e85763e815029cff003530a16..25ded35aa947cc1a90413994474172da92390829 100644 --- a/internal/auth/auth_test.go +++ b/internal/auth/auth_test.go @@ -1,266 +1,299 @@ -package auth - -import ( - "io" - "log" - "os" - "path/filepath" - "strings" - "testing" -) - -func TestParseNested(t *testing.T) { - raw := []byte(`{"auth":{"accessToken":"at","refreshToken":"rt","expiresAt":1753600000,"domain":""},"account":{"uid":"u1","enterpriseId":"e1","nickname":"n1"}}`) - sa, err := Parse(raw) - if err != nil { - t.Fatalf("nested parse err: %v", err) - } - if sa.AccessToken != "at" || sa.RefreshToken != "rt" || sa.ExpiresAt != 1753600000 { - t.Errorf("tokens: %+v", sa) - } - if sa.UID != "u1" || sa.EnterpriseID != "e1" || sa.Nickname != "n1" { - t.Errorf("account: %+v", sa) - } -} - -func TestParseFlat(t *testing.T) { - raw := []byte(`{"accessToken":"at","refreshToken":"rt","expiresAt":1753600000,"uid":"u2","nickname":"n2"}`) - sa, err := Parse(raw) - if err != nil || sa.UID != "u2" || sa.AccessToken != "at" { - t.Fatalf("flat: %+v %v", sa, err) - } -} - -func TestParseMissingToken(t *testing.T) { - if _, err := Parse([]byte(`{"uid":"u3"}`)); err == nil { - t.Fatal("want error for missing accessToken") - } -} - -func TestSaveAtomicRoundtrip(t *testing.T) { - dir := t.TempDir() - fp := filepath.Join(dir, "workbuddy-u1.json") - a := &Auth{AccessToken: "at", RefreshToken: "rt", ExpiresAt: 1753600000, - UID: "u1", EnterpriseID: "e1", Nickname: "n1", FilePath: fp} - if err := a.SaveAtomic(); err != nil { - t.Fatalf("save: %v", err) - } - if _, err := os.Stat(fp + ".tmp"); !os.IsNotExist(err) { - t.Error("tmp file should not remain") - } - raw, err := os.ReadFile(fp) - if err != nil { - t.Fatalf("read: %v", err) - } - b, err := Parse(raw) - if err != nil { - t.Fatalf("reparse: %v", err) - } - if b.AccessToken != "at" || b.UID != "u1" || b.EnterpriseID != "e1" { - t.Errorf("roundtrip: %+v", b) - } -} - -// TestLoadDirLoadsAllValid 不再按 region 过滤:所有可解析的 auth 文件都被加载, -// 解析失败的文件静默跳过。 -func TestLoadDirLoadsAllValid(t *testing.T) { - dir := t.TempDir() - cn := `{"auth":{"accessToken":"at1","refreshToken":"r","expiresAt":1,"domain":""},"account":{"uid":"cn1"}}` - other := `{"auth":{"accessToken":"at2","refreshToken":"r","expiresAt":1,"domain":"example.com"},"account":{"uid":"u2"}}` - bad := `not json` - os.WriteFile(filepath.Join(dir, "workbuddy-cn1.json"), []byte(cn), 0o600) - os.WriteFile(filepath.Join(dir, "workbuddy-u2.json"), []byte(other), 0o600) - os.WriteFile(filepath.Join(dir, "workbuddy-bad.json"), []byte(bad), 0o600) - - list, err := LoadDir(dir) - if err != nil { - t.Fatalf("load: %v", err) - } - if len(list) != 2 { - t.Fatalf("want 2 valid accounts, got %+v", list) - } - for _, a := range list { - if a.FilePath == "" { - t.Error("FilePath not set") - } - } -} - -func TestNeedsRefresh(t *testing.T) { - a := &Auth{ExpiresAt: 0} - if !a.NeedsRefresh(0) { - t.Error("zero expiry should need refresh") - } - a.ExpiresAt = 9999999999 - if a.NeedsRefresh(0) { - t.Error("far future should not need refresh") - } -} - -// TestParseDeviceToken 嵌套形与扁平形 auth 文件的顶层 device_token 键均被解析。 -func TestParseDeviceToken(t *testing.T) { - nested := []byte(`{"auth":{"accessToken":"at","refreshToken":"rt","expiresAt":1,"domain":""},"account":{"uid":"u1"},"device_token":"dev-tok-nested"}`) - sa, err := Parse(nested) - if err != nil { - t.Fatalf("nested parse: %v", err) - } - if sa.DeviceToken != "dev-tok-nested" { - t.Errorf("nested DeviceToken = %q want %q", sa.DeviceToken, "dev-tok-nested") - } - - flat := []byte(`{"accessToken":"at","refreshToken":"rt","expiresAt":1,"uid":"u2","device_token":"dev-tok-flat"}`) - fa, err := Parse(flat) - if err != nil { - t.Fatalf("flat parse: %v", err) - } - if fa.DeviceToken != "dev-tok-flat" { - t.Errorf("flat DeviceToken = %q want %q", fa.DeviceToken, "dev-tok-flat") - } -} - -// TestSaveAtomicPreservesDeviceToken SaveAtomic 写回后顶层 device_token 被保留并重新解析回来。 -func TestSaveAtomicPreservesDeviceToken(t *testing.T) { - dir := t.TempDir() - fp := filepath.Join(dir, "workbuddy-dt.json") - a := &Auth{AccessToken: "at", RefreshToken: "rt", ExpiresAt: 1, - UID: "u1", DeviceToken: "persisted-tok", FilePath: fp} - if err := a.SaveAtomic(); err != nil { - t.Fatalf("save: %v", err) - } - raw, err := os.ReadFile(fp) - if err != nil { - t.Fatalf("read: %v", err) - } - b, err := Parse(raw) - if err != nil { - t.Fatalf("reparse: %v", err) - } - if b.DeviceToken != "persisted-tok" { - t.Errorf("roundtrip DeviceToken = %q want %q", b.DeviceToken, "persisted-tok") - } -} - -// TestLoadDirBackfillsRealm 存量迁移:LoadDir 加载目录时对空 realm 的 auth 自动 -// backfill + SaveAtomic;已有 realm 的保持原值(不被 domain 覆盖);文件全部带标识。 -func TestLoadDirBackfillsRealm(t *testing.T) { - t.Parallel() - dir := t.TempDir() - fixtures := map[string]string{ - "workbuddy-g1.json": `{"auth":{"accessToken":"at","refreshToken":"r","expiresAt":1,"domain":"www.workbuddy.ai"},"account":{"uid":"g1"}}`, - "workbuddy-c1.json": `{"auth":{"accessToken":"at","refreshToken":"r","expiresAt":1,"domain":""},"account":{"uid":"c1"}}`, - // 已有 realm 的不因 domain 变化被覆盖:global domain + 显式 cn → 保持 cn - "workbuddy-c2.json": `{"auth":{"accessToken":"at","refreshToken":"r","expiresAt":1,"domain":"www.workbuddy.ai","realm":"cn"},"account":{"uid":"c2"}}`, - } - for name, body := range fixtures { - if err := os.WriteFile(filepath.Join(dir, name), []byte(body), 0o600); err != nil { - t.Fatal(err) - } - } - - list, err := LoadDir(dir) - if err != nil { - t.Fatalf("load: %v", err) - } - if len(list) != 3 { - t.Fatalf("want 3 accounts, got %d", len(list)) - } - want := map[string]string{"g1": "global", "c1": "cn", "c2": "cn"} - for _, a := range list { - // 内存态已补标识 - if got := a.RealmStored(); got != want[a.UID] { - t.Errorf("uid=%s in-memory realm=%q want %q", a.UID, got, want[a.UID]) - } - // 落盘文件也带 realm 键 - raw, err := os.ReadFile(a.FilePath) - if err != nil { - t.Fatalf("read %s: %v", a.FilePath, err) - } - b, err := Parse(raw) - if err != nil { - t.Fatalf("reparse %s: %v", a.FilePath, err) - } - if got := b.RealmStored(); got != want[a.UID] { - t.Errorf("uid=%s on-disk realm=%q want %q", a.UID, got, want[a.UID]) - } - } -} - -// TestLoadDirBackfillWriteFailureDoesNotBlock 单个文件 backfill 落盘失败(tmp 预置目录 -// 使 WriteFile 失败)不阻断启动:其他文件照常迁移,LoadDir 不向上抛错。 -// (历史纯 CN auth 目录一次性迁移时,个别文件不可写不应让整个服务起不来。) -func TestLoadDirBackfillWriteFailureDoesNotBlock(t *testing.T) { - t.Parallel() - dir := t.TempDir() - good := `{"auth":{"accessToken":"at","refreshToken":"r","expiresAt":1,"domain":"www.workbuddy.ai"},"account":{"uid":"g1"}}` - if err := os.WriteFile(filepath.Join(dir, "workbuddy-g1.json"), []byte(good), 0o600); err != nil { - t.Fatal(err) - } - // 预置同名 .tmp 目录 → SaveAtomic 的 os.WriteFile(".tmp") 报 is a directory。 - if err := os.Mkdir(filepath.Join(dir, "workbuddy-c1.json.tmp"), 0o700); err != nil { - t.Fatal(err) - } - bad := `{"auth":{"accessToken":"at","refreshToken":"r","expiresAt":1},"account":{"uid":"c1"}}` - if err := os.WriteFile(filepath.Join(dir, "workbuddy-c1.json"), []byte(bad), 0o600); err != nil { - t.Fatal(err) - } - - list, err := LoadDir(dir) - if err != nil { - t.Fatalf("load err=%v want nil (write failure must not block startup)", err) - } - if len(list) != 2 { - t.Fatalf("want 2 accounts loaded, got %d", len(list)) - } - // 好文件迁移成功 - raw, _ := os.ReadFile(filepath.Join(dir, "workbuddy-g1.json")) - b, _ := Parse(raw) - if b.RealmStored() != "global" { - t.Errorf("good file realm=%q want global (migration should succeed)", b.RealmStored()) - } -} - -// TestLoadDirDuplicateUIDWarning 同 UID 双 realm auth 文件(概率近零的 EDGE):LoadDir -// 检测到重复 UID 时打 WARN(含两文件路径),且不改变加载行为——后载入者胜出(返回 1 个、 -// 不 panic、realm 为后载入者值)。LoadDir 现在有额外 seenUID 副作用,逐字验证 WARN。 -func TestLoadDirDuplicateUIDWarning(t *testing.T) { - dir := t.TempDir() - // 同一 UID u9 的两个文件:cn realm 文件按文件名排序在前(workbuddy-a-...), - // global realm 文件在后 → 后载入者(global)胜出。 - cn := `{"auth":{"accessToken":"at1","refreshToken":"r","expiresAt":1,"domain":"www.codebuddy.cn"},"account":{"uid":"u9"}}` - gl := `{"auth":{"accessToken":"at2","refreshToken":"r","expiresAt":1,"domain":"www.workbuddy.ai"},"account":{"uid":"u9"}}` - if err := os.WriteFile(filepath.Join(dir, "workbuddy-a-cn.json"), []byte(cn), 0o600); err != nil { - t.Fatal(err) - } - if err := os.WriteFile(filepath.Join(dir, "workbuddy-z-global.json"), []byte(gl), 0o600); err != nil { - t.Fatal(err) - } - - // 捕获 log 输出(本测试不 t.Parallel:log.SetOutput 是进程级全局,需串行)。 - old := log.Writer() - r, w, err := os.Pipe() - if err != nil { - t.Fatal(err) - } - log.SetOutput(w) - - list, err := LoadDir(dir) - _ = w.Close() - raw, _ := io.ReadAll(r) - log.SetOutput(old) - - if err != nil { - t.Fatalf("load err=%v", err) - } - // 行为稳定(不改加载结果):LoadDir 返回全部可解析文件(去重发生在 pool.SyncToDir - // 的 UID 键 upsert),不 panic。 - if len(list) != 2 { - t.Fatalf("want 2 accounts loaded (dedup later in pool), got %d", len(list)) - } - // WARN 已触发且含两文件路径。 - if !strings.Contains(string(raw), "WARN: uid") || - !strings.Contains(string(raw), "duplicated") || - !strings.Contains(string(raw), "workbuddy-a-cn.json") || - !strings.Contains(string(raw), "workbuddy-z-global.json") { - t.Errorf("expected WARN with both paths, got output: %s", string(raw)) - } -} +package auth + +import ( + "fmt" + "io" + "log" + "os" + "path/filepath" + "strings" + "testing" + "time" +) + +func TestParseNested(t *testing.T) { + raw := []byte(`{"auth":{"accessToken":"at","refreshToken":"rt","expiresAt":1753600000,"domain":""},"account":{"uid":"u1","enterpriseId":"e1","nickname":"n1"}}`) + sa, err := Parse(raw) + if err != nil { + t.Fatalf("nested parse err: %v", err) + } + if sa.AccessToken != "at" || sa.RefreshToken != "rt" || sa.ExpiresAt != 1753600000 { + t.Errorf("tokens: %+v", sa) + } + if sa.UID != "u1" || sa.EnterpriseID != "e1" || sa.Nickname != "n1" { + t.Errorf("account: %+v", sa) + } +} + +func TestParseFlat(t *testing.T) { + raw := []byte(`{"accessToken":"at","refreshToken":"rt","expiresAt":1753600000,"uid":"u2","nickname":"n2"}`) + sa, err := Parse(raw) + if err != nil || sa.UID != "u2" || sa.AccessToken != "at" { + t.Fatalf("flat: %+v %v", sa, err) + } +} + +func TestParseMissingToken(t *testing.T) { + if _, err := Parse([]byte(`{"uid":"u3"}`)); err == nil { + t.Fatal("want error for missing accessToken") + } +} + +func TestSaveAtomicRoundtrip(t *testing.T) { + dir := t.TempDir() + fp := filepath.Join(dir, "workbuddy-u1.json") + a := &Auth{AccessToken: "at", RefreshToken: "rt", ExpiresAt: 1753600000, + UID: "u1", EnterpriseID: "e1", Nickname: "n1", FilePath: fp} + if err := a.SaveAtomic(); err != nil { + t.Fatalf("save: %v", err) + } + if _, err := os.Stat(fp + ".tmp"); !os.IsNotExist(err) { + t.Error("tmp file should not remain") + } + raw, err := os.ReadFile(fp) + if err != nil { + t.Fatalf("read: %v", err) + } + b, err := Parse(raw) + if err != nil { + t.Fatalf("reparse: %v", err) + } + if b.AccessToken != "at" || b.UID != "u1" || b.EnterpriseID != "e1" { + t.Errorf("roundtrip: %+v", b) + } +} + +// TestLoadDirLoadsAllValid 不再按 region 过滤:所有可解析的 auth 文件都被加载, +// 解析失败的文件静默跳过。 +func TestLoadDirLoadsAllValid(t *testing.T) { + dir := t.TempDir() + cn := `{"auth":{"accessToken":"at1","refreshToken":"r","expiresAt":1,"domain":""},"account":{"uid":"cn1"}}` + other := `{"auth":{"accessToken":"at2","refreshToken":"r","expiresAt":1,"domain":"example.com"},"account":{"uid":"u2"}}` + bad := `not json` + os.WriteFile(filepath.Join(dir, "workbuddy-cn1.json"), []byte(cn), 0o600) + os.WriteFile(filepath.Join(dir, "workbuddy-u2.json"), []byte(other), 0o600) + os.WriteFile(filepath.Join(dir, "workbuddy-bad.json"), []byte(bad), 0o600) + + list, err := LoadDir(dir) + if err != nil { + t.Fatalf("load: %v", err) + } + if len(list) != 2 { + t.Fatalf("want 2 valid accounts, got %+v", list) + } + for _, a := range list { + if a.FilePath == "" { + t.Error("FilePath not set") + } + } +} + +func TestNeedsRefresh(t *testing.T) { + a := &Auth{ExpiresAt: 0} + if !a.NeedsRefresh(0) { + t.Error("zero expiry should need refresh") + } + a.ExpiresAt = 9999999999 + if a.NeedsRefresh(0) { + t.Error("far future should not need refresh") + } +} + +// TestParseDeviceToken 嵌套形与扁平形 auth 文件的顶层 device_token 键均被解析。 +func TestParseDeviceToken(t *testing.T) { + nested := []byte(`{"auth":{"accessToken":"at","refreshToken":"rt","expiresAt":1,"domain":""},"account":{"uid":"u1"},"device_token":"dev-tok-nested"}`) + sa, err := Parse(nested) + if err != nil { + t.Fatalf("nested parse: %v", err) + } + if sa.DeviceToken != "dev-tok-nested" { + t.Errorf("nested DeviceToken = %q want %q", sa.DeviceToken, "dev-tok-nested") + } + + flat := []byte(`{"accessToken":"at","refreshToken":"rt","expiresAt":1,"uid":"u2","device_token":"dev-tok-flat"}`) + fa, err := Parse(flat) + if err != nil { + t.Fatalf("flat parse: %v", err) + } + if fa.DeviceToken != "dev-tok-flat" { + t.Errorf("flat DeviceToken = %q want %q", fa.DeviceToken, "dev-tok-flat") + } +} + +// TestSaveAtomicPreservesDeviceToken SaveAtomic 写回后顶层 device_token 被保留并重新解析回来。 +func TestSaveAtomicPreservesDeviceToken(t *testing.T) { + dir := t.TempDir() + fp := filepath.Join(dir, "workbuddy-dt.json") + a := &Auth{AccessToken: "at", RefreshToken: "rt", ExpiresAt: 1, + UID: "u1", DeviceToken: "persisted-tok", FilePath: fp} + if err := a.SaveAtomic(); err != nil { + t.Fatalf("save: %v", err) + } + raw, err := os.ReadFile(fp) + if err != nil { + t.Fatalf("read: %v", err) + } + b, err := Parse(raw) + if err != nil { + t.Fatalf("reparse: %v", err) + } + if b.DeviceToken != "persisted-tok" { + t.Errorf("roundtrip DeviceToken = %q want %q", b.DeviceToken, "persisted-tok") + } +} + +// TestLoadDirBackfillsRealm 存量迁移:LoadDir 加载目录时对空 realm 的 auth 自动 +// backfill + SaveAtomic;已有 realm 的保持原值(不被 domain 覆盖);文件全部带标识。 +func TestLoadDirBackfillsRealm(t *testing.T) { + t.Parallel() + dir := t.TempDir() + fixtures := map[string]string{ + "workbuddy-g1.json": `{"auth":{"accessToken":"at","refreshToken":"r","expiresAt":1,"domain":"www.workbuddy.ai"},"account":{"uid":"g1"}}`, + "workbuddy-c1.json": `{"auth":{"accessToken":"at","refreshToken":"r","expiresAt":1,"domain":""},"account":{"uid":"c1"}}`, + // 已有 realm 的不因 domain 变化被覆盖:global domain + 显式 cn → 保持 cn + "workbuddy-c2.json": `{"auth":{"accessToken":"at","refreshToken":"r","expiresAt":1,"domain":"www.workbuddy.ai","realm":"cn"},"account":{"uid":"c2"}}`, + } + for name, body := range fixtures { + if err := os.WriteFile(filepath.Join(dir, name), []byte(body), 0o600); err != nil { + t.Fatal(err) + } + } + + list, err := LoadDir(dir) + if err != nil { + t.Fatalf("load: %v", err) + } + if len(list) != 3 { + t.Fatalf("want 3 accounts, got %d", len(list)) + } + want := map[string]string{"g1": "global", "c1": "cn", "c2": "cn"} + for _, a := range list { + // 内存态已补标识 + if got := a.RealmStored(); got != want[a.UID] { + t.Errorf("uid=%s in-memory realm=%q want %q", a.UID, got, want[a.UID]) + } + // 落盘文件也带 realm 键 + raw, err := os.ReadFile(a.FilePath) + if err != nil { + t.Fatalf("read %s: %v", a.FilePath, err) + } + b, err := Parse(raw) + if err != nil { + t.Fatalf("reparse %s: %v", a.FilePath, err) + } + if got := b.RealmStored(); got != want[a.UID] { + t.Errorf("uid=%s on-disk realm=%q want %q", a.UID, got, want[a.UID]) + } + } +} + +// TestLoadDirBackfillWriteFailureDoesNotBlock 单个文件 backfill 落盘失败(tmp 预置目录 +// 使 WriteFile 失败)不阻断启动:其他文件照常迁移,LoadDir 不向上抛错。 +// (历史纯 CN auth 目录一次性迁移时,个别文件不可写不应让整个服务起不来。) +func TestLoadDirBackfillWriteFailureDoesNotBlock(t *testing.T) { + t.Parallel() + dir := t.TempDir() + good := `{"auth":{"accessToken":"at","refreshToken":"r","expiresAt":1,"domain":"www.workbuddy.ai"},"account":{"uid":"g1"}}` + if err := os.WriteFile(filepath.Join(dir, "workbuddy-g1.json"), []byte(good), 0o600); err != nil { + t.Fatal(err) + } + // 预置同名 .tmp 目录 → SaveAtomic 的 os.WriteFile(".tmp") 报 is a directory。 + if err := os.Mkdir(filepath.Join(dir, "workbuddy-c1.json.tmp"), 0o700); err != nil { + t.Fatal(err) + } + bad := `{"auth":{"accessToken":"at","refreshToken":"r","expiresAt":1},"account":{"uid":"c1"}}` + if err := os.WriteFile(filepath.Join(dir, "workbuddy-c1.json"), []byte(bad), 0o600); err != nil { + t.Fatal(err) + } + + list, err := LoadDir(dir) + if err != nil { + t.Fatalf("load err=%v want nil (write failure must not block startup)", err) + } + if len(list) != 2 { + t.Fatalf("want 2 accounts loaded, got %d", len(list)) + } + // 好文件迁移成功 + raw, _ := os.ReadFile(filepath.Join(dir, "workbuddy-g1.json")) + b, _ := Parse(raw) + if b.RealmStored() != "global" { + t.Errorf("good file realm=%q want global (migration should succeed)", b.RealmStored()) + } +} + +// TestLoadDirNewestFileWinsForDuplicateUID 同一 uid 多份文件时,最后一项必须是 mtime 最新的那份 +// ——pool.SyncToDir 的 upsert 是「后载入者胜出」,所以 LoadDir 的顺序决定了哪个凭证活下来。 +// 客户端会写 ....info 这类轮转备份,字典序可能让陈旧备份排在后面。 +func TestLoadDirNewestFileWinsForDuplicateUID(t *testing.T) { + dir := t.TempDir() + write := func(name, at string, mt time.Time) { + body := fmt.Sprintf(`{"auth":{"accessToken":%q,"refreshToken":"r","expiresAt":1800000000,"domain":"www.codebuddy.cn"},"account":{"uid":"u7"}}`, at) + p := filepath.Join(dir, name) + if err := os.WriteFile(p, []byte(body), 0o600); err != nil { + t.Fatal(err) + } + if err := os.Chtimes(p, mt, mt); err != nil { + t.Fatal(err) + } + } + // 字典序在后、但内容陈旧的那份故意命名 workbuddy-z-,mtime 设为 2020。 + write("workbuddy-z-stale.json", "at-stale", time.Date(2020, 1, 1, 0, 0, 0, 0, time.UTC)) + write("workbuddy-a-fresh.json", "at-fresh", time.Date(2026, 1, 1, 0, 0, 0, 0, time.UTC)) + + list, err := LoadDir(dir) + if err != nil { + t.Fatalf("load err=%v", err) + } + if len(list) != 2 { + t.Fatalf("want 2 files loaded, got %d", len(list)) + } + if got := list[len(list)-1].AccessToken; got != "at-fresh" { + t.Fatalf("最后一项应是 mtime 最新的凭证(pool 按后载入者胜出),实际 %q", got) + } +} + +// TestLoadDirDuplicateUIDWarning 同 UID 双 realm auth 文件(概率近零的 EDGE):LoadDir +// 检测到重复 UID 时打 WARN(含两文件路径),且不改变加载行为——后载入者胜出(返回 1 个、 +// 不 panic、realm 为后载入者值)。LoadDir 现在有额外 seenUID 副作用,逐字验证 WARN。 +func TestLoadDirDuplicateUIDWarning(t *testing.T) { + dir := t.TempDir() + // 同一 UID u9 的两个文件:cn realm 文件按文件名排序在前(workbuddy-a-...), + // global realm 文件在后 → 后载入者(global)胜出。 + cn := `{"auth":{"accessToken":"at1","refreshToken":"r","expiresAt":1,"domain":"www.codebuddy.cn"},"account":{"uid":"u9"}}` + gl := `{"auth":{"accessToken":"at2","refreshToken":"r","expiresAt":1,"domain":"www.workbuddy.ai"},"account":{"uid":"u9"}}` + if err := os.WriteFile(filepath.Join(dir, "workbuddy-a-cn.json"), []byte(cn), 0o600); err != nil { + t.Fatal(err) + } + if err := os.WriteFile(filepath.Join(dir, "workbuddy-z-global.json"), []byte(gl), 0o600); err != nil { + t.Fatal(err) + } + + // 捕获 log 输出(本测试不 t.Parallel:log.SetOutput 是进程级全局,需串行)。 + old := log.Writer() + r, w, err := os.Pipe() + if err != nil { + t.Fatal(err) + } + log.SetOutput(w) + + list, err := LoadDir(dir) + _ = w.Close() + raw, _ := io.ReadAll(r) + log.SetOutput(old) + + if err != nil { + t.Fatalf("load err=%v", err) + } + // 行为稳定(不改加载结果):LoadDir 返回全部可解析文件(去重发生在 pool.SyncToDir + // 的 UID 键 upsert),不 panic。 + if len(list) != 2 { + t.Fatalf("want 2 accounts loaded (dedup later in pool), got %d", len(list)) + } + // WARN 已触发,含两文件路径,并点明真实成因(同一账号的个人版/企业版 uid 相同)。 + if !strings.Contains(string(raw), "WARN: uid") || + !strings.Contains(string(raw), "个人版/企业版") || + !strings.Contains(string(raw), "workbuddy-a-cn.json") || + !strings.Contains(string(raw), "workbuddy-z-global.json") { + t.Errorf("expected WARN with both paths, got output: %s", string(raw)) + } +} diff --git a/internal/auth/enterprise_test.go b/internal/auth/enterprise_test.go new file mode 100644 index 0000000000000000000000000000000000000000..0a5aab3a08b4cc59670b1d119ccc267ac3d89b6e --- /dev/null +++ b/internal/auth/enterprise_test.go @@ -0,0 +1,39 @@ +package auth + +import "testing" + +// TestIsEnterprise 企业版判定:enterpriseId 非空即企业版(纯空白视为非企业)。 +// 该判定驱动 scheduler 五类任务与 panel 成长任务/签到入口的门控——企业版在这些 +// 端点上被上游一律拒绝(400 code 10001 / 403 growth-only),误判为个人号会导致 +// 每日对注定失败的端点空发请求。 +func TestIsEnterprise(t *testing.T) { + cases := []struct { + name string + ent string + want bool + }{ + {"个人号(空)", "", false}, + {"纯空白", " ", false}, + {"企业号", "fn7xvyc51dkw", true}, + } + for _, c := range cases { + t.Run(c.name, func(t *testing.T) { + a := &Auth{UID: "u1", EnterpriseID: c.ent} + if got := a.IsEnterprise(); got != c.want { + t.Errorf("EnterpriseID=%q IsEnterprise()=%v want %v", c.ent, got, c.want) + } + }) + } +} + +// TestIsEnterpriseAndIsGlobalIndependent 企业标识与 realm 是正交维度: +// 企业号恒为 CN realm,但两者判定互不干扰(门控引用处并列书写)。 +func TestIsEnterpriseAndIsGlobalIndependent(t *testing.T) { + a := &Auth{UID: "u1", EnterpriseID: "ent-1"} + if !a.IsEnterprise() { + t.Error("应判为企业版") + } + if a.IsGlobal() { + t.Error("企业号不应被判为 global") + } +} diff --git a/internal/auth/expires_test.go b/internal/auth/expires_test.go new file mode 100644 index 0000000000000000000000000000000000000000..1387988f3df4062ea91889ff81e8c1601845a59a --- /dev/null +++ b/internal/auth/expires_test.go @@ -0,0 +1,88 @@ +package auth + +import ( + "testing" + "time" +) + +// TestParseNormalizesOfficialCLIExpiresAt 覆盖官方 CLI 凭据文件的导入: +// 官方写 expiresAt 为**毫秒**,本仓内部按 Unix 秒。不归一会让到期时间落到公元 +// 58800 年 → NeedsRefresh 恒 false → token 永不刷新 → 到期后账号静默 401。 +func TestParseNormalizesOfficialCLIExpiresAt(t *testing.T) { + // 取自真实官方凭据文件(2026-10-24,www.codebuddy.ai)。 + const cliMillis = 1795254516410 + wantSec := int64(cliMillis / 1000) + + raw := []byte(`{ + "account": {"uid":"00000000-0000-4000-8000-000000000001","nickname":"misakano7545","uin":"000000000000"}, + "auth": {"accessToken":"at","refreshToken":"rt","expiresAt":1795254516410, + "domain":"www.codebuddy.ai","tokenType":"Bearer","expiresIn":2418995} + }`) + a, err := Parse(raw) + if err != nil { + t.Fatalf("Parse: %v", err) + } + if a.ExpiresAt != wantSec { + t.Errorf("ExpiresAt=%d want %d(毫秒未归一)", a.ExpiresAt, wantSec) + } + // 归一后必须落在合理区间:距今不到 1 年(官方 expiresIn 约 28 天)。 + if d := time.Until(time.Unix(a.ExpiresAt, 0)); d <= 0 || d > 400*24*time.Hour { + t.Errorf("归一后到期时间不合理:%v(now+%v)", time.Unix(a.ExpiresAt, 0), d) + } + // 官方国际站域必须判 global(否则错域路由)。 + if got := a.Realm(); got != "global" { + t.Errorf("Realm()=%q want global", got) + } + // NeedsRefresh:28 天后到期的 token 现在不该被要求刷新。 + if a.NeedsRefresh(time.Hour) { + t.Error("NeedsRefresh=true,说明到期时间仍被当成毫秒(未来过远)或已过期") + } +} + +// TestParseKeepsSeconds 覆盖旧格式:秒制 expiresAt 必须原样保留(不能被误除以 1000)。 +func TestParseKeepsSeconds(t *testing.T) { + const sec = int64(1795254516) + raw := []byte(`{"auth":{"accessToken":"at","refreshToken":"rt","expiresAt":1795254516,"domain":"www.codebuddy.cn"}}`) + a, err := Parse(raw) + if err != nil { + t.Fatalf("Parse: %v", err) + } + if a.ExpiresAt != sec { + t.Errorf("ExpiresAt=%d want %d(秒制被误改)", a.ExpiresAt, sec) + } +} + +// TestParseFlatFormNormalizesToo 覆盖扁平形(手写 auth 文件):两条解析分支都必须归一。 +func TestParseFlatFormNormalizesToo(t *testing.T) { + raw := []byte(`{"uid":"u1","accessToken":"at","refreshToken":"rt","expiresAt":1795254516410,"domain":"www.workbuddy.ai"}`) + a, err := Parse(raw) + if err != nil { + t.Fatalf("Parse: %v", err) + } + if a.ExpiresAt != 1795254516 { + t.Errorf("ExpiresAt=%d want 1795254516", a.ExpiresAt) + } + if got := a.Realm(); got != "global" { + t.Errorf("Realm()=%q want global", got) + } +} + +// TestNormalizeExpiresAt 覆盖阈值边界:秒制最大合理值不动,毫秒制一律 /1000。 +func TestNormalizeExpiresAt(t *testing.T) { + cases := []struct { + in int64 + want int64 + }{ + {in: 0, want: 0}, + {in: 1, want: 1}, + {in: 1795254516, want: 1795254516}, // 秒制当前值 + {in: expiresAtMillisThreshold, want: expiresAtMillisThreshold}, // 恰在阈值上:按秒(不越过才换算) + {in: expiresAtMillisThreshold + 1, want: (expiresAtMillisThreshold + 1) / 1000}, + {in: 1795254516410, want: 1795254516}, // 毫秒制当前值 + } + for _, c := range cases { + if got := normalizeExpiresAt(c.in); got != c.want { + t.Errorf("normalizeExpiresAt(%d)=%d want %d", c.in, got, c.want) + } + } +} diff --git a/internal/auth/permhint_test.go b/internal/auth/permhint_test.go index bbd93260eedf369bf4ee45d4fea2d152ea6fc33e..120447006c5ea235ec9d2d6995c8577bab324c61 100644 --- a/internal/auth/permhint_test.go +++ b/internal/auth/permhint_test.go @@ -1,29 +1,29 @@ -package auth - -import ( - "os" - "path/filepath" - "runtime" - "strings" - "testing" -) - -// TestSaveAtomicPermissionHint 无写权限目录下保存,错误应包含 Docker chown 指引。 -func TestSaveAtomicPermissionHint(t *testing.T) { - if runtime.GOOS == "windows" || os.Geteuid() == 0 { - t.Skip("Windows 无 POSIX 权限语义 / root 无权限限制,跳过") - } - dir := t.TempDir() - ro := filepath.Join(dir, "ro") - os.MkdirAll(ro, 0o555) // 只读目录 - defer os.Chmod(ro, 0o755) - a := &Auth{AccessToken: "at", RefreshToken: "rt", ExpiresAt: 1, - UID: "u1", FilePath: filepath.Join(ro, "workbuddy-u1.json")} - err := a.SaveAtomic() - if err == nil { - t.Fatal("只读目录保存应失败") - } - if !strings.Contains(err.Error(), "chown") || !strings.Contains(err.Error(), "10001") { - t.Errorf("权限错误应包含 Docker 指引,实际: %v", err) - } -} +package auth + +import ( + "os" + "path/filepath" + "runtime" + "strings" + "testing" +) + +// TestSaveAtomicPermissionHint 无写权限目录下保存,错误应包含 Docker chown 指引。 +func TestSaveAtomicPermissionHint(t *testing.T) { + if runtime.GOOS == "windows" || os.Geteuid() == 0 { + t.Skip("Windows 无 POSIX 权限语义 / root 无权限限制,跳过") + } + dir := t.TempDir() + ro := filepath.Join(dir, "ro") + os.MkdirAll(ro, 0o555) // 只读目录 + defer os.Chmod(ro, 0o755) + a := &Auth{AccessToken: "at", RefreshToken: "rt", ExpiresAt: 1, + UID: "u1", FilePath: filepath.Join(ro, "workbuddy-u1.json")} + err := a.SaveAtomic() + if err == nil { + t.Fatal("只读目录保存应失败") + } + if !strings.Contains(err.Error(), "chown") || !strings.Contains(err.Error(), "10001") { + t.Errorf("权限错误应包含 Docker 指引,实际: %v", err) + } +} diff --git a/internal/auth/realm_test.go b/internal/auth/realm_test.go index 82a6e7daed6c9e4c637212755eb652b86c518ee9..7d2aaebb4f47b7251efe796108ca24687a62b50f 100644 --- a/internal/auth/realm_test.go +++ b/internal/auth/realm_test.go @@ -1,275 +1,284 @@ -package auth - -import ( - "os" - "path/filepath" - "testing" -) - -// withGlobalEnabled 临时打开 global realm 开关(生产缺省即开,此辅助仅显式确保), -// 测试结束复位为开启态(缺省)。 -func withGlobalEnabled(t *testing.T) { - t.Helper() - globalEnabled.Store(true) - t.Cleanup(func() { globalEnabled.Store(true) }) -} - -// withGlobalDisabled 临时关闭 global realm 开关(逃生门),测试结束复位为开启态(缺省)。 -func withGlobalDisabled(t *testing.T) { - t.Helper() - globalEnabled.Store(false) - t.Cleanup(func() { globalEnabled.Store(true) }) -} - -func TestRealmExplicitGlobal(t *testing.T) { - withGlobalEnabled(t) - a := &Auth{realm: "global"} - if got := a.Realm(); got != "global" { - t.Errorf("Realm()=%q want global", got) - } - if !a.IsGlobal() { - t.Error("IsGlobal()=false want true") - } -} - -func TestRealmExplicitCN(t *testing.T) { - a := &Auth{realm: "cn"} - if got := a.Realm(); got != "cn" { - t.Errorf("Realm()=%q want cn", got) - } - if a.IsGlobal() { - t.Error("IsGlobal()=true want false") - } -} - -func TestRealmDomainFallback(t *testing.T) { - withGlobalEnabled(t) - cases := []struct{ domain, want string }{ - {"www.workbuddy.ai", "global"}, - {"workbuddy.ai", "global"}, - {"sub.workbuddy.ai", "global"}, - {"www.codebuddy.cn", "cn"}, - {"", "cn"}, - } - for _, c := range cases { - a := &Auth{Domain: c.domain} - if got := a.Realm(); got != c.want { - t.Errorf("Domain=%q Realm()=%q want %q", c.domain, got, c.want) - } - } -} - -func TestRealmEmptyFallsBackToCN(t *testing.T) { - // 开关缺省开启(零回归前提):空 realm + 空 domain → cn(老 CN 凭证的核心)。 - a := &Auth{} - if got := a.Realm(); got != "cn" { - t.Errorf("Realm()=%q want cn", got) - } - // 显式 global → global(缺省开启,Realm() 不再因"未配置"而恒 cn)。 - ag := &Auth{realm: "global"} - if got := ag.Realm(); got != "global" { - t.Errorf("Realm()=%q want global", got) - } - // domain 回落照常(缺省开启识别 workbuddy.ai)。 - ad := &Auth{Domain: "www.workbuddy.ai"} - if got := ad.Realm(); got != "global" { - t.Errorf("Realm()=%q want global", got) - } -} - -// TestRealmDefaultOnForCNZeroRegression 开关缺省开启时,老 CN 凭证(无 realm、无 domain) -// Realm() 恒为 cn——「默认开启」不影响纯 CN 部署行为。 -func TestRealmDefaultOnForCNZeroRegression(t *testing.T) { - withGlobalEnabled(t) - cases := []*Auth{ - {}, - {Domain: "www.codebuddy.cn"}, - {Domain: "codebuddy.cn"}, - {realm: "cn"}, - {realm: "cn", Domain: "www.codebuddy.cn"}, - } - for _, a := range cases { - if got := a.Realm(); got != "cn" { - t.Errorf("%+v Realm()=%q want cn", a, got) - } - if a.IsGlobal() { - t.Errorf("%+v IsGlobal()=true want false", a) - } - } -} - -// TestRealmExplicitOffEscapeHatch 逃生门:SetGlobalEnabled(false) 后恒 cn, -// 即便 realm=global / domain=workbuddy.ai(纯 CN 锁定,与旧缺省行为等价)。 -func TestRealmExplicitOffEscapeHatch(t *testing.T) { - withGlobalDisabled(t) - cases := []struct { - auth *Auth - }{ - {&Auth{realm: "global"}}, - {&Auth{realm: "global", Domain: "www.workbuddy.ai"}}, - {&Auth{Domain: "www.workbuddy.ai"}}, - } - for _, tc := range cases { - if got := tc.auth.Realm(); got != "cn" { - t.Errorf("%+v Realm()=%q want cn (switch off)", tc.auth, got) - } - if tc.auth.IsGlobal() { - t.Errorf("%+v IsGlobal()=true want false (switch off)", tc.auth) - } - } -} - -func TestParseNestedRealm(t *testing.T) { - raw := []byte(`{"auth":{"accessToken":"at","refreshToken":"rt","expiresAt":1,"domain":"www.workbuddy.ai","realm":"global"},"account":{"uid":"u1"}}`) - sa, err := Parse(raw) - if err != nil { - t.Fatalf("nested parse err: %v", err) - } - if sa.realm != "global" { - t.Errorf("nested realm=%q want global", sa.realm) - } - // 嵌套形显式 realm 空 → 读不到,靠 domain 回落。 - raw2 := []byte(`{"auth":{"accessToken":"at","refreshToken":"rt","expiresAt":1},"account":{"uid":"u1"}}`) - sa2, err := Parse(raw2) - if err != nil { - t.Fatalf("nested no-realm parse err: %v", err) - } - if sa2.realm != "" { - t.Errorf("nested missing realm key should be zero, got %q", sa2.realm) - } -} - -func TestParseFlatRealm(t *testing.T) { - withGlobalEnabled(t) - raw := []byte(`{"accessToken":"at","refreshToken":"rt","expiresAt":1,"uid":"u2","realm":"global"}`) - fa, err := Parse(raw) - if err != nil { - t.Fatalf("flat parse err: %v", err) - } - if fa.realm != "global" { - t.Errorf("flat realm=%q want global", fa.realm) - } - if !fa.IsGlobal() { - t.Error("flat global account IsGlobal()=false want true") - } - // 扁平形缺 realm 键 → 零值 → CN。 - flatCN := []byte(`{"accessToken":"at","refreshToken":"rt","expiresAt":1,"uid":"u3"}`) - fc, err := Parse(flatCN) - if err != nil { - t.Fatalf("flat cn parse err: %v", err) - } - if fc.realm != "" { - t.Errorf("flat missing realm should be zero, got %q", fc.realm) - } -} - -func TestSaveAtomicWritesRealm(t *testing.T) { - withGlobalEnabled(t) - dir := t.TempDir() - fp := filepath.Join(dir, "workbuddy-global.json") - a := &Auth{AccessToken: "at", RefreshToken: "rt", ExpiresAt: 1, - UID: "g1", realm: "global", FilePath: fp} - if err := a.SaveAtomic(); err != nil { - t.Fatalf("save: %v", err) - } - raw, err := os.ReadFile(fp) - if err != nil { - t.Fatalf("read: %v", err) - } - b, err := Parse(raw) - if err != nil { - t.Fatalf("reparse: %v", err) - } - if b.realm != "global" { - t.Errorf("roundtrip realm=%q want global", b.realm) - } - if !b.IsGlobal() { - t.Error("roundtrip global account IsGlobal()=false") - } -} - -// TestBackfillRealmDomain CN/global 按原始 domain 推断(backfill 为导出空 realm 字段服务)。 -func TestBackfillRealmDomain(t *testing.T) { - t.Parallel() // 不触碰全局开关 - cases := []struct { - domain string - want string - }{ - {"www.workbuddy.ai", "global"}, - {"workbuddy.ai", "global"}, - {"sub.workbuddy.ai", "global"}, - {"www.codebuddy.cn", "cn"}, - {"codebuddy.cn", "cn"}, - {"", "cn"}, // 空 domain + 空 realm → cn(老 CN 凭证核心) - } - for _, c := range cases { - a := &Auth{Domain: c.domain} - changed, got := a.BackfillRealm() - if !changed { - t.Errorf("Domain=%q backfill changed=false want true", c.domain) - } - assertRealmStored(a, c.want, t) - if got != c.want { - t.Errorf("Domain=%q backfill got realm=%q want %q", c.domain, got, c.want) - } - } -} - -// TestBackfillRealmEscapeHatchFree 逃生门关闭时 backfill 仍按原始 domain 推断(不受 Realm() 降级影响)。 -func TestBackfillRealmEscapeHatchFree(t *testing.T) { - withGlobalDisabled(t) // 逃生门关闭:Realm() 恒 cn,但 backfill 不得被污染 - a := &Auth{Domain: "www.workbuddy.ai"} - if g := a.Realm(); g != "cn" { - t.Fatalf("precondition Realm()=%q want cn (escape hatch on)", g) - } - changed, got := a.BackfillRealm() - if !changed { - t.Fatal("backfill changed=false want true (escape hatch free)") - } - assertRealmStored(a, "global", t) - if got != "global" { - t.Errorf("backfill got=%q want global (escape hatch must not corrupt backfill)", got) - } -} - -// TestBackfillRealmIdempotent 已有 realm 标识的文件不做修改(幂等)。 -func TestBackfillRealmIdempotent(t *testing.T) { - t.Parallel() - a := &Auth{Domain: "www.workbuddy.ai", realm: "cn"} // 已有 cn,domain 会推断 global——绝不覆盖 - changed, got := a.BackfillRealm() - if changed { - t.Errorf("backfill changed=true want false (existing realm must win)") - } - if got != "cn" { - t.Errorf("backfill got=%q want cn (existing realm preserved)", got) - } - assertRealmStored(a, "cn", t) -} - -func assertRealmStored(a *Auth, want string, t *testing.T) { - t.Helper() - if a.realm != want { - t.Errorf("stored realm field=%q want %q", a.realm, want) - } -} - -// TestResolveRealm 纯函数归一化显式 realm,缺失时按 domain 推断(与 BackfillRealm -// 共用同一来源;不受逃生门影响)。显式值优先于 domain 推断。 -func TestResolveRealm(t *testing.T) { - t.Parallel() // 纯函数:不触碰全局开关 - cases := []struct { - explicit, domain, want string - }{ - {"global", "www.codebuddy.cn", "global"}, // 显式优先:cn domain 也写 global - {"cn", "www.workbuddy.ai", "cn"}, // 显式优先:global domain 也写 cn - {"", "www.workbuddy.ai", "global"}, // 缺省按 domain 推断 - {"", "workbuddy.ai", "global"}, - {"", "codebuddy.cn", "cn"}, - {"", "", "cn"}, // 空 domain → cn(老 CN 凭证零回归) - } - for _, c := range cases { - if got := ResolveRealm(c.explicit, c.domain); got != c.want { - t.Errorf("ResolveRealm(%q,%q)=%q want %q", c.explicit, c.domain, got, c.want) - } - } -} +package auth + +import ( + "os" + "path/filepath" + "testing" +) + +// withGlobalEnabled 临时打开 global realm 开关(生产缺省即开,此辅助仅显式确保), +// 测试结束复位为开启态(缺省)。 +func withGlobalEnabled(t *testing.T) { + t.Helper() + globalEnabled.Store(true) + t.Cleanup(func() { globalEnabled.Store(true) }) +} + +// withGlobalDisabled 临时关闭 global realm 开关(逃生门),测试结束复位为开启态(缺省)。 +func withGlobalDisabled(t *testing.T) { + t.Helper() + globalEnabled.Store(false) + t.Cleanup(func() { globalEnabled.Store(true) }) +} + +func TestRealmExplicitGlobal(t *testing.T) { + withGlobalEnabled(t) + a := &Auth{realm: "global"} + if got := a.Realm(); got != "global" { + t.Errorf("Realm()=%q want global", got) + } + if !a.IsGlobal() { + t.Error("IsGlobal()=false want true") + } +} + +func TestRealmExplicitCN(t *testing.T) { + a := &Auth{realm: "cn"} + if got := a.Realm(); got != "cn" { + t.Errorf("Realm()=%q want cn", got) + } + if a.IsGlobal() { + t.Error("IsGlobal()=true want false") + } +} + +func TestRealmDomainFallback(t *testing.T) { + withGlobalEnabled(t) + cases := []struct{ domain, want string }{ + {"www.workbuddy.ai", "global"}, + {"workbuddy.ai", "global"}, + {"sub.workbuddy.ai", "global"}, + // 官方 CLI 国际站域(product.json externalDomain):不认它会把国际站账号 + // 误判成 cn,手写 auth 文件(无显式 realm 键)直接错域路由。 + {"www.codebuddy.ai", "global"}, + {"codebuddy.ai", "global"}, + {"api.codebuddy.ai", "global"}, + {"WWW.CODEBUDDY.AI", "global"}, + {"www.codebuddy.cn", "cn"}, + {"", "cn"}, + // 相似后缀不能误吞(HasSuffix 必须带点)。 + {"evilcodebuddy.ai", "cn"}, + {"codebuddy.ai.evil.com", "cn"}, + } + for _, c := range cases { + a := &Auth{Domain: c.domain} + if got := a.Realm(); got != c.want { + t.Errorf("Domain=%q Realm()=%q want %q", c.domain, got, c.want) + } + } +} + +func TestRealmEmptyFallsBackToCN(t *testing.T) { + // 开关缺省开启(零回归前提):空 realm + 空 domain → cn(老 CN 凭证的核心)。 + a := &Auth{} + if got := a.Realm(); got != "cn" { + t.Errorf("Realm()=%q want cn", got) + } + // 显式 global → global(缺省开启,Realm() 不再因"未配置"而恒 cn)。 + ag := &Auth{realm: "global"} + if got := ag.Realm(); got != "global" { + t.Errorf("Realm()=%q want global", got) + } + // domain 回落照常(缺省开启识别 workbuddy.ai)。 + ad := &Auth{Domain: "www.workbuddy.ai"} + if got := ad.Realm(); got != "global" { + t.Errorf("Realm()=%q want global", got) + } +} + +// TestRealmDefaultOnForCNZeroRegression 开关缺省开启时,老 CN 凭证(无 realm、无 domain) +// Realm() 恒为 cn——「默认开启」不影响纯 CN 部署行为。 +func TestRealmDefaultOnForCNZeroRegression(t *testing.T) { + withGlobalEnabled(t) + cases := []*Auth{ + {}, + {Domain: "www.codebuddy.cn"}, + {Domain: "codebuddy.cn"}, + {realm: "cn"}, + {realm: "cn", Domain: "www.codebuddy.cn"}, + } + for _, a := range cases { + if got := a.Realm(); got != "cn" { + t.Errorf("%+v Realm()=%q want cn", a, got) + } + if a.IsGlobal() { + t.Errorf("%+v IsGlobal()=true want false", a) + } + } +} + +// TestRealmExplicitOffEscapeHatch 逃生门:SetGlobalEnabled(false) 后恒 cn, +// 即便 realm=global / domain=workbuddy.ai(纯 CN 锁定,与旧缺省行为等价)。 +func TestRealmExplicitOffEscapeHatch(t *testing.T) { + withGlobalDisabled(t) + cases := []struct { + auth *Auth + }{ + {&Auth{realm: "global"}}, + {&Auth{realm: "global", Domain: "www.workbuddy.ai"}}, + {&Auth{Domain: "www.workbuddy.ai"}}, + } + for _, tc := range cases { + if got := tc.auth.Realm(); got != "cn" { + t.Errorf("%+v Realm()=%q want cn (switch off)", tc.auth, got) + } + if tc.auth.IsGlobal() { + t.Errorf("%+v IsGlobal()=true want false (switch off)", tc.auth) + } + } +} + +func TestParseNestedRealm(t *testing.T) { + raw := []byte(`{"auth":{"accessToken":"at","refreshToken":"rt","expiresAt":1,"domain":"www.workbuddy.ai","realm":"global"},"account":{"uid":"u1"}}`) + sa, err := Parse(raw) + if err != nil { + t.Fatalf("nested parse err: %v", err) + } + if sa.realm != "global" { + t.Errorf("nested realm=%q want global", sa.realm) + } + // 嵌套形显式 realm 空 → 读不到,靠 domain 回落。 + raw2 := []byte(`{"auth":{"accessToken":"at","refreshToken":"rt","expiresAt":1},"account":{"uid":"u1"}}`) + sa2, err := Parse(raw2) + if err != nil { + t.Fatalf("nested no-realm parse err: %v", err) + } + if sa2.realm != "" { + t.Errorf("nested missing realm key should be zero, got %q", sa2.realm) + } +} + +func TestParseFlatRealm(t *testing.T) { + withGlobalEnabled(t) + raw := []byte(`{"accessToken":"at","refreshToken":"rt","expiresAt":1,"uid":"u2","realm":"global"}`) + fa, err := Parse(raw) + if err != nil { + t.Fatalf("flat parse err: %v", err) + } + if fa.realm != "global" { + t.Errorf("flat realm=%q want global", fa.realm) + } + if !fa.IsGlobal() { + t.Error("flat global account IsGlobal()=false want true") + } + // 扁平形缺 realm 键 → 零值 → CN。 + flatCN := []byte(`{"accessToken":"at","refreshToken":"rt","expiresAt":1,"uid":"u3"}`) + fc, err := Parse(flatCN) + if err != nil { + t.Fatalf("flat cn parse err: %v", err) + } + if fc.realm != "" { + t.Errorf("flat missing realm should be zero, got %q", fc.realm) + } +} + +func TestSaveAtomicWritesRealm(t *testing.T) { + withGlobalEnabled(t) + dir := t.TempDir() + fp := filepath.Join(dir, "workbuddy-global.json") + a := &Auth{AccessToken: "at", RefreshToken: "rt", ExpiresAt: 1, + UID: "g1", realm: "global", FilePath: fp} + if err := a.SaveAtomic(); err != nil { + t.Fatalf("save: %v", err) + } + raw, err := os.ReadFile(fp) + if err != nil { + t.Fatalf("read: %v", err) + } + b, err := Parse(raw) + if err != nil { + t.Fatalf("reparse: %v", err) + } + if b.realm != "global" { + t.Errorf("roundtrip realm=%q want global", b.realm) + } + if !b.IsGlobal() { + t.Error("roundtrip global account IsGlobal()=false") + } +} + +// TestBackfillRealmDomain CN/global 按原始 domain 推断(backfill 为导出空 realm 字段服务)。 +func TestBackfillRealmDomain(t *testing.T) { + t.Parallel() // 不触碰全局开关 + cases := []struct { + domain string + want string + }{ + {"www.workbuddy.ai", "global"}, + {"workbuddy.ai", "global"}, + {"sub.workbuddy.ai", "global"}, + {"www.codebuddy.cn", "cn"}, + {"codebuddy.cn", "cn"}, + {"", "cn"}, // 空 domain + 空 realm → cn(老 CN 凭证核心) + } + for _, c := range cases { + a := &Auth{Domain: c.domain} + changed, got := a.BackfillRealm() + if !changed { + t.Errorf("Domain=%q backfill changed=false want true", c.domain) + } + assertRealmStored(a, c.want, t) + if got != c.want { + t.Errorf("Domain=%q backfill got realm=%q want %q", c.domain, got, c.want) + } + } +} + +// TestBackfillRealmEscapeHatchFree 逃生门关闭时 backfill 仍按原始 domain 推断(不受 Realm() 降级影响)。 +func TestBackfillRealmEscapeHatchFree(t *testing.T) { + withGlobalDisabled(t) // 逃生门关闭:Realm() 恒 cn,但 backfill 不得被污染 + a := &Auth{Domain: "www.workbuddy.ai"} + if g := a.Realm(); g != "cn" { + t.Fatalf("precondition Realm()=%q want cn (escape hatch on)", g) + } + changed, got := a.BackfillRealm() + if !changed { + t.Fatal("backfill changed=false want true (escape hatch free)") + } + assertRealmStored(a, "global", t) + if got != "global" { + t.Errorf("backfill got=%q want global (escape hatch must not corrupt backfill)", got) + } +} + +// TestBackfillRealmIdempotent 已有 realm 标识的文件不做修改(幂等)。 +func TestBackfillRealmIdempotent(t *testing.T) { + t.Parallel() + a := &Auth{Domain: "www.workbuddy.ai", realm: "cn"} // 已有 cn,domain 会推断 global——绝不覆盖 + changed, got := a.BackfillRealm() + if changed { + t.Errorf("backfill changed=true want false (existing realm must win)") + } + if got != "cn" { + t.Errorf("backfill got=%q want cn (existing realm preserved)", got) + } + assertRealmStored(a, "cn", t) +} + +func assertRealmStored(a *Auth, want string, t *testing.T) { + t.Helper() + if a.realm != want { + t.Errorf("stored realm field=%q want %q", a.realm, want) + } +} + +// TestResolveRealm 纯函数归一化显式 realm,缺失时按 domain 推断(与 BackfillRealm +// 共用同一来源;不受逃生门影响)。显式值优先于 domain 推断。 +func TestResolveRealm(t *testing.T) { + t.Parallel() // 纯函数:不触碰全局开关 + cases := []struct { + explicit, domain, want string + }{ + {"global", "www.codebuddy.cn", "global"}, // 显式优先:cn domain 也写 global + {"cn", "www.workbuddy.ai", "cn"}, // 显式优先:global domain 也写 cn + {"", "www.workbuddy.ai", "global"}, // 缺省按 domain 推断 + {"", "workbuddy.ai", "global"}, + {"", "codebuddy.cn", "cn"}, + {"", "", "cn"}, // 空 domain → cn(老 CN 凭证零回归) + } + for _, c := range cases { + if got := ResolveRealm(c.explicit, c.domain); got != c.want { + t.Errorf("ResolveRealm(%q,%q)=%q want %q", c.explicit, c.domain, got, c.want) + } + } +} diff --git a/internal/auth/recover_test.go b/internal/auth/recover_test.go new file mode 100644 index 0000000000000000000000000000000000000000..053f4cc4653bf8f3174773b161e727a0497abdc8 --- /dev/null +++ b/internal/auth/recover_test.go @@ -0,0 +1,56 @@ +package auth + +import ( + "os" + "path/filepath" + "testing" +) + +// 掉电把凭证文件留成全 0(长度不变、内容全空)时,账号不能凭空消失: +// 上一次写入留下的 .bak 顶上,该账号照常在池里。 +func TestLoadDirRecoversZeroedAuthFile(t *testing.T) { + dir := t.TempDir() + fp := filepath.Join(dir, "workbuddy-u1.json") + a := &Auth{AccessToken: "at1", RefreshToken: "rt1", ExpiresAt: 1753600000, UID: "u1", FilePath: fp} + if err := a.SaveAtomic(); err != nil { + t.Fatalf("save: %v", err) + } + a.AccessToken = "at2" // 第二次写入 → .bak 里是 at1 那份 + if err := a.SaveAtomic(); err != nil { + t.Fatalf("save: %v", err) + } + st, err := os.Stat(fp) + if err != nil { + t.Fatal(err) + } + if err := os.WriteFile(fp, make([]byte, st.Size()), 0o600); err != nil { + t.Fatal(err) + } + + list, err := LoadDir(dir) + if err != nil { + t.Fatalf("load: %v", err) + } + if len(list) != 1 || list[0].UID != "u1" || list[0].AccessToken != "at1" { + t.Fatalf("want u1 recovered from .bak with at1, got %+v", list) + } +} + +// 正文坏且没有 .bak:不静默跳过也不行,只能放弃这个文件——但不能影响别的账号。 +func TestLoadDirSkipsUnrecoverableFile(t *testing.T) { + dir := t.TempDir() + good := filepath.Join(dir, "workbuddy-ok.json") + if err := os.WriteFile(good, []byte(`{"auth":{"accessToken":"at","refreshToken":"r","expiresAt":1},"account":{"uid":"ok"}}`), 0o600); err != nil { + t.Fatal(err) + } + if err := os.WriteFile(filepath.Join(dir, "workbuddy-bad.json"), []byte(`{"auth":`), 0o600); err != nil { + t.Fatal(err) + } + list, err := LoadDir(dir) + if err != nil { + t.Fatalf("load: %v", err) + } + if len(list) != 1 || list[0].UID != "ok" { + t.Fatalf("got %+v", list) + } +} diff --git a/internal/auth/testdata/wbencrypted-auth.json b/internal/auth/testdata/wbencrypted-auth.json new file mode 100644 index 0000000000000000000000000000000000000000..7c4226dd61c92c649804dac71781eadacc588f7f --- /dev/null +++ b/internal/auth/testdata/wbencrypted-auth.json @@ -0,0 +1,31 @@ +{ + "account": { + "uid": "uid-wb-1", + "uin": "10001", + "nickname": { + "$wbEncrypted": 1, + "envelope": "eyJzdWl0ZSI6MSwia2V5SWQiOiI5MTI3ZGVhMWI0NDAyMGE3Iiwibm9uY2UiOiJBQkVpTTBSVlpuZUltYXE3IiwiYXV0aFRhZyI6IkdaSTVGQ21wK1NiSmFISGk5bjZxRHc9PSIsImNpcGhlcnRleHQiOiJmRTJTKzJUd3p2TTN0NkZpT2NXZ1VLV2NleGtqRUk0TjF2Nkw0L1V5QURibFNFUzNlNEd6RGpZMjN4YXZ3NDhNQ3YwPSJ9" + }, + "phoneNumber": { + "$wbEncrypted": 1, + "envelope": "eyJzdWl0ZSI6MSwia2V5SWQiOiI5MTI3ZGVhMWI0NDAyMGE3Iiwibm9uY2UiOiJBQkVpTTBSVlpuZUltYXE4IiwiYXV0aFRhZyI6Im52a1RZZTNHODZraUMvVzZ2SFdEU0E9PSIsImNpcGhlcnRleHQiOiIyNmtIT3haSTM3ejJrQzVsZU8zUHE4Z2ZEQkxkSFh3Y2FwTHRDZ2dzS0tSRWllWXJQaHNmM25zUHZhQ2Z0TnRpVmcrNCtPVHBRa0NmRHBJPSJ9" + } + }, + "auth": { + "accessToken": { + "$wbEncrypted": 1, + "envelope": "eyJzdWl0ZSI6MSwia2V5SWQiOiI5MTI3ZGVhMWI0NDAyMGE3Iiwibm9uY2UiOiJBQkVpTTBSVlpuZUltYXE5IiwiYXV0aFRhZyI6ImJJQzJ1blJXVGdZMkxjN2JoUjBnUVE9PSIsImNpcGhlcnRleHQiOiJuWDRaYW8xLyttYndYT2xwRWZWRVIrcWlVUT09In0=" + }, + "refreshToken": { + "$wbEncrypted": 1, + "envelope": "eyJzdWl0ZSI6MSwia2V5SWQiOiI5MTI3ZGVhMWI0NDAyMGE3Iiwibm9uY2UiOiJBQkVpTTBSVlpuZUltYXErIiwiYXV0aFRhZyI6ImY5TjdMbjN5OEtpSzRhTVRmQk84UWc9PSIsImNpcGhlcnRleHQiOiJnQ2tnOWtmM1BYeWdjZVFnOUw1dXM0MmNEUT09In0=" + }, + "expiresAt": { + "$wbEncrypted": 1, + "envelope": "eyJzdWl0ZSI6MSwia2V5SWQiOiI5MTI3ZGVhMWI0NDAyMGE3Iiwibm9uY2UiOiJBQkVpTTBSVlpuZUltYXEvIiwiYXV0aFRhZyI6IlRDaStDN3BHSXpMZjQ1T0NUck1YS0E9PSIsImNpcGhlcnRleHQiOiJPN0RhR1ozemVCSWF5Rm9JQnc9PSJ9" + }, + "domain": "workbuddy.cn", + "realm": "cn" + }, + "device_token": "v3:test-device-token" +} diff --git a/internal/auth/wbencrypted.go b/internal/auth/wbencrypted.go new file mode 100644 index 0000000000000000000000000000000000000000..525c704d2415df18ce504f235ee250df4df99499 --- /dev/null +++ b/internal/auth/wbencrypted.go @@ -0,0 +1,327 @@ +// wbencrypted.go 解密新版桌面端 auth 文件里的 $wbEncrypted 字段。 +// +// 逆向来源:DistPub/workbuddy2api 的 wb_auth_decrypt.js + converter.py +// (对 WorkBuddy.app 逆向得到)。新版桌面端把 auth 文件里 accessToken / +// refreshToken / expiresAt / nickname 等字段换成信封加密: +// +// {"$wbEncrypted":1,"envelope":""} +// +// key = sha256(utf8(atRestSecretKey 字符串本身)),AES-256-GCM; +// keyId = sha256(key) 的 hex 前 16 位,用于校验信封是否由同一把密钥产生; +// AAD 是固定二进制拼接(见 wbFieldAAD)。密钥来自 Electron 原生绑定 +// electron_browser_workbuddy_storage 的 loggerGet(),随版本可能变——keyId +// 对不上时报错,不猜。无 $wbEncrypted 字段的文件原样返回,零成本。 +package auth + +import ( + "bytes" + "crypto/aes" + "crypto/cipher" + "crypto/rand" + "crypto/sha256" + "encoding/base64" + "encoding/binary" + "encoding/hex" + "encoding/json" + "fmt" + "strings" +) + +// wbAtRestSecretKey 桌面端 at-rest 静态密钥(canonical base64,44 位)。 +// 桌面端升级后若 keyId 不再匹配,需重新从 loggerGet() 取,改这里。 +const wbAtRestSecretKey = "Sik9U5aXhCdwTVEwsEySDOmDoB9r9ntFxHF1fst9LQI=" + +// decryptWBEncrypted 递归解出 doc 里所有 $wbEncrypted 字段并重新 marshal。 +// 无加密字段时返回原字节(不做二次序列化,避免把客户端文件格式改写); +// sealed 记录哪些字段原本是信封(形如 "auth.accessToken")——回写时按这份清单 +// 复原,见 sealForSave。 +func decryptWBEncrypted(raw []byte) (out []byte, sealed map[string]bool, err error) { + if !bytes.Contains(raw, []byte(`"$wbEncrypted"`)) { + return raw, nil, nil + } + var doc map[string]any + if err := json.Unmarshal(raw, &doc); err != nil { + // 交给调用方按原路径报 storage_parse_error,这里不抢错误。 + return raw, nil, nil + } + key := sha256.Sum256([]byte(wbAtRestSecretKey)) + sealed = map[string]bool{} + v, changed, err := wbDecryptValue(doc, key, "", sealed) + if err != nil || !changed { + return raw, nil, err + } + out, err = json.Marshal(v) + if err != nil { + return nil, nil, fmt.Errorf("at_rest_marshal_failed: %w", err) + } + return out, sealed, nil +} + +// wbDecryptValue 深度遍历;命中信封就地替换。changed=false 表示整棵树没有加密字段。 +// prefix 是当前节点的路径("auth.accessToken"),命中信封时记进 sealed。 +func wbDecryptValue(v any, key [32]byte, prefix string, sealed map[string]bool) (any, bool, error) { + switch t := v.(type) { + case map[string]any: + if enc, ok := t["$wbEncrypted"].(float64); ok && enc == 1 { + if env, ok := t["envelope"].(string); ok && env != "" { + plain, err := wbDecryptEnvelope(env, key) + if err != nil { + return nil, false, err + } + sealed[prefix] = true + return plain, true, nil + } + } + changed := false + for k, item := range t { + nv, c, err := wbDecryptValue(item, key, wbJoinPath(prefix, k), sealed) + if err != nil { + return nil, false, err + } + if c { + t[k] = nv + changed = true + } + } + return t, changed, nil + case []any: + changed := false + for i, item := range t { + nv, c, err := wbDecryptValue(item, key, fmt.Sprintf("%s[%d]", prefix, i), sealed) + if err != nil { + return nil, false, err + } + if c { + t[i] = nv + changed = true + } + } + return t, changed, nil + } + return v, false, nil +} + +// wbJoinPath 拼 sealed 路径;顶层容器不加前缀("auth.accessToken")。 +func wbJoinPath(prefix, key string) string { + if prefix == "" { + return key + } + return prefix + "." + key +} + +// sealForSave 只重新封装「读入时确实是信封」的字段。 +// +// 为什么不按固定清单封:客户端封哪些字段是它自己的契约(实测封 accessToken / +// refreshToken / nickname / phoneNumber,expiresAt 保持明文),照我们的清单去封会把 +// 它读作明文的字段也加密,桌面端就读不回来了。来源文件没加密的字段一律不碰。 +// 任一字段封装失败即报错(调用方不得落盘),不静默降级成明文。 +func sealForSave(doc map[string]any, sealed map[string]bool) error { + for path := range sealed { + parts := strings.Split(path, ".") + if len(parts) != 2 { + continue // accounts[]/allAccounts[] 这类我们不回写的容器,跳过 + } + parent, ok := doc[parts[0]].(map[string]any) + if !ok { + continue + } + v, ok := parent[parts[1]] + if !ok || v == nil { + continue + } + if _, isEnvelope := v.(map[string]any); isEnvelope { + continue // 已经是信封 + } + env, err := sealWBValue(v) + if err != nil { + return err + } + parent[parts[1]] = env + } + // 凭据两个字段必须封上:漏了就是明文 token 覆盖加密文件。 + for _, k := range []string{"accessToken", "refreshToken"} { + if authObj, ok := doc["auth"].(map[string]any); ok && sealed["auth."+k] { + if _, isEnvelope := authObj[k].(map[string]any); !isEnvelope { + return fmt.Errorf("at_rest_seal_failed: %s 未能封装,拒绝以明文落盘", k) + } + } + } + return nil +} + +// wbDecryptEnvelope 解一个 base64 信封,返回明文解包后的值。 +func wbDecryptEnvelope(envelopeB64 string, key [32]byte) (any, error) { + rawEnv, err := base64.StdEncoding.DecodeString(envelopeB64) + if err != nil { + return nil, fmt.Errorf("at_rest_bad_envelope: %w", err) + } + var env struct { + Suite uint32 `json:"suite"` + KeyID string `json:"keyId"` + Nonce string `json:"nonce"` + AuthTag string `json:"authTag"` + Ciphertext string `json:"ciphertext"` + } + if err := json.Unmarshal(rawEnv, &env); err != nil { + return nil, fmt.Errorf("at_rest_bad_envelope: %w", err) + } + wantID := wbKeyID(key) + if env.KeyID != wantID { + return nil, fmt.Errorf("at_rest_key_mismatch: envelope keyId=%s want %s"+ + "(桌面端换了 at-rest 密钥,需重新逆向 loggerGet)", env.KeyID, wantID) + } + nonce, tag, ct, err := b64Triple(env.Nonce, env.AuthTag, env.Ciphertext) + if err != nil { + return nil, err + } + block, err := aes.NewCipher(key[:]) + if err != nil { + return nil, fmt.Errorf("at_rest_cipher_failed: %w", err) + } + gcm, err := cipher.NewGCM(block) + if err != nil { + return nil, fmt.Errorf("at_rest_gcm_failed: %w", err) + } + plain, err := gcm.Open(nil, nonce, append(ct, tag...), wbFieldAAD(env.Suite, env.KeyID)) + if err != nil { + return nil, fmt.Errorf("at_rest_decrypt_failed: %w", err) + } + return wbDecodePlain(plain), nil +} + +// wbKeyID sha256(sha256(secret)) 的 hex 前 16 位——信封里的 keyId 校验口径。 +func wbKeyID(key [32]byte) string { + h := sha256.Sum256(key[:]) + return hex.EncodeToString(h[:])[:16] +} + +// wbFieldAAD 字段级 AAD(framing=2)。任意一个字节不同都会解密失败。 +func wbFieldAAD(suite uint32, keyID string) []byte { + var b bytes.Buffer + b.WriteString("WB-AAD\x00") + b.WriteByte(1) + wbWriteLP(&b, "WBEV1") // framing tag + wbWriteLP(&b, "sym-v1") // scheme + var u [4]byte + binary.BigEndian.PutUint32(u[:], suite) + b.Write(u[:]) + wbWriteLP(&b, keyID) + b.WriteByte(2) // framing: file=1 field=2 record=3 stream=4 + b.WriteByte(0) // 无 sequence + b.WriteByte(0) // 无 final + return b.Bytes() +} + +func wbWriteLP(b *bytes.Buffer, s string) { + var u [4]byte + binary.BigEndian.PutUint32(u[:], uint32(len(s))) + b.Write(u[:]) + b.WriteString(s) +} + +func b64Triple(nonce, tag, ct string) (n, t, c []byte, err error) { + for _, f := range []struct { + name string + in string + out *[]byte + }{{"nonce", nonce, &n}, {"authTag", tag, &t}, {"ciphertext", ct, &c}} { + v, e := base64.StdEncoding.DecodeString(f.in) + if e != nil { + return nil, nil, nil, fmt.Errorf("at_rest_bad_envelope: %s: %w", f.name, e) + } + *f.out = v + } + return n, t, c, nil +} + +// wbDecodePlain 明文可能是:纯文本、JSON、或是 Buffer 形态的 JSON +// ({"type":"Buffer","data":[字节]}——UTF-8 字节包装),个别字段还会双重 JSON。 +func wbDecodePlain(plain []byte) any { + var v any + if json.Unmarshal(plain, &v) != nil { + return string(plain) + } + v = wbUnwrapBuffer(v) + if s, ok := v.(string); ok { + var again any + if json.Unmarshal([]byte(s), &again) == nil { + return wbUnwrapBuffer(again) + } + } + return v +} + +// sealWBValue 把一个值包成 $wbEncrypted 信封,明文取值的文本形态 +// (字符串原样,其余走 JSON)。SaveAtomic 回写时用它,避免把用完就刷新的 +// 凭据以明文覆盖掉桌面端的加密文件。 +// +// shortcut: 只按 sym-v1/field framing 加密,不回放桌面端的 Buffer 包装形态(我们的 +// 读取路径两种都认);哪天要写回给桌面端直接读的字段,再对齐包装形态。 +func sealWBValue(v any) (map[string]any, error) { + text, ok := v.(string) + if !ok { + b, err := json.Marshal(v) + if err != nil { + return nil, fmt.Errorf("at_rest_seal_failed: %w", err) + } + text = string(b) + } + key := sha256.Sum256([]byte(wbAtRestSecretKey)) + block, err := aes.NewCipher(key[:]) + if err != nil { + return nil, fmt.Errorf("at_rest_cipher_failed: %w", err) + } + gcm, err := cipher.NewGCM(block) + if err != nil { + return nil, fmt.Errorf("at_rest_gcm_failed: %w", err) + } + keyID := wbKeyID(key) + nonce := make([]byte, gcm.NonceSize()) + if _, err := rand.Read(nonce); err != nil { + return nil, fmt.Errorf("at_rest_seal_failed: %w", err) + } + ct := gcm.Seal(nil, nonce, []byte(text), wbFieldAAD(1, keyID)) + env, err := json.Marshal(map[string]any{ + "suite": 1, + "keyId": keyID, + "nonce": base64.StdEncoding.EncodeToString(nonce), + "authTag": base64.StdEncoding.EncodeToString(ct[len(ct)-16:]), + "ciphertext": base64.StdEncoding.EncodeToString(ct[:len(ct)-16]), + }) + if err != nil { + return nil, fmt.Errorf("at_rest_seal_failed: %w", err) + } + return map[string]any{ + "$wbEncrypted": 1, + "envelope": base64.StdEncoding.EncodeToString(env), + }, nil +} + +func wbUnwrapBuffer(v any) any { + switch t := v.(type) { + case map[string]any: + if t["type"] == "Buffer" { + if arr, ok := t["data"].([]any); ok { + buf := make([]byte, 0, len(arr)) + for _, n := range arr { + f, ok := n.(float64) + if !ok { + return t // 形状不符就不解,原样留着让上层看到 + } + buf = append(buf, byte(f)) + } + return string(buf) + } + } + for k, item := range t { + t[k] = wbUnwrapBuffer(item) + } + return t + case []any: + for i, item := range t { + t[i] = wbUnwrapBuffer(item) + } + return t + } + return v +} diff --git a/internal/auth/wbencrypted_test.go b/internal/auth/wbencrypted_test.go new file mode 100644 index 0000000000000000000000000000000000000000..db61f45bc0e63eede278cdc856809f38c2aee3ee --- /dev/null +++ b/internal/auth/wbencrypted_test.go @@ -0,0 +1,186 @@ +package auth + +import ( + "crypto/sha256" + "encoding/base64" + "encoding/hex" + "encoding/json" + "os" + "path/filepath" + "strings" + "testing" +) + +// testdata/wbencrypted-auth.json 是**合成**向量:用 wbencrypted.go 里记录的 +// at-rest 密钥 + 文档化的 AAD 拼接口径加密而成(生成脚本走的是 DistPub/workbuddy2api +// 的同一套参数),不是任何真实账号的凭据。三个字段刻意覆盖三种明文形态: +// 纯文本 token、Buffer 包装的昵称、数字型的 expiresAt。 +const wbVectorPath = "testdata/wbencrypted-auth.json" + +func TestParseWBEncryptedAuthFile(t *testing.T) { + raw, err := os.ReadFile(wbVectorPath) + if err != nil { + t.Fatalf("读向量失败: %v", err) + } + a, err := Parse(raw) + if err != nil { + t.Fatalf("解析加密 auth 文件失败: %v", err) + } + for _, c := range []struct{ name, got, want string }{ + {"accessToken", a.AccessToken, "at-from-wbencrypted"}, + {"refreshToken", a.RefreshToken, "rt-from-wbencrypted"}, + {"nickname", a.Nickname, "小凛"}, + {"uid", a.UID, "uid-wb-1"}, + {"deviceToken", a.DeviceToken, "v3:test-device-token"}, + {"realm", a.Realm(), "cn"}, + } { + if c.got != c.want { + t.Errorf("%s = %q want %q", c.name, c.got, c.want) + } + } + // expiresAt 在文件里是毫秒,Parse 后必须归一成秒。 + if a.ExpiresAt != 1800000000 { + t.Errorf("expiresAt = %d want 1800000000(毫秒应归一为秒)", a.ExpiresAt) + } +} + +// AAD 是最容易错一个字节的地方:这里对着参考实现的字节串逐位校验。 +func TestWBFieldAADMatchesReference(t *testing.T) { + const want = "57422d41414400010000000557424556310000000673796d2d763100000001" + + "0000001039313237646561316234343032306137020000" + got := hex.EncodeToString(wbFieldAAD(1, wbKeyID(sha256.Sum256([]byte(wbAtRestSecretKey))))) + if got != want { + t.Fatalf("AAD 与参考实现不一致:\n got %s\nwant %s", got, want) + } +} + +// 桌面端换过 at-rest 密钥时必须报错而不是解出乱码当 token 用。 +func TestParseWBEncryptedKeyIDMismatchFails(t *testing.T) { + raw, err := os.ReadFile(wbVectorPath) + if err != nil { + t.Fatalf("读向量失败: %v", err) + } + var doc map[string]any + if err := json.Unmarshal(raw, &doc); err != nil { + t.Fatalf("向量不是合法 JSON: %v", err) + } + authObj := doc["auth"].(map[string]any) + env := authObj["accessToken"].(map[string]any) + // 换掉 envelope 里的 keyId(解 base64 再改再编回)。 + rawEnv, err := base64.StdEncoding.DecodeString(env["envelope"].(string)) + if err != nil { + t.Fatalf("信封不是合法 base64: %v", err) + } + keyID := wbKeyID(sha256.Sum256([]byte(wbAtRestSecretKey))) + plainEnv := strings.Replace(string(rawEnv), keyID, "0000000000000000", 1) + if plainEnv == string(rawEnv) { + t.Fatal("向量里找不到 keyId,测试自身失效") + } + env["envelope"] = base64.StdEncoding.EncodeToString([]byte(plainEnv)) + bad, _ := json.Marshal(doc) + + if _, err := Parse(bad); err == nil { + t.Fatal("keyId 不匹配时应当报错") + } else if !strings.Contains(err.Error(), "at_rest_key_mismatch") { + t.Fatalf("错误应说明是密钥不匹配,实际: %v", err) + } +} + +// 刷新后的写回:来源是加密文件,就只能回写加密形态——明文覆盖桌面端文件是把 +// 别人的登录态写成我们能读、桌面端读不了的样子。 +func TestSaveAtomicKeepsEnvelopeForEncryptedSource(t *testing.T) { + raw, err := os.ReadFile(wbVectorPath) + if err != nil { + t.Fatalf("读向量失败: %v", err) + } + path := filepath.Join(t.TempDir(), "auth.info") + if err := os.WriteFile(path, raw, 0o600); err != nil { + t.Fatalf("写临时 auth 失败: %v", err) + } + a, err := Parse(raw) + if err != nil { + t.Fatalf("解析失败: %v", err) + } + a.FilePath = path + a.AccessToken = "at-refreshed" + a.RefreshToken = "rt-refreshed" + if err := a.SaveAtomic(); err != nil { + t.Fatalf("写回失败: %v", err) + } + + saved, err := os.ReadFile(path) + if err != nil { + t.Fatalf("读回失败: %v", err) + } + if strings.Contains(string(saved), "at-refreshed") || strings.Contains(string(saved), "rt-refreshed") { + t.Fatal("写回文件里出现了明文 token") + } + if !strings.Contains(string(saved), `"$wbEncrypted"`) { + t.Fatal("写回文件丢了信封形态") + } + again, err := Parse(saved) + if err != nil { + t.Fatalf("回写后再解析失败: %v", err) + } + if again.AccessToken != "at-refreshed" || again.RefreshToken != "rt-refreshed" { + t.Fatalf("回写后的 token 读不回来: %+v", again) + } + if again.Nickname != "小凛" { + t.Fatalf("回写后的昵称读不回来: %q", again.Nickname) + } +} + +// 客户端不加密的字段,回写也必须留明文。 +// +// 实测客户端的信封清单是 accessToken / refreshToken / nickname / phoneNumber, +// expiresAt 明文。按固定清单去封会把它读作明文的 expiresAt 加密,桌面端就读不回来。 +func TestSaveAtomicLeavesPlainFieldsPlain(t *testing.T) { + raw, err := os.ReadFile(wbVectorPath) + if err != nil { + t.Fatalf("读向量失败: %v", err) + } + var doc map[string]any + if err := json.Unmarshal(raw, &doc); err != nil { + t.Fatalf("向量不是合法 JSON: %v", err) + } + doc["auth"].(map[string]any)["expiresAt"] = float64(1800000000000) // 还原成明文数字 + raw, _ = json.Marshal(doc) + + path := filepath.Join(t.TempDir(), "auth.info") + if err := os.WriteFile(path, raw, 0o600); err != nil { + t.Fatalf("写临时 auth 失败: %v", err) + } + a, err := Parse(raw) + if err != nil { + t.Fatalf("解析失败: %v", err) + } + a.FilePath = path + if err := a.SaveAtomic(); err != nil { + t.Fatalf("写回失败: %v", err) + } + saved, _ := os.ReadFile(path) + var back map[string]any + if err := json.Unmarshal(saved, &back); err != nil { + t.Fatalf("写回文件不是合法 JSON: %v", err) + } + if _, isEnvelope := back["auth"].(map[string]any)["expiresAt"].(map[string]any); isEnvelope { + t.Error("expiresAt 原本明文,回写不该加密") + } + if _, isEnvelope := back["auth"].(map[string]any)["accessToken"].(map[string]any); !isEnvelope { + t.Error("accessToken 原本加密,回写必须仍是信封") + } + if again, err := Parse(saved); err != nil || again.ExpiresAt != 1800000000 { + t.Errorf("回写后再解析失败或到期时间不对: %v %+v", err, again) + } +} + +// 未加密文件必须原样走老路径(零回归)。 +func TestParseUnencryptedStillWorks(t *testing.T) { + a, err := Parse([]byte(`{"auth":{"accessToken":"at","refreshToken":"rt","realm":"global"},"account":{"uid":"u1"}}`)) + if err != nil { + t.Fatalf("明文 auth 解析失败: %v", err) + } + if a.AccessToken != "at" || a.UID != "u1" || a.Realm() != "global" { + t.Fatalf("明文解析结果不对: %+v", a) + } +} diff --git a/internal/balance/balance.go b/internal/balance/balance.go new file mode 100644 index 0000000000000000000000000000000000000000..2273ef0349212cebfc9d9b1aeaa4a6ef8c489795 --- /dev/null +++ b/internal/balance/balance.go @@ -0,0 +1,623 @@ +// Package balance 按固定间隔采样账号积分余额,供面板「余额趋势」视图画折线。 +// +// 与 internal/usage 的区别(两者刻意分开,不合并): +// - usage 是**事件驱动**:每次聊天请求 Add 一次,记录的是「流量」(token 数), +// 没有请求就没有数据点; +// - 本包是**定时驱动**:每 sampleInterval 主动查一次余额,记录的是「存量」 +// (某时刻的水位值),没有请求也照常采样。 +// 把存量塞进请求驱动的桶里会出现「空闲时段无采样点 → 折线断裂」,那是数据缺陷 +// 而非实现细节,故独立成包。 +// +// 保留策略(两级粒度,总量有界): +// - 近 detailedKeep 内:原始采样点(默认 30 分钟一个) +// - 更早:折叠为日粒度(每天取当日最后一个采样值 = 当日收盘水位),保留 detailKeep +// +// 落盘:与 state 文件同目录的 balance_history.json,原子替换 + 防抖刷新,重启不丢。 +package balance + +import ( + "encoding/json" + "fmt" + "log" + "os" + "path/filepath" + "sort" + "sync" + "time" +) + +const ( + // sampleInterval 采样间隔:30 分钟一个点(1440 分钟 / 30 = 每天 48 点)。 + sampleInterval = 30 * time.Minute + + // detailedKeep 原始采样点的保留时长;超出后折叠为日粒度。 + // 30 天 × 48 点 ≈ 1440 点/账号,折线图可读且文件很小。 + detailedKeep = 30 * 24 * time.Hour + + // dayKeep 日粒度点的保留时长;更早的丢弃(总量有界)。 + dayKeep = 365 * 24 * time.Hour + + // flushInterval 防抖落盘间隔。 + flushInterval = 30 * time.Second + + // maxPoints 点数硬上限(所有账号合计)。超过时立即折叠,避免异常把文件撑爆。 + maxPoints = 200_000 + + // dayLayout 日粒度键的格式(本地时区,与用户直觉一致)。 + dayLayout = "2006-01-02" + + // expectedPerDay 判定"某日采样完整"所需的最少点数。 + // 理论值 = 24h/30min = 48;留容差取 40(服务重启/短暂停机会让点数略少, + // 不该因此判定整日不完整)。 + expectedPerDay = 40 +) + +// Point 一次采样(某账号在某时刻的积分水位)。 +// JSON 字段名取短:点数会随时间增长。 +type Point struct { + TS int64 `json:"t"` // Unix 秒 + UID string `json:"u"` // 账号 uid + Credits int64 `json:"c"` // 该时刻积分余额 + Day string `json:"d,omitempty"` // 非空 = 日粒度折叠点(值形如 2006-01-02) + + // 仅日粒度折叠点(Day != "")有意义:折叠时把当日原始采样算出的 + // 消耗/到账一并记下来。折叠点每天只剩一个水位值,dailyOf 按相邻差值 + // 累加时拿不到任何相邻对,结果恒为 0 —— 表现为「30 天前的日子里 + // 消耗/到账永远是 0」,那是数据被丢掉了,不是真的没消耗。 + // 口径与 Daily.Consumed/Gained 一致(相邻采样下降/上升量之和),同为下界估计。 + Consumed int64 `json:"cons,omitempty"` + Gained int64 `json:"gain,omitempty"` + First int64 `json:"f,omitempty"` // 折叠点记录的当日首个水位(见 dailyOf) +} + +// file 落盘结构。 +type file struct { + Version int `json:"version"` + Saved string `json:"saved"` + Points []Point `json:"points"` +} + +// Recorder 并发安全的余额采样记录器。 +type Recorder struct { + mu sync.Mutex + path string + points []Point // 按 TS 升序维护(Add 时追加,采样本身即时间递增) + dirty bool + + // 每账号的上次采样时刻,用于「距上次不足 sampleInterval 则跳过」的节流 + // (防止高频调用把曲线打成锯齿)。 + // + // ⚠️ 必须**按账号**而非全局:采样由 RunBalanceRefreshNow 并发触达所有账号, + // 若共用一个时间戳,同一窗口内只有"抢到"的那个账号能落点,其余账号的点被 + // 静默丢弃 —— 症状是「多个账号只有一条线」。单账号时该缺陷不显形,故曾漏测。 + lastSample map[string]time.Time + + // names uid → 昵称,仅供 API 展示(不入盘:账号改名不影响历史数据)。 + names map[string]string + + // realms uid 到账号域("cn"/"global")的映射,仅供 API 分组展示(不入盘)。 + // + // 语义:这是账号的**当前属性**,不是采样时刻的快照。账号重登/换域后, + // 其全部历史点都会归入新域——有意取舍:realm 极少变化,变了通常意味着 + // 账号重登(历史余额本就该随账号归新域);若把 realm 写进 Point,内存会 + // 放大 maxPoints 倍且结构复杂化,收益不抵成本。 + realms map[string]string + + clock func() time.Time // 便于测试注入 + + stopOnce sync.Once + stop chan struct{} + done chan struct{} +} + +// New 构造。path 为空时不做任何落盘(纯内存,用于测试)。 +func New(path string) *Recorder { + r := &Recorder{ + path: path, + names: map[string]string{}, + realms: map[string]string{}, + clock: time.Now, + lastSample: map[string]time.Time{}, + stop: make(chan struct{}), + done: make(chan struct{}), + } + if path != "" { + if err := r.load(); err != nil { + log.Printf("[balance] 载入失败(按空历史启动): %v", err) + } + } + return r +} + +// Interval 返回采样间隔,供调度器使用(避免两处各写一个魔法数字)。 +func Interval() time.Duration { return sampleInterval } + +// SetName 记录账号昵称(仅供展示,不落盘)。 +func (r *Recorder) SetName(uid, name string) { + if r == nil || uid == "" { + return + } + r.mu.Lock() + r.names[uid] = name + r.mu.Unlock() +} + +// SetRealm 记录账号所属域("cn"/"global"),供面板按域分组展示。 +// 与 SetName 同为展示元数据:不入盘,进程重启后由面板重新注入。 +// realm 为空时忽略(不清除已有值,避免上游偶发空值抹掉已记录的域)。 +func (r *Recorder) SetRealm(uid, realm string) { + if r == nil || uid == "" || realm == "" { + return + } + r.mu.Lock() + r.realms[uid] = realm + r.mu.Unlock() +} + +// Add 记录一次采样。同一账号、同一采样窗口内重复调用只保留最后一个值 +// (签到/领奖后余额会跳变,取最新值才是真实水位)。 +// 与上次采样间隔不足 sampleInterval 时跳过,返回 false。 +func (r *Recorder) Add(uid string, credits int64) bool { + if r == nil || uid == "" { + return false + } + now := r.clock() + r.mu.Lock() + defer r.mu.Unlock() + + if last, ok := r.lastSample[uid]; ok && now.Sub(last) < sampleInterval { + return false + } + r.lastSample[uid] = now + r.points = append(r.points, Point{TS: now.Unix(), UID: uid, Credits: credits}) + r.dirty = true + + // 点数超硬上限:立即折叠一次(异常保护)。 + if len(r.points) > maxPoints { + r.rollupLocked(now) + } + return true +} + +// Rollup 把超出 detailedKeep 的原始点折叠为日粒度(每账号每天留最后一个值)。 +// 由调度器周期调用;也可在 Add 触发上限时内部调用。 +func (r *Recorder) Rollup(now time.Time) { + if r == nil { + return + } + r.mu.Lock() + defer r.mu.Unlock() + r.rollupLocked(now) +} + +func (r *Recorder) rollupLocked(now time.Time) { + cutoff := now.Add(-detailedKeep).Unix() + + // 待折叠:超出 detailedKeep 的原始点,按 (uid, 日) 分组取当日最后一个水位, + // 同时把当日全部原始点按相邻差值累加出消耗/到账(折叠后没有相邻对了, + // 不在这里算就永久丢失,见 Point.Consumed 注释)。 + // + // 累加必须按时间顺序进行:Recorder.points 契约是 TS 升序(见结构体注释), + // 故逐点与同账号同日前一个原始点比较即可,不需要再排序。 + type key struct { + uid string + day string + } + type fold struct { + last Point + first int64 // 当日首个水位(写进折叠点,保住 Change 口径) + consumed int64 + gained int64 + prev int64 + hasPrev bool + } + folds := map[key]*fold{} + var order []key + var kept []Point + folded := 0 + for _, p := range r.points { + if p.Day != "" || p.TS >= cutoff { + kept = append(kept, p) + continue + } + day := time.Unix(p.TS, 0).In(time.Local).Format(dayLayout) + k := key{p.UID, day} + f, ok := folds[k] + if !ok { + f = &fold{first: p.Credits} + folds[k] = f + order = append(order, k) + } + if f.hasPrev { + if d := p.Credits - f.prev; d > 0 { + f.gained += d + } else if d < 0 { + f.consumed += -d + } + } + f.prev, f.hasPrev = p.Credits, true + if !ok || p.TS > f.last.TS { + f.last = p + } + folded++ + } + if folded == 0 { + r.pruneDaysLocked(now) + return + } + for _, k := range order { + f := folds[k] + kept = append(kept, Point{ + TS: f.last.TS, UID: f.last.UID, Credits: f.last.Credits, Day: k.day, + Consumed: f.consumed, Gained: f.gained, First: f.first, + }) + } + sort.Slice(kept, func(i, j int) bool { return kept[i].TS < kept[j].TS }) + r.points = kept + r.dirty = true + log.Printf("[balance] 折叠 %d 个原始采样点为 %d 个日粒度点(保留 %v 细粒度)", folded, len(order), detailedKeep) + + r.pruneDaysLocked(now) +} + +// pruneDaysLocked 丢弃超出 dayKeep 的日粒度点。 +func (r *Recorder) pruneDaysLocked(now time.Time) { + cutoff := now.Add(-dayKeep) + var kept []Point + dropped := 0 + for _, p := range r.points { + if p.Day == "" { + kept = append(kept, p) + continue + } + t, err := time.ParseInLocation(dayLayout, p.Day, time.Local) + if err == nil && t.Before(cutoff) { + dropped++ + continue + } + kept = append(kept, p) + } + if dropped > 0 { + r.points = kept + r.dirty = true + log.Printf("[balance] 丢弃 %d 个超期日粒度点(保留 %v)", dropped, dayKeep) + } +} + +// ---------------------------------------------------------------- 持久化 ---- + +func (r *Recorder) load() error { + raw, err := os.ReadFile(r.path) + if err != nil { + if os.IsNotExist(err) { + return nil // 首次启动:空历史 + } + return err + } + var f file + if err := json.Unmarshal(raw, &f); err != nil { + return err + } + if f.Version != 1 { + return fmt.Errorf("不支持的版本 %d", f.Version) + } + // 过滤非法值(手改/损坏文件不该让服务起不来)。 + pts := make([]Point, 0, len(f.Points)) + for _, p := range f.Points { + if p.UID == "" || p.TS <= 0 { + continue + } + pts = append(pts, p) + } + sort.Slice(pts, func(i, j int) bool { return pts[i].TS < pts[j].TS }) + r.points = pts + // 按账号恢复「上次采样时刻」(各取最后一个原始点),避免重启后立刻补点导致 + // 曲线密集;只认原始点——日粒度点是折叠产物,不代表上次采样时刻。 + for _, p := range pts { + if p.Day != "" { + continue + } + at := time.Unix(p.TS, 0) + if old, ok := r.lastSample[p.UID]; !ok || at.After(old) { + r.lastSample[p.UID] = at + } + } + return nil +} + +func (r *Recorder) flush(force bool) { + if r == nil || r.path == "" { + return + } + r.mu.Lock() + if !r.dirty && !force { + r.mu.Unlock() + return + } + snap := file{Version: 1, Saved: time.Now().Format(time.RFC3339), Points: r.points} + r.dirty = false + r.mu.Unlock() + + raw, err := json.Marshal(snap) + if err != nil { + log.Printf("[balance] 序列化失败: %v", err) + return + } + if err := os.MkdirAll(filepath.Dir(r.path), 0o755); err != nil { + log.Printf("[balance] 建目录失败: %v", err) + return + } + tmp := r.path + ".tmp" + if err := os.WriteFile(tmp, raw, 0o600); err != nil { + log.Printf("[balance] 写临时文件失败: %v", err) + return + } + if err := os.Rename(tmp, r.path); err != nil { + log.Printf("[balance] 原子替换失败: %v", err) + } +} + +// Save 立即落盘(关闭前调用)。 +func (r *Recorder) Save() { r.flush(true) } + +// Start 启动后台防抖落盘与周期折叠。 +// 为什么必须显式 Start:Recorder 只在内存累积,缺了这个协程就永远不落盘 +// (重启即丢光历史)——这是很容易漏掉的一环。 +func (r *Recorder) Start() { + if r == nil { + return + } + go func() { + defer close(r.done) + t := time.NewTicker(flushInterval) + defer t.Stop() + for { + select { + case <-r.stop: + r.flush(true) + return + case <-t.C: + r.Rollup(time.Now()) // 顺带做粒度折叠(含超期裁剪) + r.flush(false) + } + } + }() +} + +// Stop 停止后台协程并最终落盘(进程退出前调用)。 +func (r *Recorder) Stop() { + if r == nil { + return + } + r.stopOnce.Do(func() { + close(r.stop) + <-r.done + }) +} + +// ---------------------------------------------------------------- 查询 ---- + +// Series 单账号的余额序列(供面板画折线)。 +type Series struct { + UID string `json:"uid"` + Name string `json:"name,omitempty"` + Points []Point `json:"points"` + Current int64 `json:"current"` // 最新值 + Min int64 `json:"min"` + Max int64 `json:"max"` + Change int64 `json:"change"` // 窗口内净变化(末 - 首) + Daily []Daily `json:"daily,omitempty"` // 按日聚合(升序),供每日对照视图 + // Realm 账号域("cn"/"global"),供前端分域切换。 + // cn 与 global 的积分不同源、不可互换,跨域求和语义不成立,故 UI 必须分域展示。 + // 空 = 未注入(未调 SetRealm),前端归入 other 组。 + Realm string `json:"realm,omitempty"` +} + +// Daily 单账号某一天的余额变化(供「每日变化对照」)。 +// +// 口径(末值 − 首值):取该日**首次采样**与**最后采样**之差。 +// - 含当日签到/领奖到账,也含当日消耗;不含跨零点时段的变化。 +// - Full=false 表示该日采样不完整(当天尚未结束、或服务当日中途启用), +// UI 必须显式标注——否则"今天只赚了一点"会误导(其实还没采完一天)。 +type Daily struct { + Day string `json:"day"` // 2006-01-02(本地时区) + First int64 `json:"first"` // 当日首个采样值 + Last int64 `json:"last"` // 当日最后一个采样值 + Change int64 `json:"change"` // Last - First + Min int64 `json:"min"` + Max int64 `json:"max"` + N int `json:"n"` // 当日采样点数 + Full bool `json:"full"` // 是否为完整一天(非今日、且点数达到预期) + + // Consumed / Gained 当日「消耗」与「到账」估算量(相邻采样差值分正负累加)。 + // + // 口径局限(UI 必须标注,见 cross/dev-principles.md 第十一节):采样间隔 30 + // 分钟,真实事件远密于此(实测 6 小时 2127 次请求 vs 14 个采样点)。同一 + // 窗口内消耗与到账会被合并成一个净差,故 Consumed 是下界估计:窗口内若 + // 既消耗又到账,只能观测到净值,真实消耗可能更高。它仍比只有 Change 有 + // 信息量——Change 为 +262 时看不出「其实消耗了 124」。 + Consumed int64 `json:"consumed"` // 相邻采样下降量之和,恒 >= 0 + Gained int64 `json:"gained"` // 相邻采样上升量之和,恒 >= 0 +} + +// Snapshot 返回窗口内的余额序列。since 为零值 = 全部。 +// 每账号一条序列,点按时间升序。 +func (r *Recorder) Snapshot(since time.Time) ([]Series, time.Time) { + if r == nil { + return nil, time.Time{} + } + r.mu.Lock() + defer r.mu.Unlock() + + var cutoff int64 + if !since.IsZero() { + cutoff = since.Unix() + } + byUID := map[string][]Point{} + for _, p := range r.points { + if cutoff > 0 && p.TS < cutoff { + continue + } + byUID[p.UID] = append(byUID[p.UID], p) + } + out := make([]Series, 0, len(byUID)) + for uid, pts := range byUID { + sort.Slice(pts, func(i, j int) bool { return pts[i].TS < pts[j].TS }) + s := Series{UID: uid, Name: r.names[uid], Points: pts, Realm: r.realms[uid]} + if n := len(pts); n > 0 { + s.Current = pts[n-1].Credits + // 水位极值与窗口净变化都要把**折叠点的当日首值**算进去:折叠点只剩末值, + // 只看末值会让窗口首日的水位抬高/压低、净变化失真(见 Point.First)。 + lo, hi := pts[0].Credits, pts[0].Credits + for _, p := range pts { + if p.Credits < lo { + lo = p.Credits + } + if p.Credits > hi { + hi = p.Credits + } + if p.Day != "" && p.First != 0 { + if p.First < lo { + lo = p.First + } + if p.First > hi { + hi = p.First + } + } + } + s.Min, s.Max = lo, hi + // 首点若是折叠点,窗口期初水位应为当日首值而非其末值 + first := pts[0].Credits + if pts[0].Day != "" && pts[0].First != 0 { + first = pts[0].First + } + s.Change = pts[n-1].Credits - first + s.Daily = dailyOf(pts, r.clock()) + } + out = append(out, s) + } + // 稳定排序:按最新值降序(主账号在前),再按 uid 保证确定性。 + sort.Slice(out, func(i, j int) bool { + if out[i].Current != out[j].Current { + return out[i].Current > out[j].Current + } + return out[i].UID < out[j].UID + }) + return out, time.Now() +} + +// dailyOf 把某账号的采样点按本地日历日聚合为每日变化。 +// +// 口径:**末值 − 首值**(当日首个采样到最后一个采样)。 +// 为何不用「末值 − 昨日末值」:那是跨零点连续口径,会把夜间变化算进今天, +// 与用户对"今天赚了多少"的直觉不符。首末口径更直观、可解释。 +// +// 完整性判定:只有**非今日**且**点数达标(>= expectedPerDay)**才标记 Full。 +// 今天必然不完整(一天还没过完);服务中途启用的那天也不完整。 +// UI 必须据此标注,否则"今天只涨了一点"会被误读成"今天赚得少"。 +func dailyOf(pts []Point, now time.Time) []Daily { + if len(pts) == 0 { + return nil + } + type acc struct { + first, last, min, max int64 + n int + consumed, gained int64 // 相邻采样差值分正负累加(见 Daily 字段注释) + prev int64 // 上一采样值(算相邻差) + hasPrev bool + } + m := map[string]*acc{} + var days []string + for _, p := range pts { + day := time.Unix(p.TS, 0).In(time.Local).Format(dayLayout) + a, ok := m[day] + if !ok { + // 折叠点自带当日首值:它只剩末值一个水位,first 不能取自身, + // 否则 Change(末−首)恒为 0,历史日净变化全显示 0。 + first := p.Credits + if p.Day != "" && p.First != 0 { + first = p.First + } + a = &acc{first: first, last: p.Credits, min: p.Credits, max: p.Credits} + m[day] = a + days = append(days, day) + } + a.last = p.Credits + // 相邻采样差值分正负累加:涨 = 到账,跌 = 消耗。跨日时 a 是新建的, + // hasPrev=false 不会把昨日末值误算进今日。 + if a.hasPrev { + if d := p.Credits - a.prev; d > 0 { + a.gained += d + } else if d < 0 { + a.consumed += -d + } + } + // 日粒度折叠点自带的消耗/到账是**折叠时算好的当日合计**,必须加进来。 + // 否则折叠日只剩一个点、没有相邻对,结果恒为 0 —— 前端会显示 + // 「30 天前每天消耗 0」,那是数据丢失而非真实无消耗(见 Point.Consumed)。 + // 两种来源不会重复计数:折叠点没有相邻的原始点可比较(hasPrev 为 false + // 的只有当日首个点),且折叠点本身按天唯一(rollupLocked 保证)。 + a.consumed += p.Consumed + a.gained += p.Gained + a.prev = p.Credits + a.hasPrev = true + // 折叠点的当日首值也要参与 min/max:折叠只剩末值,当日最低(或最高) + // 若出现在开盘就会被漏掉。 + lo, hi := p.Credits, p.Credits + if p.Day != "" && p.First != 0 { + if p.First < lo { + lo = p.First + } + if p.First > hi { + hi = p.First + } + } + if lo < a.min { + a.min = lo + } + if hi > a.max { + a.max = hi + } + a.n++ + } + sort.Strings(days) + today := now.In(time.Local).Format(dayLayout) + out := make([]Daily, 0, len(days)) + for _, day := range days { + a := m[day] + out = append(out, Daily{ + Day: day, + First: a.first, + Last: a.last, + Change: a.last - a.first, + Min: a.min, + Max: a.max, + N: a.n, + + Consumed: a.consumed, + Gained: a.gained, + Full: day != today && a.n >= expectedPerDay, + }) + } + return out +} + +// Describe 返回一行状态摘要(启动日志用)。 +func (r *Recorder) Describe() string { + if r == nil { + return "off" + } + r.mu.Lock() + defer r.mu.Unlock() + uids := map[string]struct{}{} + raw, day := 0, 0 + for _, p := range r.points { + uids[p.UID] = struct{}{} + if p.Day == "" { + raw++ + } else { + day++ + } + } + return fmt.Sprintf("%d 点(原始 %d / 日粒度 %d), %d 账号", len(r.points), raw, day, len(uids)) +} diff --git a/internal/balance/balance_test.go b/internal/balance/balance_test.go new file mode 100644 index 0000000000000000000000000000000000000000..57ee47e2e469f9b6740e0bde9706e78d544bef0b --- /dev/null +++ b/internal/balance/balance_test.go @@ -0,0 +1,663 @@ +package balance + +import ( + "os" + "path/filepath" + "runtime" + "strings" + "testing" + "time" +) + +// 固定时钟,避免依赖真实时间。 +func fixedClock(t time.Time) func() time.Time { return func() time.Time { return t } } + +func TestAddRespectsInterval(t *testing.T) { + now := time.Date(2026, 9, 16, 10, 0, 0, 0, time.Local) + r := New("") + cur := now + r.clock = func() time.Time { return cur } + + if !r.Add("u1", 100) { + t.Fatal("首次采样应被接受") + } + // 同一时刻重复调用:节流拒绝 + if r.Add("u1", 101) { + t.Error("间隔不足应被节流拒绝") + } + // 推进 29 分钟:仍拒绝 + cur = now.Add(29 * time.Minute) + if r.Add("u1", 102) { + t.Error("29 分钟仍不足采样间隔,应拒绝") + } + // 推进 30 分钟:接受 + cur = now.Add(30 * time.Minute) + if !r.Add("u1", 103) { + t.Error("满 30 分钟应被接受") + } + if got := len(r.points); got != 2 { + t.Errorf("点数 = %d, 期望 2", got) + } +} + +func TestAddSkipsEmptyUID(t *testing.T) { + r := New("") + if r.Add("", 100) { + t.Error("空 uid 不应记录") + } + if len(r.points) != 0 { + t.Errorf("点数 = %d, 期望 0", len(r.points)) + } +} + +// 关键行为:超期原始点折叠为日粒度,每账号每天只留「当日最后一个值」。 +func TestRollupFoldsToDailyKeepLast(t *testing.T) { + base := time.Date(2026, 8, 1, 0, 0, 0, 0, time.Local) + r := New("") + // 手工构造 3 天前的多个点(同一天 3 个,值递增) + d0 := base + r.points = []Point{ + {TS: d0.Add(0 * time.Hour).Unix(), UID: "u1", Credits: 500}, + {TS: d0.Add(2 * time.Hour).Unix(), UID: "u1", Credits: 480}, + {TS: d0.Add(4 * time.Hour).Unix(), UID: "u1", Credits: 460}, // 当日最后 + } + // 现在 = 31 天后 → 超过 detailedKeep(30 天),上面 3 个点全部超期 + now := base.Add(31 * 24 * time.Hour) + r.Rollup(now) + + if got := len(r.points); got != 1 { + t.Fatalf("折叠后点数 = %d, 期望 1(每天 1 个)", got) + } + p := r.points[0] + if p.Day == "" { + t.Error("折叠点应带 Day 标记") + } + if p.Credits != 460 { + t.Errorf("应保留当日最后一个值 460, 得到 %d", p.Credits) + } +} + +// 多账号折叠互相独立:同名日不同账号不得互相覆盖。 +func TestRollupPerUID(t *testing.T) { + base := time.Date(2026, 8, 1, 0, 0, 0, 0, time.Local) + r := New("") + r.points = []Point{ + {TS: base.Unix(), UID: "u1", Credits: 100}, + {TS: base.Add(time.Hour).Unix(), UID: "u2", Credits: 200}, + } + r.Rollup(base.Add(72 * time.Hour)) + if got := len(r.points); got != 2 { + t.Errorf("两个账号应各留一个日点, 得到 %d", got) + } +} + +// 未超期的点不得被折叠(边界:刚过 detailedKeep 才折)。 +func TestRollupKeepsRecent(t *testing.T) { + now := time.Date(2026, 9, 16, 10, 0, 0, 0, time.Local) + r := New("") + r.points = []Point{{TS: now.Add(-time.Hour).Unix(), UID: "u1", Credits: 999}} + r.Rollup(now) + if len(r.points) != 1 || r.points[0].Day != "" { + t.Error("近期点不应被折叠") + } +} + +// 超期日粒度点应被丢弃(dayKeep 上限)。 +func TestRollupPrunesOldDays(t *testing.T) { + now := time.Date(2026, 9, 16, 10, 0, 0, 0, time.Local) + old := now.Add(-400 * 24 * time.Hour) + r := New("") + r.points = []Point{{TS: old.Unix(), UID: "u1", Credits: 1, Day: old.In(time.Local).Format(dayLayout)}} + r.Rollup(now) + if len(r.points) != 0 { + t.Errorf("超期日点应被丢弃, 得到 %d", len(r.points)) + } +} + +func TestSnapshotSeriesStats(t *testing.T) { + now := time.Date(2026, 9, 16, 10, 0, 0, 0, time.Local) + r := New("") + r.points = []Point{ + {TS: now.Add(-2 * time.Hour).Unix(), UID: "u1", Credits: 1000}, + {TS: now.Add(-1 * time.Hour).Unix(), UID: "u1", Credits: 700}, + {TS: now.Unix(), UID: "u1", Credits: 900}, + {TS: now.Unix(), UID: "u2", Credits: 50}, + } + r.SetName("u1", "主号") + got, _ := r.Snapshot(time.Time{}) + if len(got) != 2 { + t.Fatalf("序列数 = %d, 期望 2", len(got)) + } + // 按最新值降序:u1(900) 在前 + if got[0].UID != "u1" { + t.Errorf("首个序列应为 u1, 得到 %s", got[0].UID) + } + s := got[0] + if s.Current != 900 || s.Min != 700 || s.Max != 1000 || s.Change != -100 { + t.Errorf("统计错误: current=%d min=%d max=%d change=%d", s.Current, s.Min, s.Max, s.Change) + } + if s.Name != "主号" { + t.Errorf("昵称未透出: %q", s.Name) + } +} + +// since 过滤:只返回窗口内的点。 +func TestSnapshotSinceFilter(t *testing.T) { + now := time.Date(2026, 9, 16, 10, 0, 0, 0, time.Local) + r := New("") + r.points = []Point{ + {TS: now.Add(-48 * time.Hour).Unix(), UID: "u1", Credits: 1}, + {TS: now.Add(-1 * time.Hour).Unix(), UID: "u1", Credits: 2}, + } + got, _ := r.Snapshot(now.Add(-24 * time.Hour)) + if len(got) != 1 || len(got[0].Points) != 1 { + t.Fatalf("窗口过滤失败: %+v", got) + } + if got[0].Points[0].Credits != 2 { + t.Errorf("应只保留窗口内的点") + } +} + +// 落盘 + 重载:数据不丢,且 lastSample 以最后点恢复(避免重启后立刻补点)。 +func TestPersistAndReload(t *testing.T) { + dir := t.TempDir() + path := filepath.Join(dir, "balance_history.json") + now := time.Date(2026, 9, 16, 10, 0, 0, 0, time.Local) + + r := New(path) + r.clock = fixedClock(now) + r.Add("u1", 1234) + r.Save() + + if _, err := os.Stat(path); err != nil { + t.Fatalf("文件未生成: %v", err) + } + // 权限 0600(含账号数据)。Windows 上 os.Chmod 只映射只读位,Mode().Perm() 恒为 + // 0666,该断言只在 POSIX 有意义(与 internal/auth/permhint_test.go、 + // internal/credithist/fault_test.go 同口径)。 + if runtime.GOOS != "windows" { + fi, _ := os.Stat(path) + if fi.Mode().Perm() != 0o600 { + t.Errorf("权限 = %o, 期望 600", fi.Mode().Perm()) + } + } + + r2 := New(path) + got, _ := r2.Snapshot(time.Time{}) + if len(got) != 1 || got[0].Current != 1234 { + t.Fatalf("重载失败: %+v", got) + } + if len(r2.lastSample) == 0 { + t.Error("重载后每账号的 lastSample 应恢复") + } +} + +// 损坏文件不应让服务起不来(过滤非法点)。 +func TestLoadSkipsInvalid(t *testing.T) { + dir := t.TempDir() + path := filepath.Join(dir, "balance_history.json") + raw := `{"version":1,"saved":"x","points":[{"t":0,"u":"u1","c":1},{"t":100,"u":"","c":2},{"t":200,"u":"u2","c":3}]}` + if err := os.WriteFile(path, []byte(raw), 0o600); err != nil { + t.Fatal(err) + } + r := New(path) + if len(r.points) != 1 { + t.Errorf("非法点应被过滤, 得到 %d 个", len(r.points)) + } +} + +func TestLoadMissingFileStartsEmpty(t *testing.T) { + r := New(filepath.Join(t.TempDir(), "nope.json")) + if len(r.points) != 0 { + t.Error("缺文件应空历史启动") + } +} + +func TestDescribe(t *testing.T) { + r := New("") + r.points = []Point{{TS: 1, UID: "u1", Credits: 1}, {TS: 2, UID: "u1", Credits: 2, Day: "x"}} + if s := r.Describe(); s == "" { + t.Error("Describe 不应为空") + } +} + +func TestNilRecorderSafe(t *testing.T) { + var r *Recorder + if r.Add("u1", 1) { + t.Error("nil 应安全返回 false") + } + r.Rollup(time.Now()) // 不应 panic + if got, _ := r.Snapshot(time.Time{}); got != nil { + t.Error("nil 应返回空") + } + r.SetName("u1", "x") // 不应 panic +} + +// ⭐ 回归网:节流必须按账号独立。 +// 曾经的缺陷:lastSample 是全局单个时间戳,而采样由 RunBalanceRefreshNow 并发 +// 触达所有账号 → 同一窗口只有"抢到"的账号落点,其余被静默丢弃,症状是 +// 「多个账号只有一条线」。单账号时该缺陷不显形,故当初漏测——本用例专门钉住它。 +func TestAddThrottleIsPerAccount(t *testing.T) { + now := time.Date(2026, 9, 16, 10, 0, 0, 0, time.Local) + r := New("") + cur := now + r.clock = func() time.Time { return cur } + + // 同一时刻、三个账号依次采样:全部都应被接受(各自独立窗口)。 + for _, uid := range []string{"A", "B", "C"} { + if !r.Add(uid, 100) { + t.Fatalf("账号 %s 首次采样应被接受(节流必须按账号独立)", uid) + } + } + if len(r.points) != 3 { + t.Fatalf("三个账号各应落一点,共 3 点, 得到 %d", len(r.points)) + } + + // 同一账号在窗口内重复:应被拒。 + if r.Add("A", 101) { + t.Error("同账号在 30 分钟内重复应被节流") + } + + // 推进 30 分钟:三个账号都应再次落点。 + cur = now.Add(30 * time.Minute) + for _, uid := range []string{"A", "B", "C"} { + if !r.Add(uid, 200) { + t.Errorf("满 30 分钟后账号 %s 应可再次采样", uid) + } + } + if len(r.points) != 6 { + t.Errorf("应累计 6 点, 得到 %d", len(r.points)) + } + // 且每条序列各 2 点(前端一条线一账号的依据) + got, _ := r.Snapshot(time.Time{}) + if len(got) != 3 { + t.Fatalf("应有 3 条序列, 得到 %d", len(got)) + } + for _, s := range got { + if len(s.Points) != 2 { + t.Errorf("账号 %s 应有 2 点, 得到 %d", s.UID, len(s.Points)) + } + } +} + +// 回归网:重载后每账号的节流时刻各自恢复(否则重启后会给某账号连补多点)。 +func TestReloadRestoresPerAccountThrottle(t *testing.T) { + dir := t.TempDir() + path := filepath.Join(dir, "b.json") + t0 := time.Date(2026, 9, 16, 10, 0, 0, 0, time.Local) + + r := New(path) + cur := t0 + r.clock = func() time.Time { return cur } + r.Add("A", 1000) + cur = t0.Add(10 * time.Minute) + r.Add("B", 2000) // B 晚 10 分钟 + r.Save() + + r2 := New(path) + if len(r2.points) != 2 { + t.Fatalf("重载应得 2 点, 得到 %d", len(r2.points)) + } + // A 的最后采样是 t0,距 t0+10min 仅 10 分钟 → 应被节流 + cur2 := t0.Add(10 * time.Minute) + r2.clock = func() time.Time { return cur2 } + if r2.Add("A", 1001) { + t.Error("A 距上次仅 10 分钟,重载后应仍被节流") + } + // B 的最后采样就是此刻 → 也应被节流 + if r2.Add("B", 2001) { + t.Error("B 恰在采样时刻,应被节流") + } + // 满 30 分钟后放行 + cur2 = t0.Add(30 * time.Minute) + if !r2.Add("A", 1002) { + t.Error("A 满 30 分钟应放行") + } +} + +// 每日聚合:口径 = 末值 − 首值;跨日要正确切分。 +func TestDailyOfBasic(t *testing.T) { + d1 := time.Date(2026, 9, 16, 8, 0, 0, 0, time.Local) + d2 := time.Date(2026, 9, 17, 8, 0, 0, 0, time.Local) + pts := []Point{ + {TS: d1.Unix(), Credits: 1000}, + {TS: d1.Add(30 * time.Minute).Unix(), Credits: 900}, + {TS: d1.Add(time.Hour).Unix(), Credits: 800}, // 9/16 末值 800 → 变化 -200 + {TS: d2.Unix(), Credits: 1200}, + {TS: d2.Add(30 * time.Minute).Unix(), Credits: 1100}, // 9/17 末值 1100 → 变化 -100 + } + now := time.Date(2026, 9, 18, 10, 0, 0, 0, time.Local) // 站在 9/18 看,两天都已过完 + got := dailyOf(pts, now) + if len(got) != 2 { + t.Fatalf("应 2 天, 得到 %d", len(got)) + } + if got[0].Day != "2026-09-16" || got[1].Day != "2026-09-17" { + t.Errorf("日期错误: %s / %s", got[0].Day, got[1].Day) + } + if got[0].First != 1000 || got[0].Last != 800 || got[0].Change != -200 { + t.Errorf("9/16 聚合错误: first=%d last=%d change=%d", got[0].First, got[0].Last, got[0].Change) + } + if got[0].Min != 800 || got[0].Max != 1000 { + t.Errorf("9/16 min/max 错误: %d/%d", got[0].Min, got[0].Max) + } + if got[1].Change != -100 { + t.Errorf("9/17 变化应为 -100, 得到 %d", got[1].Change) + } +} + +// ⭐ 关键边界:今日必须标记为「不完整」——否则"今天只涨一点"会被误读。 +func TestDailyOfTodayNotFull(t *testing.T) { + now := time.Date(2026, 9, 17, 10, 0, 0, 0, time.Local) + // 今日只采了 3 点(远少于 expectedPerDay=40) + pts := []Point{ + {TS: now.Add(-2 * time.Hour).Unix(), Credits: 500}, + {TS: now.Add(-time.Hour).Unix(), Credits: 450}, + {TS: now.Unix(), Credits: 400}, + } + got := dailyOf(pts, now) + if len(got) != 1 { + t.Fatalf("应 1 天, 得到 %d", len(got)) + } + if got[0].Full { + t.Error("今日必须标记为不完整(Full=false),否则读数会被误读") + } +} + +// 历史完整日(点数达标)应标记 Full=true。 +func TestDailyOfPastFullDay(t *testing.T) { + day := time.Date(2026, 9, 16, 0, 0, 0, 0, time.Local) + var pts []Point + for i := 0; i < 48; i++ { // 全天 48 点 + pts = append(pts, Point{TS: day.Add(time.Duration(i) * 30 * time.Minute).Unix(), Credits: 1000 - int64(i)}) + } + now := time.Date(2026, 9, 17, 12, 0, 0, 0, time.Local) + got := dailyOf(pts, now) + if len(got) != 1 || !got[0].Full { + t.Errorf("48 点的历史日应 Full=true, 得到 %+v", got) + } +} + +// 点数不足的历史日(服务中途启用)也应标记不完整。 +func TestDailyOfPastPartialDay(t *testing.T) { + day := time.Date(2026, 9, 16, 20, 0, 0, 0, time.Local) + pts := []Point{ + {TS: day.Unix(), Credits: 100}, + {TS: day.Add(30 * time.Minute).Unix(), Credits: 90}, + } + now := time.Date(2026, 9, 17, 12, 0, 0, 0, time.Local) + got := dailyOf(pts, now) + if len(got) != 1 { + t.Fatalf("应 1 天, 得到 %d", len(got)) + } + if got[0].Full { + t.Error("仅 2 点的历史日应标记不完整") + } +} + +func TestDailyOfEmpty(t *testing.T) { + if got := dailyOf(nil, time.Now()); got != nil { + t.Errorf("空输入应返回 nil, 得到 %v", got) + } +} + +// Snapshot 应把 daily 一并带出(前端每日对照视图的数据来源)。 +func TestSnapshotIncludesDaily(t *testing.T) { + base := time.Date(2026, 9, 16, 8, 0, 0, 0, time.Local) + r := New("") + r.points = []Point{ + {TS: base.Unix(), UID: "u1", Credits: 1000}, + {TS: base.Add(time.Hour).Unix(), UID: "u1", Credits: 1200}, + } + got, _ := r.Snapshot(time.Time{}) + if len(got) != 1 { + t.Fatalf("应 1 序列") + } + if len(got[0].Daily) != 1 { + t.Fatalf("应带出 1 天 daily, 得到 %d", len(got[0].Daily)) + } + if got[0].Daily[0].Change != 200 { + t.Errorf("daily 变化应为 +200, 得到 %d", got[0].Daily[0].Change) + } +} + +// TestSetRealmAppearsInSnapshot realm 注入后必须出现在 Snapshot 的每条序列上, +// 供前端分域切换(cn 与 global 的积分不可跨域求和)。 +func TestSetRealmAppearsInSnapshot(t *testing.T) { + r := New("") + now := time.Date(2026, 9, 17, 10, 0, 0, 0, time.Local) + r.clock = func() time.Time { return now } + r.SetRealm("uid-cn", "cn") + r.SetRealm("uid-global", "global") + r.Add("uid-cn", 100) + r.Add("uid-global", 200) + + series, _ := r.Snapshot(time.Time{}) + got := map[string]string{} + for _, s := range series { + got[s.UID] = s.Realm + } + if got["uid-cn"] != "cn" { + t.Errorf("uid-cn realm = %q, want cn", got["uid-cn"]) + } + if got["uid-global"] != "global" { + t.Errorf("uid-global realm = %q, want global", got["uid-global"]) + } +} + +// TestSetRealmEmptyIgnored 空 realm 不得覆盖已记录的值 +// (上游偶发空值不该把已分好组的账号打回 other)。 +func TestSetRealmEmptyIgnored(t *testing.T) { + r := New("") + r.SetRealm("uid1", "cn") + r.SetRealm("uid1", "") // 空值:忽略 + r.SetRealm("", "global") // 空 uid:忽略 + + series, _ := r.Snapshot(time.Time{}) + r.Add("uid1", 1) + series, _ = r.Snapshot(time.Time{}) + if len(series) != 1 { + t.Fatalf("series len = %d, want 1", len(series)) + } + if series[0].Realm != "cn" { + t.Errorf("realm = %q, want cn(空值不应覆盖)", series[0].Realm) + } +} + +// TestSetRealmNilSafe nil Recorder 上调用 SetRealm 不得 panic(防御)。 +func TestSetRealmNilSafe(t *testing.T) { + var r *Recorder + r.SetRealm("uid", "cn") // 不应 panic +} + +// TestSetRealmNotPersisted realm 是展示元数据,不入盘;重启后由面板重新注入。 +func TestSetRealmNotPersisted(t *testing.T) { + dir := t.TempDir() + path := filepath.Join(dir, "bal.json") + r := New(path) + r.SetRealm("uid1", "cn") + r.Add("uid1", 500) + r.flush(true) // force:立即落盘(正常路径是 30s 防抖) + raw, err := os.ReadFile(path) + if err != nil { + t.Fatalf("read: %v", err) + } + if strings.Contains(string(raw), `"cn"`) { + t.Errorf("realm 不应入盘,实际文件含 cn:\n%s", raw) + } +} + +// TestDailyConsumedGained 消耗/到账必须由相邻采样差值分正负累加得出, +// 且与净变化满足恒等式:Change == Gained - Consumed。 +// +// 该恒等式是本字段的正确性判据:若破坏(如把跨日差值也累加进来、 +// 或漏算首点),三者会对不上。见 dev-principles.md 第十节(不得产出 +// 语义上不可能的值:消耗/到账都恒 >= 0)。 +func TestDailyConsumedGained(t *testing.T) { + r := New("") + // 逐点推进时钟,全部落在同一天内 + base := time.Date(2026, 9, 17, 10, 0, 0, 0, time.Local) + cur := base + r.clock = func() time.Time { return cur } + step := 31 * time.Minute + + // 100 -> 130 (+30 到账) -> 110 (-20 消耗) -> 150 (+40 到账) -> 120 (-30 消耗) + for _, v := range []int64{100, 130, 110, 150, 120} { + r.Add("u1", v) + cur = cur.Add(step) + } + + series, _ := r.Snapshot(time.Time{}) + if len(series) != 1 || len(series[0].Daily) != 1 { + t.Fatalf("want 1 series with 1 day, got %+v", series) + } + d := series[0].Daily[0] + if d.Gained != 70 { // 30 + 40 + t.Errorf("Gained = %d, want 70", d.Gained) + } + if d.Consumed != 50 { // 20 + 30 + t.Errorf("Consumed = %d, want 50", d.Consumed) + } + if d.Change != d.Gained-d.Consumed { + t.Errorf("恒等式破坏:Change=%d != Gained(%d) - Consumed(%d)", d.Change, d.Gained, d.Consumed) + } + if d.Consumed < 0 || d.Gained < 0 { + t.Errorf("消耗/到账不得为负:consumed=%d gained=%d", d.Consumed, d.Gained) + } +} + +// TestDailyConsumedNotCrossDay 跨日的相邻点不得互相累加: +// 昨日末值 → 今日首值 的差值属于隔夜变化,不是今天的消耗/到账。 +func TestDailyConsumedNotCrossDay(t *testing.T) { + r := New("") + cur := time.Date(2026, 9, 16, 23, 30, 0, 0, time.Local) + r.clock = func() time.Time { return cur } + step := 31 * time.Minute + + r.Add("u1", 100) // 09-16 23:30 + cur = cur.Add(step) // -> 09-17 00:01 + r.Add("u1", 500) // 跨日大涨 400:不应算进任一天的 gained + cur = cur.Add(step) + r.Add("u1", 480) // 09-17 内跌 20 + + series, _ := r.Snapshot(time.Time{}) + if len(series) != 1 { + t.Fatalf("want 1 series, got %d", len(series)) + } + days := series[0].Daily + if len(days) != 2 { + t.Fatalf("want 2 days, got %d: %+v", len(days), days) + } + for _, d := range days { + if d.Day == "2026-09-16" { + if d.Gained != 0 || d.Consumed != 0 { + t.Errorf("09-16 不该有流量(单点无相邻):gained=%d consumed=%d", d.Gained, d.Consumed) + } + } + if d.Day == "2026-09-17" { + // 该日只有 500 -> 480 一对,跌 20;500 相对昨日 100 的 +400 不算今日到账 + if d.Gained != 0 { + t.Errorf("09-17 Gained = %d, want 0(跨日涨幅不该算今日到账)", d.Gained) + } + if d.Consumed != 20 { + t.Errorf("09-17 Consumed = %d, want 20", d.Consumed) + } + } + } +} + +// TestDailyZeroFlowIsZero 余额全程不变时,消耗/到账必须都是 0(不是负值、不是残留)。 +func TestDailyZeroFlowIsZero(t *testing.T) { + r := New("") + cur := time.Date(2026, 9, 17, 10, 0, 0, 0, time.Local) + r.clock = func() time.Time { return cur } + for i := 0; i < 3; i++ { + r.Add("u1", 349) + cur = cur.Add(31 * time.Minute) + } + series, _ := r.Snapshot(time.Time{}) + d := series[0].Daily[0] + if d.Consumed != 0 || d.Gained != 0 || d.Change != 0 { + t.Errorf("余额恒定时应为全零:%+v", d) + } +} + +// TestRollupKeepsFlows 折叠不得丢失当日的消耗/到账。 +// +// 事故形态(本测试存在的原因):折叠点每天只剩一个水位,dailyOf 按「相邻 +// 采样差值累加」算消耗/到账时拿不到任何相邻对 → 结果恒为 0。前端把这段 +// 历史显示为「30 天前每天消耗 0」,数字看着正常,但**是错的**(数据被丢掉了)。 +// 这类"静默归零"比报错危险:没有异常、没有空值,只有错的 0。 +func TestRollupKeepsFlows(t *testing.T) { + base := time.Date(2026, 8, 1, 0, 0, 0, 0, time.Local) + r := New("") + // 同日 5 点:500 -> 480(跌 20)-> 600(涨 120)-> 600 -> 550(跌 50) + // 期望:consumed = 20 + 50 = 70,gained = 120 + r.points = []Point{ + {TS: base.Add(0 * time.Hour).Unix(), UID: "u1", Credits: 500}, + {TS: base.Add(2 * time.Hour).Unix(), UID: "u1", Credits: 480}, + {TS: base.Add(4 * time.Hour).Unix(), UID: "u1", Credits: 600}, + {TS: base.Add(6 * time.Hour).Unix(), UID: "u1", Credits: 600}, + {TS: base.Add(8 * time.Hour).Unix(), UID: "u1", Credits: 550}, // 当日最后 + } + now := base.Add(31 * 24 * time.Hour) + r.Rollup(now) + + if len(r.points) != 1 { + t.Fatalf("折叠后点数 = %d, 期望 1", len(r.points)) + } + p := r.points[0] + if p.Credits != 550 { + t.Errorf("水位应保留当日最后值 550, 得到 %d", p.Credits) + } + if p.Consumed != 70 { + t.Errorf("折叠点 Consumed = %d, want 70(20+50)", p.Consumed) + } + if p.Gained != 120 { + t.Errorf("折叠点 Gained = %d, want 120", p.Gained) + } + + // 端到端:dailyOf 必须把折叠点自带的值算进当日汇总。 + // 折叠后的点落在 30 天前的窗口里,用 Snapshot 全量取。 + series, _ := r.Snapshot(time.Time{}) + if len(series) != 1 || len(series[0].Daily) != 1 { + t.Fatalf("期望 1 账号 1 天, 得到 %+v", series) + } + d := series[0].Daily[0] + if d.Consumed != 70 || d.Gained != 120 { + t.Errorf("Daily 未纳入折叠点流量:consumed=%d gained=%d, want 70/120(折叠日流量被丢掉会显示为 0)", + d.Consumed, d.Gained) + } + // Change 口径不变:末值 − 首值 = 550 − 500 = 50(首值来自原始点,故仍正确) + if d.Change != 50 { + t.Errorf("Change = %d, want 50(首末口径不因折叠而变)", d.Change) + } +} + +// TestRollupFlowsPerDayIndependent 折叠时按日分组,消耗/到账不得串天。 +func TestRollupFlowsPerDayIndependent(t *testing.T) { + base := time.Date(2026, 8, 1, 0, 0, 0, 0, time.Local) + r := New("") + r.points = []Point{ + {TS: base.Unix(), UID: "u1", Credits: 1000}, + {TS: base.Add(time.Hour).Unix(), UID: "u1", Credits: 900}, // D1 跌 100 + {TS: base.Add(25 * time.Hour).Unix(), UID: "u1", Credits: 1500}, // D2 首点(不跨日累加) + {TS: base.Add(26 * time.Hour).Unix(), UID: "u1", Credits: 1400}, // D2 跌 100 + } + r.Rollup(base.Add(40 * 24 * time.Hour)) + + byDay := map[string]Point{} + for _, p := range r.points { + byDay[p.Day] = p + } + d1, d2 := byDay["2026-08-01"], byDay["2026-08-02"] + if d1.Consumed != 100 || d1.Gained != 0 { + t.Errorf("D1 = %+v, want consumed=100 gained=0", d1) + } + // D2 的 1500 − 900 = 600 是隔夜涨幅,不得算作 D2 的到账 + if d2.Gained != 0 { + t.Errorf("D2 Gained = %d, want 0(跨日涨幅不该进折叠值)", d2.Gained) + } + if d2.Consumed != 100 { + t.Errorf("D2 Consumed = %d, want 100", d2.Consumed) + } +} diff --git a/internal/credithist/credithist.go b/internal/credithist/credithist.go new file mode 100644 index 0000000000000000000000000000000000000000..b4c0e58127c62c1d5ef97beff30d77c0df1fa15f --- /dev/null +++ b/internal/credithist/credithist.go @@ -0,0 +1,195 @@ +// Package credithist 积分历史:把「每次真实查到的余额」与上一次比对,变动即留痕。 +// +// 为什么需要:签到 / 活跃上报 / 猫猫旅行 / 成长任务都会让余额增加,但上游只在少数 +// 渠道留下可读金额;面板「用量」折算的是**消耗**,此前没有任何逐账号的余额时间线。 +// 把余额当观测量逐次比对,就能覆盖全部获取渠道(做法与 workbuddy-manager 的 +// 「积分变动流水」一致)。 +// +// 与参考实现的有意差异:参考实现只记增加(减少属"消耗",已有用量视图覆盖)。本 +// 实现两个方向都留痕(Delta 带符号),因为本面板缺的正是"什么时候变成多少"这条 +// 时间线;展示层用正负号区分获取与消耗。 +// +// 首次见到某个 uid 只建立基线、不记流水——否则会把历史余额误报成"刚获得"。 +package credithist + +import ( + "encoding/json" + "errors" + "io/fs" + "log" + "os" + "path/filepath" + "strings" + "sync" + "time" + + "github.com/misakano7545/workbuddy2api-panel/internal/safefile" +) + +// maxDelta 单次变动的留痕上限(对齐参考实现的 _MAX_DELTA):超过它基本可断定是 +// 上游脏数据或口径切换(如企业版"不限量"哨兵值),只更新基线、不留痕,避免一条 +// 假流水污染整段历史。 +const maxDelta = 1_000_000 + +// defaultMaxEntries 流水条数上限(超出丢最旧):按每日数十条估计可留数月。 +const defaultMaxEntries = 2000 + +// Entry 一条积分变动流水。Before/After 是变动前后余额,Delta = After - Before +// (正 = 获取,负 = 消耗)。 +type Entry struct { + Time time.Time `json:"time"` + UID string `json:"uid"` + Delta int64 `json:"delta"` + Before int64 `json:"before"` + After int64 `json:"after"` +} + +// fileVersion 落盘格式版本(与 usage.json 同风格,便于将来迁移)。 +const fileVersion = 1 + +// diskFile 落盘结构:余额快照(uid → 最近余额)与流水同文件——重启后基线不丢, +// 不会把"上次进程结束时的余额"当成新增。 +type diskFile struct { + Version int `json:"version"` + Saved string `json:"saved,omitempty"` + Snapshot map[string]int64 `json:"snapshot"` + Entries []Entry `json:"entries"` +} + +// Ledger 并发安全的积分账本。path 为空 = 纯内存(不落盘)。 +type Ledger struct { + mu sync.Mutex + path string + max int + snapshot map[string]int64 + entries []Entry // 时间升序 +} + +// New 创建账本;path 非空且文件存在时加载既有快照与流水。加载失败只记日志、 +// 从空账本开始——丢历史好过让面板起不来。maxEntries <= 0 回落默认上限。 +func New(path string, maxEntries int) *Ledger { + if maxEntries <= 0 { + maxEntries = defaultMaxEntries + } + l := &Ledger{path: path, max: maxEntries, snapshot: map[string]int64{}} + l.load() + return l +} + +// load 读回快照与流水(无文件 = 空账本,不是错误)。 +func (l *Ledger) load() { + if l.path == "" { + return + } + raw, err := safefile.Read(l.path, nil) + if err != nil { + if !errors.Is(err, fs.ErrNotExist) { + log.Printf("[credithist] 读取 %s 失败(从空账本开始): %v", l.path, err) + } + return + } + var f diskFile + if err := json.Unmarshal(raw, &f); err != nil { + log.Printf("[credithist] 解析 %s 失败(从空账本开始): %v", l.path, err) + return + } + if f.Snapshot != nil { + l.snapshot = f.Snapshot + } + l.entries = f.Entries + if len(l.entries) > l.max { + l.entries = append([]Entry(nil), l.entries[len(l.entries)-l.max:]...) + } + log.Printf("[credithist] 已恢复 %d 条积分流水 / %d 个余额基线(%s)", + len(l.entries), len(l.snapshot), l.path) +} + +// Observe 记录一次真实查到的余额(uid + 余额绝对值)。 +// +// 语义: +// - 首次见到该 uid:只建基线,不记流水; +// - 余额与基线相同:直接返回(不落盘); +// - 余额变化且 |Delta| <= maxDelta:追加一条流水; +// - 余额变化但 |Delta| > maxDelta:只更新基线(脏数据不留痕)。 +// +// 同步落盘:留痕频率是"每次余额刷新"级(分钟级),文件很小,无需防抖队列。 +func (l *Ledger) Observe(uid string, credits int64) { + // 纯空白 uid 与空 uid 一样无效:放进去只会留下一个面板永远筛不到的幽灵基线 + // (uid 过滤参数为空 = 不过滤,所以这种条目既无用也删不掉)。 + if l == nil || strings.TrimSpace(uid) == "" { + return + } + l.mu.Lock() + prev, seen := l.snapshot[uid] + if seen && prev == credits { + l.mu.Unlock() + return + } + l.snapshot[uid] = credits + if seen { + if delta := credits - prev; delta >= -maxDelta && delta <= maxDelta { + l.entries = append(l.entries, Entry{ + Time: time.Now(), + UID: uid, + Delta: delta, + Before: prev, + After: credits, + }) + if len(l.entries) > l.max { + // 丢最旧:copy 到新底层数组,避免 append 复用旧数组导致内存不释放。 + l.entries = append([]Entry(nil), l.entries[len(l.entries)-l.max:]...) + } + } + } + raw, err := json.Marshal(diskFile{ + Version: fileVersion, + Saved: time.Now().Format(time.RFC3339), + Snapshot: l.snapshot, + Entries: l.entries, + }) + if err != nil { + l.mu.Unlock() + log.Printf("[credithist] 序列化失败: %v", err) + return + } + // 落盘仍在锁内:多个账号并发刷新余额时,"快照+流水"必须按同一顺序写盘, + // 否则慢的那次会把新的文件内容覆盖成旧的(内存正确、重启后少一条)。 + // 留痕频率是分钟级且仅在余额变化时触发,锁内小文件原子写无性能顾虑。 + l.write(raw) + l.mu.Unlock() +} + +// Read 返回最近 limit 条流水(新的在前);limit <= 0 = 全部。 +func (l *Ledger) Read(limit int) []Entry { + if l == nil { + return []Entry{} + } + l.mu.Lock() + defer l.mu.Unlock() + n := len(l.entries) + if limit <= 0 || limit > n { + limit = n + } + out := make([]Entry, 0, limit) + for i := n - 1; i >= n-limit; i-- { + out = append(out, l.entries[i]) + } + return out +} + +// write 原子写盘(临时文件 + rename,与 usage.Recorder 同口径)。失败只记日志: +// 留痕是旁路观测,不能反过来影响余额刷新主流程。 +func (l *Ledger) write(raw []byte) { + if l.path == "" { + return + } + if dir := filepath.Dir(l.path); dir != "" && dir != "." { + if err := os.MkdirAll(dir, 0o755); err != nil { + log.Printf("[credithist] 建目录失败: %v", err) + return + } + } + if err := safefile.WriteKeep(l.path, raw, 0o600); err != nil { + log.Printf("[credithist] 原子替换失败: %v", err) + } +} diff --git a/internal/credithist/credithist_test.go b/internal/credithist/credithist_test.go new file mode 100644 index 0000000000000000000000000000000000000000..fb6651f54dd52a65c39d07a6ec9f7c4e2db90e48 --- /dev/null +++ b/internal/credithist/credithist_test.go @@ -0,0 +1,181 @@ +package credithist + +import ( + "fmt" + "os" + "path/filepath" + "sync" + "testing" +) + +// 首次见到账号只建基线:把历史余额误报成「刚获得」是最刺眼的错误, +// 也是参考实现明确写下的一条约束。 +func TestFirstObserveOnlyBaselines(t *testing.T) { + l := New("", 100) + l.Observe("u1", 1000) + if got := len(l.Read(0)); got != 0 { + t.Fatalf("首次观测应只建基线,得到 %d 条流水", got) + } + // 基线生效:下一次同值不记、变化才记。 + l.Observe("u1", 1000) + if got := len(l.Read(0)); got != 0 { + t.Fatalf("余额未变不应记流水,得到 %d 条", got) + } + l.Observe("u1", 1100) + got := l.Read(0) + if len(got) != 1 { + t.Fatalf("余额 +100 应记 1 条,得到 %d 条", len(got)) + } + if got[0].Delta != 100 || got[0].Before != 1000 || got[0].After != 1100 || got[0].UID != "u1" { + t.Fatalf("流水字段不符: %+v", got[0]) + } +} + +// 消耗(余额下降)同样留痕,Delta 为负:面板缺的是逐账号余额时间线, +// 只记增加会让"什么时候变少"永远无从查证。 +func TestDecreaseIsRecorded(t *testing.T) { + l := New("", 100) + l.Observe("u1", 1000) + l.Observe("u1", 940) + got := l.Read(0) + if len(got) != 1 || got[0].Delta != -60 { + t.Fatalf("余额 -60 应记一条 delta=-60 的流水,得到 %+v", got) + } +} + +// |Delta| 超过 maxDelta 视为上游脏数据:只更新基线、不留痕(对齐参考实现 +// _MAX_DELTA),且不得把基线留在旧值上导致下一轮继续误判。 +func TestDirtyDeltaOnlyUpdatesBaseline(t *testing.T) { + l := New("", 100) + l.Observe("u1", 100) + l.Observe("u1", 100+maxDelta+1) // 超过上限 → 不留痕 + if got := len(l.Read(0)); got != 0 { + t.Fatalf("超限变动不应留痕,得到 %d 条", got) + } + // 基线已更新到新值:回落 100 应记一条 -1000001 之外的正常流水。 + l.Observe("u1", 200) + got := l.Read(0) + if len(got) != 1 || got[0].Before != 100+maxDelta+1 || got[0].After != 200 { + t.Fatalf("基线未更新,得到 %+v", got) + } +} + +// maxEntries 截断:只保留最新的 N 条,丢的是最旧的。 +func TestMaxEntriesTrimsOldest(t *testing.T) { + l := New("", 3) + l.Observe("u1", 0) + for i := int64(1); i <= 5; i++ { + l.Observe("u1", i*10) + } + got := l.Read(0) + if len(got) != 3 { + t.Fatalf("上限 3 应只保留 3 条,得到 %d 条", len(got)) + } + // 新的在前:10→20→30→40→50 里应剩 30/40/50。 + if got[0].After != 50 || got[1].After != 40 || got[2].After != 30 { + t.Fatalf("截断应保留最新 3 条,得到 %+v", got) + } +} + +// 落盘后重建实例仍能续接基线:快照与流水同文件,重启不会重复记基线、 +// 也不会把重启当成一次变动。 +func TestSnapshotSurvivesRestart(t *testing.T) { + path := filepath.Join(t.TempDir(), "credit-history.json") + l := New(path, 100) + l.Observe("u1", 1000) // 基线落盘 + if _, err := os.Stat(path); err != nil { + t.Fatalf("Observe 后应已落盘: %v", err) + } + + l2 := New(path, 100) + l2.Observe("u1", 1000) // 同值:不记 + if got := len(l2.Read(0)); got != 0 { + t.Fatalf("重启后同值不应记流水,得到 %d 条", got) + } + l2.Observe("u1", 1250) + got := l2.Read(0) + if len(got) != 1 || got[0].Delta != 250 || got[0].Before != 1000 { + t.Fatalf("重启后应能续接基线并记 +250,得到 %+v", got) + } +} + +// Read 的倒序与 limit 语义:新的在前,limit<=0 = 全部。 +func TestReadOrderAndLimit(t *testing.T) { + l := New("", 100) + l.Observe("u1", 0) + l.Observe("u1", 10) + l.Observe("u1", 20) + l.Observe("u1", 30) + all := l.Read(0) + if len(all) != 3 || all[0].After != 30 || all[2].After != 10 { + t.Fatalf("全量应新的在前: %+v", all) + } + one := l.Read(1) + if len(one) != 1 || one[0].After != 30 { + t.Fatalf("limit=1 应取最新一条: %+v", one) + } +} + +// 空 uid 不建基线:面板存在 uid 为空的异常条目,不能污染账本。 +func TestEmptyUIDIgnored(t *testing.T) { + l := New("", 100) + l.Observe("", 100) + l.Observe("", 200) + if got := len(l.Read(0)); got != 0 { + t.Fatalf("空 uid 不应记账,得到 %d 条", got) + } +} + +// 损坏文件不能拖垮启动:从空账本开始,后续观测照常工作。 +func TestCorruptFileFallsBackToEmpty(t *testing.T) { + path := filepath.Join(t.TempDir(), "credit-history.json") + if err := os.WriteFile(path, []byte("{not json"), 0o600); err != nil { + t.Fatal(err) + } + l := New(path, 100) + l.Observe("u1", 500) + l.Observe("u1", 600) + got := l.Read(0) + if len(got) != 1 || got[0].Delta != 100 { + t.Fatalf("损坏文件后应能正常建基线并记账,得到 %+v", got) + } +} + +// 并发 Observe:调度器全量余额刷新是多账号并行的,观测不能丢记录, +// 落盘也不能被慢写覆盖(内存与磁盘最终必须一致)。 +func TestConcurrentObserve(t *testing.T) { + path := filepath.Join(t.TempDir(), "credit-history.json") + l := New(path, 500) + const accounts = 8 + const rounds = 20 + for i := 0; i < accounts; i++ { + l.Observe(fmt.Sprintf("u%d", i), 100) // 基线 + } + var wg sync.WaitGroup + for i := 0; i < accounts; i++ { + uid := fmt.Sprintf("u%d", i) + wg.Add(1) + go func() { + defer wg.Done() + for n := int64(1); n <= rounds; n++ { + l.Observe(uid, 100+n*10) + } + }() + } + wg.Wait() + + want := accounts * rounds + if got := len(l.Read(0)); got != want { + t.Fatalf("并发观测应产生 %d 条流水,得到 %d", want, got) + } + // 重启读取必须与内存一致:慢写覆盖会让磁盘少条、快照回退。 + l2 := New(path, 500) + if got := len(l2.Read(0)); got != want { + t.Fatalf("重启后应保留 %d 条,得到 %d(落盘被覆盖)", want, got) + } + for i := 0; i < accounts; i++ { + if v := l2.snapshot[fmt.Sprintf("u%d", i)]; v != 300 { + t.Fatalf("u%d 快照应为 300,得到 %d", i, v) + } + } +} diff --git a/internal/credithist/fault_test.go b/internal/credithist/fault_test.go new file mode 100644 index 0000000000000000000000000000000000000000..598de86b93d5a311b549f3e9133d926d8117cdbb --- /dev/null +++ b/internal/credithist/fault_test.go @@ -0,0 +1,424 @@ +package credithist + +// T5 故障注入与边界测试(账本层)。只新增测试,不改业务代码。 + +import ( + "fmt" + "os" + "path/filepath" + "runtime" + "sync" + "testing" +) + +// ── 1. 落盘目标不可写 ────────────────────────────────────────────────────── + +// 目标路径任何一段不可写(这里用「父路径是普通文件」构造,Windows / POSIX 都成立) +// 时,Observe 只能记日志:不得 panic、不得影响内存账本;故障排除后必须恢复落盘。 +func TestFaultUnwritableTargetKeepsMemoryAndRecovers(t *testing.T) { + dir := t.TempDir() + blocker := filepath.Join(dir, "blocker") + if err := os.WriteFile(blocker, []byte("x"), 0o600); err != nil { + t.Fatal(err) + } + path := filepath.Join(blocker, "credit-history.json") // 父路径是普通文件 → MkdirAll 与写盘必失败 + + l := New(path, 100) + l.Observe("u1", 100) // 基线:落盘失败 + l.Observe("u1", 250) // +150:落盘失败 + got := l.Read(0) + if len(got) != 1 || got[0].Delta != 150 || got[0].After != 250 { + t.Fatalf("落盘失败不应影响内存账本,得到 %+v", got) + } + if l.snapshot["u1"] != 250 { + t.Fatalf("内存基线应为 250,得到 %d", l.snapshot["u1"]) + } + if _, err := os.Stat(path); err == nil { + t.Fatal("父路径是普通文件时不应写出账本文件") + } + + // 排除故障:删掉阻塞文件、建同名目录,再观察必须恢复落盘。 + if err := os.Remove(blocker); err != nil { + t.Fatal(err) + } + if err := os.Mkdir(blocker, 0o755); err != nil { + t.Fatal(err) + } + l.Observe("u1", 300) // +50 + l2 := New(path, 100) + got = l2.Read(0) + if len(got) != 2 || got[0].Delta != 50 || got[1].Delta != 150 { + t.Fatalf("恢复可写后应落盘并保留两条流水,得到 %+v", got) + } + if l2.snapshot["u1"] != 300 { + t.Fatalf("恢复后快照应为 300,得到 %d", l2.snapshot["u1"]) + } +} + +// POSIX 目录只读路径。Windows 的 os.Chmod 只改文件只读属性,没有目录写保护语义, +// 故在 Windows 上跳过(不可写路径已由上面的父路径为文件用例覆盖)。 +func TestFaultReadOnlyDirPOSIX(t *testing.T) { + if runtime.GOOS == "windows" { + t.Skip("Windows 无 POSIX 目录权限语义") + } + if os.Geteuid() == 0 { + t.Skip("root 不受目录权限限制") + } + dir := t.TempDir() + sub := filepath.Join(dir, "ro") + if err := os.Mkdir(sub, 0o755); err != nil { + t.Fatal(err) + } + path := filepath.Join(sub, "credit-history.json") + l := New(path, 100) + l.Observe("u1", 10) // 正常落盘 + if err := os.Chmod(sub, 0o500); err != nil { + t.Fatal(err) + } + l.Observe("u1", 20) // 写临时文件失败 → 只记日志 + if got := l.Read(0); len(got) != 1 || got[0].Delta != 10 { + t.Fatalf("只读目录下内存账本仍应正确,得到 %+v", got) + } + if err := os.Chmod(sub, 0o755); err != nil { + t.Fatal(err) + } + l.Observe("u1", 30) + l2 := New(path, 100) + if got := l2.Read(0); len(got) != 2 || got[1].Delta != 10 { + t.Fatalf("恢复可写后应落盘两条,得到 %+v", got) + } +} + +// ── 2. 退化/损坏文件 ────────────────────────────────────────────────────── + +// 损坏 JSON、null 快照/流水、空文件、类型不符、顶层数组、路径本身是目录—— +// 一律从空账本安全启动,后续 Observe 正常,不得 panic。 +func TestFaultDegenerateFilesStartEmpty(t *testing.T) { + cases := []struct { + name string + setup func(t *testing.T, path string) + }{ + {"invalid_json", func(t *testing.T, p string) { + if err := os.WriteFile(p, []byte("{not json"), 0o600); err != nil { + t.Fatal(err) + } + }}, + {"empty_file", func(t *testing.T, p string) { + if err := os.WriteFile(p, nil, 0o600); err != nil { + t.Fatal(err) + } + }}, + {"null_snapshot_and_entries", func(t *testing.T, p string) { + if err := os.WriteFile(p, []byte(`{"version":1,"snapshot":null,"entries":null}`), 0o600); err != nil { + t.Fatal(err) + } + }}, + {"entries_null", func(t *testing.T, p string) { + if err := os.WriteFile(p, []byte(`{"version":1,"snapshot":{"u1":5},"entries":null}`), 0o600); err != nil { + t.Fatal(err) + } + }}, + {"wrong_types", func(t *testing.T, p string) { + if err := os.WriteFile(p, []byte(`{"version":1,"snapshot":"x","entries":42}`), 0o600); err != nil { + t.Fatal(err) + } + }}, + {"top_level_array", func(t *testing.T, p string) { + if err := os.WriteFile(p, []byte("[]"), 0o600); err != nil { + t.Fatal(err) + } + }}, + {"path_is_directory", func(t *testing.T, p string) { + if err := os.Mkdir(p, 0o755); err != nil { + t.Fatal(err) + } + }}, + } + for _, c := range cases { + t.Run(c.name, func(t *testing.T) { + path := filepath.Join(t.TempDir(), "credit-history.json") + c.setup(t, path) + l := New(path, 100) // 必须不 panic + base := len(l.Read(0)) + l.Observe("fresh", 100) // 基线 + l.Observe("fresh", 130) // +30 + got := l.Read(0) + if len(got) != base+1 { + t.Fatalf("退化输入后应能正常观测:base=%d 期望 %d 条,得到 %d(%+v)", base, base+1, len(got), got) + } + if got[0].UID != "fresh" || got[0].Delta != 30 || got[0].Before != 100 || got[0].After != 130 { + t.Fatalf("新增流水字段不符: %+v", got[0]) + } + }) + } +} + +// ── 3. maxEntries 回落与截断 ────────────────────────────────────────────── + +// maxEntries <= 0 回落默认上限,不产生无界增长;=1 只留最新一条。 +func TestFaultMaxEntriesFallbackAndTrim(t *testing.T) { + for _, m := range []int{0, -1, -1000} { + l := New("", m) + if l.max != defaultMaxEntries { + t.Fatalf("maxEntries=%d 应回落默认 %d,得到 %d", m, defaultMaxEntries, l.max) + } + } + + // 不无界增长:写 defaultMaxEntries+300 次,条数必须恰为默认上限。 + l := New("", 0) + l.Observe("u1", 0) + for i := int64(1); i <= int64(defaultMaxEntries)+300; i++ { + l.Observe("u1", i) + } + got := l.Read(0) + if len(got) != defaultMaxEntries { + t.Fatalf("默认上限 %d 应截断,得到 %d", defaultMaxEntries, len(got)) + } + if got[0].After != int64(defaultMaxEntries)+300 { + t.Fatalf("截断后最新一条应保留,得到 %+v", got[0]) + } + + // maxEntries=1:只留最新一条,且丢的是最旧。 + l1 := New("", 1) + l1.Observe("u1", 0) + l1.Observe("u1", 10) + l1.Observe("u1", 20) + one := l1.Read(0) + if len(one) != 1 || one[0].After != 20 || one[0].Delta != 10 { + t.Fatalf("上限 1 应只留最新一条,得到 %+v", one) + } +} + +// ── 4. Read 边界 ────────────────────────────────────────────────────────── + +// limit<=0 = 全部;大于总数 = 全部;1 = 最新;顺序严格新的在前。 +func TestFaultReadBoundaries(t *testing.T) { + l := New("", 100) + l.Observe("u1", 0) + for i := int64(1); i <= 3; i++ { + l.Observe("u1", i*10) + } + cases := []struct { + name string + limit int + want int + }{ + {"zero_is_all", 0, 3}, + {"negative_is_all", -7, 3}, + {"over_total_is_all", 99, 3}, + {"exact_total", 3, 3}, + {"two", 2, 2}, + {"one", 1, 1}, + } + for _, c := range cases { + if got := l.Read(c.limit); len(got) != c.want { + t.Fatalf("%s: Read(%d) 得到 %d 条,期望 %d", c.name, c.limit, len(got), c.want) + } + } + got := l.Read(0) + if got[0].After != 30 || got[1].After != 20 || got[2].After != 10 { + t.Fatalf("必须严格新的在前: %+v", got) + } + got = l.Read(1) + if len(got) != 1 || got[0].After != 30 { + t.Fatalf("Read(1) 应取最新一条: %+v", got) + } +} + +// ── 5. Δ 边界 ──────────────────────────────────────────────────────────── + +// 恰好 ±maxDelta 记账;±(maxDelta+1) 只更新基线、不留痕,且基线必须推进到新值。 +func TestFaultDeltaBoundaries(t *testing.T) { + // +++ 恰好 +1000000 记账 + l := New("", 100) + l.Observe("u1", 0) + l.Observe("u1", maxDelta) + if got := l.Read(0); len(got) != 1 || got[0].Delta != maxDelta || got[0].Before != 0 || got[0].After != maxDelta { + t.Fatalf("恰好 +%d 应记账: %+v", maxDelta, got) + } + // --- 恰好 -1000000 记账 + l = New("", 100) + l.Observe("u1", maxDelta) + l.Observe("u1", 0) + if got := l.Read(0); len(got) != 1 || got[0].Delta != -maxDelta { + t.Fatalf("恰好 -%d 应记账: %+v", maxDelta, got) + } + // +++ 超限 +1000001 不留痕,但基线推进 + l = New("", 100) + l.Observe("u1", 0) + l.Observe("u1", maxDelta+1) + if got := len(l.Read(0)); got != 0 { + t.Fatalf("超限 +%d 不应留痕,得到 %d 条", maxDelta+1, got) + } + if l.snapshot["u1"] != maxDelta+1 { + t.Fatalf("超限后基线应推进到 %d,得到 %d", maxDelta+1, l.snapshot["u1"]) + } + l.Observe("u1", 1) // Δ = 1-(maxDelta+1) = -maxDelta → 正常记账 + got := l.Read(0) + if len(got) != 1 || got[0].Delta != -maxDelta || got[0].Before != maxDelta+1 || got[0].After != 1 { + t.Fatalf("超限后应按新基线记账: %+v", got) + } + // --- 超限 -1000001 不留痕,基线推进 + l = New("", 100) + l.Observe("u1", 0) + l.Observe("u1", -(maxDelta + 1)) + if got := len(l.Read(0)); got != 0 { + t.Fatalf("超限 -%d 不应留痕,得到 %d 条", maxDelta+1, got) + } + if l.snapshot["u1"] != -(maxDelta + 1) { + t.Fatalf("超限后基线应推进到 %d,得到 %d", -(maxDelta + 1), l.snapshot["u1"]) + } + l.Observe("u1", -1) // Δ = -1-(-(maxDelta+1)) = +maxDelta + got = l.Read(0) + if len(got) != 1 || got[0].Delta != maxDelta || got[0].Before != -(maxDelta+1) { + t.Fatalf("超限后应按新基线记账: %+v", got) + } +} + +// ── 6. uid 边界 ─────────────────────────────────────────────────────────── + +// 空 uid(上游异常条目)不建基线、不记账。 +func TestFaultEmptyUIDIgnored(t *testing.T) { + l := New("", 100) + l.Observe("", 100) + l.Observe("", 200) + if got := len(l.Read(0)); got != 0 { + t.Fatalf("空 uid 不应记账,得到 %d 条", got) + } + if len(l.snapshot) != 0 { + t.Fatalf("空 uid 不应建基线,得到 %v", l.snapshot) + } +} + +// 任务描述要求纯空白 uid(上游脏数据)同样不建基线。当前实现只判 uid == "", +// 纯空白会进快照——此用例作为复现保留,等 lead 裁决。 +func TestFaultWhitespaceUIDNotBaselined(t *testing.T) { + l := New("", 100) + l.Observe(" ", 100) + l.Observe("\t\n", 100) + if got := len(l.Read(0)); got != 0 { + t.Fatalf("纯空白 uid 不应记账,得到 %d 条", got) + } + if len(l.snapshot) != 0 { + t.Fatalf("纯空白 uid 不应建基线,但快照里有 %d 个键: %v", len(l.snapshot), l.snapshot) + } +} + +// ── 7. 并发 ────────────────────────────────────────────────────────────── + +// 多 goroutine(不同 uid 定量 + 同一 uid 混跑)不 panic、不同 uid 条数不丢、 +// 磁盘与内存逐条一致;同一 uid 并发后再顺序写一个唯一哨兵,必须是最终基线。 +func TestFaultConcurrentMixedUIDs(t *testing.T) { + path := filepath.Join(t.TempDir(), "credit-history.json") + l := New(path, 4000) + const accounts = 6 + const rounds = 30 + for i := 0; i < accounts; i++ { + l.Observe(fmt.Sprintf("acct-%d", i), 0) + } + l.Observe("shared", 0) + + var wg sync.WaitGroup + for i := 0; i < accounts; i++ { + uid := fmt.Sprintf("acct-%d", i) + wg.Add(1) + go func() { + defer wg.Done() + for n := int64(1); n <= rounds; n++ { + l.Observe(uid, n*10) + } + }() + } + for w := 0; w < 8; w++ { + base := int64(w) * 1000 + wg.Add(1) + go func() { + defer wg.Done() + for n := int64(1); n <= 20; n++ { + l.Observe("shared", base+n) + } + }() + } + wg.Wait() + + // 顺序写入唯一哨兵 = 「最后一次写入」,并发结束后必须生效。 + l.Observe("shared", 777777) + if l.snapshot["shared"] != 777777 { + t.Fatalf("最后写入应成为基线,得到 %d", l.snapshot["shared"]) + } + + mem := l.Read(0) + per := map[string]int{} + for _, e := range mem { + per[e.UID]++ + } + for i := 0; i < accounts; i++ { + uid := fmt.Sprintf("acct-%d", i) + if per[uid] != rounds { + t.Fatalf("%s 应有 %d 条流水,得到 %d", uid, rounds, per[uid]) + } + } + + // 磁盘必须与内存逐条一致(慢写覆盖会让磁盘少条/快照回退)。 + l2 := New(path, 4000) + disk := l2.Read(0) + if len(disk) != len(mem) { + t.Fatalf("重启后条数不一致:内存 %d / 磁盘 %d", len(mem), len(disk)) + } + for i := range mem { + m, d := mem[i], disk[i] + // 不能直接比较 struct:内存里的 time.Time 带单调时钟读数,落盘再读回后没有。 + if m.UID != d.UID || m.Delta != d.Delta || m.Before != d.Before || m.After != d.After || !m.Time.Equal(d.Time) { + t.Fatalf("第 %d 条内存/磁盘不一致: 内存 %+v / 磁盘 %+v", i, m, d) + } + } + if l2.snapshot["shared"] != 777777 { + t.Fatalf("重启后 shared 基线应为 777777,得到 %d", l2.snapshot["shared"]) + } + for i := 0; i < accounts; i++ { + uid := fmt.Sprintf("acct-%d", i) + if l2.snapshot[uid] != rounds*10 { + t.Fatalf("重启后 %s 基线应为 %d,得到 %d", uid, rounds*10, l2.snapshot[uid]) + } + } +} + +// ── 8. 临时文件残留与文件权限 ────────────────────────────────────────────── + +// 正常落盘(临时文件 + rename)不得在目录里留下 .tmp 残留。 +func TestFaultNoTempResidueAfterWrite(t *testing.T) { + dir := t.TempDir() + path := filepath.Join(dir, "credit-history.json") + l := New(path, 100) + l.Observe("u1", 1) + l.Observe("u1", 2) + l.Observe("u1", 3) + left, err := filepath.Glob(filepath.Join(dir, "*.tmp")) + if err != nil { + t.Fatal(err) + } + if len(left) != 0 { + t.Fatalf("正常落盘不应残留临时文件,发现 %v", left) + } + if _, err := os.Stat(path); err != nil { + t.Fatalf("应有账本文件: %v", err) + } +} + +// 账本文件权限不得宽于 0600。Windows 的 os.WriteFile 不套用 POSIX 权限位, +// Stat().Mode().Perm() 恒为 0666,故该断言只在 POSIX 生效。 +func TestFaultFileModeNotWiderThan0600(t *testing.T) { + if runtime.GOOS == "windows" { + t.Skip("Windows 不应用 POSIX 权限位(Perm() 恒为 0666);该断言只在 POSIX 生效") + } + path := filepath.Join(t.TempDir(), "credit-history.json") + l := New(path, 100) + l.Observe("u1", 1) + fi, err := os.Stat(path) + if err != nil { + t.Fatal(err) + } + if perm := fi.Mode().Perm(); perm&0o077 != 0 { + t.Fatalf("账本文件权限不应宽于 0600,得到 %04o", perm) + } +} diff --git a/internal/cst/cst.go b/internal/cst/cst.go new file mode 100644 index 0000000000000000000000000000000000000000..efe1b973866580ef432fc795eb39f6403c7083f1 --- /dev/null +++ b/internal/cst/cst.go @@ -0,0 +1,26 @@ +// Package cst 固定 UTC+8(北京时间):上游「自然日」的唯一定义。 +// +// 为什么需要一个包:WorkBuddy 的额度、签到、每日活跃、夜猫子窗口、积分包到期日 +// 全部按北京时间零点切日,而网关可能跑在 Docker / NAS / 海外 VPS 上——那些机器的 +// 本地时区不是 UTC+8。判定跟着宿主时区走,「今天」的边界就整体漂移 8 小时: +// UTC 主机上配的 activity_hours=[10] 实际在 CST 18:00 跑,硬冷却的「次日 04:00」 +// 落在 CST 12:00(签到早已结束),夜猫子 23:00–08:00 的窗口也跟着错位。 +// 这些错都不会报错,只会静默少拿积分——所以日界只能由一个常量决定。 +// +// 为什么是固定偏移而不是时区库:中国标准时间没有夏令时,1970 年后恒为 +08:00, +// 固定偏移既够用又不依赖宿主 tzdata。(agent2api 的 core::beijing 同一口径。) +// +// 什么时候**不**该用:面向操作者的统计口径(用量报表按小时/按天分桶、请求日志 +// 按天切文件)保留宿主本地时区——那看的是「我的昨天」,不是上游的自然日。 +package cst + +import "time" + +// Loc 固定 UTC+8 时区。 +var Loc = time.FixedZone("CST", 8*60*60) + +// Now 当前时刻(带 CST 时区信息;Go 的 time.Time 本身存绝对时刻,转区不改语义)。 +func Now() time.Time { return time.Now().In(Loc) } + +// Day 返回 t 所属的上游自然日(CST),格式 2006-01-02,字典序即时间序。 +func Day(t time.Time) string { return t.In(Loc).Format("2006-01-02") } diff --git a/internal/cst/cst_test.go b/internal/cst/cst_test.go new file mode 100644 index 0000000000000000000000000000000000000000..3260d2fdce5ece595f88c0bd94f60c6d3be0bb62 --- /dev/null +++ b/internal/cst/cst_test.go @@ -0,0 +1,17 @@ +package cst + +import ( + "testing" + "time" +) + +// 日界必须按 CST:UTC 主机上 2026-10-21T17:00Z 已经是北京 10-22 01:00。 +func TestDayIsUTCPlusEight(t *testing.T) { + utc := time.Date(2026, 10, 21, 17, 0, 0, 0, time.UTC) + if got := Day(utc); got != "2026-10-22" { + t.Fatalf("Day(UTC 17:00) = %s,应为 CST 次日 2026-10-22", got) + } + if got := Day(time.Date(2026, 10, 21, 15, 59, 0, 0, time.UTC)); got != "2026-10-21" { + t.Fatalf("Day(UTC 15:59) = %s,应为 2026-10-21", got) + } +} diff --git a/internal/debugcap/debugcap.go b/internal/debugcap/debugcap.go new file mode 100644 index 0000000000000000000000000000000000000000..97bb8c0ec32d392cf5b79080d52d8dbe59b8477c --- /dev/null +++ b/internal/debugcap/debugcap.go @@ -0,0 +1,111 @@ +// Package debugcap 一次性取证落盘:把线上「只能靠猜」的形态抓成 JSONL。 +// +// 定位方式:默认**完全不启用**(不设 WB2API_CAPTURE_DIR 就没有任何 IO、没有额外 +// 分配)。设了目录之后,只有调用方显式命中的形态才会写一行——不是全量采样, +// 否则 26 万请求/天会直接把磁盘写满。 +// +// 为什么要这个:网关只记元数据不存 body,而「模型说一句就停」这种形态无法从 +// 元数据判断是上游行为、客户端 tool_choice、还是网关改写造成的。抓一次真实 +// 请求的正文与出站形态,比在生产上反复试参数快得多,也可复现。 +// +// 硬上限:每个 tag 最多 MaxLines 行、单行最长 maxLineBytes、整个捕获目录超过 +// maxDirBytes 就停止(并记一条日志)。取证是诊断,不允许影响业务。 +package debugcap + +import ( + "encoding/json" + "os" + "path/filepath" + "sync" + "sync/atomic" + "time" +) + +var ( + mu sync.Mutex + lines = map[string]int{} + wrote int64 + disabled atomic.Bool +) + +// MaxLines 每个 tag 最多写多少行(够复现就行)。 +const MaxLines = 40 + +const ( + maxLineBytes = 8 << 10 // 单行 8KB + maxDirBytes = 32 << 20 // 整个目录 32MB +) + +// Enabled 报告取证是否启用(未设 WB2API_CAPTURE_DIR → false)。 +func Enabled() bool { return os.Getenv("WB2API_CAPTURE_DIR") != "" && !disabled.Load() } + +// Capture 把 rec 序列化后追加到 /.jsonl。任何失败都静默(取证不该 +// 影响业务),并在超过上限时永久关闭。 +func Capture(tag string, rec any) { + dir := os.Getenv("WB2API_CAPTURE_DIR") + if dir == "" || disabled.Load() { + return + } + if tag == "" { + tag = "misc" + } + mu.Lock() + defer mu.Unlock() + if lines[tag] >= MaxLines { + return + } + if size := dirBytes(dir); size > maxDirBytes { + disabled.Store(true) + return + } + raw, err := json.Marshal(rec) + if err != nil { + return + } + if len(raw) > maxLineBytes { + raw = raw[:maxLineBytes] + } + if err := os.MkdirAll(dir, 0o755); err != nil { + return + } + f, err := os.OpenFile(filepath.Join(dir, tag+".jsonl"), os.O_CREATE|os.O_WRONLY|os.O_APPEND, 0o644) + if err != nil { + return + } + defer f.Close() + if _, err := f.Write(append(raw, '\n')); err != nil { + return + } + lines[tag]++ + wrote++ +} + +// dirBytes 目录总大小(只看一层,够用了:所有文件都直接写在该目录下)。 +func dirBytes(dir string) int64 { + ents, err := os.ReadDir(dir) + if err != nil { + return 0 + } + var total int64 + for _, e := range ents { + if info, err := e.Info(); err == nil { + total += info.Size() + } + } + return total +} + +// Wrote 返回已写行数(测试与日志用)。 +func Wrote() int64 { return atomic.LoadInt64(&wrote) } + +// Reset 清空计数与熔断(仅测试用)。 +func Reset() { + mu.Lock() + defer mu.Unlock() + lines = map[string]int{} + wrote = 0 + disabled.Store(false) +} + +// Now 统一时间格式(与 reqlog 一致,便于对齐)。 +func Now() string { return time.Now().Format(time.RFC3339Nano) } diff --git a/internal/debugcap/debugcap_test.go b/internal/debugcap/debugcap_test.go new file mode 100644 index 0000000000000000000000000000000000000000..536ab11b7c8b653f50a10a75d52be647f8857c71 --- /dev/null +++ b/internal/debugcap/debugcap_test.go @@ -0,0 +1,104 @@ +package debugcap + +import ( + "encoding/json" + "os" + "path/filepath" + "testing" +) + +// TestCaptureDisabledByDefault 默认(未设环境变量)必须完全不写盘。 +func TestCaptureDisabledByDefault(t *testing.T) { + t.Setenv("WB2API_CAPTURE_DIR", "") + Reset() + if Enabled() { + t.Fatal("未设目录时不应启用") + } + Capture("x", map[string]any{"a": 1}) + if Wrote() != 0 { + t.Fatalf("禁用时不应写盘,写了 %d 行", Wrote()) + } +} + +// TestCaptureWritesJSONL 启用后按 tag 追加,字段可原样解回。 +func TestCaptureWritesJSONL(t *testing.T) { + dir := t.TempDir() + t.Setenv("WB2API_CAPTURE_DIR", dir) + Reset() + if !Enabled() { + t.Fatal("设了目录应启用") + } + Capture("stop-no-toolcall", map[string]any{"text": "现在把这两个审批单补进映射。", "tools": 8}) + Capture("stop-no-toolcall", map[string]any{"text": "第二条"}) + if Wrote() != 2 { + t.Fatalf("应写 2 行,实际 %d", Wrote()) + } + raw, err := os.ReadFile(filepath.Join(dir, "stop-no-toolcall.jsonl")) + if err != nil { + t.Fatalf("读文件: %v", err) + } + lines := 0 + for _, line := range splitLines(raw) { + var rec map[string]any + if err := json.Unmarshal(line, &rec); err != nil { + t.Fatalf("第 %d 行不是合法 JSON: %v", lines+1, err) + } + lines++ + } + if lines != 2 { + t.Fatalf("应 2 行合法 JSON,实际 %d", lines) + } +} + +// TestCaptureStopsAtMaxLines 超过上限就不再写(防 26 万请求/天写满磁盘)。 +func TestCaptureStopsAtMaxLines(t *testing.T) { + dir := t.TempDir() + t.Setenv("WB2API_CAPTURE_DIR", dir) + Reset() + for i := 0; i < MaxLines+10; i++ { + Capture("cap", map[string]any{"i": i}) + } + if got := Wrote(); got != MaxLines { + t.Fatalf("应在上限 %d 处停,实际 %d", MaxLines, got) + } + raw, _ := os.ReadFile(filepath.Join(dir, "cap.jsonl")) + if n := len(splitLines(raw)); n != MaxLines { + t.Fatalf("文件行数 %d want %d", n, MaxLines) + } +} + +// TestCaptureTruncatesHugeRecord 单行超长要截断,不能把 200KB 的正文整段写进去。 +func TestCaptureTruncatesHugeRecord(t *testing.T) { + dir := t.TempDir() + t.Setenv("WB2API_CAPTURE_DIR", dir) + Reset() + big := make([]byte, maxLineBytes*2) + for i := range big { + big[i] = 'x' + } + Capture("big", map[string]any{"text": string(big)}) + info, err := os.Stat(filepath.Join(dir, "big.jsonl")) + if err != nil { + t.Fatalf("stat: %v", err) + } + if info.Size() > maxLineBytes+10 { + t.Fatalf("单行 %d 字节,超过上限 %d", info.Size(), maxLineBytes) + } +} + +func splitLines(b []byte) [][]byte { + var out [][]byte + start := 0 + for i := 0; i < len(b); i++ { + if b[i] == '\n' { + if i > start { + out = append(out, b[start:i]) + } + start = i + 1 + } + } + if start < len(b) { + out = append(out, b[start:]) + } + return out +} diff --git a/internal/extstore/extstore.go b/internal/extstore/extstore.go new file mode 100644 index 0000000000000000000000000000000000000000..7cc78e969cd8aaecba59ab063bfcd38beb63c411 --- /dev/null +++ b/internal/extstore/extstore.go @@ -0,0 +1,790 @@ +// Package extstore 保存面板扩展配置:免登录免费模型、自定义模型映射、访问密钥。 +// +// 为什么单独一个文件而不是塞进 config.json:这三块都是「运行期增删」的集合, +// 面板每次改动都重写整份配置既容易与其他字段的保存互相踩,也不适合放在 +// 需要人工编辑的 config.json 里。文件落在 data 目录(HF 上就是存储桶卷), +// 与 state/usage 同一个持久化口径。 +package extstore + +import ( + "crypto/rand" + "encoding/base64" + "encoding/json" + "errors" + "fmt" + "os" + "path/filepath" + "strings" + "sync" + "time" +) + +// 免费模型渠道名(同时也是 /v1/models 里 free:/ 的 provider 段)。 +const ( + ProviderOpenCode = "opencode" + ProviderKilo = "kilo" +) + +// 渠道协议类型:决定请求怎么整形、模型清单怎么解析。 +const ( + // TypeOpenCode OpenCode Zen:官方 CLI 指纹 + 工具整形。 + TypeOpenCode = "opencode" + // TypeKilo Kilo 公共网关:OpenAI 兼容 + isFree 过滤 + 归因头。 + TypeKilo = "kilo" + // TypeOpenAI 任意 OpenAI 兼容端点:只做透明转发。 + TypeOpenAI = "openai" +) + +// DefaultOpenCodeBase / DefaultKiloBase 上游默认地址(与 dsh-our-free-model 一致)。 +const ( + DefaultOpenCodeBase = "https://opencode.ai" + DefaultKiloBase = "https://ai-gateway.kilo.ai/api/v1" +) + +// FreeModel 一个已发现的免费模型。 +type FreeModel struct { + ID string `json:"id"` + Name string `json:"name,omitempty"` + Enabled bool `json:"enabled"` + // Note 上游/用户备注(例如「地区受限」「已下线」),仅展示。 + Note string `json:"note,omitempty"` +} + +// FreeProvider 一个免登录渠道。除了内置的 OpenCode / Kilo,也可以加任意 +// OpenAI 兼容端点(TypeOpenAI),面板里填 base URL 与模型清单路径即可。 +type FreeProvider struct { + // Name 渠道 slug,同时是模型前缀 free:/;只允许 [a-z0-9_-]。 + Name string `json:"name"` + // Label 面板显示名(默认取 Name)。 + Label string `json:"label,omitempty"` + // Type opencode / kilo / openai。 + Type string `json:"type"` + // Enabled 渠道总开关。 + Enabled bool `json:"enabled"` + // BaseURL 上游根地址,例如 https://api.example.com/v1。 + BaseURL string `json:"base_url"` + // ModelsPath 模型清单路径,默认 /models(TypeOpenCode 默认 /inference/v1/models)。 + ModelsPath string `json:"models_path,omitempty"` + // ChatPath 对话路径,默认 /chat/completions(TypeOpenCode 默认 + // /inference/openai/v1/chat/completions)。 + ChatPath string `json:"chat_path,omitempty"` + // FreeFilter 免费模型筛选:all(全部)/ free-suffix(id 含 free 段)/ + // is-free(清单行 isFree=true,Kilo 用)。 + FreeFilter string `json:"free_filter,omitempty"` + // AuthHeader / AuthValue 可选:需要固定 Key 的公共端点(多数免登录渠道留空)。 + AuthHeader string `json:"auth_header,omitempty"` + AuthValue string `json:"auth_value,omitempty"` + // Headers 额外请求头。 + Headers map[string]string `json:"headers,omitempty"` + // Models 已发现的模型清单(含启停状态)。 + Models []FreeModel `json:"models"` + // UpdatedAt 最近一次成功刷新时间。 + UpdatedAt time.Time `json:"updated_at,omitempty"` +} + +// FreeSettings 免登录免费模型层设置。 +type FreeSettings struct { + Enabled bool `json:"enabled"` + // Providers 渠道列表(顺序即面板展示顺序)。 + Providers []FreeProvider `json:"providers"` + // UpdatedAt 最近一次成功刷新模型清单的时间(展示用)。 + UpdatedAt time.Time `json:"updated_at,omitempty"` + + // 兼容旧版 extensions.json 的固定字段(读取时迁移到 Providers,写回时清空)。 + OpenCode *FreeProvider `json:"opencode,omitempty"` + Kilo *FreeProvider `json:"kilo,omitempty"` +} + +// CustomModel 自定义模型:客户端点名该模型时改写为 Target 并注入 Prompt。 +// 与 ds2api 面板里的「自定义模型列表」同一语义——不是新模型,只是一层提示词外壳。 +type CustomModel struct { + Name string `json:"name"` + Target string `json:"target"` + Prompt string `json:"prompt"` + Mode string `json:"mode,omitempty"` // append(默认)/ prepend / replace + Description string `json:"description,omitempty"` + // Temperature / MaxTokens 可选覆盖;nil = 不修改客户端请求。 + Temperature *float64 `json:"temperature,omitempty"` + MaxTokens *int `json:"max_tokens,omitempty"` + Enabled bool `json:"enabled"` +} + +// AccessKey 面板签发的访问密钥(用于 /v1/* 与 /status,不用于面板本身)。 +type AccessKey struct { + ID string `json:"id"` + Name string `json:"name"` + Key string `json:"key"` + Enabled bool `json:"enabled"` + CreatedAt time.Time `json:"created_at"` + LastUsedAt time.Time `json:"last_used_at,omitempty"` + // AllowModels 非空 = 白名单:只有匹配的模型可用。 + AllowModels []string `json:"allow_models,omitempty"` + // DenyModels 黑名单:匹配的模型不可用(白名单命中后仍受黑名单约束)。 + DenyModels []string `json:"deny_models,omitempty"` + // Note 备注/用途说明。 + Note string `json:"note,omitempty"` +} + +// Data 整个扩展配置文件。 +type Data struct { + Free FreeSettings `json:"free"` + CustomModels []CustomModel `json:"custom_models"` + AccessKeys []AccessKey `json:"access_keys"` +} + +// Store 并发安全的扩展配置存储;path 为空时只在内存里(测试用)。 +type Store struct { + mu sync.RWMutex + path string + data Data +} + +// Open 读取(不存在则返回默认值)。默认开启 OpenCode 免登录渠道,Kilo 关闭, +// 模型清单留空——第一次启动后由后台刷新填充。 +func Open(path string) *Store { + s := &Store{path: path, data: Defaults()} + if path == "" { + return s + } + raw, err := os.ReadFile(path) + if err == nil { + var d Data + if json.Unmarshal(raw, &d) == nil { + // 免费层总开关缺省开启;只有文件里显式写了 false 才关闭。 + var probe struct { + Free struct { + Enabled *bool `json:"enabled"` + } `json:"free"` + } + if json.Unmarshal(raw, &probe) != nil || probe.Free.Enabled == nil { + d.Free.Enabled = true + } + s.data = normalize(d) + } + } + return s +} + +func defaultProvider(name, typ, label, base string, enabled bool) FreeProvider { + return FreeProvider{ + Name: name, + Label: label, + Type: typ, + Enabled: enabled, + BaseURL: base, + } +} + +// Defaults 默认扩展配置。 +func Defaults() Data { + return Data{Free: FreeSettings{ + Enabled: true, + Providers: []FreeProvider{ + defaultProvider(ProviderOpenCode, TypeOpenCode, "OpenCode Zen", DefaultOpenCodeBase, true), + defaultProvider(ProviderKilo, TypeKilo, "Kilo", DefaultKiloBase, false), + }, + }} +} + +// NormalizeProviderSlug 校验/归一化渠道名:只保留 [a-z0-9_-],其它字符换成 '-'。 +func NormalizeProviderSlug(name string) string { + name = strings.ToLower(strings.TrimSpace(name)) + var b strings.Builder + for _, r := range name { + switch { + case r >= 'a' && r <= 'z', r >= '0' && r <= '9', r == '-', r == '_': + b.WriteRune(r) + case r == ' ', r == '.': + b.WriteByte('-') + } + } + return strings.Trim(b.String(), "-") +} + +func normalizeProvider(p FreeProvider) FreeProvider { + p.Name = NormalizeProviderSlug(p.Name) + if p.Name == "" { + p.Name = "provider" + } + if p.Type == "" { + p.Type = TypeOpenAI + } + switch p.Type { + case TypeOpenCode: + if p.Label == "" { + p.Label = "OpenCode Zen" + } + if p.BaseURL == "" { + p.BaseURL = DefaultOpenCodeBase + } + if p.ModelsPath == "" { + p.ModelsPath = "/inference/v1/models" + } + if p.ChatPath == "" { + p.ChatPath = "/inference/openai/v1/chat/completions" + } + if p.FreeFilter == "" { + p.FreeFilter = "free-suffix" + } + case TypeKilo: + if p.Label == "" { + p.Label = "Kilo" + } + if p.BaseURL == "" { + p.BaseURL = DefaultKiloBase + } + if p.ModelsPath == "" { + p.ModelsPath = "/models" + } + if p.ChatPath == "" { + p.ChatPath = "/chat/completions" + } + if p.FreeFilter == "" { + p.FreeFilter = "is-free" + } + default: + p.Type = TypeOpenAI + if p.Label == "" { + p.Label = p.Name + } + if p.ModelsPath == "" { + p.ModelsPath = "/models" + } + if p.ChatPath == "" { + p.ChatPath = "/chat/completions" + } + if p.FreeFilter == "" { + p.FreeFilter = "all" + } + } + p.BaseURL = strings.TrimRight(strings.TrimSpace(p.BaseURL), "/") + p.ModelsPath = "/" + strings.TrimLeft(strings.TrimSpace(p.ModelsPath), "/") + p.ChatPath = "/" + strings.TrimLeft(strings.TrimSpace(p.ChatPath), "/") + if p.Models == nil { + p.Models = []FreeModel{} + } + if p.Headers == nil { + p.Headers = map[string]string{} + } + return p +} + +func normalize(d Data) Data { + // 旧版固定字段迁移:只在 Providers 为空时采用,避免覆盖用户新加的渠道。 + if len(d.Free.Providers) == 0 { + if d.Free.OpenCode != nil { + legacy := *d.Free.OpenCode + legacy.Name = ProviderOpenCode + legacy.Type = TypeOpenCode + legacy.Label = "OpenCode Zen" + d.Free.Providers = append(d.Free.Providers, legacy) + } + if d.Free.Kilo != nil { + legacy := *d.Free.Kilo + legacy.Name = ProviderKilo + legacy.Type = TypeKilo + legacy.Label = "Kilo" + d.Free.Providers = append(d.Free.Providers, legacy) + } + } + d.Free.OpenCode = nil + d.Free.Kilo = nil + if len(d.Free.Providers) == 0 { + d.Free.Providers = Defaults().Free.Providers + } + seen := map[string]bool{} + providers := make([]FreeProvider, 0, len(d.Free.Providers)) + for _, p := range d.Free.Providers { + p = normalizeProvider(p) + if seen[p.Name] { + continue + } + seen[p.Name] = true + providers = append(providers, p) + } + d.Free.Providers = providers + if d.CustomModels == nil { + d.CustomModels = []CustomModel{} + } + if d.AccessKeys == nil { + d.AccessKeys = []AccessKey{} + } + for i := range d.CustomModels { + cm := &d.CustomModels[i] + cm.Name = strings.TrimSpace(cm.Name) + cm.Target = strings.TrimSpace(cm.Target) + switch cm.Mode { + case "prepend", "replace": + default: + cm.Mode = "append" + } + } + return d +} + +// Path 返回配置文件路径。 +func (s *Store) Path() string { return s.path } + +// Snapshot 返回深拷贝快照(调用方随便改)。 +func (s *Store) Snapshot() Data { + s.mu.RLock() + defer s.mu.RUnlock() + return clone(s.data) +} + +func clone(d Data) Data { + out := d + out.Free.Providers = make([]FreeProvider, len(d.Free.Providers)) + for i, p := range d.Free.Providers { + cp := p + cp.Models = append([]FreeModel(nil), p.Models...) + if p.Headers != nil { + cp.Headers = make(map[string]string, len(p.Headers)) + for k, v := range p.Headers { + cp.Headers[k] = v + } + } + out.Free.Providers[i] = cp + } + out.CustomModels = append([]CustomModel(nil), d.CustomModels...) + out.AccessKeys = append([]AccessKey(nil), d.AccessKeys...) + for i := range out.AccessKeys { + out.AccessKeys[i].AllowModels = append([]string(nil), d.AccessKeys[i].AllowModels...) + out.AccessKeys[i].DenyModels = append([]string(nil), d.AccessKeys[i].DenyModels...) + } + return out +} + +// Update 在锁内修改并原子落盘;fn 返回错误时不改内存、不写盘。 +func (s *Store) Update(fn func(*Data) error) error { + s.mu.Lock() + defer s.mu.Unlock() + d := clone(s.data) + if err := fn(&d); err != nil { + return err + } + d = normalize(d) + if err := s.saveLocked(d); err != nil { + return err + } + s.data = d + return nil +} + +func (s *Store) saveLocked(d Data) error { + if s.path == "" { + return nil + } + raw, err := json.MarshalIndent(d, "", " ") + if err != nil { + return err + } + if dir := filepath.Dir(s.path); dir != "" && dir != "." { + if err := os.MkdirAll(dir, 0o700); err != nil { + return err + } + } + tmp := s.path + ".tmp" + if err := os.WriteFile(tmp, append(raw, '\n'), 0o600); err != nil { + return err + } + return os.Rename(tmp, s.path) +} + +// HasFreeModels 是否有可用的免费模型(渠道开关 + 模型开关)。 +func (d Data) HasFreeModels() bool { + if !d.Free.Enabled { + return false + } + for _, p := range d.Free.Providers { + if !p.Enabled { + continue + } + for _, m := range p.Models { + if m.Enabled { + return true + } + } + } + return false +} + +// Provider 返回指定渠道设置。 +func (d Data) Provider(name string) (FreeProvider, bool) { + name = NormalizeProviderSlug(name) + for _, p := range d.Free.Providers { + if p.Name == name { + return p, true + } + } + return FreeProvider{}, false +} + +// ProviderNames 返回所有渠道名(保持面板顺序)。 +func (d Data) ProviderNames() []string { + out := make([]string, 0, len(d.Free.Providers)) + for _, p := range d.Free.Providers { + out = append(out, p.Name) + } + return out +} + +// FreeModelEnabled 报告 provider 下的 id 是否启用。 +func (d Data) FreeModelEnabled(provider, id string) bool { + if !d.Free.Enabled { + return false + } + p, ok := d.Provider(provider) + if !ok || !p.Enabled { + return false + } + for _, m := range p.Models { + if m.ID == id { + return m.Enabled + } + } + return false +} + +// FindFreeModel 按 provider/id 查找。 +func (d Data) FindFreeModel(provider, id string) (FreeModel, bool) { + p, ok := d.Provider(provider) + if !ok { + return FreeModel{}, false + } + for _, m := range p.Models { + if m.ID == id { + return m, true + } + } + return FreeModel{}, false +} + +// CustomFor 按模型名(大小写不敏感)查找启用的自定义模型。 +func (d Data) CustomFor(name string) (CustomModel, bool) { + name = strings.TrimSpace(name) + if name == "" { + return CustomModel{}, false + } + for _, m := range d.CustomModels { + if m.Enabled && strings.EqualFold(m.Name, name) { + return m, true + } + } + return CustomModel{}, false +} + +// AccessTokens 返回所有启用的访问密钥。 +func (d Data) AccessTokens() []string { + out := make([]string, 0, len(d.AccessKeys)) + for _, k := range d.AccessKeys { + if k.Enabled && strings.TrimSpace(k.Key) != "" { + out = append(out, k.Key) + } + } + return out +} + +// AccessKeyFor 按密钥原文查找启用的访问密钥。 +func (d Data) AccessKeyFor(token string) (AccessKey, bool) { + if token == "" { + return AccessKey{}, false + } + for _, k := range d.AccessKeys { + if k.Enabled && k.Key == token { + return k, true + } + } + return AccessKey{}, false +} + +func providerPtr(d *Data, name string) *FreeProvider { + name = NormalizeProviderSlug(name) + for i := range d.Free.Providers { + if d.Free.Providers[i].Name == name { + return &d.Free.Providers[i] + } + } + return nil +} + +// UpsertFreeProvider 新增或按 Name 覆盖渠道(同时可更新开关/地址/协议等)。 +func (s *Store) UpsertFreeProvider(p FreeProvider) error { + if NormalizeProviderSlug(p.Name) == "" { + return errors.New("provider name is required") + } + return s.Update(func(d *Data) error { + p = normalizeProvider(p) + if cur := providerPtr(d, p.Name); cur != nil { + // 保留已有模型清单与刷新时间(除非调用方显式带了模型)。 + if len(p.Models) == 0 { + p.Models = cur.Models + } + if p.UpdatedAt.IsZero() { + p.UpdatedAt = cur.UpdatedAt + } + *cur = p + return nil + } + d.Free.Providers = append(d.Free.Providers, p) + return nil + }) +} + +// DeleteFreeProvider 删除渠道。 +func (s *Store) DeleteFreeProvider(name string) error { + return s.Update(func(d *Data) error { + name = NormalizeProviderSlug(name) + out := d.Free.Providers[:0] + for _, p := range d.Free.Providers { + if p.Name != name { + out = append(out, p) + } + } + if len(out) == len(d.Free.Providers) { + return fmt.Errorf("unknown provider: %s", name) + } + d.Free.Providers = out + return nil + }) +} + +// SetFreeEnabled 总开关。 +func (s *Store) SetFreeEnabled(enabled bool) error { + return s.Update(func(d *Data) error { d.Free.Enabled = enabled; return nil }) +} + +// SetModelEnabled 单模型开关(不存在时报错)。 +func (s *Store) SetModelEnabled(provider, id string, enabled bool) error { + return s.Update(func(d *Data) error { + p := providerPtr(d, provider) + if p == nil { + return fmt.Errorf("unknown provider: %s", provider) + } + for i := range p.Models { + if p.Models[i].ID == id { + p.Models[i].Enabled = enabled + return nil + } + } + return fmt.Errorf("unknown free model: %s/%s", provider, id) + }) +} + +// MergeModels 把一次刷新结果并进当前清单:保留已有模型的启用状态,新模型默认启用, +// 上游已下架的模型保留(标为不可用由调用方决定,这里不删除用户的选择)。 +func (s *Store) MergeModels(provider string, models []FreeModel) error { + return s.Update(func(d *Data) error { + p := providerPtr(d, provider) + if p == nil { + return fmt.Errorf("unknown provider: %s", provider) + } + prev := make(map[string]FreeModel, len(p.Models)) + for _, m := range p.Models { + prev[m.ID] = m + } + next := make([]FreeModel, 0, len(models)+len(p.Models)) + seen := make(map[string]bool, len(models)) + for _, m := range models { + if m.ID == "" || seen[m.ID] { + continue + } + seen[m.ID] = true + if old, ok := prev[m.ID]; ok { + m.Enabled = old.Enabled + if m.Name == "" { + m.Name = old.Name + } + if m.Note == "" { + m.Note = old.Note + } + } else { + // 新发现的模型默认启用;上游把付费 id 也列出来时由调用方过滤。 + m.Enabled = true + } + next = append(next, m) + } + for _, old := range p.Models { + if !seen[old.ID] { + next = append(next, old) + } + } + p.Models = next + p.UpdatedAt = time.Now() + d.Free.UpdatedAt = time.Now() + return nil + }) +} + +// UpsertCustom 新增或按 name 覆盖自定义模型。 +func (s *Store) UpsertCustom(cm CustomModel) error { + cm.Name = strings.TrimSpace(cm.Name) + cm.Target = strings.TrimSpace(cm.Target) + if cm.Name == "" { + return errors.New("name is required") + } + if strings.ContainsAny(cm.Name, "/: \t\r\n") { + return errors.New("name must not contain '/', ':' or whitespace") + } + if cm.Target == "" { + return errors.New("target model is required") + } + switch cm.Mode { + case "prepend", "replace": + default: + cm.Mode = "append" + } + if cm.Temperature != nil && (*cm.Temperature < 0 || *cm.Temperature > 2) { + return errors.New("temperature must be between 0 and 2") + } + if cm.MaxTokens != nil && *cm.MaxTokens <= 0 { + return errors.New("max_tokens must be positive") + } + return s.Update(func(d *Data) error { + for i := range d.CustomModels { + if strings.EqualFold(d.CustomModels[i].Name, cm.Name) { + d.CustomModels[i] = cm + return nil + } + } + d.CustomModels = append(d.CustomModels, cm) + return nil + }) +} + +// DeleteCustom 删除自定义模型。 +func (s *Store) DeleteCustom(name string) error { + return s.Update(func(d *Data) error { + out := d.CustomModels[:0] + for _, m := range d.CustomModels { + if !strings.EqualFold(m.Name, name) { + out = append(out, m) + } + } + d.CustomModels = out + return nil + }) +} + +// AddAccessKey 生成并保存一个访问密钥,返回明文(只在此刻完整返回一次)。 +func (s *Store) AddAccessKey(name, note string, allow, deny []string) (AccessKey, error) { + buf := make([]byte, 24) + if _, err := rand.Read(buf); err != nil { + return AccessKey{}, err + } + key := AccessKey{ + ID: "ak_" + randomHex(6), + Name: strings.TrimSpace(name), + Key: "sk-wb2api-" + base64.RawURLEncoding.EncodeToString(buf), + Enabled: true, + CreatedAt: time.Now(), + Note: strings.TrimSpace(note), + AllowModels: cleanPatterns(allow), + DenyModels: cleanPatterns(deny), + } + if key.Name == "" { + key.Name = "key-" + key.ID[3:] + } + err := s.Update(func(d *Data) error { + d.AccessKeys = append(d.AccessKeys, key) + return nil + }) + return key, err +} + +// UpdateAccessKey 修改密钥的备注、启停与模型白/黑名单(Key 原文不可改)。 +func (s *Store) UpdateAccessKey(id, name, note string, enabled bool, allow, deny []string) error { + return s.Update(func(d *Data) error { + for i := range d.AccessKeys { + if d.AccessKeys[i].ID != id { + continue + } + if strings.TrimSpace(name) != "" { + d.AccessKeys[i].Name = strings.TrimSpace(name) + } + d.AccessKeys[i].Note = strings.TrimSpace(note) + d.AccessKeys[i].Enabled = enabled + d.AccessKeys[i].AllowModels = cleanPatterns(allow) + d.AccessKeys[i].DenyModels = cleanPatterns(deny) + return nil + } + return fmt.Errorf("unknown access key: %s", id) + }) +} + +func cleanPatterns(patterns []string) []string { + out := make([]string, 0, len(patterns)) + for _, p := range patterns { + p = strings.TrimSpace(p) + if p != "" { + out = append(out, p) + } + } + if len(out) == 0 { + return nil + } + return out +} + +// DeleteAccessKey 删除访问密钥。 +func (s *Store) DeleteAccessKey(id string) error { + return s.Update(func(d *Data) error { + out := d.AccessKeys[:0] + for _, k := range d.AccessKeys { + if k.ID != id { + out = append(out, k) + } + } + d.AccessKeys = out + return nil + }) +} + +// SetAccessKeyEnabled 启停访问密钥。 +func (s *Store) SetAccessKeyEnabled(id string, enabled bool) error { + return s.Update(func(d *Data) error { + for i := range d.AccessKeys { + if d.AccessKeys[i].ID == id { + d.AccessKeys[i].Enabled = enabled + return nil + } + } + return fmt.Errorf("unknown access key: %s", id) + }) +} + +// TouchAccessKey 记录最近使用时间(只改内存,不写盘;下一次其它改动会一起落盘)。 +func (s *Store) TouchAccessKey(token string) { + if s == nil || token == "" { + return + } + s.mu.Lock() + defer s.mu.Unlock() + for i := range s.data.AccessKeys { + if s.data.AccessKeys[i].Key == token { + s.data.AccessKeys[i].LastUsedAt = time.Now() + return + } + } +} + +// HasAccessToken 报告 token 是否是任一启用的访问密钥(常量时间比较在调用方)。 +func (d Data) HasAccessToken(token string) bool { + if token == "" { + return false + } + for _, k := range d.AccessKeys { + if k.Enabled && k.Key == token { + return true + } + } + return false +} + +func randomHex(n int) string { + buf := make([]byte, n) + if _, err := rand.Read(buf); err != nil { + return fmt.Sprintf("%d", time.Now().UnixNano()) + } + return fmt.Sprintf("%x", buf) +} diff --git a/internal/extstore/extstore_test.go b/internal/extstore/extstore_test.go new file mode 100644 index 0000000000000000000000000000000000000000..a1558be894a0be83820cd9f309d5e49d095b37a7 --- /dev/null +++ b/internal/extstore/extstore_test.go @@ -0,0 +1,113 @@ +package extstore + +import ( + "encoding/json" + "os" + "path/filepath" + "testing" +) + +func TestLegacyMigration(t *testing.T) { + dir := t.TempDir() + path := filepath.Join(dir, "extensions.json") + legacy := `{ + "free": { + "enabled": true, + "opencode": {"enabled": true, "base_url": "https://opencode.ai", "models": [{"id": "big-pickle", "enabled": false}]}, + "kilo": {"enabled": true, "base_url": "https://ai-gateway.kilo.ai/api/v1", "models": [{"id": "kilo-auto/free", "enabled": true}]} + }, + "custom_models": [{"name": "x", "target": "cn:y", "prompt": "p", "enabled": true}], + "access_keys": [] + }` + if err := os.WriteFile(path, []byte(legacy), 0o600); err != nil { + t.Fatal(err) + } + s := Open(path) + d := s.Snapshot() + if len(d.Free.Providers) != 2 { + t.Fatalf("providers = %#v", d.Free.Providers) + } + oc, ok := d.Provider("opencode") + if !ok || !oc.Enabled || len(oc.Models) != 1 || oc.Models[0].Enabled { + t.Fatalf("opencode migration wrong: %#v", oc) + } + kilo, ok := d.Provider("kilo") + if !ok || !kilo.Enabled || len(kilo.Models) != 1 { + t.Fatalf("kilo migration wrong: %#v", kilo) + } + if d.CustomModels[0].Mode != "append" { + t.Fatalf("mode default = %q", d.CustomModels[0].Mode) + } + // 写回后不应再出现 legacy 字段。 + if err := s.SetFreeEnabled(true); err != nil { + t.Fatal(err) + } + raw, _ := os.ReadFile(path) + var probe map[string]any + _ = json.Unmarshal(raw, &probe) + free := probe["free"].(map[string]any) + if _, has := free["opencode"]; has { + t.Fatal("legacy opencode field must be gone after save") + } + if _, has := free["providers"]; !has { + t.Fatal("providers must be persisted") + } +} + +func TestUpsertProviderAndMergeModels(t *testing.T) { + s := Open("") + if err := s.UpsertFreeProvider(FreeProvider{Name: "My API!", Type: TypeOpenAI, BaseURL: "https://x/v1"}); err != nil { + t.Fatal(err) + } + d := s.Snapshot() + p, ok := d.Provider("my-api") + if !ok || p.BaseURL != "https://x/v1" || p.ModelsPath != "/models" || p.ChatPath != "/chat/completions" { + t.Fatalf("provider normalize wrong: %#v", p) + } + if err := s.MergeModels("my-api", []FreeModel{{ID: "a"}, {ID: "b"}}); err != nil { + t.Fatal(err) + } + if err := s.SetModelEnabled("my-api", "a", false); err != nil { + t.Fatal(err) + } + // 第二次刷新保留 a 的停用状态。 + if err := s.MergeModels("my-api", []FreeModel{{ID: "a"}, {ID: "c"}}); err != nil { + t.Fatal(err) + } + d = s.Snapshot() + p, _ = d.Provider("my-api") + if len(p.Models) != 3 { + t.Fatalf("models = %#v", p.Models) + } + for _, m := range p.Models { + if m.ID == "a" && m.Enabled { + t.Fatal("existing disabled model must stay disabled") + } + if m.ID == "c" && !m.Enabled { + t.Fatal("new model must default enabled") + } + } +} + +func TestAccessKeyPermissions(t *testing.T) { + s := Open("") + key, err := s.AddAccessKey("laptop", "note", []string{"free:*"}, []string{"free:bad/*"}) + if err != nil { + t.Fatal(err) + } + d := s.Snapshot() + got, ok := d.AccessKeyFor(key.Key) + if !ok || len(got.AllowModels) != 1 || len(got.DenyModels) != 1 { + t.Fatalf("key = %#v", got) + } + if err := s.UpdateAccessKey(key.ID, "phone", "n2", false, nil, []string{"cn:*"}); err != nil { + t.Fatal(err) + } + d = s.Snapshot() + if _, ok := d.AccessKeyFor(key.Key); ok { + t.Fatal("disabled key must not authenticate") + } + if d.AccessKeys[0].Name != "phone" || d.AccessKeys[0].Enabled { + t.Fatalf("update failed: %#v", d.AccessKeys[0]) + } +} diff --git a/internal/freemodel/assets/opencode_prompt_v2.txt b/internal/freemodel/assets/opencode_prompt_v2.txt new file mode 100644 index 0000000000000000000000000000000000000000..daff28574b70f656b2aaed8cb29185eed9cfd75b --- /dev/null +++ b/internal/freemodel/assets/opencode_prompt_v2.txt @@ -0,0 +1,96 @@ +You are opencode, an interactive CLI tool that helps users with software engineering tasks. Use the instructions below and the tools available to you to assist the user. + +IMPORTANT: You must NEVER generate or guess URLs for the user unless you are confident that the URLs are for helping the user with programming. You may use URLs provided by the user in their messages or local files. + +If the user asks for help or wants to give feedback inform them of the following: +- /help: Get help with using opencode +- To give feedback, users should report the issue at https://github.com/anomalyco/opencode/issues + +When the user directly asks about opencode (eg 'can opencode do...', 'does opencode have...') or asks in second person (eg 'are you able...', 'can you do...'), first use the webfetch tool to gather information to answer the question from opencode docs at https://opencode.ai + +# Tone and style +You should be concise, direct, and to the point. When you run a non-trivial bash command, you should explain what the command does and why you are running it, to make sure the user understands what you are doing (this is especially important when you are running a command that will make changes to the user's system). +Remember that your output will be displayed on a command line interface. Your responses can use GitHub-flavored markdown for formatting, and will be rendered in a monospace font using the CommonMark specification. +Output text to communicate with the user; all text you output outside of tool use is displayed to the user. Only use tools to complete tasks. Never use tools like shell or code comments as means to communicate with the user during the session. +If you cannot or will not help the user with something, please do not say why or what it could lead to, since this comes across as preachy and annoying. Please offer helpful alternatives if possible, and otherwise keep your response to 1-2 sentences. +Only use emojis if the user explicitly requests it. Avoid using emojis in all communication unless asked. +IMPORTANT: You should minimize output tokens as much as possible while maintaining helpfulness, quality, and accuracy. Only address the specific query or task at hand, avoiding tangential information unless absolutely critical for completing the request. If you can answer in 1-3 sentences or a short paragraph, please do. +IMPORTANT: You should NOT answer with unnecessary preamble or postamble (such as explaining your code or summarizing your action), unless the user asks you to. +IMPORTANT: Keep your responses short, since they will be displayed on a command line interface. You MUST answer concisely with fewer than 4 lines (not including tool use or code generation), unless user asks for detail. Answer the user's question directly, without elaboration, explanation, or details. One word answers are best. Avoid introductions, conclusions, and explanations. You MUST avoid text before/after your response, such as "The answer is .", "Here is the content of the file..." or "Based on the information provided, the answer is..." or "Here is what I will do next...". Here are some examples to demonstrate appropriate verbosity: + +user: what is 2+2? +assistant: 4 + + + +user: is 11 a prime number? +assistant: Yes + + + +user: what command should I run to list files in the current directory? +assistant: ls + + + +user: what command should I run to watch files in the current directory? +assistant: [use the ls tool to list the files in the current directory, then read docs/commands in the relevant file to find out how to watch files] +npm run dev + + + +user: what files are in the directory src/? +assistant: [runs ls and sees foo.c, bar.c, baz.c] +user: which file contains the implementation of foo? +assistant: src/foo.c + + + +user: write tests for new feature +assistant: [uses grep and glob search tools to find where similar tests are defined, uses concurrent read file tool use blocks in one tool call to read relevant files at the same time, uses edit file tool to write new tests] + + +# Proactiveness +You are allowed to be proactive, but only when the user asks you to do something. You should strive to strike a balance between: +1. Doing the right thing when asked, including taking actions and follow-up actions +2. Not surprising the user with actions you take without asking +For example, if the user asks you how to approach something, you should do your best to answer their question first, and not immediately jump into taking actions. +3. Do not add additional code explanation summary unless requested by the user. After working on a file, just stop, rather than providing an explanation of what you did. + +# Following conventions +When making changes to files, first understand the file's code conventions. Mimic code style, use existing libraries and utilities, and follow existing patterns. +- NEVER assume that a given library is available, even if it is well known. Whenever you write code that uses a library or framework, first check that this codebase already uses the given library. For example, you might look at neighboring files, or check the package.json (or cargo.toml, and so on depending on the language). +- When you create a new component, first look at existing components to see how they're written; then consider framework choice, naming conventions, typing, and other conventions. +- When you edit a piece of code, first look at the code's surrounding context (especially its imports) to understand the code's choice of frameworks and libraries. Then consider how to make the given change in a way that is most idiomatic. +- Always follow security best practices. Never introduce code that exposes or logs secrets and keys. Never commit secrets or keys to the repository. + +# Code style +- IMPORTANT: DO NOT ADD ***ANY*** COMMENTS unless asked + +# Doing tasks +The user will primarily request you perform software engineering tasks. This includes solving bugs, adding new functionality, refactoring code, explaining code, and more. For these tasks the following steps are recommended: +- Use the available search tools to understand the codebase and the user's query. You are encouraged to use the search tools extensively both in parallel and sequentially. +- Implement the solution using all tools available to you +- Verify the solution if possible with tests. NEVER assume specific test framework or test script. Check the README or search codebase to determine the testing approach. +- VERY IMPORTANT: When you have completed a task, you MUST run the lint and typecheck commands (e.g. npm run lint, npm run typecheck, ruff, etc.) with shell if they were provided to you to ensure your code is correct. If you are unable to find the correct command, ask the user for the command to run and if they supply it, proactively suggest writing it to AGENTS.md so that you will know to run it next time. +NEVER commit changes unless the user explicitly asks you to. It is VERY IMPORTANT to only commit when explicitly asked, otherwise the user will feel that you are being too proactive. + +- Tool results and user messages may include tags. tags contain useful information and reminders. They are NOT part of the user's provided input or the tool result. + +# Tool usage policy +- When doing file search, prefer to use the subagent tool in order to reduce context usage. +- You have the capability to call multiple tools in a single response. When multiple independent pieces of information are requested, batch your tool calls together for optimal performance. When making multiple bash tool calls, you MUST send a single message with multiple tools calls to run the calls in parallel. For example, if you need to run "git status" and "git diff", send a single message with two tool calls to run the calls in parallel. + +You MUST answer concisely with fewer than 4 lines of text (not including tool use or code generation), unless user asks for detail. + +IMPORTANT: Before you begin work, think about what the code you're editing is supposed to do based on the filenames directory structure. + +# Code References + +When referencing specific functions or pieces of code include the pattern `file_path:line_number` to allow the user to easily navigate to the source code location. + + +user: Where are errors from the client handled? +assistant: Clients are marked as failed in the `connectToServer` function in src/services/process.ts:712. + + diff --git a/internal/freemodel/assets/opencode_tools.json b/internal/freemodel/assets/opencode_tools.json new file mode 100644 index 0000000000000000000000000000000000000000..c1c148209765b7961dab08873455bd92c32f91fb --- /dev/null +++ b/internal/freemodel/assets/opencode_tools.json @@ -0,0 +1,327 @@ +{ + "edit": { + "description": "Edit the contents of a file by finding and replacing exact text. When editing text from Read output, preserve the exact indentation (tabs or spaces) and omit the line-number prefix, such as `1: `. Never include the prefix in oldString or newString. Write line breaks as \\n; the file's existing CRLF or LF line endings are matched and preserved. To change line endings themselves, make oldString and newString differ only in \\r; that edit applies to the exact bytes. If there is no exact match, the edit retries while ignoring typographic quote, dash, and space variants, then trailing whitespace on each line. The edit fails if oldString is not found. By default, oldString must identify a UNIQUE location. Multiple matches FAIL unless replaceAll is true. Add more surrounding context to disambiguate, or set replaceAll to true to replace every occurrence. Use replaceAll when the change should apply to every occurrence, such as renaming a variable.", + "parameters": { + "additionalProperties": false, + "properties": { + "newString": { + "description": "Text to replace oldString with (must differ from oldString)", + "type": "string" + }, + "oldString": { + "description": "Exact text to find and replace", + "type": "string" + }, + "path": { + "description": "File to edit", + "type": "string" + }, + "replaceAll": { + "description": "Whether to replace every occurrence of oldString. When false, oldString must match exactly once. Defaults to false.", + "type": "boolean" + } + }, + "required": ["path", "oldString", "newString"], + "type": "object" + } + }, + "execute": { + "description": "Run JavaScript in a confined Code Mode runtime to script tool calls and HTTP requests and compose their results.\n`fetch` is available for HTTP requests. Imports, direct filesystem access, and timers are unavailable; all other external access goes through `tools`.\nWithin `{ code }`, the only callable tools are those explicitly listed in the Code Mode catalog instructions or returned by the `search` function. Inside `{ code }`, ignore tools shown outside the Code Mode catalog. They are not available in the Code Mode runtime.\nCall tools through `tools` using only exact paths and signatures from the catalog. Do not infer or normalize tool names; preserve bracket notation such as `tools.[\"tool-name\"](input)`.\nPrefer an explicit `return`; if omitted, the final top-level expression becomes the result.\nAwait every call whose completion matters; pending calls are interrupted when execution ends. Run independent calls concurrently with `Promise.allSettled`.", + "parameters": { + "additionalProperties": false, + "properties": { + "code": { + "type": "string" + } + }, + "required": ["code"], + "type": "object" + } + }, + "glob": { + "description": "Search file paths using a glob pattern (examples: \"**/*.ts\", \"src/**/*.tsx\").", + "parameters": { + "additionalProperties": false, + "properties": { + "hidden": { + "description": "Include hidden files and directories (default: false).", + "type": "boolean" + }, + "limit": { + "description": "Maximum number of matching files to return (default: 100)", + "exclusiveMinimum": 0, + "type": "integer" + }, + "path": { + "description": "Directory to search. Defaults to the current working directory.", + "type": "string" + }, + "pattern": { + "description": "Glob pattern to match files against", + "type": "string" + } + }, + "required": ["pattern"], + "type": "object" + } + }, + "grep": { + "description": "Search file contents using ripgrep's regular expression syntax or literal text matching. Use it to locate specific code, symbols, or text patterns, and narrow searches with `path` or `include`. Returns matching file paths, line numbers, and line previews.", + "parameters": { + "additionalProperties": false, + "properties": { + "caseSensitive": { + "description": "Use case-sensitive matching (default: true).", + "type": "boolean" + }, + "include": { + "description": "Glob pattern to filter files (for example, \"*.js\" or \"*.{ts,tsx}\")", + "type": "string" + }, + "limit": { + "description": "Maximum number of matching lines to return (default: 100)", + "exclusiveMinimum": 0, + "type": "integer" + }, + "literal": { + "description": "Treat `pattern` as exact text instead of a regular expression (default: false).", + "type": "boolean" + }, + "path": { + "description": "File or directory to search. Defaults to the current working directory.", + "type": "string" + }, + "pattern": { + "description": "Regular expression or literal text to match in file contents.", + "minLength": 1, + "type": "string" + } + }, + "required": ["pattern"], + "type": "object" + } + }, + "question": { + "description": "Use this tool when you need to ask the user questions during execution. This allows you to:\n1. Gather user preferences or requirements\n2. Clarify ambiguous instructions\n3. Get decisions on implementation choices as you work\n4. Offer choices to the user about what direction to take.\n\nUsage notes:\n- A \"Type your own answer\" option is added automatically; don't include a separate option for free form answers\n- Set `multiple: true` to allow selecting more than one option\n- If you recommend a specific option, make that the first option in the list and add \"(Recommended)\" at the end of the label", + "parameters": { + "additionalProperties": false, + "properties": { + "questions": { + "description": "Questions to ask", + "items": { + "additionalProperties": false, + "properties": { + "header": { + "description": "Very short label (max 30 chars)", + "type": "string" + }, + "multiple": { + "type": "boolean" + }, + "options": { + "description": "Available choices", + "items": { + "additionalProperties": false, + "properties": { + "description": { + "description": "Explanation of choice", + "type": "string" + }, + "label": { + "description": "Display text (1-5 words, concise)", + "type": "string" + } + }, + "required": ["label", "description"], + "type": "object" + }, + "type": "array" + }, + "question": { + "description": "Complete question", + "type": "string" + } + }, + "required": ["question", "header", "options"], + "type": "object" + }, + "minItems": 1, + "type": "array" + } + }, + "required": ["questions"], + "type": "object" + } + }, + "read": { + "description": "Read the contents of a file or directory. Supports text files, images, and PDFs. Images and PDFs are presented directly to the model. Each text line is prefixed by its 1-based line number as : . The prefix is for reference and is not part of the file content. Directory entries are returned one per line. Use offset and limit to read large files or directories in sections. Prefer one larger read over many small slices, and use grep to find specific content in large files.", + "parameters": { + "additionalProperties": false, + "properties": { + "limit": { + "description": "The maximum number of lines or directory entries to read (defaults to and capped at 2000)", + "minimum": 0, + "type": "integer" + }, + "offset": { + "description": "The line or directory entry to start reading from (1-based)", + "minimum": 0, + "type": "integer" + }, + "path": { + "description": "File or directory to read", + "type": "string" + } + }, + "required": ["path"], + "type": "object" + } + }, + "shell": { + "description": "Execute a shell command and return its output. Commands run on Linux using bash. Quote file paths containing spaces or special characters. Prefer dedicated tools over shell commands when possible. When output is large, the full result is saved to a file and a truncated preview is returned. Rely on automatic truncation unless filtering the output is more useful. Commands accept an optional timeout, background commands have no timeout by default. Background commands return immediately, and you will be notified when they complete.", + "parameters": { + "additionalProperties": false, + "properties": { + "background": { + "description": "Run the command in the background and return immediately (useful for dev servers and long-running builds). You do not need to use '&' at the end of the command when using this parameter. You will be notified when it completes. DO NOT poll for completion.", + "type": "boolean" + }, + "command": { + "description": "Shell command string to execute", + "type": "string" + }, + "timeout": { + "description": "Timeout in milliseconds. Set to 0 to disable the timeout. Defaults to 120000 for foreground commands. Background commands have no timeout by default.", + "minimum": 0, + "type": "integer" + }, + "workdir": { + "description": "Working directory to execute the command in. Defaults to the current working directory. When possible, avoid changing directories in the command and set the working directory here instead.", + "type": "string" + } + }, + "required": ["command"], + "type": "object" + } + }, + "skill": { + "description": "Load a specialized skill's instructions and resources into the current conversation when the task at hand matches its description.\n\nThe skill ID must match an available skill or a skill explicitly referenced by the user.", + "parameters": { + "additionalProperties": false, + "properties": { + "id": { + "description": "The ID of an available skill or a skill explicitly referenced by the user", + "type": "string" + } + }, + "required": ["id"], + "type": "object" + } + }, + "subagent": { + "description": "Spawns an agent in a child session to work on the specified task.\nThe output includes a sessionID you can pass back later to continue that specific conversation with the subagent.\nNew child sessions start with fresh context, so include all relevant context and instructions when you don't pass a sessionID.\nForeground (default) runs the subagent to completion and returns its final response.\nBackground mode (background=true) launches it asynchronously and returns immediately; you are notified when it finishes.\nUse background only for independent work that can run while you continue elsewhere.\n\nAvailable subagents:\n- explore: Fast agent specialized for exploring codebases. Use this when you need to quickly find files by patterns (eg. \"src/components/**/*.tsx\"), search code for keywords (eg. \"API endpoints\"), or answer questions about the codebase (eg. \"how do API endpoints work?\"). When calling this agent, specify the desired thoroughness level: \"quick\" for basic searches, \"medium\" for moderate exploration, or \"very thorough\" for comprehensive analysis across multiple locations and naming conventions.\n- general: General-purpose agent for researching complex questions and executing multi-step tasks. Use this agent to execute multiple units of work in parallel.", + "parameters": { + "additionalProperties": false, + "properties": { + "agent": { + "description": "The type of specialized agent to use for this task. If the user asks for a subagent by a name that is not one of the available subagents, they most likely mean a model: pick a suitable agent and pass the name through the model parameter instead.", + "type": "string" + }, + "background": { + "description": "Run the subagent in the background and return immediately. You will be notified when it completes. DO NOT sleep, poll, or proactively check on its progress.", + "type": "boolean" + }, + "description": { + "description": "A short 3-5 word label for the task, displayed to the user", + "type": "string" + }, + "model": { + "description": "NEVER set this unless the user explicitly asks for a particular model or variant. The value is written as \"providerID/modelID\", or \"providerID/modelID#variant\" to include a variant. Do not guess the ID: look the model up with the models tool, filtering to your own provider first.", + "type": "string" + }, + "prompt": { + "description": "The task for the subagent to perform", + "type": "string" + }, + "sessionID": { + "description": "Continue a specific previous subagent conversation by passing its sessionID. Calls without a sessionID start a new conversation.", + "pattern": "^ses", + "type": "string" + } + }, + "required": ["agent", "description", "prompt"], + "type": "object" + } + }, + "webfetch": { + "description": "Fetch content from an HTTP or HTTPS URL and return it as text, markdown, or HTML. Markdown is the default.\n\nUse a more targeted tool when one is available. This tool is read-only. Large text results may be replaced with a preview while the complete output is retained in managed storage.", + "parameters": { + "additionalProperties": false, + "properties": { + "format": { + "description": "The format to return the content in. Defaults to markdown.", + "enum": ["text", "markdown", "html"], + "type": "string" + }, + "timeout": { + "description": "Optional timeout in seconds (maximum: 120)", + "exclusiveMinimum": 0, + "maximum": 120, + "type": "number" + }, + "url": { + "description": "The HTTP or HTTPS URL to fetch content from", + "type": "string" + } + }, + "required": ["url"], + "type": "object" + } + }, + "websearch": { + "description": "Search the web using the user's selected search integration. Use this for current information beyond knowledge cutoff.\n\nThe current year is 2026. Use this year when searching for recent information or current events.", + "parameters": { + "additionalProperties": false, + "properties": { + "query": { + "description": "Websearch query", + "type": "string" + } + }, + "required": ["query"], + "type": "object" + } + }, + "write": { + "description": "Writes a file to the local filesystem, overwriting if one exists.\n\nMissing parent directories are created automatically.\n\nUse this tool to create new files or overwrite existing files. For partial changes, use the edit tool instead.", + "parameters": { + "additionalProperties": false, + "properties": { + "content": { + "description": "Content to write to the file", + "type": "string" + }, + "path": { + "description": "Path to the file to write to", + "type": "string" + } + }, + "required": ["path", "content"], + "type": "object" + } + }, + "patch": { + "description": "Use the `patch` tool to edit files. Your patch language is a stripped‑down, file‑oriented diff format designed to be easy to parse and safe to apply. You can think of it as a high‑level envelope:\n\n*** Begin Patch\n[ one or more file sections ]\n*** End Patch\n\nWithin that envelope, you get a sequence of file operations.\nYou MUST include a header to specify the action you are taking.\nEach operation starts with one of three headers:\n\n*** Add File: - create a new file. Every following line is a + line (the initial contents).\n*** Delete File: - remove an existing file. Nothing follows.\n*** Update File: - patch an existing file in place (optionally with a rename).\n\nExample patch:\n\n```\n*** Begin Patch\n*** Add File: hello.txt\n+Hello world\n*** Update File: src/app.py\n*** Move to: src/main.py\n@@ def greet():\n-print(\"Hi\")\n+print(\"Hello, world!\")\n*** Delete File: obsolete.txt\n*** End Patch\n```\n\nIt is important to remember:\n\n- You must include a header with your intended action (Add/Delete/Update)\n- You must prefix new lines with `+` even when creating a new file", + "parameters": { + "additionalProperties": false, + "properties": { + "patchText": { + "description": "The full patch text describing add, update, and delete operations", + "type": "string" + } + }, + "required": ["patchText"], + "type": "object" + } + } +} diff --git a/internal/freemodel/client.go b/internal/freemodel/client.go new file mode 100644 index 0000000000000000000000000000000000000000..b2776370f059d545c1b66b9dfa320823697e982e --- /dev/null +++ b/internal/freemodel/client.go @@ -0,0 +1,578 @@ +// Package freemodel 免登录免费模型层:把 OpenCode Zen / Kilo 公共网关的免费模型 +// 接进本网关的 OpenAI 兼容接口。 +// +// 这一层不碰 WorkBuddy 账号池:请求命中 free:/ 时直接转发到上游, +// 不选号、不扣积分、不写 pool 状态。请求整形移植自 dsh-our-free-model 的 o2a 层 +// (opencode2api 的 Go 实现的 JS 移植),只保留 chat 线所需的部分。 +package freemodel + +import ( + "bufio" + "bytes" + "context" + "encoding/json" + "fmt" + "io" + "net/http" + "regexp" + "strings" + "sync" + "time" + + "github.com/misakano7545/workbuddy2api-panel/internal/extstore" +) + +// Prefix 免费模型在 /v1/models 与请求里的前缀。 +const Prefix = "free:" + +const ( + listTimeout = 15 * time.Second + headerTimeout = 120 * time.Second + turnTimeout = 300 * time.Second + maxErrorBytes = 64 << 10 + maxBodyRewrite = 64 << 20 +) + +// Client 免费模型层。 +type Client struct { + store *extstore.Store + http *http.Client + + refreshMu sync.Mutex +} + +// New 构建客户端。store 为空时只读默认值(不会保存)。 +func New(store *extstore.Store) *Client { + return &Client{ + store: store, + http: newFreeHTTPClient(), + } +} + +// Store 返回底层存储。 +func (c *Client) Store() *extstore.Store { return c.store } + +// FreeModelID 拼出对外模型名。 +func FreeModelID(provider, id string) string { return Prefix + provider + "/" + id } + +// ParseModel 拆出 provider 与上游 model id。 +func ParseModel(model string) (provider, id string, ok bool) { + model = strings.TrimSpace(model) + if !strings.HasPrefix(model, Prefix) { + return "", "", false + } + rest := strings.TrimPrefix(model, Prefix) + provider, id, ok = strings.Cut(rest, "/") + if !ok || provider == "" || id == "" { + return "", "", false + } + if provider != extstore.ProviderOpenCode && provider != extstore.ProviderKilo { + return "", "", false + } + return provider, id, true +} + +// Enabled 免费模型层是否可用。 +func (c *Client) Enabled() bool { + if c == nil || c.store == nil { + return false + } + return c.store.Snapshot().Free.Enabled +} + +// Handles 报告 model 是否属于本层且已启用。 +func (c *Client) Handles(model string) bool { + if c == nil || c.store == nil { + return false + } + provider, id, ok := ParseModel(model) + if !ok { + return false + } + return c.store.Snapshot().FreeModelEnabled(provider, id) +} + +// Model 一个对外可用的免费模型(带渠道信息)。 +type Model struct { + Provider string + ProviderLabel string + ID string + Name string +} + +// Models 返回当前已启用(并已发现)的免费模型,供 /v1/models 汇总。 +// 只读缓存:清单由启动后的后台刷新与面板「刷新模型清单」维护,避免模型列表 +// 接口被上游超时拖住(首次启动 3 秒后就会有清单)。 +func (c *Client) Models(ctx context.Context) []Model { + if c == nil || c.store == nil { + return nil + } + snap := c.store.Snapshot() + if !snap.Free.Enabled { + return nil + } + var out []Model + for _, p := range snap.Free.Providers { + if !p.Enabled { + continue + } + for _, m := range p.Models { + if m.Enabled { + out = append(out, Model{Provider: p.Name, ProviderLabel: ProviderLabel(p), ID: m.ID, Name: m.Name}) + } + } + } + return out +} + +// ProviderLabel 返回渠道显示名(Store 已带 Label,这里只做兜底)。 +func ProviderLabel(p extstore.FreeProvider) string { + if strings.TrimSpace(p.Label) != "" { + return p.Label + } + switch p.Type { + case extstore.TypeOpenCode: + return "OpenCode Zen" + case extstore.TypeKilo: + return "Kilo" + } + return p.Name +} + +// Refresh 拉取一次上游模型清单并合并进存储。 +func (c *Client) Refresh(ctx context.Context, provider string) (int, error) { + if c == nil || c.store == nil { + return 0, fmt.Errorf("free model store not configured") + } + snap := c.store.Snapshot() + p, ok := snap.Provider(provider) + if !ok { + return 0, fmt.Errorf("unknown provider %q", provider) + } + if !p.Enabled { + return 0, fmt.Errorf("provider %s is disabled", provider) + } + c.refreshMu.Lock() + defer c.refreshMu.Unlock() + + models, err := c.listModels(ctx, p) + if err != nil { + return 0, err + } + if err := c.store.MergeModels(p.Name, models); err != nil { + return 0, err + } + return len(models), nil +} + +// RefreshAll 刷新所有已启用渠道。 +func (c *Client) RefreshAll(ctx context.Context) { + if c == nil || c.store == nil { + return + } + snap := c.store.Snapshot() + if !snap.Free.Enabled { + return + } + for _, p := range snap.Free.Providers { + if p.Enabled { + _, _ = c.Refresh(ctx, p.Name) + } + } +} + +// RunRefresh 启动后台清单刷新:启动 3 秒后一次,之后每 6 小时一次。 +// 上游清单会随改版增删模型;没有它,进程重启后要么空清单、要么永远停在旧快照。 +func (c *Client) RunRefresh(ctx context.Context) { + if c == nil || c.store == nil { + return + } + timer := time.NewTimer(3 * time.Second) + defer timer.Stop() + select { + case <-ctx.Done(): + return + case <-timer.C: + } + c.RefreshAll(ctx) + ticker := time.NewTicker(6 * time.Hour) + defer ticker.Stop() + for { + select { + case <-ctx.Done(): + return + case <-ticker.C: + c.RefreshAll(ctx) + } + } +} + +// listModels 拉取一个渠道的模型清单,并按渠道的 FreeFilter 过滤。 +func (c *Client) listModels(ctx context.Context, p extstore.FreeProvider) ([]extstore.FreeModel, error) { + ctx, cancel := context.WithTimeout(ctx, listTimeout) + defer cancel() + url := strings.TrimRight(p.BaseURL, "/") + p.ModelsPath + req, err := http.NewRequestWithContext(ctx, http.MethodGet, url, nil) + if err != nil { + return nil, err + } + req.Header.Set("accept", "application/json") + c.applyProviderHeaders(req, p) + + resp, err := c.http.Do(req) + if err != nil { + return nil, err + } + defer resp.Body.Close() + raw, err := io.ReadAll(io.LimitReader(resp.Body, 16<<20)) + if err != nil { + return nil, err + } + if resp.StatusCode != http.StatusOK { + return nil, fmt.Errorf("%s listing: HTTP %d: %s", p.Name, resp.StatusCode, truncate(string(raw), 300)) + } + var doc struct { + Data []struct { + ID string `json:"id"` + Name string `json:"name"` + IsFree bool `json:"isFree"` + } `json:"data"` + } + if err := json.Unmarshal(raw, &doc); err != nil { + return nil, fmt.Errorf("%s listing: %w", p.Name, err) + } + out := make([]extstore.FreeModel, 0, len(doc.Data)) + for _, row := range doc.Data { + if row.ID == "" { + continue + } + if !providerFreeFilter(p, row.ID, row.IsFree) { + continue + } + out = append(out, extstore.FreeModel{ID: row.ID, Name: row.Name, Enabled: true}) + } + return out, nil +} + +func providerFreeFilter(p extstore.FreeProvider, id string, isFree bool) bool { + switch p.FreeFilter { + case "all": + return true + case "free-suffix": + return isOpenCodeFree(id) + case "is-free": + return isFree + default: + return true + } +} + +// applyProviderHeaders 统一设置渠道请求头(清单与对话共用)。 +func (c *Client) applyProviderHeaders(req *http.Request, p extstore.FreeProvider) { + switch p.Type { + case extstore.TypeOpenCode: + req.Header.Set("authorization", "Bearer public") + req.Header.Set("user-agent", clientUA) + case extstore.TypeKilo: + req.Header.Set("user-agent", "dsh-our-free-model") + req.Header.Set("http-referer", "https://kilo.ai/") + req.Header.Set("x-title", "Our Free Model") + default: + req.Header.Set("user-agent", "wb2api-freemodel") + } + if p.AuthHeader != "" { + req.Header.Set(p.AuthHeader, p.AuthValue) + } + for k, v := range p.Headers { + if strings.TrimSpace(k) != "" { + req.Header.Set(k, v) + } + } +} + +// ── 免费 id 判定 ──────────────────────────────────────────────────────────── + +var openCodeAlwaysFree = map[string]bool{ + "big-pickle": true, + // 这两条在 2026-10-31 的上游改版里下线过;保留判定,上游复活即可用。 + "union-alpha": true, + "space-bunny-free": true, +} + +// freeIDSegment 与 dsh 的 isFreeLane 同口径:free 必须是独立分段 +// (-free / _free / .free / :free,也允许出现在中间),不能是 freedom 这类子串。 +var freeIDSegment = regexp.MustCompile(`(?:^|[-_.:])free(?:$|[-_.:])`) + +func isOpenCodeFree(id string) bool { + id = strings.TrimSpace(id) + if id == "" { + return false + } + if openCodeAlwaysFree[id] { + return true + } + return freeIDSegment.MatchString(strings.ToLower(id)) +} + +// ── 请求转发 ──────────────────────────────────────────────────────────────── + +// ServeChat 处理一条命中免费模型层的 /v1/chat/completions 请求。 +// body 是已经读出的原始请求体;exposed 是客户端请求的对外模型名。 +func (c *Client) ServeChat(w http.ResponseWriter, r *http.Request, body []byte, exposed string) { + c.ServeChatEcho(w, r, body, exposed, exposed) +} + +// ServeChatEcho 同 ServeChat,但响应里的 model 用 echo 覆写(自定义模型映射时 +// 客户端请求名与免费模型名不同,响应必须回显客户端自己那个名字)。 +func (c *Client) ServeChatEcho(w http.ResponseWriter, r *http.Request, body []byte, exposed, echo string) { + provider, model, ok := ParseModel(exposed) + if !ok { + writeOpenAIError(w, http.StatusBadRequest, "model_not_found", "unknown free model: "+exposed) + return + } + if !c.Handles(exposed) { + writeOpenAIError(w, http.StatusBadRequest, "model_not_found", + "free model is disabled in the panel: "+exposed) + return + } + if strings.TrimSpace(echo) == "" { + echo = exposed + } + snap := c.store.Snapshot() + p, ok := snap.Provider(provider) + if !ok { + writeOpenAIError(w, http.StatusBadRequest, "model_not_found", "unknown free provider: "+provider) + return + } + + switch p.Type { + case extstore.TypeOpenCode: + c.serveOpenCodeChat(w, r, p, model, exposed, echo, body) + default: + c.serveOpenAIChat(w, r, p, model, exposed, echo, body) + } +} + +// serveOpenAIChat 任意 OpenAI 兼容渠道(Kilo / 自定义公共端点)的透明转发。 +func (c *Client) serveOpenAIChat(w http.ResponseWriter, r *http.Request, p extstore.FreeProvider, model, exposed, echo string, body []byte) { + var obj map[string]any + if err := json.Unmarshal(body, &obj); err != nil { + writeOpenAIError(w, http.StatusBadRequest, "invalid_request_error", "invalid JSON body: "+err.Error()) + return + } + obj["model"] = model + out, err := json.Marshal(obj) + if err != nil { + writeOpenAIError(w, http.StatusBadRequest, "invalid_request_error", err.Error()) + return + } + ctx, cancel := context.WithTimeout(r.Context(), turnTimeout) + defer cancel() + url := strings.TrimRight(p.BaseURL, "/") + p.ChatPath + req, err := http.NewRequestWithContext(ctx, http.MethodPost, url, bytes.NewReader(out)) + if err != nil { + writeOpenAIError(w, http.StatusBadGateway, "upstream_error", err.Error()) + return + } + req.Header.Set("content-type", "application/json") + req.Header.Set("accept", "text/event-stream") + c.applyProviderHeaders(req, p) + resp, err := c.http.Do(req) + if err != nil { + writeOpenAIError(w, http.StatusBadGateway, "upstream_error", "free upstream: "+err.Error()) + return + } + defer resp.Body.Close() + // 原样透传内容,只把上游真实模型名改回客户端请求的 free: 名。 + copyUpstreamResponseRewritten(w, resp, nil, echo) +} + +func (c *Client) serveOpenCodeChat(w http.ResponseWriter, r *http.Request, p extstore.FreeProvider, model, exposed, echo string, body []byte) { + var obj map[string]any + if err := json.Unmarshal(body, &obj); err != nil { + writeOpenAIError(w, http.StatusBadRequest, "invalid_request_error", "invalid JSON body: "+err.Error()) + return + } + obj["model"] = model + session := sessionFor(r, obj) + project := projectID(r, session) + renames := applyFingerprint(obj, model, session) + out, err := json.Marshal(obj) + if err != nil { + writeOpenAIError(w, http.StatusBadRequest, "invalid_request_error", err.Error()) + return + } + ctx, cancel := context.WithTimeout(r.Context(), turnTimeout) + defer cancel() + req, err := http.NewRequestWithContext(ctx, http.MethodPost, strings.TrimRight(p.BaseURL, "/")+p.ChatPath, bytes.NewReader(out)) + if err != nil { + writeOpenAIError(w, http.StatusBadGateway, "upstream_error", err.Error()) + return + } + for k, v := range gatewayHeaders(session, project) { + req.Header.Set(k, v) + } + // 官方指纹头之后允许渠道额外覆盖(自定义 Headers / AuthHeader)。 + c.applyProviderHeaders(req, p) + resp, err := c.http.Do(req) + if err != nil { + writeOpenAIError(w, http.StatusBadGateway, "upstream_error", "free upstream: "+err.Error()) + return + } + defer resp.Body.Close() + copyUpstreamResponseRewritten(w, resp, renames, echo) +} + +// copyUpstreamResponseRewritten 透传 OpenCode 响应,并把工具名/模型名还原。 +func copyUpstreamResponseRewritten(w http.ResponseWriter, resp *http.Response, renames *renameMap, exposed string) { + contentType := resp.Header.Get("content-type") + isSSE := strings.Contains(strings.ToLower(contentType), "text/event-stream") + if resp.StatusCode < 200 || resp.StatusCode >= 300 { + raw, _ := io.ReadAll(io.LimitReader(resp.Body, maxErrorBytes)) + w.Header().Set("content-type", "application/json") + w.WriteHeader(resp.StatusCode) + _, _ = w.Write(raw) + return + } + if !isSSE { + raw, err := io.ReadAll(io.LimitReader(resp.Body, maxBodyRewrite)) + if err != nil { + writeOpenAIError(w, http.StatusBadGateway, "upstream_error", "read upstream: "+err.Error()) + return + } + rewritten := rewriteJSONPayload(raw, renames, exposed) + w.Header().Set("content-type", "application/json") + w.WriteHeader(resp.StatusCode) + _, _ = w.Write(rewritten) + return + } + copyHeaders(w, resp) + w.Header().Set("content-type", "text/event-stream; charset=utf-8") + w.Header().Set("cache-control", "no-cache") + w.Header().Set("x-accel-buffering", "no") + w.WriteHeader(resp.StatusCode) + flusher, _ := w.(http.Flusher) + reader := bufio.NewReaderSize(resp.Body, 64<<10) + for { + line, err := reader.ReadBytes('\n') + if len(line) > 0 { + trimmed := bytes.TrimRight(line, "\r\n") + if bytes.HasPrefix(trimmed, []byte("data:")) { + payload := bytes.TrimSpace(trimmed[len("data:"):]) + if len(payload) > 0 && !bytes.Equal(payload, []byte("[DONE]")) { + payload = rewriteJSONPayload(payload, renames, exposed) + } + _, _ = w.Write([]byte("data: ")) + _, _ = w.Write(payload) + _, _ = w.Write([]byte("\n\n")) + } else { + _, _ = w.Write(line) + if !bytes.HasSuffix(line, []byte("\n")) { + _, _ = w.Write([]byte("\n")) + } + } + if flusher != nil { + flusher.Flush() + } + } + if err != nil { + if err != io.EOF { + // 流中断:写一条协议内错误帧,客户端不会把它当成正常结束。 + _, _ = w.Write([]byte("data: {\"error\":{\"message\":\"free upstream stream interrupted: " + + jsonEscape(err.Error()) + "\",\"type\":\"upstream_error\"}}\n\n")) + if flusher != nil { + flusher.Flush() + } + } + return + } + } +} + +func rewriteJSONPayload(raw []byte, renames *renameMap, exposed string) []byte { + var obj map[string]any + if err := json.Unmarshal(raw, &obj); err != nil { + return raw + } + restoreResponse(obj, renames, exposed) + out, err := json.Marshal(obj) + if err != nil { + return raw + } + return out +} + +func restoreResponse(obj map[string]any, renames *renameMap, exposed string) { + if exposed != "" { + obj["model"] = exposed + } + if renames == nil { + return + } + choices, _ := obj["choices"].([]any) + for _, rawChoice := range choices { + choice, _ := rawChoice.(map[string]any) + if choice == nil { + continue + } + for _, key := range []string{"delta", "message"} { + holder, _ := choice[key].(map[string]any) + if holder == nil { + continue + } + restoreToolCalls(holder, renames) + if fc, ok := holder["function_call"].(map[string]any); ok { + if name, ok := fc["name"].(string); ok { + fc["name"] = renames.resolve(name) + } + } + } + } + // 非流式的 responses 形状兜底(output 里可能带 function_call)。 + restoreToolCalls(obj, renames) +} + +func restoreToolCalls(holder map[string]any, renames *renameMap) { + calls, _ := holder["tool_calls"].([]any) + for _, rawCall := range calls { + call, _ := rawCall.(map[string]any) + fn, _ := call["function"].(map[string]any) + if fn == nil { + continue + } + if name, ok := fn["name"].(string); ok { + fn["name"] = renames.resolve(name) + } + } +} + +func copyHeaders(w http.ResponseWriter, resp *http.Response) { + for _, key := range []string{"retry-after", "x-request-id"} { + if v := resp.Header.Get(key); v != "" { + w.Header().Set(key, v) + } + } +} + +func writeOpenAIError(w http.ResponseWriter, status int, code, msg string) { + w.Header().Set("content-type", "application/json") + w.WriteHeader(status) + _ = json.NewEncoder(w).Encode(map[string]any{ + "error": map[string]any{"message": msg, "type": code, "code": code}, + }) +} + +func truncate(s string, n int) string { + if len(s) <= n { + return s + } + return s[:n] +} + +func jsonEscape(s string) string { + b, _ := json.Marshal(s) + if len(b) >= 2 { + return string(b[1 : len(b)-1]) + } + return s +} diff --git a/internal/freemodel/freemodel_test.go b/internal/freemodel/freemodel_test.go new file mode 100644 index 0000000000000000000000000000000000000000..726208291d5eb6844950225ec7d85a15a51ce1e2 --- /dev/null +++ b/internal/freemodel/freemodel_test.go @@ -0,0 +1,160 @@ +package freemodel + +import ( + "encoding/json" + "regexp" + "strings" + "testing" + "time" +) + +var ( + sessionRE = regexp.MustCompile(`^ses_[0-9a-f]{12}[0-9A-Za-z]{14}$`) + descendRE = regexp.MustCompile(`^[0-9a-f]{9}f[c-f][0-9a-f]$`) +) + +func TestCanonicalSessionShape(t *testing.T) { + for _, signal := range []string{"global", "chat:abc", "user:1"} { + id := canonicalSession(signal) + if !sessionRE.MatchString(id) { + t.Fatalf("session %q does not match wire shape", id) + } + if !descendRE.MatchString(id[4:16]) { + t.Fatalf("session %q time part %q is not the descending encoding", id, id[4:16]) + } + if canonicalSession(signal) != id { + t.Fatalf("session not stable for %q", signal) + } + } + official := mintSessionID(time.Now()) + if canonicalSession(official) != official { + t.Fatalf("official session %q must pass through unchanged", official) + } +} + +func TestGatewayHeaders(t *testing.T) { + id := canonicalSession("global") + headers := gatewayHeaders(id, projectID(nil, id)) + for _, key := range []string{ + "content-type", "authorization", "user-agent", "accept", "x-opencode-client", + "x-session-affinity", "x-session-id", "x-opencode-session", "x-opencode-session-id", + "x-opencode-project", "traceparent", "b3", + } { + if headers[key] == "" { + t.Fatalf("missing header %s", key) + } + } + if headers["authorization"] != "Bearer public" { + t.Fatalf("authorization = %q", headers["authorization"]) + } + if len(headers["x-opencode-project"]) != 40 { + t.Fatalf("project id must be 40 hex chars: %q", headers["x-opencode-project"]) + } +} + +func TestApplyFingerprintShapesChat(t *testing.T) { + body := map[string]any{ + "model": "deepseek-v4.1-flash-free", + "stream": true, + "messages": []any{ + map[string]any{"role": "system", "content": "be terse"}, + map[string]any{"role": "user", "content": "hi"}, + }, + "tools": []any{ + map[string]any{"type": "function", "function": map[string]any{ + "name": "my_tool", "description": "x", "parameters": map[string]any{"type": "object", "properties": map[string]any{"q": map[string]any{"type": "string"}}}, + }}, + map[string]any{"type": "function", "function": map[string]any{ + "name": "Bash", "description": "run", "parameters": map[string]any{"type": "object", "properties": map[string]any{}}, + }}, + }, + "tool_choice": "none", + } + renames := applyFingerprint(body, "deepseek-v4.1-flash-free", canonicalSession("t")) + + if _, ok := body["tool_choice"]; ok { + t.Fatalf("tool_choice none must be stripped") + } + tools, _ := body["tools"].([]any) + if len(tools) != 14 { // 2 client tools + 12 unbound officials + t.Fatalf("tools = %d, want 14", len(tools)) + } + msgs, _ := body["messages"].([]any) + first := msgs[0].(map[string]any) + if !strings.Contains(first["content"].(string), officialPromptMarker) { + t.Fatalf("official prompt not injected: %q", first["content"]) + } + if !strings.Contains(first["content"].(string), "placeholders") { + t.Fatalf("placeholder note not appended") + } + opts, _ := body["stream_options"].(map[string]any) + if opts["include_usage"] != true { + t.Fatalf("stream_options.include_usage missing") + } + if body["max_completion_tokens"] != completionLimit { + t.Fatalf("max_completion_tokens = %v", body["max_completion_tokens"]) + } + // 客户端 my_tool 必须改名;Bash 绑定到官方 shell,不产生 clint_。 + var wireMyTool, sawShell bool + for _, raw := range tools { + tool := raw.(map[string]any) + fn := tool["function"].(map[string]any) + name := fn["name"].(string) + if strings.HasPrefix(name, clientToolPrefix) { + wireMyTool = true + } + if name == "shell" { + sawShell = true + } + } + if !wireMyTool || !sawShell { + t.Fatalf("tool shaping wrong: myTool=%v shell=%v", wireMyTool, sawShell) + } + if got := renames.resolve("shell"); got != "Bash" { + t.Fatalf("reset tool name = %q, want Bash", got) + } +} + +func TestApplyFingerprintSkipsTitleRequest(t *testing.T) { + body := map[string]any{ + "messages": []any{map[string]any{"role": "user", "content": "Generate a title for this conversation"}}, + } + applyFingerprint(body, "m", "s") + if _, ok := body["tools"]; ok { + t.Fatalf("title request must not be shaped") + } +} + +func TestRestoreResponse(t *testing.T) { + renames := newRenameMap() + renames.add("my_tool", "clint_abcdefabcdef") + raw := []byte(`{"model":"upstream","choices":[{"delta":{"tool_calls":[{"function":{"name":"clint_abcdefabcdef"}}]}}]}`) + var obj map[string]any + if err := json.Unmarshal(raw, &obj); err != nil { + t.Fatal(err) + } + restoreResponse(obj, renames, "free:opencode/x") + if obj["model"] != "free:opencode/x" { + t.Fatalf("model not restored: %v", obj["model"]) + } + choices := obj["choices"].([]any) + delta := choices[0].(map[string]any)["delta"].(map[string]any) + call := delta["tool_calls"].([]any)[0].(map[string]any) + name := call["function"].(map[string]any)["name"] + if name != "my_tool" { + t.Fatalf("tool name = %v, want my_tool", name) + } +} + +func TestIsOpenCodeFree(t *testing.T) { + for _, id := range []string{"deepseek-v4.1-flash-free", "big-pickle", "glm-5.3-flash-free"} { + if !isOpenCodeFree(id) { + t.Fatalf("%s should be free", id) + } + } + for _, id := range []string{"deepseek-v4.1-flash", "gpt-5"} { + if isOpenCodeFree(id) { + t.Fatalf("%s should not be free", id) + } + } +} diff --git a/internal/freemodel/session.go b/internal/freemodel/session.go new file mode 100644 index 0000000000000000000000000000000000000000..afa5950df32c2913f80840017c18aa24dcc85dc7 --- /dev/null +++ b/internal/freemodel/session.go @@ -0,0 +1,244 @@ +// session.go 免费车道的会话/项目身份与请求头。 +// +// 这些值不是业务字段,而是上游用来校验「这是官方 OpenCode 客户端」的指纹: +// - ses_<12 hex><14 base62>,12 位 hex 是 ~(ms<<12|1) 的降序编码; +// - x-opencode-project 是 40 位 hex(git 根提交形状); +// - 四个会话头同值,另带 traceparent/b3。 +// +// 移植自 dsh-our-free-model 的 src/o2a/{identity,headers}.js。 +package freemodel + +import ( + "crypto/rand" + "crypto/sha256" + "encoding/hex" + "net/http" + "strings" + "sync" + "time" +) + +const ( + base62Alphabet = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz" + clientUA = "opencode/latest/2.2.3/cli" + anonCredential = "public" + sessionPrefix = "ses_" +) + +var ( + bootNonce = randomBytes(16) + lastStamp int64 + seq int + stampMu sync.Mutex + sessionNow = time.Now +) + +func randomBytes(n int) []byte { + buf := make([]byte, n) + _, _ = rand.Read(buf) + return buf +} + +func isHex(s string) bool { + if s == "" { + return false + } + for _, r := range s { + if !((r >= '0' && r <= '9') || (r >= 'a' && r <= 'f')) { + return false + } + } + return true +} + +// isCanonicalSession 报告 id 是否是上游接受的会话形状。 +func isCanonicalSession(id string) bool { + if !strings.HasPrefix(id, sessionPrefix) || len(id) != 4+12+14 { + return false + } + if !isHex(id[4:16]) { + return false + } + // 降序时间编码的计数器窗口:第 10 位必须是 f,第 11 位 c-f。 + if id[13] != 'f' { + return false + } + if id[14] < 'c' || id[14] > 'f' { + return false + } + for _, r := range id[16:] { + if !strings.ContainsRune(base62Alphabet, r) { + return false + } + } + return true +} + +// canonicalSession 把任意 signal 收敛成上游接受的会话 id。 +func canonicalSession(signal string) string { + signal = strings.TrimSpace(signal) + if isCanonicalSession(signal) { + return signal + } + h := sha256.New() + h.Write([]byte("ses\x00")) + h.Write(bootNonce) + h.Write([]byte{0}) + h.Write([]byte(signal)) + digest := h.Sum(nil) + return sessionPrefix + descendingTimePart(digest) + base62Fixed(digest[6:16], 14) +} + +// descendingTimePart 生成 12 位降序时间 hex:今日 UTC 零点减去最多 30 天的 +// 哈希偏移,再 <<12|1 取反。 +func descendingTimePart(hash []byte) string { + offset := (uint32(hash[0])<<24 | uint32(hash[1])<<16 | uint32(hash[2])<<8 | uint32(hash[3])) % uint32(30*24*60*60*1000) + now := sessionNow().UTC() + midnight := time.Date(now.Year(), now.Month(), now.Day(), 0, 0, 0, 0, time.UTC).UnixMilli() + base := uint64(midnight) - uint64(offset) + inverted := ^((base << 12) | 1) & 0xFFFFFFFFFFFF + return hex.EncodeToString([]byte{ + byte(inverted >> 40), byte(inverted >> 32), byte(inverted >> 24), + byte(inverted >> 16), byte(inverted >> 8), byte(inverted), + }) +} + +func base62Fixed(bytes []byte, width int) string { + n := newBigInt() + for _, b := range bytes { + n.mul(256) + n.add(int(b)) + } + out := make([]byte, width) + for i := width - 1; i >= 0; i-- { + out[i] = base62Alphabet[n.mod(62)] + n.div(62) + } + return string(out) +} + +// 极小的大整数实现:只用于 8 字节 → 14 位 base62,避免为一行逻辑引入 math/big。 +type smallBig struct{ words [8]uint32 } // 256-bit,足够 + +func newBigInt() *smallBig { return &smallBig{} } + +func (b *smallBig) mul(m uint32) { + carry := uint64(0) + for i := range b.words { + v := uint64(b.words[i])*uint64(m) + carry + b.words[i] = uint32(v) + carry = v >> 32 + } +} + +func (b *smallBig) add(v int) { + carry := uint64(v) + for i := range b.words { + if carry == 0 { + return + } + sum := uint64(b.words[i]) + carry + b.words[i] = uint32(sum) + carry = sum >> 32 + } +} + +func (b *smallBig) div(d uint32) { + rem := uint64(0) + for i := len(b.words) - 1; i >= 0; i-- { + cur := (rem << 32) | uint64(b.words[i]) + b.words[i] = uint32(cur / uint64(d)) + rem = cur % uint64(d) + } +} + +func (b *smallBig) mod(d uint32) int { + rem := uint64(0) + for i := len(b.words) - 1; i >= 0; i-- { + rem = ((rem << 32) | uint64(b.words[i])) % uint64(d) + } + return int(rem) +} + +// sessionSignal 从请求里挑一个稳定的会话信号:优先显式头,其次首条用户消息, +// 最后回落到全局桶。 +func sessionSignal(r *http.Request, body map[string]any) string { + for _, key := range []string{"x-opencode-session", "x-session-id", "X-Session-Id", "x-session-affinity"} { + if v := strings.TrimSpace(r.Header.Get(key)); isCanonicalSession(v) { + return v + } + } + if v, ok := body["user"].(string); ok && strings.TrimSpace(v) != "" { + return "user:" + strings.TrimSpace(v) + } + if messages, ok := body["messages"].([]any); ok { + for _, raw := range messages { + msg, _ := raw.(map[string]any) + if msg == nil { + continue + } + if role, _ := msg["role"].(string); role != "system" && role != "developer" { + if text, ok := msg["content"].(string); ok && strings.TrimSpace(text) != "" { + sum := sha256.Sum256([]byte(text)) + return "chat:" + hex.EncodeToString(sum[:8]) + } + } + } + } + return "global" +} + +func sessionFor(r *http.Request, body map[string]any) string { + return canonicalSession(sessionSignal(r, body)) +} + +// projectID 生成 40 位 hex 项目 id:调用方给了 git 提交形状或 global 就沿用, +// 其余从会话 id 派生(同一会话一个配额桶)。 +func projectID(r *http.Request, session string) string { + if r != nil { + if raw := strings.TrimSpace(r.Header.Get("x-opencode-project")); raw == "global" || (len(raw) == 40 && isHex(raw)) { + return raw + } + } + sum := sha256.Sum256([]byte("opencode-project\x00" + session)) + return hex.EncodeToString(sum[:20]) +} + +// gatewayHeaders 官方 2.2.3 客户端的请求头集合。 +func gatewayHeaders(session, project string) map[string]string { + trace := randomBytes(16) + span := randomBytes(8) + parent := randomBytes(8) + return map[string]string{ + "content-type": "application/json", + "authorization": "Bearer " + anonCredential, + "user-agent": clientUA, + "accept": "*/*", + "x-opencode-client": "cli", + "x-session-affinity": session, + "x-session-id": session, + "x-opencode-session": session, + "x-opencode-session-id": session, + "x-opencode-project": project, + "traceparent": "00-" + hex.EncodeToString(trace) + "-" + hex.EncodeToString(span) + "-01", + "b3": hex.EncodeToString(trace) + "-" + hex.EncodeToString(span) + "-1-" + hex.EncodeToString(parent), + } +} + +// mintSessionID 仅用于测试与调试:按上游算法铸造一个新会话。 +func mintSessionID(t time.Time) string { + stampMu.Lock() + defer stampMu.Unlock() + ms := t.UnixMilli() + if ms != lastStamp { + lastStamp = ms + seq = 0 + } + seq++ + value := ^((uint64(ms) << 12) | uint64(seq)) + var out [6]byte + for i := 0; i < 6; i++ { + out[i] = byte(value >> (40 - 8*i)) + } + return sessionPrefix + hex.EncodeToString(out[:]) + base62Fixed(randomBytes(14), 14) +} diff --git a/internal/freemodel/shape.go b/internal/freemodel/shape.go new file mode 100644 index 0000000000000000000000000000000000000000..b0a8bd0f9daed272759a4a430bcbfca8b210c6cf --- /dev/null +++ b/internal/freemodel/shape.go @@ -0,0 +1,801 @@ +// shape.go 免费车道(OpenCode)的请求整形:官方系统提示 + 工具改名 + 官方工具集。 +// +// 移植自 dsh-our-free-model 的 src/o2a/(opencode2api Go 实现的 JS 移植), +// 只保留 chat 线(本网关的免费层只暴露 /v1/chat/completions)。每条事实都有 +// 实测依据,见 dsh 仓库 docs/free-lane-wire.md: +// - 请求体必须带官方 CLI 系统提示(base + + skills); +// - 调用方工具必须全部改名成不透明的 clint_; +// - 必须补齐官方 13 个工具定义(read/shell 两个是闸门直接读的); +// - 绝不下发 tool_choice:"none";流式补 stream_options.include_usage, +// 调用方没给上限时补 max_completion_tokens:32000。 +package freemodel + +import ( + "crypto/sha256" + _ "embed" + "encoding/hex" + "encoding/json" + "fmt" + "runtime" + "strings" + "time" +) + +//go:embed assets/opencode_prompt_v2.txt +var openCodePromptBase string + +//go:embed assets/opencode_tools.json +var openCodeToolsJSON []byte + +const ( + officialPromptMarker = "You are opencode, an interactive CLI tool" + clientToolPrefix = "clint_" + completionLimit = 32000 +) + +const officialSkills = `Skills provide specialized instructions and workflows for specific tasks. +Use the skill tool to load a skill when a task matches its description. + + + customize-opencode + Use ONLY when the user is editing or creating opencode's own configuration: opencode.json, opencode.jsonc, files under .opencode/, or files under ~/.config/opencode/. Also use when creating or fixing opencode agents, subagents, skills, plugins, MCP servers, or permission rules. Do not use for the user's own application code, or for any project that is not configuring opencode itself. + <built-in> + +` + +// v2OfficialToolOrder 官方工具的固定顺序(JSON key 顺序不保证)。 +var v2OfficialToolOrder = []string{ + "edit", "execute", "glob", "grep", "question", "read", "shell", + "skill", "subagent", "webfetch", "websearch", "write", "patch", +} + +// officialClientAliases 客户端常见工具名 → 官方工具名(折叠比较)。 +var officialClientAliases = map[string]string{ + "edit": "edit", "glob": "glob", "grep": "grep", + "question": "question", "askuserquestion": "question", + "read": "read", "view": "read", + "shell": "shell", "bash": "shell", + "skill": "skill", + "subagent": "subagent", "agent": "subagent", "task": "subagent", + "webfetch": "webfetch", "fetch": "webfetch", + "websearch": "websearch", "write": "write", + "patch": "patch", "applypatch": "patch", +} + +var officialTools map[string]map[string]any + +func init() { + officialTools = map[string]map[string]any{} + var parsed map[string]struct { + Description string `json:"description"` + Parameters map[string]any `json:"parameters"` + } + if json.Unmarshal(openCodeToolsJSON, &parsed) == nil { + for name, def := range parsed { + if def.Description == "" || def.Parameters == nil { + continue + } + officialTools[name] = map[string]any{ + "description": def.Description, + "parameters": def.Parameters, + } + } + } +} + +// officialTool 渲染一个官方工具(chat 形状带 strict:false)。 +func officialTool(name string) map[string]any { + description := "Agent tool " + name + parameters := map[string]any{"type": "object", "properties": map[string]any{}} + if def, ok := officialTools[name]; ok { + if d, ok := def["description"].(string); ok { + description = d + } + if p, ok := def["parameters"].(map[string]any); ok { + parameters = deepCopyMap(p) + } + } + if name == "shell" && runtime.GOOS == "windows" { + description = strings.ReplaceAll(description, "on Linux using bash", "on Windows using powershell") + } + return map[string]any{ + "type": "function", + "function": map[string]any{ + "name": name, + "description": description, + "parameters": parameters, + "strict": false, + }, + } +} + +func deepCopyMap(in map[string]any) map[string]any { + raw, _ := json.Marshal(in) + var out map[string]any + _ = json.Unmarshal(raw, &out) + return out +} + +// foldToolName 小写并去掉分隔符,用于别名比较。 +func foldToolName(name string) string { + var b strings.Builder + for _, r := range strings.ToLower(name) { + switch r { + case '_', '.', '-', ' ', '\t', '\r', '\n': + continue + } + b.WriteRune(r) + } + return b.String() +} + +func officialForClientName(name string) string { + return officialClientAliases[foldToolName(name)] +} + +// clientToolWireName 生成不透明 wire 名:clint_ + sha256(name)[:12]。 +func clientToolWireName(name string, used map[string]bool) string { + sum := sha256.Sum256([]byte(name)) + base := clientToolPrefix + hex.EncodeToString(sum[:])[:12] + if !used[base] { + used[base] = true + return base + } + for suffix := 2; ; suffix++ { + tag := fmt.Sprintf("_%d", suffix) + candidate := base + if len(candidate)+len(tag) > 64 { + candidate = candidate[:64-len(tag)] + } + candidate += tag + if !used[candidate] { + used[candidate] = true + return candidate + } + } +} + +// renameMap wire 名 → 客户端原名。 +type renameMap struct { + byClient map[string]string + byWire map[string]string + byCase map[string]string + byShape map[string]string +} + +func newRenameMap() *renameMap { + return &renameMap{ + byClient: map[string]string{}, + byWire: map[string]string{}, + byCase: map[string]string{}, + byShape: map[string]string{}, + } +} + +func (m *renameMap) add(client, wire string) { + if client == "" || wire == "" || client == wire { + return + } + if _, ok := m.byClient[client]; ok { + return + } + if _, ok := m.byWire[wire]; ok { + return + } + m.byClient[client] = wire + m.byWire[wire] = client + m.bindFolded(m.byCase, strings.ToLower(client), client) + m.bindFolded(m.byShape, foldToolName(client), client) +} + +func (m *renameMap) bindFolded(index map[string]string, key, client string) { + if key == "" { + return + } + if existing, ok := index[key]; !ok { + index[key] = client + } else if existing != client { + index[key] = "" + } +} + +func (m *renameMap) wireOf(client string) (string, bool) { + w, ok := m.byClient[client] + return w, ok +} + +// resolve 上游回来的名字 → 客户端原名。 +func (m *renameMap) resolve(wire string) string { + if m == nil || wire == "" { + return wire + } + if exact, ok := m.byWire[wire]; ok { + return exact + } + client := wire + if strings.HasPrefix(client, clientToolPrefix) { + client = strings.TrimPrefix(client, clientToolPrefix) + if client == "" { + return wire + } + } + if _, ok := m.byClient[client]; ok { + return client + } + if folded, ok := m.byCase[strings.ToLower(client)]; ok && folded != "" { + return folded + } + if folded, ok := m.byShape[foldToolName(client)]; ok && folded != "" { + return folded + } + return client +} + +// applyFingerprint 对 chat 请求体做完整整形,返回改名表(响应侧还原用)。 +func applyFingerprint(body map[string]any, model, session string) *renameMap { + if body == nil { + return newRenameMap() + } + if isTitleRequest(body) { + return newRenameMap() + } + injectOfficialPrompt(body, model) + renames, injected := shapeTools(body) + if len(injected) > 0 { + noteInjectedTools(body, injected) + } + if choice, ok := body["tool_choice"].(string); ok && choice == "none" { + delete(body, "tool_choice") + } + if choice, ok := body["tool_choice"].(map[string]any); ok { + if t, _ := choice["type"].(string); t == "none" { + delete(body, "tool_choice") + } + } + ensureChatUsage(body) + ensureV2CompletionLimit(body) + return renames +} + +// isTitleRequest 与 dsh 同一判定:没有工具、1-3 轮纯 user/system、且带标题标记。 +// 这类请求整形反而会被上游 403/429。 +func isTitleRequest(body map[string]any) bool { + if tools, ok := body["tools"].([]any); ok && len(tools) > 0 { + return false + } + if functions, ok := body["functions"].([]any); ok && len(functions) > 0 { + return false + } + if _, ok := body["tool_choice"]; ok { + return false + } + messages, _ := body["messages"].([]any) + if len(messages) == 0 || len(messages) > 3 { + return false + } + var text strings.Builder + for _, raw := range messages { + msg, _ := raw.(map[string]any) + if msg == nil { + return false + } + role, _ := msg["role"].(string) + if role != "user" && role != "system" && role != "developer" { + return false + } + text.WriteString(textOf(msg["content"])) + text.WriteString("\n") + } + lower := strings.ToLower(text.String()) + markers := []string{ + "generate a title", "write a title", "create a title", "come up with a title", + "conversation title", "summarize this conversation", "summarize the conversation", + } + for _, marker := range markers { + if strings.Contains(lower, marker) { + return true + } + } + return false +} + +// injectOfficialPrompt 把官方 CLI 提示注入首条 system/developer 消息。 +func injectOfficialPrompt(body map[string]any, model string) { + prompt := officialSystemPrompt(model) + if prompt == "" { + return + } + messages, _ := body["messages"].([]any) + anchor := -1 + for i, raw := range messages { + msg, _ := raw.(map[string]any) + if msg == nil { + continue + } + role, _ := msg["role"].(string) + if role != "system" && role != "developer" { + continue + } + if carriesOpenCodePrompt(msg["content"]) { + return + } + if anchor == -1 { + anchor = i + } + } + if anchor == -1 { + body["messages"] = append([]any{map[string]any{"role": "system", "content": prompt}}, messages...) + return + } + msg := messages[anchor].(map[string]any) + switch content := msg["content"].(type) { + case []any: + msg["content"] = append([]any{map[string]any{"type": "text", "text": prompt}}, content...) + case string: + if strings.TrimSpace(content) == "" { + msg["content"] = prompt + } else { + msg["content"] = prompt + "\n\n" + content + } + default: + msg["content"] = prompt + } + messages[anchor] = msg + body["messages"] = messages +} + +func officialSystemPrompt(model string) string { + if strings.TrimSpace(openCodePromptBase) == "" { + return "" + } + return openCodePromptBase + officialEnvironment(model) + "\n" + officialSkills +} + +func officialEnvironment(model string) string { + apiModel := strings.TrimPrefix(strings.TrimSpace(model), "opencode/") + if apiModel == "" { + apiModel = "unknown" + } + platform := runtime.GOOS + if platform == "windows" { + platform = "win32" + } + now := time.Now().UTC() + date := fmt.Sprintf("%s %s %02d %d", now.Format("Mon"), now.Format("Jan"), now.Day(), now.Year()) + return fmt.Sprintf("You are powered by the model named %s. The exact model ID is opencode/%s\n"+ + "Here is some useful information about the environment you are running in:\n"+ + "\n Working directory: /workspace\n Workspace root folder: /workspace\n"+ + " Is directory a git repo: yes\n Platform: %s\n Today's date: %s\n", + apiModel, apiModel, platform, date) +} + +func textOf(value any) string { + switch v := value.(type) { + case string: + return v + case []any: + var b strings.Builder + for _, item := range v { + b.WriteString(textOf(item)) + } + return b.String() + case map[string]any: + if t, ok := v["text"].(string); ok { + return t + } + if c, ok := v["content"]; ok { + return textOf(c) + } + } + return "" +} + +func carriesOpenCodePrompt(value any) bool { + switch v := value.(type) { + case string: + return strings.Contains(v, officialPromptMarker) + case []any: + for _, item := range v { + if carriesOpenCodePrompt(item) { + return true + } + } + case map[string]any: + if t, ok := v["text"].(string); ok && strings.Contains(t, officialPromptMarker) { + return true + } + if c, ok := v["content"]; ok { + return carriesOpenCodePrompt(c) + } + } + return false +} + +// shapeTools 改名调用方工具并补齐官方 13 工具集。 +func shapeTools(body map[string]any) (*renameMap, []string) { + renames := newRenameMap() + used := map[string]bool{} + officialUsed := map[string]bool{} + + items, _ := body["tools"].([]any) + if functions, ok := body["functions"].([]any); ok { + items = append(items, convertLegacyFunctions(functions, renames, used)...) + delete(body, "functions") + } + // 已逐字带官方定义的声明视为官方声明,不重命名也不重复补。 + keep := map[string]bool{} + for _, raw := range items { + if name := renamableToolName(raw); name != "" && carriesOfficialDefinition(raw, name) { + keep[name] = true + officialUsed[name] = true + } + } + declaredClientTools := 0 + for _, raw := range items { + if renamableToolName(raw) != "" { + declaredClientTools++ + } + } + shaped := make([]any, 0, len(items)+len(v2OfficialToolOrder)) + for _, raw := range items { + name := renamableToolName(raw) + if name == "" { + shaped = append(shaped, raw) + continue + } + if keep[name] || strings.HasPrefix(name, clientToolPrefix) { + shaped = append(shaped, raw) + continue + } + if official := officialForClientName(name); official != "" && !officialUsed[official] { + if _, exists := officialTools[official]; exists { + officialUsed[official] = true + renames.add(name, official) + shaped = append(shaped, withToolName(raw, official)) + continue + } + } + wireName, ok := renames.wireOf(name) + if !ok { + wireName = clientToolWireName(name, used) + renames.add(name, wireName) + } + if wireName != name { + shaped = append(shaped, withToolName(raw, wireName)) + } else { + shaped = append(shaped, raw) + } + } + injected := make([]string, 0) + for _, name := range v2OfficialToolOrder { + if officialUsed[name] { + continue + } + shaped = append(shaped, officialTool(name)) + injected = append(injected, name) + officialUsed[name] = true + } + body["tools"] = shaped + rewriteToolReferences(body, renames) + if declaredClientTools > 0 { + known := map[string]bool{} + for name := range officialUsed { + known[name] = true + } + for wire := range renames.byWire { + known[wire] = true + } + sanitizeToolHistory(body, known) + dropDanglingToolChoice(body, known) + } + return renames, injected +} + +func renamableToolName(entry any) string { + tool, _ := entry.(map[string]any) + if tool == nil { + return "" + } + fn, _ := tool["function"].(map[string]any) + if fn == nil { + return "" + } + name, _ := fn["name"].(string) + return strings.TrimSpace(name) +} + +func carriesOfficialDefinition(entry any, name string) bool { + tool, _ := entry.(map[string]any) + fn, _ := tool["function"].(map[string]any) + official := officialTool(name) + ofn, _ := official["function"].(map[string]any) + if fn == nil || ofn == nil { + return false + } + if fn["description"] != ofn["description"] { + return false + } + a, _ := json.Marshal(fn["parameters"]) + b, _ := json.Marshal(ofn["parameters"]) + return string(a) == string(b) +} + +func withToolName(entry any, name string) any { + tool, _ := entry.(map[string]any) + if tool == nil { + return entry + } + clone := make(map[string]any, len(tool)) + for k, v := range tool { + clone[k] = v + } + fn, _ := clone["function"].(map[string]any) + fnClone := make(map[string]any, len(fn)+1) + for k, v := range fn { + fnClone[k] = v + } + fnClone["name"] = name + clone["function"] = fnClone + return clone +} + +func convertLegacyFunctions(functions []any, renames *renameMap, used map[string]bool) []any { + out := make([]any, 0, len(functions)) + for _, raw := range functions { + fn, _ := raw.(map[string]any) + if fn == nil { + continue + } + name, _ := fn["name"].(string) + if name == "" { + continue + } + wireName, ok := renames.wireOf(name) + if !ok { + wireName = clientToolWireName(name, used) + renames.add(name, wireName) + } + params := fn["parameters"] + if params == nil { + params = map[string]any{"type": "object", "properties": map[string]any{}} + } + converted := map[string]any{ + "type": "function", + "function": map[string]any{ + "name": wireName, + "description": fn["description"], + "parameters": params, + }, + } + if strict, ok := fn["strict"]; ok { + converted["function"].(map[string]any)["strict"] = strict + } + out = append(out, converted) + } + return out +} + +func rewriteToolReferences(body map[string]any, renames *renameMap) { + if len(renames.byClient) == 0 { + return + } + resolve := func(container map[string]any) (string, bool) { + name, _ := container["name"].(string) + if name == "" { + return "", false + } + wire, ok := renames.wireOf(name) + if !ok || wire == name { + return "", false + } + return wire, true + } + if choice, ok := body["tool_choice"].(map[string]any); ok { + if fn, ok := choice["function"].(map[string]any); ok { + if wire, ok := resolve(fn); ok { + fn["name"] = wire + } + } else if wire, ok := resolve(choice); ok { + choice["name"] = wire + } + } + if fc, ok := body["function_call"].(map[string]any); ok { + if wire, ok := resolve(fc); ok { + fc["name"] = wire + } + } + messages, _ := body["messages"].([]any) + for _, raw := range messages { + msg, _ := raw.(map[string]any) + if msg == nil { + continue + } + if fc, ok := msg["function_call"].(map[string]any); ok { + if wire, ok := resolve(fc); ok { + fc["name"] = wire + } + } + calls, _ := msg["tool_calls"].([]any) + for _, rawCall := range calls { + call, _ := rawCall.(map[string]any) + fn, _ := call["function"].(map[string]any) + if fn == nil { + continue + } + if wire, ok := resolve(fn); ok { + fn["name"] = wire + } + } + } +} + +// sanitizeToolHistory 丢掉历史里「本轮 wire 不提供」的工具调用及其配对结果。 +func sanitizeToolHistory(body map[string]any, known map[string]bool) { + messages, _ := body["messages"].([]any) + if messages == nil { + return + } + droppedCalls := map[string]bool{} + droppedFunctions := map[string]bool{} + out := make([]any, 0, len(messages)) + for _, raw := range messages { + msg, _ := raw.(map[string]any) + if msg == nil { + out = append(out, raw) + continue + } + drop := false + if role, _ := msg["role"].(string); role == "tool" { + if id, _ := msg["tool_call_id"].(string); droppedCalls[id] { + continue + } + } + if role, _ := msg["role"].(string); role == "function" { + if name, _ := msg["name"].(string); droppedFunctions[name] { + continue + } + } + if calls, ok := msg["tool_calls"].([]any); ok { + kept := make([]any, 0, len(calls)) + for _, rawCall := range calls { + call, _ := rawCall.(map[string]any) + fn, _ := call["function"].(map[string]any) + name, _ := fn["name"].(string) + if name == "" { + continue + } + if known[name] { + kept = append(kept, call) + continue + } + if official := officialForClientName(name); official != "" && known[official] { + fn["name"] = official + kept = append(kept, call) + continue + } + if id, _ := call["id"].(string); id != "" { + droppedCalls[id] = true + } + } + if len(kept) == 0 { + delete(msg, "tool_calls") + if !rowHasContent(msg) { + drop = true + } + } else if len(kept) != len(calls) { + msg["tool_calls"] = kept + } + } + if fc, ok := msg["function_call"].(map[string]any); ok { + name, _ := fc["name"].(string) + if official := officialForClientName(name); official != "" && known[official] { + fc["name"] = official + } else if !known[name] { + if name != "" { + droppedFunctions[name] = true + } + delete(msg, "function_call") + if !rowHasContent(msg) { + drop = true + } + } + } + if !drop { + out = append(out, msg) + } + } + body["messages"] = out +} + +func rowHasContent(msg map[string]any) bool { + for _, key := range []string{"content", "reasoning_content", "reasoning"} { + switch v := msg[key].(type) { + case string: + if v != "" { + return true + } + case []any: + if len(v) > 0 { + return true + } + case map[string]any: + if len(v) > 0 { + return true + } + case nil: + default: + return true + } + } + return false +} + +func dropDanglingToolChoice(body map[string]any, known map[string]bool) { + choice, ok := body["tool_choice"].(map[string]any) + if !ok { + return + } + name := "" + if fn, ok := choice["function"].(map[string]any); ok { + name, _ = fn["name"].(string) + } else { + name, _ = choice["name"].(string) + } + if name != "" && !known[name] { + delete(body, "tool_choice") + } +} + +func noteInjectedTools(body map[string]any, names []string) { + quoted := make([]string, len(names)) + for i, name := range names { + quoted[i] = "`" + name + "`" + } + note := "The tools " + strings.Join(quoted, ", ") + + " are part of the host CLI's own toolset and are placeholders in this session; they do nothing here. Use the other tools you have been given instead." + appendSystemContext(body, note) +} + +func appendSystemContext(body map[string]any, note string) { + messages, _ := body["messages"].([]any) + if len(messages) > 0 { + if first, ok := messages[0].(map[string]any); ok { + if role, _ := first["role"].(string); role == "system" || role == "developer" { + switch content := first["content"].(type) { + case string: + first["content"] = content + "\n\n" + note + return + case []any: + first["content"] = append(content, map[string]any{"type": "text", "text": note}) + return + } + first["content"] = note + return + } + } + } + body["messages"] = append([]any{map[string]any{"role": "system", "content": note}}, messages...) +} + +func ensureChatUsage(body map[string]any) { + if stream, _ := body["stream"].(bool); !stream { + return + } + if opts, ok := body["stream_options"].(map[string]any); ok { + if include, _ := opts["include_usage"].(bool); !include { + opts["include_usage"] = true + } + return + } + body["stream_options"] = map[string]any{"include_usage": true} +} + +func ensureV2CompletionLimit(body map[string]any) { + if _, ok := body["max_completion_tokens"]; ok { + return + } + if _, ok := body["max_tokens"]; ok { + return + } + body["max_completion_tokens"] = completionLimit +} diff --git a/internal/freemodel/tls.go b/internal/freemodel/tls.go new file mode 100644 index 0000000000000000000000000000000000000000..67c2c4cc148167284d85758c3011af7443b6d44f --- /dev/null +++ b/internal/freemodel/tls.go @@ -0,0 +1,213 @@ +// tls.go 免费车道的出站传输:用 uTLS 复刻 Bun fetch 的 ClientHello。 +// +// 为什么需要:OpenCode 的免费车道在 HTTP 指纹之外还看 TLS 指纹。Go crypto/tls +// 的 ClientHello 与官方客户端(Bun/OpenCode CLI)差异明显,实测同字节的 HTTP +// 请求在 Go 栈上也可能被判成非官方客户端并回 429 FreeUsageLimitError。这里 +// 照抄参考实现 opencode2api 的 Bun ClientHello(JA4 t13d1713h1),只支持 +// HTTP(S) 代理与直连。 +package freemodel + +import ( + "bufio" + "context" + "crypto/tls" + "encoding/base64" + "fmt" + "io" + "net" + "net/http" + "net/url" + "time" + + utls "github.com/refraction-networking/utls" +) + +const handshakeTimeout = 10 * time.Second + +// bunClientHello 复刻 Bun 1.4.3 fetch 的 ClientHello(参考实现抓包)。 +func bunClientHello() *utls.ClientHelloSpec { + return &utls.ClientHelloSpec{ + TLSVersMin: utls.VersionTLS12, + TLSVersMax: utls.VersionTLS13, + CipherSuites: []uint16{ + utls.TLS_AES_128_GCM_SHA256, + utls.TLS_AES_256_GCM_SHA384, + utls.TLS_CHACHA20_POLY1305_SHA256, + utls.TLS_ECDHE_ECDSA_WITH_AES_128_GCM_SHA256, + utls.TLS_ECDHE_RSA_WITH_AES_128_GCM_SHA256, + utls.TLS_ECDHE_ECDSA_WITH_AES_256_GCM_SHA384, + utls.TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384, + utls.TLS_ECDHE_ECDSA_WITH_CHACHA20_POLY1305_SHA256, + utls.TLS_ECDHE_RSA_WITH_CHACHA20_POLY1305_SHA256, + utls.TLS_ECDHE_ECDSA_WITH_AES_128_CBC_SHA, + utls.TLS_ECDHE_RSA_WITH_AES_128_CBC_SHA, + utls.TLS_ECDHE_ECDSA_WITH_AES_256_CBC_SHA, + utls.TLS_ECDHE_RSA_WITH_AES_256_CBC_SHA, + utls.TLS_RSA_WITH_AES_128_GCM_SHA256, + utls.TLS_RSA_WITH_AES_256_GCM_SHA384, + utls.TLS_RSA_WITH_AES_128_CBC_SHA, + utls.TLS_RSA_WITH_AES_256_CBC_SHA, + }, + CompressionMethods: []uint8{0}, + Extensions: []utls.TLSExtension{ + &utls.SNIExtension{}, + &utls.ExtendedMasterSecretExtension{}, + &utls.RenegotiationInfoExtension{Renegotiation: utls.RenegotiateOnceAsClient}, + &utls.SupportedCurvesExtension{Curves: []utls.CurveID{utls.X25519MLKEM768, utls.X25519, utls.CurveP256, utls.CurveP384}}, + &utls.SupportedPointsExtension{SupportedPoints: []uint8{0}}, + &utls.SessionTicketExtension{}, + &utls.ALPNExtension{AlpnProtocols: []string{"http/1.1"}}, + &utls.StatusRequestExtension{}, + &utls.SignatureAlgorithmsExtension{SupportedSignatureAlgorithms: []utls.SignatureScheme{ + utls.ECDSAWithP256AndSHA256, + utls.PSSWithSHA256, + utls.PKCS1WithSHA256, + utls.ECDSAWithP384AndSHA384, + utls.PSSWithSHA384, + utls.PKCS1WithSHA384, + utls.PSSWithSHA512, + utls.PKCS1WithSHA512, + utls.PKCS1WithSHA1, + }}, + &utls.SCTExtension{}, + &utls.KeyShareExtension{KeyShares: []utls.KeyShare{{Group: utls.X25519MLKEM768}, {Group: utls.X25519}}}, + &utls.PSKKeyExchangeModesExtension{Modes: []uint8{utls.PskModeDHE}}, + &utls.SupportedVersionsExtension{Versions: []uint16{utls.VersionTLS13, utls.VersionTLS12}}, + }, + } +} + +// newFreeHTTPClient 构建免费车道专用客户端:HTTP/1.1、uTLS Bun 指纹、 +// 自己处理 HTTP(S)_PROXY(因为同时用 DialTLSContext 时 http.Transport 的 +// 内建代理隧道不会走这里)。 +func newFreeHTTPClient() *http.Client { + tr := &http.Transport{ + Proxy: nil, + DialTLSContext: dialBunTLS, + ForceAttemptHTTP2: false, + MaxIdleConns: 64, + IdleConnTimeout: 90 * time.Second, + ResponseHeaderTimeout: headerTimeout, + } + return &http.Client{Transport: tr} +} + +func dialBunTLS(ctx context.Context, network, addr string) (net.Conn, error) { + host, _, err := net.SplitHostPort(addr) + if err != nil { + return nil, err + } + conn, err := dialMaybeProxy(ctx, addr) + if err != nil { + return nil, err + } + tlsConn := utls.UClient(conn, &utls.Config{ServerName: host}, utls.HelloCustom) + if err := tlsConn.ApplyPreset(bunClientHello()); err != nil { + _ = conn.Close() + return nil, err + } + handshakeCtx, cancel := context.WithTimeout(ctx, handshakeTimeout) + defer cancel() + if err := tlsConn.HandshakeContext(handshakeCtx); err != nil { + _ = conn.Close() + return nil, err + } + return tlsConn, nil +} + +func dialMaybeProxy(ctx context.Context, addr string) (net.Conn, error) { + proxyURL := proxyFor(addr) + if proxyURL == nil { + d := &net.Dialer{Timeout: handshakeTimeout, KeepAlive: 30 * time.Second} + return d.DialContext(ctx, "tcp", addr) + } + switch proxyURL.Scheme { + case "http", "https": + return dialHTTPProxy(ctx, proxyURL, addr) + default: + return nil, fmt.Errorf("unsupported proxy scheme %q for free model lane (http/https only)", proxyURL.Scheme) + } +} + +func proxyFor(addr string) *url.URL { + req := &http.Request{URL: &url.URL{Scheme: "https", Host: addr}} + u, err := http.ProxyFromEnvironment(req) + if err != nil { + return nil + } + return u +} + +func dialHTTPProxy(ctx context.Context, proxyURL *url.URL, addr string) (net.Conn, error) { + d := &net.Dialer{Timeout: handshakeTimeout, KeepAlive: 30 * time.Second} + conn, err := d.DialContext(ctx, "tcp", proxyAddr(proxyURL)) + if err != nil { + return nil, err + } + stop := context.AfterFunc(ctx, func() { _ = conn.Close() }) + _ = conn.SetDeadline(time.Now().Add(handshakeTimeout)) + if proxyURL.Scheme == "https" { + tlsConn := tls.Client(conn, &tls.Config{ServerName: proxyURL.Hostname()}) + if err = tlsConn.HandshakeContext(ctx); err == nil { + conn = tlsConn + } + } + if err == nil { + conn, err = httpConnect(conn, proxyURL.User, addr) + } + if !stop() && err == nil { + err = ctx.Err() + } + if err == nil { + err = conn.SetDeadline(time.Time{}) + } + if err != nil { + _ = conn.Close() + return nil, err + } + return conn, nil +} + +func proxyAddr(proxy *url.URL) string { + port := proxy.Port() + if port == "" { + switch proxy.Scheme { + case "https": + port = "443" + default: + port = "80" + } + } + return net.JoinHostPort(proxy.Hostname(), port) +} + +func httpConnect(conn net.Conn, user *url.Userinfo, addr string) (net.Conn, error) { + request := "CONNECT " + addr + " HTTP/1.1\r\nHost: " + addr + "\r\n" + if user != nil { + password, _ := user.Password() + request += "Proxy-Authorization: Basic " + + base64.StdEncoding.EncodeToString([]byte(user.Username()+":"+password)) + "\r\n" + } + if _, err := io.WriteString(conn, request+"\r\n"); err != nil { + return conn, err + } + reader := bufio.NewReader(conn) + resp, err := http.ReadResponse(reader, &http.Request{Method: http.MethodConnect}) + if err != nil { + return conn, err + } + if resp.StatusCode/100 != 2 { + return conn, fmt.Errorf("proxy refused CONNECT: %s", resp.Status) + } + if reader.Buffered() > 0 { + return &bufferedConn{Conn: conn, reader: reader}, nil + } + return conn, nil +} + +type bufferedConn struct { + net.Conn + reader *bufio.Reader +} + +func (c *bufferedConn) Read(p []byte) (int, error) { return c.reader.Read(p) } diff --git a/internal/httpauth/httpauth.go b/internal/httpauth/httpauth.go index a94035573e26e5cdd78796c6a30f7c6d9464ea1d..b1a7fc36b0cc40eac193b418ef31dacc83cec30d 100644 --- a/internal/httpauth/httpauth.go +++ b/internal/httpauth/httpauth.go @@ -1,43 +1,43 @@ -// Package httpauth 网关与面板共用的 Bearer 鉴权原语。 -// -// 单独成包的原因:server(/v1/*、/status)与 panel(/panel/api/*)两处鉴权 -// 必须完全同口径——此前各自复制了一份"字符串直接比较"的实现,既容易漂移, -// 又都带计时侧信道。统一到这里后,口径只有一份,且天然常量时间比较。 -package httpauth - -import ( - "crypto/sha256" - "crypto/subtle" - "net/http" - "strings" -) - -// bearerPrefix 认证方案前缀(大小写敏感,与 HTTP 规范及既有实现一致)。 -const bearerPrefix = "Bearer " - -// VerifyBearer 校验请求头是否携带正确的 Bearer 密钥。 -// -// key 为空表示"未启用鉴权",恒返回 true(调用方据此放行)。 -// 比较用 SHA-256 摘要 + subtle.ConstantTimeCompare: -// - 常量时间,不因前缀匹配长度而泄露信息; -// - 先摘要再比较,长度差异被吸收进摘要(不会因长度不同提前返回); -// - 摘要本身不可逆,即便有侧信道也拿不到密钥原文。 -func VerifyBearer(r *http.Request, key string) bool { - if key == "" { - return true - } - authz := r.Header.Get("Authorization") - if !strings.HasPrefix(authz, bearerPrefix) { - // 缺头/方案不对:仍走一次摘要比较,保持耗时形状一致。 - subtle.ConstantTimeCompare(digest(""), digest(key)) - return false - } - tok := authz[len(bearerPrefix):] - return subtle.ConstantTimeCompare(digest(tok), digest(key)) == 1 -} - -// digest 返回 s 的 SHA-256(定长 32 字节,供常量时间比较)。 -func digest(s string) []byte { - sum := sha256.Sum256([]byte(s)) - return sum[:] -} +// Package httpauth 网关与面板共用的 Bearer 鉴权原语。 +// +// 单独成包的原因:server(/v1/*、/status)与 panel(/panel/api/*)两处鉴权 +// 必须完全同口径——此前各自复制了一份"字符串直接比较"的实现,既容易漂移, +// 又都带计时侧信道。统一到这里后,口径只有一份,且天然常量时间比较。 +package httpauth + +import ( + "crypto/sha256" + "crypto/subtle" + "net/http" + "strings" +) + +// bearerPrefix 认证方案前缀(大小写敏感,与 HTTP 规范及既有实现一致)。 +const bearerPrefix = "Bearer " + +// VerifyBearer 校验请求头是否携带正确的 Bearer 密钥。 +// +// key 为空表示"未启用鉴权",恒返回 true(调用方据此放行)。 +// 比较用 SHA-256 摘要 + subtle.ConstantTimeCompare: +// - 常量时间,不因前缀匹配长度而泄露信息; +// - 先摘要再比较,长度差异被吸收进摘要(不会因长度不同提前返回); +// - 摘要本身不可逆,即便有侧信道也拿不到密钥原文。 +func VerifyBearer(r *http.Request, key string) bool { + if key == "" { + return true + } + authz := r.Header.Get("Authorization") + if !strings.HasPrefix(authz, bearerPrefix) { + // 缺头/方案不对:仍走一次摘要比较,保持耗时形状一致。 + subtle.ConstantTimeCompare(digest(""), digest(key)) + return false + } + tok := authz[len(bearerPrefix):] + return subtle.ConstantTimeCompare(digest(tok), digest(key)) == 1 +} + +// digest 返回 s 的 SHA-256(定长 32 字节,供常量时间比较)。 +func digest(s string) []byte { + sum := sha256.Sum256([]byte(s)) + return sum[:] +} diff --git a/internal/httpauth/httpauth_test.go b/internal/httpauth/httpauth_test.go index 4d05ffd3edeb740d33b755f73164f6ae03a1e130..bf1ab10a77822e989d8ecbfd5b2138f504912f0b 100644 --- a/internal/httpauth/httpauth_test.go +++ b/internal/httpauth/httpauth_test.go @@ -1,61 +1,61 @@ -package httpauth - -import ( - "net/http" - "net/http/httptest" - "testing" -) - -func req(authz string) *http.Request { - r := httptest.NewRequest("GET", "/", nil) - if authz != "" { - r.Header.Set("Authorization", authz) - } - return r -} - -func TestVerifyBearer(t *testing.T) { - cases := []struct { - name string - key string - authz string - want bool - }{ - {"空 key 放行(未启用鉴权)", "", "", true}, - {"空 key 也放行任意头", "", "Bearer whatever", true}, - {"正确 key", "sk-abc123", "Bearer sk-abc123", true}, - {"错误 key", "sk-abc123", "Bearer sk-wrong", false}, - {"缺 Authorization 头", "sk-abc123", "", false}, - {"缺 Bearer 前缀", "sk-abc123", "sk-abc123", false}, - {"前缀大小写不符(规范要求精确)", "sk-abc123", "bearer sk-abc123", false}, - {"多余空格", "sk-abc123", "Bearer sk-abc123", false}, - {"前缀相同但内容短", "sk-abc123", "Bearer sk-abc12", false}, - {"前缀相同但内容长", "sk-abc123", "Bearer sk-abc1234", false}, - {"key 恰好是前缀", "sk-abc", "Bearer sk-abcdef", false}, - } - for _, c := range cases { - t.Run(c.name, func(t *testing.T) { - if got := VerifyBearer(req(c.authz), c.key); got != c.want { - t.Errorf("VerifyBearer(key=%q, authz=%q) = %v, want %v", c.key, c.authz, got, c.want) - } - }) - } -} - -// TestVerifyBearerWithoutHeaderStillCompares 缺头路径不应因"提前返回"而暴露形状差异: -// 这里只验证它确实返回 false 且不 panic(常量时间的性质无法用单测断言,靠实现保证)。 -func TestVerifyBearerWithoutHeaderStillCompares(t *testing.T) { - if VerifyBearer(req(""), "any-key") { - t.Error("missing header must not pass") - } -} - -func TestDigestIsFixedLength(t *testing.T) { - // 不同长度输入摘要后应等长(这是常量时间比较的前提) - if len(digest("")) != len(digest("a-much-longer-secret-value")) { - t.Error("digest length must not depend on input length") - } - if len(digest("x")) != 32 { - t.Errorf("sha256 digest length = %d, want 32", len(digest("x"))) - } -} +package httpauth + +import ( + "net/http" + "net/http/httptest" + "testing" +) + +func req(authz string) *http.Request { + r := httptest.NewRequest("GET", "/", nil) + if authz != "" { + r.Header.Set("Authorization", authz) + } + return r +} + +func TestVerifyBearer(t *testing.T) { + cases := []struct { + name string + key string + authz string + want bool + }{ + {"空 key 放行(未启用鉴权)", "", "", true}, + {"空 key 也放行任意头", "", "Bearer whatever", true}, + {"正确 key", "sk-abc123", "Bearer sk-abc123", true}, + {"错误 key", "sk-abc123", "Bearer sk-wrong", false}, + {"缺 Authorization 头", "sk-abc123", "", false}, + {"缺 Bearer 前缀", "sk-abc123", "sk-abc123", false}, + {"前缀大小写不符(规范要求精确)", "sk-abc123", "bearer sk-abc123", false}, + {"多余空格", "sk-abc123", "Bearer sk-abc123", false}, + {"前缀相同但内容短", "sk-abc123", "Bearer sk-abc12", false}, + {"前缀相同但内容长", "sk-abc123", "Bearer sk-abc1234", false}, + {"key 恰好是前缀", "sk-abc", "Bearer sk-abcdef", false}, + } + for _, c := range cases { + t.Run(c.name, func(t *testing.T) { + if got := VerifyBearer(req(c.authz), c.key); got != c.want { + t.Errorf("VerifyBearer(key=%q, authz=%q) = %v, want %v", c.key, c.authz, got, c.want) + } + }) + } +} + +// TestVerifyBearerWithoutHeaderStillCompares 缺头路径不应因"提前返回"而暴露形状差异: +// 这里只验证它确实返回 false 且不 panic(常量时间的性质无法用单测断言,靠实现保证)。 +func TestVerifyBearerWithoutHeaderStillCompares(t *testing.T) { + if VerifyBearer(req(""), "any-key") { + t.Error("missing header must not pass") + } +} + +func TestDigestIsFixedLength(t *testing.T) { + // 不同长度输入摘要后应等长(这是常量时间比较的前提) + if len(digest("")) != len(digest("a-much-longer-secret-value")) { + t.Error("digest length must not depend on input length") + } + if len(digest("x")) != 32 { + t.Errorf("sha256 digest length = %d, want 32", len(digest("x"))) + } +} diff --git a/internal/jsonscan/jsonscan.go b/internal/jsonscan/jsonscan.go new file mode 100644 index 0000000000000000000000000000000000000000..ec3b4375eb7f4a67c3b5f37c6aa9a1ee77042641 --- /dev/null +++ b/internal/jsonscan/jsonscan.go @@ -0,0 +1,447 @@ +// Package jsonscan 从**原始 JSON 字节**里读取少数几个字段,不做整棵树的解析。 +// +// 为什么需要它:网关每处理一个 chat 请求,会对同一个 body 做 4~6 次 +// json.Unmarshal(会话键、首条 role、kimi 工具、body 归一化、会话字段注入), +// 而线上代理负载的 body 常在 100~500KB。整棵树解析要给每个字符串解转义、 +// 建 map、分配几十万对象;其中大部分字段根本没人看。 +// +// 本包遍历一次、只解出被问到的少数几个字符串,其余值按 JSON 语法跳过(零分配)。 +// 语义与 encoding/json 一致:解出来的值走 json.Unmarshal 解转义;跳过只看语法。 +// 任何解析不了的情况都返回 Ok=false,调用方**必须**回落到整树解析。 +// +// 性能要点(都是实测踩出来的): +// - 不要为「查一个键」扫整个 body 多次——一次遍历收集所有想要的键; +// - 不要对跳过的字符串调用 json.Unmarshal(第一版的致命错误:600KB 历史消息里 +// 几千个字符串各解一次,比整树解析还慢 4 倍); +// - 字符串边界用 bytes.IndexByte,只在疑似反斜杠时才回退逐字节。 +package jsonscan + +import ( + "bytes" + "encoding/json" + "fmt" + "unicode/utf8" +) + +// Query 描述要读的字段。 +type Query struct { + // Top 顶层键(只取值是字符串的那些)。 + Top []string + // Nested 顶层子对象键(例如 "metadata");与 NestedKeys 都非空时才生效。 + Nested string + NestedKeys []string +} + +// Result 读取结果。Ok=false 表示 body 不是本包能完整走完的 JSON 对象, +// 调用方应回落整树解析(此时其它字段的值不可信)。 +type Result struct { + Top map[string]string + Nested map[string]string + Ok bool +} + +// Get 取顶层键的值(未命中 / 非字符串 → "")。 +func (r Result) Get(key string) string { return r.Top[key] } + +// GetNested 取顶层子对象里的键值(未命中 / 非字符串 → "")。 +func (r Result) GetNested(key string) string { return r.Nested[key] } + +// Lookup 单遍遍历顶层对象,收集 Query 要求的字符串值。 +// +// 大数据量的字段(messages/tools)在这里只是被跳过,不做任何解码。 +func Lookup(body []byte, q Query) Result { + res := Result{Top: map[string]string{}, Nested: map[string]string{}} + i := skipSpace(body, 0) + if i >= len(body) || body[i] != '{' { + return res + } + i++ + for { + i = skipSpace(body, i) + if i >= len(body) { + return res + } + if body[i] == '}' { + res.Ok = true + return res + } + key, next, ok := readKey(body, i) + if !ok { + return res + } + i = skipSpace(body, next) + if i >= len(body) || body[i] != ':' { + return res + } + i = skipSpace(body, i+1) + if q.Nested != "" && len(q.NestedKeys) > 0 && string(key) == q.Nested { + res.Nested = collect(body, i, q.NestedKeys) + j, ok := skipValue(body, i) + if !ok { + return res + } + i = skipSpace(body, j) + } else if matchAny(key, q.Top) { + if v, after, ok := readStrValue(body, i); ok { + res.Top[string(key)] = v + i = skipSpace(body, after) + } else { + j, ok := skipValue(body, i) + if !ok { + return res + } + i = skipSpace(body, j) + } + } else { + j, ok := skipValue(body, i) + if !ok { + return res + } + i = skipSpace(body, j) + } + if i >= len(body) { + return res + } + switch body[i] { + case ',': + i++ + case '}': + res.Ok = true + return res + default: + return res + } + } +} + +// collect 在 body[i] 处的对象里收集 keys 的字符串值(未命中留空)。 +func collect(body []byte, i int, keys []string) map[string]string { + out := map[string]string{} + i = skipSpace(body, i) + if i >= len(body) || body[i] != '{' { + return out + } + i++ + for { + i = skipSpace(body, i) + if i >= len(body) || body[i] == '}' { + return out + } + key, next, ok := readKey(body, i) + if !ok { + return out + } + i = skipSpace(body, next) + if i >= len(body) || body[i] != ':' { + return out + } + i = skipSpace(body, i+1) + if matchAny(key, keys) { + if v, after, ok := readStrValue(body, i); ok { + out[string(key)] = v + i = skipSpace(body, after) + } else { + j, ok := skipValue(body, i) + if !ok { + return out + } + i = skipSpace(body, j) + } + } else { + j, ok := skipValue(body, i) + if !ok { + return out + } + i = skipSpace(body, j) + } + if i >= len(body) { + return out + } + switch body[i] { + case ',': + i++ + case '}': + return out + default: + return out + } + } +} + +// TopLevelString 取顶层对象里某个键的字符串值(便捷入口;查多个键时直接用 Lookup)。 +func TopLevelString(body []byte, key string) (string, bool) { + res := Lookup(body, Query{Top: []string{key}}) + if !res.Ok { + return "", false + } + v, ok := res.Top[key] + return v, ok +} + +// NestedString 取顶层对象.objKey 这个子对象里 key 的字符串值。 +func NestedString(body []byte, objKey, key string) (string, bool) { + res := Lookup(body, Query{Nested: objKey, NestedKeys: []string{key}}) + if !res.Ok { + return "", false + } + v, ok := res.Nested[key] + return v, ok +} + +// FirstMessageRole 取 messages[0].role。语义与整树解析一致: +// messages 不是非空数组 / 首元素不是对象 / role 缺失或不是字符串 → ok=false。 +func FirstMessageRole(body []byte) (string, bool) { + i := skipSpace(body, 0) + if i >= len(body) || body[i] != '{' { + return "", false + } + i++ + for { + i = skipSpace(body, i) + if i >= len(body) || body[i] == '}' { + return "", false + } + key, next, ok := readKey(body, i) + if !ok { + return "", false + } + i = skipSpace(body, next) + if i >= len(body) || body[i] != ':' { + return "", false + } + i = skipSpace(body, i+1) + if string(key) == "messages" { + i = skipSpace(body, i) + if i >= len(body) || body[i] != '[' { + return "", false + } + i = skipSpace(body, i+1) + if i < len(body) && body[i] == ']' { + return "", false + } + first := collect(body, i, []string{"role"}) + role, ok := first["role"] + return role, ok + } + j, ok := skipValue(body, i) + if !ok { + return "", false + } + i = skipSpace(body, j) + if i >= len(body) { + return "", false + } + switch body[i] { + case ',': + i++ + case '}': + return "", false + default: + return "", false + } + } +} + +// IsObject 报告扫描器能否完整走完这个 body 的顶层对象。 +// +// 用途:调用方用它决定「扫描结果可信」还是「回落整树解析」。走不通说明 body +// 不是合法对象或形态超出本包假设——此时不要相信「没找到键」的结论。 +func IsObject(body []byte) bool { + i := skipSpace(body, 0) + if i >= len(body) || body[i] != '{' { + return false + } + i++ + for { + i = skipSpace(body, i) + if i >= len(body) { + return false + } + if body[i] == '}' { + return true + } + _, next, ok := readKey(body, i) + if !ok { + return false + } + i = skipSpace(body, next) + if i >= len(body) || body[i] != ':' { + return false + } + j, ok := skipValue(body, i+1) + if !ok { + return false + } + i = skipSpace(body, j) + if i >= len(body) { + return false + } + switch body[i] { + case ',': + i++ + case '}': + return true + default: + return false + } + } +} + +// matchAny 报告 key 是否在 want 里。 +func matchAny(key []byte, want []string) bool { + for _, w := range want { + if string(key) == w { + return true + } + } + return false +} + +// skipSpace 跳过 JSON 空白。 +func skipSpace(b []byte, i int) int { + for i < len(b) { + switch b[i] { + case ' ', '\t', '\n', '\r': + i++ + default: + return i + } + } + return i +} + +// readKey 读一个对象键(b[i] 必须是 '"'),返回**未解转义**的原始字节与结束偏移。 +// 键几乎总是纯 ASCII,原始字节可直接与候选键比较;含转义的键由调用方按原文比较 +// (对候选键无转义这一前提成立)。这里不做解码,避免为每个键付一次 Unmarshal。 +func readKey(b []byte, i int) ([]byte, int, bool) { + if i >= len(b) || b[i] != '"' { + return nil, i, false + } + j := i + 1 + for { + n := bytes.IndexByte(b[j:], '"') + if n < 0 { + return nil, i, false + } + j += n + if !escaped(b, i, j) { + return b[i+1 : j], j + 1, true + } + j++ + } +} + +// escaped 报告 b[pos] 处的引号是否被反斜杠转义(数前面连续反斜杠的奇偶)。 +func escaped(b []byte, start, pos int) bool { + bs := 0 + for k := pos - 1; k > start && b[k] == '\\'; k-- { + bs++ + } + return bs%2 == 1 +} + +// readStrValue 读一个字符串值并解转义。b[i] 必须是 '"'。 +func readStrValue(b []byte, i int) (string, int, bool) { + raw, end, ok := readKey(b, i) + if !ok { + return "", i, false + } + // 快路径只处理「无转义 + 合法 UTF-8」的字符串(绝大多数情况)。 + // 其余一律交给 encoding/json:它会把非法 UTF-8 字节替换成 U+FFFD、把 \uXXXX + // 解成对应字符——直接 string(raw) 会漏掉前者(fuzz 抓到的真实差异)。 + if bytes.IndexByte(raw, '\\') < 0 && utf8.Valid(raw) { + return string(raw), end, true + } + var s string + if err := json.Unmarshal(b[i:end], &s); err != nil { + return "", i, false + } + return s, end, true +} + +// skipString 跳过一个字符串(不解转义、不分配),返回结束偏移。 +func skipString(b []byte, i int) (int, bool) { + if i >= len(b) || b[i] != '"' { + return i, false + } + j := i + 1 + for { + n := bytes.IndexByte(b[j:], '"') + if n < 0 { + return i, false + } + j += n + if !escaped(b, i, j) { + return j + 1, true + } + j++ + } +} + +// skipValue 从 b[i] 起跳过一个完整 JSON 值,返回其后的偏移。零分配、不解转义。 +func skipValue(b []byte, i int) (int, bool) { + i = skipSpace(b, i) + if i >= len(b) { + return i, false + } + switch b[i] { + case '"': + return skipString(b, i) + case '{', '[': + depth := 0 + for i < len(b) { + switch b[i] { + case '"': + next, ok := skipString(b, i) + if !ok { + return i, false + } + i = next + continue + case '{', '[': + depth++ + case '}', ']': + depth-- + if depth == 0 { + return i + 1, true + } + } + i++ + } + return i, false + default: + // 数字 / true / false / null:扫到分隔符为止。 + start := i + for i < len(b) { + switch b[i] { + case ',', '}', ']', ' ', '\t', '\n', '\r': + if i == start { + return i, false + } + return i, true + } + i++ + } + return i, i > start + } +} + +// Validate 只在测试里用:确认扫描器与整树解析对同一 body 的判定一致。 +func Validate(body []byte) error { + var obj map[string]any + if err := json.Unmarshal(body, &obj); err != nil { + return nil // 坏 body 不是本函数的关注点 + } + keys := []string{"model", "conversation_id", "conversationId", "user_id", "prompt_cache_key"} + res := Lookup(body, Query{Top: keys}) + if !res.Ok { + return fmt.Errorf("scanner could not walk object: %s", body) + } + for _, k := range keys { + want, _ := obj[k].(string) + if want != res.Top[k] { + return fmt.Errorf("key %q: got %q want %q", k, res.Top[k], want) + } + } + return nil +} diff --git a/internal/jsonscan/jsonscan_test.go b/internal/jsonscan/jsonscan_test.go new file mode 100644 index 0000000000000000000000000000000000000000..95bbdfece9be521fae2f99366f7780b23d5148e4 --- /dev/null +++ b/internal/jsonscan/jsonscan_test.go @@ -0,0 +1,126 @@ +package jsonscan + +import ( + "encoding/json" + "testing" +) + +func TestTopLevelString(t *testing.T) { + body := []byte(`{"model":"cn:deepseek-v4.1-flash","stream":true,"max_tokens":16, + "messages":[{"role":"user","content":"hi"}],"metadata":{"conversation_id":"m-1"}, + "nested":{"model":"inner"},"esc":"a\"b\\c\n","n":null}`) + cases := []struct { + key, want string + ok bool + }{ + {"model", "cn:deepseek-v4.1-flash", true}, + {"esc", "a\"b\\c\n", true}, + {"missing", "", false}, + {"stream", "", false}, // 非字符串 + {"n", "", false}, // null + {"messages", "", false}, // 数组 + } + for _, c := range cases { + got, ok := TopLevelString(body, c.key) + if ok != c.ok || (ok && got != c.want) { + t.Errorf("TopLevelString(%q) = %q,%v want %q,%v", c.key, got, ok, c.want, c.ok) + } + } + // 嵌套对象里的同名键不能被顶层扫描到 + if got, ok := TopLevelString(body, "nested"); ok || got != "" { + t.Errorf("不应把嵌套对象当字符串: %q %v", got, ok) + } +} + +func TestNestedString(t *testing.T) { + body := []byte(`{"messages":[],"metadata":{"conversation_id":"m-1","user_id":"u-9","n":1}}`) + if v, ok := NestedString(body, "metadata", "conversation_id"); !ok || v != "m-1" { + t.Fatalf("got %q ok=%v", v, ok) + } + if v, ok := NestedString(body, "metadata", "user_id"); !ok || v != "u-9" { + t.Fatalf("got %q ok=%v", v, ok) + } + if _, ok := NestedString(body, "metadata", "n"); ok { + t.Fatal("数字不应算字符串") + } + if _, ok := NestedString(body, "absent", "x"); ok { + t.Fatal("缺键不应命中") + } +} + +func TestFirstMessageRole(t *testing.T) { + cases := []struct { + body, want string + ok bool + }{ + {`{"messages":[{"role":"system","content":"x"}]}`, "system", true}, + {`{"messages": [ {"content":[{"type":"text","text":"y"}],"role":"developer"} ]}`, "developer", true}, + {`{"messages":[]}`, "", false}, + {`{"messages":"nope"}`, "", false}, + {`{"messages":[{"content":"no role"}]}`, "", false}, + {`{"model":"m"}`, "", false}, + {`{}`, "", false}, + {``, "", false}, + {`{"messages":[{"role":1}]}`, "", false}, + } + for _, c := range cases { + got, ok := FirstMessageRole([]byte(c.body)) + if ok != c.ok || got != c.want { + t.Errorf("FirstMessageRole(%s) = %q,%v want %q,%v", c.body, got, ok, c.want, c.ok) + } + } +} + +// TestScanMatchesEncodingJSON 与整树解析对拍:真实形状的 body 上两者必须给出相同结果。 +func TestScanMatchesEncodingJSON(t *testing.T) { + bodies := []string{ + `{"model":"kimi-k2","tools":[{"function":{"parameters":{"$ref":"#/$defs/a"}}}],"messages":[{"role":"system","content":"s"},{"role":"user","content":"u"}]}`, + `{"messages":[{"role":"user","content":"含转义 \" 与 \\\\ 与 \u4e2d\u6587"}]}`, + `{"conversation_id":"c-1","metadata":{"conversationId":"c-2","user_id":"u"},"messages":[{"role":"assistant"}]}`, + `{"prompt_cache_key":"p-1","user_id":"u-1","messages":[{"role":"system"}]}`, + } + for _, b := range bodies { + if err := Validate([]byte(b)); err != nil { + t.Errorf("%v", err) + } + var obj map[string]any + if err := json.Unmarshal([]byte(b), &obj); err != nil { + t.Fatalf("bad fixture: %v", err) + } + if msgs, ok := obj["messages"].([]any); ok && len(msgs) > 0 { + if m, ok := msgs[0].(map[string]any); ok { + want, _ := m["role"].(string) + got, ok := FirstMessageRole([]byte(b)) + if want != "" && (!ok || got != want) { + t.Errorf("role: got %q ok=%v want %q", got, ok, want) + } + } + } + } +} + +func TestSkipValueDeepNesting(t *testing.T) { + body := []byte(`{"a":{"b":[{"c":[[["x"]]]},2]},"model":"m"}`) + if v, ok := TopLevelString(body, "model"); !ok || v != "m" { + t.Fatalf("深层嵌套后应仍能读到 model: %q %v", v, ok) + } +} + +func FuzzTopLevelString(f *testing.F) { + for _, s := range []string{ + `{"model":"m"}`, `{}`, `{"a":1`, `{"model":}}`, `[]`, ``, `{"model":"m\u0041"}`, + } { + f.Add([]byte(s)) + } + f.Fuzz(func(t *testing.T, b []byte) { + got, ok := TopLevelString(b, "model") + var obj map[string]any + if err := json.Unmarshal(b, &obj); err != nil { + return + } + want, wantOK := obj["model"].(string) + if ok != wantOK || got != want { + t.Fatalf("mismatch on %q: got %q,%v want %q,%v", b, got, ok, want, wantOK) + } + }) +} diff --git a/internal/jsonscan/testdata/fuzz/FuzzTopLevelString/288fd379d2a8e3f9 b/internal/jsonscan/testdata/fuzz/FuzzTopLevelString/288fd379d2a8e3f9 new file mode 100644 index 0000000000000000000000000000000000000000..5b47e109df338c6a00fcc4fc86e403dd07651b34 --- /dev/null +++ b/internal/jsonscan/testdata/fuzz/FuzzTopLevelString/288fd379d2a8e3f9 @@ -0,0 +1,2 @@ +go test fuzz v1 +[]byte("{\"model\":\"\x8c\"}") diff --git a/internal/livecfg/livecfg.go b/internal/livecfg/livecfg.go index fec4483bc2905ba5f0d56d52a6d7741bfb5178ff..09e5ea8b1b12e4c5168b6fdab6305f36a2857495 100644 --- a/internal/livecfg/livecfg.go +++ b/internal/livecfg/livecfg.go @@ -1,48 +1,173 @@ -// Package livecfg 运行期可变配置的并发安全持有者。 -// -// 背景:进程启动时读入的配置是普通字段(读多写零),但管理面板允许在线改配置, -// 于是少量"可热生效"的字段需要有并发安全的读写点。此处用不可变快照 + atomic 指针: -// 读方 Load 拿到一致视图,写方 Store 整体替换,无锁无数据竞争。 -// -// 只承载**读路径深、热改需求强**的少数字段;池参数/排程参数等各有既有 setter -// (pool.SetBreaker、scheduler.Reconfigure 等),不重复收编到这里。 -package livecfg - -import ( - "sync/atomic" - "time" -) - -// Snapshot 一次读取的不可变配置视图。 -type Snapshot struct { - APIKey string // 网关/面板共同鉴权密钥;空 = 不鉴权 - SoftCooldown time.Duration // 429 软冷却基数(<=0 时调用方回退内置默认) - SanitizeFingerprints bool // 出站请求体指纹脱敏 - RecordClientInfo bool // 请求日志是否记录调用来源(客户端 IP / UA) -} - -// Holder 原子持有当前快照。 -type Holder struct { - p atomic.Pointer[Snapshot] -} - -// New 以初始快照构建。 -func New(s Snapshot) *Holder { - h := &Holder{} - h.Store(s) - return h -} - -// Load 返回当前快照(Holder 为 nil 或从未 Store 时返回零值快照,调用方无需判空)。 -func (h *Holder) Load() Snapshot { - if h == nil { - return Snapshot{} - } - if s := h.p.Load(); s != nil { - return *s - } - return Snapshot{} -} - -// Store 整体替换快照。 -func (h *Holder) Store(s Snapshot) { h.p.Store(&s) } +// Package livecfg 运行期可变配置的并发安全持有者。 +// +// 背景:进程启动时读入的配置是普通字段(读多写零),但管理面板允许在线改配置, +// 于是少量"可热生效"的字段需要有并发安全的读写点。此处用不可变快照 + atomic 指针: +// 读方 Load 拿到一致视图,写方 Store 整体替换,无锁无数据竞争。 +// +// 只承载**读路径深、热改需求强**的少数字段;池参数/排程参数等各有既有 setter +// (pool.SetBreaker、scheduler.Reconfigure 等),不重复收编到这里。 +package livecfg + +import ( + "strings" + "sync/atomic" + "time" +) + +// Snapshot 一次读取的不可变配置视图。 +type Snapshot struct { + APIKey string // 网关/面板共同鉴权密钥;空 = 不鉴权 + SoftCooldown time.Duration // 429/限流软冷却基数(<=0 时调用方回退内置默认) + SanitizeFingerprints bool // 出站请求体指纹脱敏 + // EmbeddingsEnabled 实验特性 /v1/embeddings 总开关(features.embeddings_enabled); + // 默认 false,面板保存后热生效。 + EmbeddingsEnabled bool // 嵌入端点开关 + // WatermarkStripEnabled 实验特性「水印裁切」总开关(features.watermark_strip_enabled); + // 默认 false,面板保存后热生效。 + WatermarkStripEnabled bool + RecordClientInfo bool // 请求日志是否记录调用来源(客户端 IP / UA) + RecordContext bool // 请求事件是否记录会话上下文(system + messages) + HiddenModels map[string]struct{} // 精确隐藏的模型 id(已归一化为 "cn:x"/"global:x" 全量形式);nil = 不隐藏 + // AllowedModels 模型白名单(config models.allowed,issue #68):已归一化为 + // "cn:x"/"global:x" 全量形式的精确 id 集合;nil = 未启用(默认放行所有模型)。 + // 与 HiddenModels 完全对称:Hidden 是「可见集合再剔除」,Allowed 是「可能可见」集合。 + AllowedModels map[string]struct{} + // AllowlistEnabled 白名单是否启用(归一化结果非空即启用);false = 全部放行。 + AllowlistEnabled bool + ModelAliases map[string]string // 客户端名 → 真实模型名(键已归一化小写;"cn:x"/"global:x" 前缀键只在该域生效,裸名键两域都生效);nil = 不映射。issue #30 + // ModelFallback 模型降级路由表(pool.model_fallback):6004 模型级限流时改用 + // 的等价模型(裸名 → 裸名)。nil = 不降级。与 aliases 的区别:aliases 是 + // 「客户端名→真实名」的静态映射,本表是「限流时的临时改道」,且不写持久状态。 + ModelFallback map[string]string + // Thinking* 网关卡点思考档位策略(config thinking 节)的只读镜像。出站改写由 + // upstream.Client 自己持有 EffortPolicy;这里只给面板「网关档位」列算**当前生效值**, + // 让模型列表与真实注入口径一致(含按模型覆盖 model_defaults 的域精确键)。 + ThinkingEnabled bool + ThinkingDefaultEffort string + ThinkingClientPriority bool + ThinkingOverrideScope string + ThinkingModelDefaults map[string]string +} + +// NormalizeModelAliases 把用户配置的 aliases 条目("客户端名=真实模型名")归一化为查找表。 +// +// 语义: +// - 条目按第一个 "=" 拆键值;键/值都 Trim 空间,键小写存储(查找端同样小写—— +// OpenAI 生态的模型名事实大小写不敏感,而 WorkBuddy 上游目录 id 是小写, +// 归一化避免 "DeepSeek-V4.1-Flash" 这类拼法查空)。 +// - 键带合法 realm 前缀("cn:"/"global:")→ 键存 "cn:x" 全量形式,只在该域生效; +// 裸名 → 同时登记 "cn:x" 与 "global:x",两域都生效(与 NormalizeHiddenModels 同口径)。 +// - 值原样保留(含值里的 realm 前缀——映射完再走一遍 resolveModel, +// 所以别名可以跨域指向:"my-glm" → "global:glm-5.2" 合法)。 +// - 无 "="、空键、空值、键==值(大小写不敏感)→ 丢弃(自我映射还可能成环)。 +// - 同一键后写条目覆盖先写条目(配置里重复定义以最后一条为准,与 map 字面量一致)。 +func NormalizeModelAliases(in []string) map[string]string { + if len(in) == 0 { + return nil + } + out := make(map[string]string, len(in)*2) + for _, item := range in { + k, v, ok := strings.Cut(item, "=") + if !ok { + continue + } + k = strings.ToLower(strings.TrimSpace(k)) + v = strings.TrimSpace(v) + if k == "" || v == "" || strings.EqualFold(k, v) { + continue + } + if prefix, bare, cut := strings.Cut(k, ":"); cut && (prefix == "cn" || prefix == "global") { + out[prefix+":"+bare] = v + } else { + out["cn:"+k] = v + out["global:"+k] = v + } + } + if len(out) == 0 { + return nil + } + return out +} + +// Holder 原子持有当前快照。 +type Holder struct { + p atomic.Pointer[Snapshot] +} + +// New 以初始快照构建。 +func New(s Snapshot) *Holder { + h := &Holder{} + h.Store(s) + return h +} + +// Load 返回当前快照(Holder 为 nil 或从未 Store 时返回零值快照,调用方无需判空)。 +func (h *Holder) Load() Snapshot { + if h == nil { + return Snapshot{} + } + if s := h.p.Load(); s != nil { + return *s + } + return Snapshot{} +} + +// Store 整体替换快照。 +func (h *Holder) Store(s Snapshot) { h.p.Store(&s) } + +// NormalizeHiddenModels 把用户配置的 hidden 条目归一化为精确 id 集合。 +// +// 条目带合法 "cn:"/"global:" 前缀 → 只隐藏该域;裸名 → 两域都隐藏。 +// 大小写敏感(与 internal/server.resolveModel 的前缀规则对称:取第一个 ":", +// 前段恰为 "cn"/"global" 才剥离)。返回的 map 只读共享,调用方不得修改。 +func NormalizeHiddenModels(hidden []string) map[string]struct{} { + if len(hidden) == 0 { + return nil + } + out := make(map[string]struct{}, len(hidden)*2) + for _, m := range hidden { + m = strings.TrimSpace(m) + if m == "" { + continue + } + if prefix, bare, ok := strings.Cut(m, ":"); ok && (prefix == "cn" || prefix == "global") { + out[prefix+":"+bare] = struct{}{} + } else { + out["cn:"+m] = struct{}{} + out["global:"+m] = struct{}{} + } + } + if len(out) == 0 { + return nil + } + return out +} + +// NormalizeAllowedModels 把用户配置的 allowed 条目归一化为精确 id 集合。 +// +// 条目语法与 NormalizeHiddenModels 完全一致:带合法 "cn:"/"global:" 前缀 → +// 只在该域允许;裸名 → 两域都允许。大小写敏感。返回 enabled 表示白名单是否 +// 启用:入参为空或全部为无效条目(Trim 后为空)→ false,调用方据此走 +// 「默认放行所有模型」的向后兼容路径。返回的 map 只读共享,调用方不得修改。 +func NormalizeAllowedModels(in []string) (map[string]struct{}, bool) { + if len(in) == 0 { + return nil, false + } + out := make(map[string]struct{}, len(in)*2) + for _, m := range in { + m = strings.TrimSpace(m) + if m == "" { + continue + } + if prefix, bare, ok := strings.Cut(m, ":"); ok && (prefix == "cn" || prefix == "global") { + out[prefix+":"+bare] = struct{}{} + } else { + out["cn:"+m] = struct{}{} + out["global:"+m] = struct{}{} + } + } + if len(out) == 0 { + return nil, false + } + return out, true +} diff --git a/internal/livecfg/livecfg_test.go b/internal/livecfg/livecfg_test.go new file mode 100644 index 0000000000000000000000000000000000000000..03f8b13470c122c1b872caa10043bb95f9e7ada0 --- /dev/null +++ b/internal/livecfg/livecfg_test.go @@ -0,0 +1,170 @@ +package livecfg + +import "testing" + +// TestNormalizeHiddenModels 归一化语义: +// - nil/空/全空白 → nil(不隐藏) +// - 裸名 → 两域都藏("cn:x" + "global:x") +// - "cn:"/"global:" 前缀 → 只藏该域 +// - 非 cn/global 前缀(如 "xx:yy")视为裸名整体(与 resolveModel 对称: +// 前缀不合法时 realm=cn、bare=原串,网关侧检查 "cn:xx:yy" 命中) +func TestNormalizeHiddenModels(t *testing.T) { + if got := NormalizeHiddenModels(nil); got != nil { + t.Errorf("nil → %v, want nil", got) + } + if got := NormalizeHiddenModels([]string{}); got != nil { + t.Errorf("empty → %v, want nil", got) + } + if got := NormalizeHiddenModels([]string{" ", ""}); got != nil { + t.Errorf("all blank → %v, want nil", got) + } + + got := NormalizeHiddenModels([]string{"deepseek-v3"}) + for _, want := range []string{"cn:deepseek-v3", "global:deepseek-v3"} { + if _, ok := got[want]; !ok { + t.Errorf("bare name: missing %q in %v", want, got) + } + } + if len(got) != 2 { + t.Errorf("bare name: got %d entries %v, want 2", len(got), got) + } + + got = NormalizeHiddenModels([]string{"cn:pro-model"}) + if _, ok := got["cn:pro-model"]; !ok { + t.Errorf("cn: prefix: missing %q in %v", "cn:pro-model", got) + } + if _, ok := got["global:pro-model"]; ok { + t.Errorf("cn: prefix: %q must not hide global realm", "global:pro-model") + } + + // 前后空白被裁掉 + got = NormalizeHiddenModels([]string{" glm-5.2 "}) + if _, ok := got["cn:glm-5.2"]; !ok { + t.Errorf("trimmed bare name: missing %q in %v", "cn:glm-5.2", got) + } + + // 非法前缀视为裸名整体 + got = NormalizeHiddenModels([]string{"xx:yy"}) + for _, want := range []string{"cn:xx:yy", "global:xx:yy"} { + if _, ok := got[want]; !ok { + t.Errorf("odd prefix: missing %q in %v", want, got) + } + } +} + +// TestNormalizeAllowedModels 白名单归一化(issue #68):条目语法与 +// NormalizeHiddenModels 完全一致,另返回 enabled 标志—— +// - nil/空/全空白 → nil,false(白名单不启用 = 默认放行全部) +// - 裸名 → 两域都允许("cn:x" + "global:x") +// - "cn:"/"global:" 前缀 → 只允许该域;非合法前缀视为裸名整体 +// - 前后空白裁掉;条目大小写敏感(与 hidden 同口径) +func TestNormalizeAllowedModels(t *testing.T) { + if got, enabled := NormalizeAllowedModels(nil); got != nil || enabled { + t.Errorf("nil → %v,%v, want nil,false", got, enabled) + } + if got, enabled := NormalizeAllowedModels([]string{}); got != nil || enabled { + t.Errorf("empty → %v,%v, want nil,false", got, enabled) + } + if got, enabled := NormalizeAllowedModels([]string{" ", ""}); got != nil || enabled { + t.Errorf("all blank → %v,%v, want nil,false (全空条目必须回落到不启用)", got, enabled) + } + + got, enabled := NormalizeAllowedModels([]string{"glm-5.2"}) + if !enabled { + t.Fatal("非空有效条目应启用白名单") + } + for _, want := range []string{"cn:glm-5.2", "global:glm-5.2"} { + if _, ok := got[want]; !ok { + t.Errorf("裸名:缺 %q in %v", want, got) + } + } + if len(got) != 2 { + t.Errorf("裸名:得 %d 条 %v, want 2", len(got), got) + } + + got, _ = NormalizeAllowedModels([]string{"cn:pro-model"}) + if _, ok := got["cn:pro-model"]; !ok { + t.Errorf("cn: 前缀:缺 %q in %v", "cn:pro-model", got) + } + if _, ok := got["global:pro-model"]; ok { + t.Errorf("cn: 前缀:%q 不得泄漏到 global 域", "global:pro-model") + } + + // 前后空白被裁掉 + got, _ = NormalizeAllowedModels([]string{" deepseek-v4-pro "}) + if _, ok := got["cn:deepseek-v4-pro"]; !ok { + t.Errorf("trim:缺 %q in %v", "cn:deepseek-v4-pro", got) + } + + // 大小写敏感(与 hidden 同口径:不做归一化) + got, _ = NormalizeAllowedModels([]string{"glm-5.2"}) + if _, ok := got["cn:GLM-5.2"]; ok { + t.Error("条目应大小写敏感,GLM-5.2 不该被登记") + } + + // 非法前缀视为裸名整体(与 NormalizeHiddenModels 对称) + got, _ = NormalizeAllowedModels([]string{"xx:yy"}) + for _, want := range []string{"cn:xx:yy", "global:xx:yy"} { + if _, ok := got[want]; !ok { + t.Errorf("非法前缀:缺 %q in %v", want, got) + } + } +} + +// TestNormalizeModelAliases 模型映射归一化(issue #30): +// - nil/空/无 "="/空键/空值/自我映射 → 丢弃 +// - 键小写化(查找端同口径,大小写不敏感) +// - 裸名键 → 两域都生效;"cn:"/"global:" 前缀键 → 只在该域生效 +// - 值原样保留(可带 realm 前缀跨域指向) +func TestNormalizeModelAliases(t *testing.T) { + if got := NormalizeModelAliases(nil); got != nil { + t.Errorf("nil → %v, want nil", got) + } + if got := NormalizeModelAliases([]string{}); got != nil { + t.Errorf("empty → %v, want nil", got) + } + if got := NormalizeModelAliases([]string{"no-equals", " ", "", "=x", "y=", "self=self"}); got != nil { + t.Errorf("all invalid → %v, want nil", got) + } + + // 裸名键:两域都生效,键小写化 + got := NormalizeModelAliases([]string{"My-GPT=glm-5.2"}) + for _, k := range []string{"cn:my-gpt", "global:my-gpt"} { + if got[k] != "glm-5.2" { + t.Errorf("bare key: %q = %q, want glm-5.2 (%v)", k, got[k], got) + } + } + if len(got) != 2 { + t.Errorf("bare key: got %d entries %v, want 2", len(got), got) + } + + // 域前缀键:只在该域生效;值带前缀原样保留(跨域指向) + got = NormalizeModelAliases([]string{"cn:opus=global:gpt-5.4"}) + if got["cn:opus"] != "global:gpt-5.4" { + t.Errorf("scoped key: cn:opus = %q, want global:gpt-5.4", got["cn:opus"]) + } + if _, ok := got["global:opus"]; ok { + t.Error("scoped key: must not register global realm") + } + + // 键值两侧空白裁掉;值只在 "=" 第一次出现处切分 + got = NormalizeModelAliases([]string{" alias1 =glm-5.2 "}) + if got["cn:alias1"] != "glm-5.2" { + t.Errorf("trim: cn:alias1 = %q, want glm-5.2 (%v)", got["cn:alias1"], got) + } +} + +// TestModelAliasesHotReload 快照整体替换后立即生效(面板保存语义)。 +func TestModelAliasesHotReload(t *testing.T) { + h := New(Snapshot{ModelAliases: NormalizeModelAliases([]string{"a=glm-5.2"})}) + if _, ok := h.Load().ModelAliases["cn:a"]; !ok { + t.Fatal("初始快照应含 cn:a") + } + h.Store(Snapshot{ModelAliases: NormalizeModelAliases([]string{"b=deepseek-v3"})}) + if _, ok := h.Load().ModelAliases["cn:a"]; ok { + t.Error("替换快照后旧映射必须消失(整体覆盖语义)") + } + if _, ok := h.Load().ModelAliases["cn:b"]; !ok { + t.Error("替换快照后新映射应生效") + } +} diff --git a/internal/logfmt/logfmt.go b/internal/logfmt/logfmt.go index 2a9aec57787f0945a0077a4232ee4132f79a91c6..e4d01c0824617bbe58c838bfbfd2c087ad43e05f 100644 --- a/internal/logfmt/logfmt.go +++ b/internal/logfmt/logfmt.go @@ -1,166 +1,166 @@ -// Package logfmt 统一网关日志的 uid 截断与模块前缀约定。 -// -// 约定: -// - uid 统一截 8 位:与 chat 流水行(internal/server/logging.go uidPrefix)对齐, -// 日志行只留 uid 前 8 位。全量 uid 可从 data/state.json 查(54 个号无 8 位前缀碰撞)。 -// - 模块前缀:调度四类已有天然前缀(travel/activity/checkin/keepalive)保持; -// 其他补 [pool]/[auth]/[server] 等 [mod] 方括号前缀,redisstore/session 已有保持。 -// - 级别语义:正常流转不打级别字样(保持简洁);可疑/降级/失败行加 WARN:/ERR: 前缀。 -// -// 本包不引入日志库,只提供 UID8 截断 / Label 账号标签 / Pad 显示宽对齐三个纯字符串 -// helper,供各包替代裸写 [:8] 与手算表格列宽(防 uid 短于 8 越界、防中文昵称错位)。 -package logfmt - -import ( - "strings" - "unicode/utf8" -) - -// Truncate 截断字符串到 n 字节上限(先 TrimSpace,与旧 upstream/内部实现口径 -// 一致),切点落在多字节字符中间时回退到 UTF-8 rune 边界——错误 body 多为中文 -// ("将在 … 重置"),按字节切会出半截序列乱码。短于 n 原样返回;n<=0 返回空串。 -func Truncate(s string, n int) string { - if n <= 0 { - return "" - } - s = strings.TrimSpace(s) - if len(s) > n { - // s[n] 是切点后的首字节:是 rune 的后续字节(continuation)说明切点落在 - // 多字节字符中间,逐字节回退到 rune 边界(该字符整个让出)。 - for n > 0 && !utf8.RuneStart(s[n]) { - n-- - } - return s[:n] - } - return s -} - -// UID8 返回 uid 的前 8 位;空 uid 返回 "-"(与 server.uidPrefix 对齐)。 -// -// 用于调度类与非调度类日志行,把 : ... 改为 : ... -// 全量 uid 留在 state.json 供排查,日志里 8 位足够唯一定位。 -func UID8(uid string) string { - if uid == "" { - return "-" - } - if len(uid) > 8 { - return uid[:8] - } - return uid -} - -// Label 返回日志里的账号标签,形如 "示例昵称甲(a1b2c3d4)";昵称为空时退回 "a1b2c3d4"。 -// -// 为什么需要:uid8 是机器标识,排障时人眼无法直接判断"刚才那个 429/6004 是哪个号", -// 必须再拿 uid8 去 auths/ 或 data/state.json 反查昵称,一条日志要多跳一步。昵称随 -// 登录落在 auths/.json 的 account.nickname,这里把它与 uid8 拼成可直接辨认的 -// 标签——昵称认人、uid8 供 grep,两者都保留。 -// -// uid 与 nick 同时为空时返回 "-"(与 UID8 口径一致,避免打出 "(-)")。 -func Label(uid, nick string) string { - short := UID8(uid) - nick = strings.TrimSpace(nick) - if nick == "" { - return short - } - return nick + "(" + short + ")" -} - -// DisplayWidth 返回 s 的终端显示列宽:CJK / 全角 / emoji 记 2 列,其余记 1 列。 -// -// 存在意义:账号昵称是用户自定的中文("猫" 是 3 字节但占 2 列,"sample" 是 6 字节占 -// 6 列),用 len()(字节数)做表格对齐会导致列宽忽宽忽窄。Go 标准库没有显示宽度函数, -// 本仓库不引 go-runewidth(保持零第三方依赖),故内置这份覆盖常见宽字符区段的判定。 -func DisplayWidth(s string) int { - w := 0 - for _, r := range s { - w += runeWidth(r) - } - return w -} - -// Pad 把 s 右补空格到 width 显示列宽;已超宽或 width<=0 时原样返回(不截断)。 -// 只补不截:截断会丢信息,超宽时让该行自然变宽,保持内容完整。 -func Pad(s string, width int) string { - if width <= 0 { - return s - } - if d := width - DisplayWidth(s); d > 0 { - return s + strings.Repeat(" ", d) - } - return s -} - -// maxShortUALen ShortUA 的返回上限(显示列宽足够放下 "WorkBuddy/5.5.6"、 -// "python-requests/2.31.0" 这类常见客户端标签)。 -const maxShortUALen = 40 - -// shortUAEngines UA 里只说明渲染引擎、不说明"是什么客户端"的通用 token:浏览器 UA -// 恒定包含它们,拿它当客户端标签等于没信息。 -var shortUAEngines = map[string]bool{ - "mozilla": true, "applewebkit": true, "gecko": true, "khtml": true, - "like": true, "safari": true, "compatible": true, "msie": true, "trident": true, -} - -// ShortUA 从 User-Agent 提取便于人眼识别的客户端标签("curl/8.4.0"、 -// "WorkBuddy/5.5.6"、"Chrome/120.0.0.0")。 -// -// 为什么需要:面板「运行日志」与 stdout 流水行都要展示调用来源,而完整 UA 动辄 -// 120+ 字符(浏览器尤其),直接铺进表格会把其它列挤没。这里只留"是什么客户端", -// 完整 UA 仍存在 reqlog.Event.UserAgent 里供面板悬停查看。 -// -// 规则:取第一个形如 name/version 且 name 不是渲染引擎的 token;没有则回落整串 -// 的前 maxShortUALen 字节(纯产品名 UA,如 "node")。空 UA 返回空串。 -func ShortUA(ua string) string { - ua = strings.TrimSpace(ua) - if ua == "" { - return "" - } - for _, tok := range strings.Fields(ua) { - tok = strings.Trim(tok, "(),;") - name, _, ok := strings.Cut(tok, "/") - if !ok || name == "" { - continue - } - if shortUAEngines[strings.ToLower(name)] { - continue - } - return Truncate(tok, maxShortUALen) - } - return Truncate(ua, maxShortUALen) -} - -// runeWidth 单个 rune 的显示列宽。区段判定取自 Unicode East Asian Width 的 -// Wide/Fullwidth 集合(与 go-runewidth 的默认表口径一致),只保留实际会用到的段。 -func runeWidth(r rune) int { - switch { - case r == 0: - return 0 - case r < 0x20 || (r >= 0x7f && r < 0xa0): - // 控制字符(含 DEL/C1)不占位:日志里若混入 \t \r 不破坏列宽计算。 - return 0 - case r < 0x1100: - return 1 - case r <= 0x115f: // Hangul Jamo 初声 - return 2 - case r == 0x2329 || r == 0x232a: - return 2 - case r >= 0x2e80 && r <= 0xa4cf && r != 0x303f: // CJK 部首…Yi(303f 是窄字符) - return 2 - case r >= 0xac00 && r <= 0xd7a3: // Hangul 音节 - return 2 - case r >= 0xf900 && r <= 0xfaff: // CJK 兼容表意 - return 2 - case r >= 0xfe30 && r <= 0xfe6f: // CJK 兼容形式 - return 2 - case r >= 0xff00 && r <= 0xff60: // 全角 ASCII - return 2 - case r >= 0xffe0 && r <= 0xffe6: // 全角符号 - return 2 - case r >= 0x1f300 && r <= 0x1f9ff: // emoji - return 2 - case r >= 0x20000 && r <= 0x3fffd: // CJK 扩展 B 及以后 - return 2 - } - return 1 -} +// Package logfmt 统一网关日志的 uid 截断与模块前缀约定。 +// +// 约定: +// - uid 统一截 8 位:与 chat 流水行(internal/server/logging.go uidPrefix)对齐, +// 日志行只留 uid 前 8 位。全量 uid 可从 data/state.json 查(54 个号无 8 位前缀碰撞)。 +// - 模块前缀:调度四类已有天然前缀(travel/activity/checkin/keepalive)保持; +// 其他补 [pool]/[auth]/[server] 等 [mod] 方括号前缀,redisstore/session 已有保持。 +// - 级别语义:正常流转不打级别字样(保持简洁);可疑/降级/失败行加 WARN:/ERR: 前缀。 +// +// 本包不引入日志库,只提供 UID8 截断 / Label 账号标签 / Pad 显示宽对齐三个纯字符串 +// helper,供各包替代裸写 [:8] 与手算表格列宽(防 uid 短于 8 越界、防中文昵称错位)。 +package logfmt + +import ( + "strings" + "unicode/utf8" +) + +// Truncate 截断字符串到 n 字节上限(先 TrimSpace,与旧 upstream/内部实现口径 +// 一致),切点落在多字节字符中间时回退到 UTF-8 rune 边界——错误 body 多为中文 +// ("将在 … 重置"),按字节切会出半截序列乱码。短于 n 原样返回;n<=0 返回空串。 +func Truncate(s string, n int) string { + if n <= 0 { + return "" + } + s = strings.TrimSpace(s) + if len(s) > n { + // s[n] 是切点后的首字节:是 rune 的后续字节(continuation)说明切点落在 + // 多字节字符中间,逐字节回退到 rune 边界(该字符整个让出)。 + for n > 0 && !utf8.RuneStart(s[n]) { + n-- + } + return s[:n] + } + return s +} + +// UID8 返回 uid 的前 8 位;空 uid 返回 "-"(与 server.uidPrefix 对齐)。 +// +// 用于调度类与非调度类日志行,把 : ... 改为 : ... +// 全量 uid 留在 state.json 供排查,日志里 8 位足够唯一定位。 +func UID8(uid string) string { + if uid == "" { + return "-" + } + if len(uid) > 8 { + return uid[:8] + } + return uid +} + +// Label 返回日志里的账号标签,形如 "示例昵称甲(a1b2c3d4)";昵称为空时退回 "a1b2c3d4"。 +// +// 为什么需要:uid8 是机器标识,排障时人眼无法直接判断"刚才那个 429/6004 是哪个号", +// 必须再拿 uid8 去 auths/ 或 data/state.json 反查昵称,一条日志要多跳一步。昵称随 +// 登录落在 auths/.json 的 account.nickname,这里把它与 uid8 拼成可直接辨认的 +// 标签——昵称认人、uid8 供 grep,两者都保留。 +// +// uid 与 nick 同时为空时返回 "-"(与 UID8 口径一致,避免打出 "(-)")。 +func Label(uid, nick string) string { + short := UID8(uid) + nick = strings.TrimSpace(nick) + if nick == "" { + return short + } + return nick + "(" + short + ")" +} + +// DisplayWidth 返回 s 的终端显示列宽:CJK / 全角 / emoji 记 2 列,其余记 1 列。 +// +// 存在意义:账号昵称是用户自定的中文("猫" 是 3 字节但占 2 列,"sample" 是 6 字节占 +// 6 列),用 len()(字节数)做表格对齐会导致列宽忽宽忽窄。Go 标准库没有显示宽度函数, +// 本仓库不引 go-runewidth(保持零第三方依赖),故内置这份覆盖常见宽字符区段的判定。 +func DisplayWidth(s string) int { + w := 0 + for _, r := range s { + w += runeWidth(r) + } + return w +} + +// Pad 把 s 右补空格到 width 显示列宽;已超宽或 width<=0 时原样返回(不截断)。 +// 只补不截:截断会丢信息,超宽时让该行自然变宽,保持内容完整。 +func Pad(s string, width int) string { + if width <= 0 { + return s + } + if d := width - DisplayWidth(s); d > 0 { + return s + strings.Repeat(" ", d) + } + return s +} + +// maxShortUALen ShortUA 的返回上限(显示列宽足够放下 "WorkBuddy/5.5.6"、 +// "python-requests/2.31.0" 这类常见客户端标签)。 +const maxShortUALen = 40 + +// shortUAEngines UA 里只说明渲染引擎、不说明"是什么客户端"的通用 token:浏览器 UA +// 恒定包含它们,拿它当客户端标签等于没信息。 +var shortUAEngines = map[string]bool{ + "mozilla": true, "applewebkit": true, "gecko": true, "khtml": true, + "like": true, "safari": true, "compatible": true, "msie": true, "trident": true, +} + +// ShortUA 从 User-Agent 提取便于人眼识别的客户端标签("curl/8.4.0"、 +// "WorkBuddy/5.5.6"、"Chrome/120.0.0.0")。 +// +// 为什么需要:面板「运行日志」与 stdout 流水行都要展示调用来源,而完整 UA 动辄 +// 120+ 字符(浏览器尤其),直接铺进表格会把其它列挤没。这里只留"是什么客户端", +// 完整 UA 仍存在 reqlog.Event.UserAgent 里供面板悬停查看。 +// +// 规则:取第一个形如 name/version 且 name 不是渲染引擎的 token;没有则回落整串 +// 的前 maxShortUALen 字节(纯产品名 UA,如 "node")。空 UA 返回空串。 +func ShortUA(ua string) string { + ua = strings.TrimSpace(ua) + if ua == "" { + return "" + } + for _, tok := range strings.Fields(ua) { + tok = strings.Trim(tok, "(),;") + name, _, ok := strings.Cut(tok, "/") + if !ok || name == "" { + continue + } + if shortUAEngines[strings.ToLower(name)] { + continue + } + return Truncate(tok, maxShortUALen) + } + return Truncate(ua, maxShortUALen) +} + +// runeWidth 单个 rune 的显示列宽。区段判定取自 Unicode East Asian Width 的 +// Wide/Fullwidth 集合(与 go-runewidth 的默认表口径一致),只保留实际会用到的段。 +func runeWidth(r rune) int { + switch { + case r == 0: + return 0 + case r < 0x20 || (r >= 0x7f && r < 0xa0): + // 控制字符(含 DEL/C1)不占位:日志里若混入 \t \r 不破坏列宽计算。 + return 0 + case r < 0x1100: + return 1 + case r <= 0x115f: // Hangul Jamo 初声 + return 2 + case r == 0x2329 || r == 0x232a: + return 2 + case r >= 0x2e80 && r <= 0xa4cf && r != 0x303f: // CJK 部首…Yi(303f 是窄字符) + return 2 + case r >= 0xac00 && r <= 0xd7a3: // Hangul 音节 + return 2 + case r >= 0xf900 && r <= 0xfaff: // CJK 兼容表意 + return 2 + case r >= 0xfe30 && r <= 0xfe6f: // CJK 兼容形式 + return 2 + case r >= 0xff00 && r <= 0xff60: // 全角 ASCII + return 2 + case r >= 0xffe0 && r <= 0xffe6: // 全角符号 + return 2 + case r >= 0x1f300 && r <= 0x1f9ff: // emoji + return 2 + case r >= 0x20000 && r <= 0x3fffd: // CJK 扩展 B 及以后 + return 2 + } + return 1 +} diff --git a/internal/logfmt/logfmt_test.go b/internal/logfmt/logfmt_test.go new file mode 100644 index 0000000000000000000000000000000000000000..5b36796d2645935ecf43ee4d456fec7c11b0a32a --- /dev/null +++ b/internal/logfmt/logfmt_test.go @@ -0,0 +1,37 @@ +package logfmt + +import ( + "strings" + "testing" + "unicode/utf8" +) + +// Truncate 的契约:按字节上限截断,但切点落在多字节字符中间时让出整个字符。 +// 这条契约此前只存在于注释里(上游 #166 的教训:错误 body / 奖品载荷多为中文, +// 按字节切会打出半截序列)。 +func TestTruncateRuneBoundary(t *testing.T) { + // 短于上限:原样(顺带 TrimSpace)。 + if got := Truncate("abc", 10); got != "abc" { + t.Errorf("短串应原样:%q", got) + } + if got := Truncate(" abc ", 10); got != "abc" { + t.Errorf("应 TrimSpace:%q", got) + } + // 上限非正:空串(不为负索引 panic)。 + if got := Truncate("abc", 0); got != "" { + t.Errorf("n<=0 应返回空串:%q", got) + } + // 中文 3 字节:上限 10 落在第 4 个字中间 → 只能让出该字,返回 9 字节。 + got := Truncate(strings.Repeat("奖", 10), 10) + if !utf8.ValidString(got) { + t.Fatalf("截断结果必须仍是合法 UTF-8:%q", got) + } + if len(got) != 9 || utf8.RuneCountInString(got) != 3 { + t.Errorf("应回退到 rune 边界(9 字节 3 字),实际 %d 字节 %d 字:%q", + len(got), utf8.RuneCountInString(got), got) + } + // 上限恰好落在字符边界:不多让。 + if got := Truncate(strings.Repeat("奖", 4), 9); got != strings.Repeat("奖", 3) { + t.Errorf("边界对齐时不应少让:%q", got) + } +} diff --git a/internal/logfmt/shortua_test.go b/internal/logfmt/shortua_test.go index 6d50c4dfa892c12d87ba8455c1c79ce210732cd6..ab0882fe38a43681dc47391770a09a9eb373ce4c 100644 --- a/internal/logfmt/shortua_test.go +++ b/internal/logfmt/shortua_test.go @@ -1,50 +1,50 @@ -package logfmt - -import "testing" - -func TestShortUA(t *testing.T) { - cases := []struct { - name string - ua string - want string - }{ - {"empty", "", ""}, - {"blank", " ", ""}, - {"curl", "curl/8.4.0", "curl/8.4.0"}, - {"python", "python-requests/2.31.0", "python-requests/2.31.0"}, - {"openai", "OpenAI/Python 1.30.0", "OpenAI/Python"}, - {"workbuddy", "WorkBuddy/5.5.6 WorkBuddy/5.5.6 CLI/2.137.1", "WorkBuddy/5.5.6"}, - { - "chrome skips engine tokens", - "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36", - "Chrome/120.0.0.0", - }, - { - "firefox", - "Mozilla/5.0 (X11; Linux x86_64; rv:121.0) Gecko/20100101 Firefox/121.0", - "Firefox/121.0", - }, - {"no version token", "node", "node"}, - {"only engine tokens falls back to whole", "Mozilla/5.0 AppleWebKit/537.36", "Mozilla/5.0 AppleWebKit/537.36"}, - } - for _, tc := range cases { - t.Run(tc.name, func(t *testing.T) { - if got := ShortUA(tc.ua); got != tc.want { - t.Fatalf("ShortUA(%q) = %q want %q", tc.ua, got, tc.want) - } - }) - } -} - -// ShortUA 的返回值必须有界:UA 是客户端可控自由文本,超长值不能原样带进日志列。 -func TestShortUABounded(t *testing.T) { - long := "VeryLongClientNameThatKeepsGoingAndGoing/1.2.3" - if got := ShortUA(long); len(got) > maxShortUALen { - t.Fatalf("len(ShortUA) = %d want <= %d (%q)", len(got), maxShortUALen, got) - } - // 没有 name/version token 时回落整串,同样受上限约束。 - got := ShortUA("x" + string(make([]byte, 0)) + "yyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyy") - if len(got) > maxShortUALen { - t.Fatalf("fallback not truncated: %d", len(got)) - } -} +package logfmt + +import "testing" + +func TestShortUA(t *testing.T) { + cases := []struct { + name string + ua string + want string + }{ + {"empty", "", ""}, + {"blank", " ", ""}, + {"curl", "curl/8.4.0", "curl/8.4.0"}, + {"python", "python-requests/2.31.0", "python-requests/2.31.0"}, + {"openai", "OpenAI/Python 1.30.0", "OpenAI/Python"}, + {"workbuddy", "WorkBuddy/5.5.6 WorkBuddy/5.5.6 CLI/2.137.1", "WorkBuddy/5.5.6"}, + { + "chrome skips engine tokens", + "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36", + "Chrome/120.0.0.0", + }, + { + "firefox", + "Mozilla/5.0 (X11; Linux x86_64; rv:121.0) Gecko/20100101 Firefox/121.0", + "Firefox/121.0", + }, + {"no version token", "node", "node"}, + {"only engine tokens falls back to whole", "Mozilla/5.0 AppleWebKit/537.36", "Mozilla/5.0 AppleWebKit/537.36"}, + } + for _, tc := range cases { + t.Run(tc.name, func(t *testing.T) { + if got := ShortUA(tc.ua); got != tc.want { + t.Fatalf("ShortUA(%q) = %q want %q", tc.ua, got, tc.want) + } + }) + } +} + +// ShortUA 的返回值必须有界:UA 是客户端可控自由文本,超长值不能原样带进日志列。 +func TestShortUABounded(t *testing.T) { + long := "VeryLongClientNameThatKeepsGoingAndGoing/1.2.3" + if got := ShortUA(long); len(got) > maxShortUALen { + t.Fatalf("len(ShortUA) = %d want <= %d (%q)", len(got), maxShortUALen, got) + } + // 没有 name/version token 时回落整串,同样受上限约束。 + got := ShortUA("x" + string(make([]byte, 0)) + "yyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyy") + if len(got) > maxShortUALen { + t.Fatalf("fallback not truncated: %d", len(got)) + } +} diff --git a/internal/loginsite/loginsite.go b/internal/loginsite/loginsite.go new file mode 100644 index 0000000000000000000000000000000000000000..d099225706cd6c2eb0b626ca58755a4b40b0b431 --- /dev/null +++ b/internal/loginsite/loginsite.go @@ -0,0 +1,413 @@ +// Package loginsite 官方登录站点表与登录协议常量(对齐 CodeBuddy CLI 的 +// product.json 域表与 auth 模块码表)。 +// +// 为什么单独一个包:设备授权链路有**两个**调用方——面板内嵌流程 +// (internal/panel/login.go)与命令行工具(cmd/login)。域表、UA 版本、登录码 +// 语义一旦在两处各写一份,就会出现「面板能登、CLI 工具不能登」这种最难查的分叉。 +// 所有官方口径收敛在这里,两处只做流程编排。 +package loginsite + +import ( + cryptorand "crypto/rand" + "encoding/hex" + "fmt" + "net/url" + "strings" + "time" +) + +// ClientVersion 官方 CLI 版本。UA 与授权链接的 version 参数同源。 +// +// 对齐 2026-10-26 的 @tencent-ai/codebuddy-code@2.176.0(npm dist-tag latest)。 +// 官方 CLI 把它自己的 package version 写进授权链接的 version,同时以 +// ?platform=CLI&version= 打 console/auth/risk-context —— 版本串确实会进风控判定, +// 落后两个小版本(2.174.0,10-25 发布)时用户侧登录页按旧客户端渲染并埋点。 +// 上游 CLI 日更,这个常量要跟着 dist-tag latest 走。 +const ClientVersion = "2.176.0" + +// ClientUA 设备授权链路的 User-Agent(CodeBuddy CLI 家族形态)。 +// +// 仅作**未复核站点**的兜底:WorkBuddy 桌面端(5.9.3 国内 / 5.9.4 国际)的设备码 +// 三端点实测发的是桌面端 RPC 族 UA,见 Site.UserAgent。 +const ClientUA = "CLI/" + ClientVersion + " CodeBuddy/" + ClientVersion + +// WorkBuddy 桌面端版本与内置 CLI 版本(真机 UA 段)。 +// +// 2026-10-30 拆包:cli/product.json genieVersion / package.json version +// + resources/install-manifest.json appVersion 三处一致。 +// CLI 段恒 2.165.0(cli/package.json 的 @genie/agent-cli),与业务链路同一个值。 +const ( + ClientVersionWorkBuddyCN = "5.9.3" + ClientVersionWorkBuddyGL = "5.9.4" + ClientVersionBuiltinCLI = "2.165.0" +) + +// 站点标识(对外 API 取值)。 +const ( + SiteCN = "cn" // 国内站:API copilot.tencent.com,Origin www.codebuddy.cn + SiteIntl = "intl" // 官方国际站:www.codebuddy.ai(product.json externalDomain) + SiteWorkBuddy = "workbuddy" // 旧桌面端国际版:www.workbuddy.ai +) + +// Realm 取值(池内分域标识,与 auth.Realm() 输出一致)。 +const ( + RealmCN = "cn" + RealmGlobal = "global" +) + +// Site 一个登录站点的全部端点要素。 +type Site struct { + ID string + Realm string // 落盘 realm:cn / global + API string // 上游 API base(三端点同域) + Origin string // Origin/Referer(仅授权页跳转用;设备码三端点**不发**,见 Headers) + // Platform 授权页 platform 口径。官方只对 platform=workbuddy 追加 + // ww_device_nonce(桌面端设备绑定),其余站点只追加 version。 + Platform string + // UserAgent 设备码三端点(auth/state、auth/token、login/account)的 UA。 + // + // 2026-10-30 真机实测:这三条走的是桌面端 **RPC 族** UA,与业务链路同源, + // 不是 `CLI/ CodeBuddy/`: + // + // CN 5.9.3 WorkBuddy/5.9.3 WorkBuddy/5.9.3 CLI/2.165.0 + // GL 5.9.4 workbuddy-ai/5.9.4 workbuddy-ai/5.9.4 CLI/2.165.0 + // + // 空 = 保留 ClientUA(CodeBuddy CLI 家族),仅供未复核的站点兜底。 + UserAgent string + // Domain 设备码端点的 X-Domain 取值(**前端主机名**,不是 API base)。 + // + // 真机 CN 5.9.3:请求打到 copilot.tencent.com,但 `x-domain: www.workbuddy.cn` + // —— 该头声明「哪个前端在调用」,与落到哪台机器无关。 + // 空 = 回落 Origin 的主机名。 + Domain string + // Version 授权链接的 version 参数(官方客户端写自己的包版本)。 + // + // 2026-11-14 真机实测(CN 5.9.3,Chrome 地址栏):官方链接带 `version=5.9.3`, + // 授权页把这个值原样转给 `console/auth/risk-context?platform=workbuddy&version=5.9.3` + // 并编进回调地址——它确实被读取,不是装饰。空 = 不加(未复核站点)。 + Version string +} + +// 官方域表。两个国际站实测是同一后端(2026-10-24:同一 token 打两域, +// /billing/meter/get-user-resource-summary 返回完全相同的 PackageCode 与容量), +// 差别只在主机名与 WAF 口径。 +// +// Platform 是设备授权 `?platform=` 的取值,来自各分发包 `product.json` 的 +// authentication.attributes.platform(**不是** 顶层 platform 字段,那个是 "CLI")。 +// 2026-10-30 真机实测: +// +// CN 5.9.3 POST /v2/plugin/auth/state?platform=workbuddy +// GL 5.9.4 POST /v2/plugin/auth/state?platform=workbuddy-ai +// +// 旧实现一律发 platform=CLI —— 取了顶层字段,两个真机形态都不符。 +var ( + siteCN = Site{ + ID: SiteCN, Realm: RealmCN, + API: "https://copilot.tencent.com", Origin: "https://www.codebuddy.cn", + Platform: "workbuddy", + UserAgent: "WorkBuddy/" + ClientVersionWorkBuddyCN + " WorkBuddy/" + ClientVersionWorkBuddyCN + " CLI/" + ClientVersionBuiltinCLI, + Domain: "www.workbuddy.cn", + Version: ClientVersionWorkBuddyCN, + } + siteIntl = Site{ + ID: SiteIntl, Realm: RealmGlobal, + API: "https://www.codebuddy.ai", Origin: "https://www.codebuddy.ai", + // codebuddy.ai 分发包本轮未抓包,但它是 **同一个** WorkBuddy AI 国际包 + // (product.json externalDomain 首位,platform=workbuddy-ai)。这里沿用 + // workbuddy.ai 站点的真机口径,而不是退回 CodeBuddy CLI 家族: + // 该包 externalDomain 里 codebuddy.ai 与 workbuddy.ai 并列,同一份 auth 属性。 + Platform: "workbuddy-ai", + UserAgent: "workbuddy-ai/" + ClientVersionWorkBuddyGL + " workbuddy-ai/" + ClientVersionWorkBuddyGL + " CLI/" + ClientVersionBuiltinCLI, + Domain: "www.codebuddy.ai", + } + siteWorkBuddy = Site{ + ID: SiteWorkBuddy, Realm: RealmGlobal, + API: "https://www.workbuddy.ai", Origin: "https://www.workbuddy.ai", + Platform: "workbuddy-ai", + UserAgent: "workbuddy-ai/" + ClientVersionWorkBuddyGL + " workbuddy-ai/" + ClientVersionWorkBuddyGL + " CLI/" + ClientVersionBuiltinCLI, + Domain: "www.workbuddy.ai", + } +) + +// For 按站点标识返回站点定义;空/未知 → 国内站(零回归)。 +func For(id string) Site { + switch strings.ToLower(strings.TrimSpace(id)) { + case SiteIntl: + return siteIntl + case SiteWorkBuddy: + return siteWorkBuddy + } + return siteCN +} + +// Default 缺省站点(国内站)。 +func Default() Site { return siteCN } + +// ForRealm 按 realm 映射站点:global → 旧桌面端 workbuddy.ai(历史行为,保证 +// 只传 realm 的老调用方语义不变),cn → 国内站。 +// +// 要官方国际站请显式用 SiteIntl(codebuddy.ai)。 +func ForRealm(realm string) Site { + if strings.TrimSpace(realm) == RealmGlobal { + return siteWorkBuddy + } + return siteCN +} + +// ValidID 报告 id 是否是已知站点标识。 +func ValidID(id string) bool { + switch strings.ToLower(strings.TrimSpace(id)) { + case SiteCN, SiteIntl, SiteWorkBuddy: + return true + } + return false +} + +// Endpoints 返回设备授权三端点(auth/state、token、account)与 Origin。 +// +// `platform` 取站点自己的 Platform(真机 CN=workbuddy / workbuddy.ai=workbuddy-ai), +// 不再硬编码 CLI——见 var 块上方注释。 +func (s Site) Endpoints() (state, token, account, origin string) { + platform := s.Platform + if platform == "" { + platform = "workbuddy" + } + return s.API + "/v2/plugin/auth/state?platform=" + platform, + s.API + "/v2/plugin/auth/token?state=", + s.API + "/v2/plugin/login/account?state=", + s.Origin +} + +// EndpointHeaders 设备码三端点的公共出站头族(真机形态)。 +// +// 2026-10-30 双版本逐头核对,三端点(auth/state、auth/token、login/account)共同拥有: +// +// accept: application/json, text/plain, */* +// user-agent: (RPC 族;空则回落 ClientUA) +// x-product: SaaS +// x-request-id: 32 hex 纯随机(无时间前缀) +// +// **不含 Content-Type**:只有 POST(auth/state)带 `application/json`;两条 GET +// (auth/token、login/account)真机没有该头——GET 无请求体,带上是多余形态。 +// +// 且**不发** Origin / Referer / X-Requested-With —— 旧实现在这里发了三者,等于给 +// 「桌面端 node fetch」盖上一层浏览器痕迹(浏览器同源语义只属于「打开授权页」那一步)。 +// +// 三条端点的**差异**(content-type、x-domain、x-no-* 哨兵、x-device-token)见 +// HeadersForState / HeadersForToken / HeadersForAccount,不要在这里抹平。 +func (s Site) EndpointHeaders() map[string]string { + return map[string]string{ + "Accept": "application/json, text/plain, */*", + "User-Agent": s.userAgent(), + "X-Product": "SaaS", + // X-Request-ID:真机三端点恒带(每条一个,纯随机 32 hex,无毫秒前缀)。 + "X-Request-ID": newTraceID(), + } +} + +// newTraceID 生成 32 hex 纯随机请求 ID(真机 X-Request-ID 形态:无毫秒前缀)。 +// +// 不复用 internal/session.NewTraceID 是刻意的:那会把 redisstore 整条依赖链拉进 +// loginsite(登录站表只需要一个随机串,不该背着会话存储)。熵源故障时回落时间派生, +// 仍恒 32 hex,不 panic、不空串。 +func newTraceID() string { + var b [16]byte + if _, err := cryptorand.Read(b[:]); err != nil { + ms := time.Now().UnixMilli() + return fmt.Sprintf("%012x%020x", ms, uint64(ms)) + } + return hex.EncodeToString(b[:]) +} + +// userAgent 站点 UA:真机口径优先,未复核站点回落 ClientUA。 +func (s Site) userAgent() string { + if s.UserAgent != "" { + return s.UserAgent + } + return ClientUA +} + +// host 设备码端点的 X-Domain 取值:站点显式 Domain 优先,否则回落 Origin 主机名。 +// +// **不是 API base 的主机名**:真机 CN auth/state 的 `x-domain: www.workbuddy.cn`, +// 而该请求实际打到 copilot.tencent.com —— 该头声明「哪个前端在调用」,与落到哪台 +// 机器无关。2026-10-30 实测:CN 5.9.3 → www.workbuddy.cn;GL 5.9.4 → www.workbuddy.ai。 +func (s Site) host() string { + if s.Domain != "" { + return s.Domain + } + h := strings.TrimPrefix(strings.TrimPrefix(s.Origin, "https://"), "http://") + return strings.TrimSuffix(h, "/") +} + +// sentinelNo 未鉴权/未落库端点的 x-no-* 哨兵头。 +// +// 真机值是字符串 "true"(不是 "1");auth/state 与 auth/token 四个全发, +// login/account 只发后三个(它已带 Bearer,唯一缺的是「账号信息还没落库」)。 +func sentinelNo(noAuth bool) map[string]string { + out := map[string]string{ + "X-No-User-Id": "true", + "X-No-Enterprise-Id": "true", + "X-No-Department-Info": "true", + } + if noAuth { + out["X-No-Authorization"] = "true" + } + return out +} + +// HeadersForState POST /v2/plugin/auth/state 的出站头。 +// +// 真机(CN 5.9.3 / GL 5.9.4 同形): +// +// 公共头 + x-domain + 四个 x-no-* + x-custom-channel-id: unknown +// + x-device-token(取到才发;空则不发,不伪造) +func (s Site) HeadersForState(deviceToken string) map[string]string { + h := s.EndpointHeaders() + // 只有 POST 带 Content-Type(真机两条 GET 都没有)。 + h["Content-Type"] = "application/json" + h["X-Domain"] = s.host() + // x-custom-channel-id 真机恒为字面量 "unknown"(渠道号未知的分发包)。 + h["X-Custom-Channel-Id"] = "unknown" + for k, v := range sentinelNo(true) { + h[k] = v + } + if deviceToken != "" { + h["X-Device-Token"] = deviceToken + } + return h +} + +// HeadersForToken GET /v2/plugin/auth/token 的出站头。 +// +// 真机**没有 x-domain**(与 state / account 不同,这是唯一缺它的端点): +// 公共头 + 四个 x-no-*,无 x-device-token、无 x-custom-channel-id。 +func (s Site) HeadersForToken() map[string]string { + h := s.EndpointHeaders() + for k, v := range sentinelNo(true) { + h[k] = v + } + return h +} + +// HeadersForAccount GET /v2/plugin/login/account 的出站头。 +// +// 真机:公共头 + x-domain + Authorization + 三个 x-no-*(**无** x-no-authorization, +// 但仍有 x-no-user-id —— token 已发、uid 还没落库,这正是该端点的语义)。 +func (s Site) HeadersForAccount(accessToken string) map[string]string { + h := s.EndpointHeaders() + h["X-Domain"] = s.host() + for k, v := range sentinelNo(false) { + h[k] = v + } + if accessToken != "" { + h["Authorization"] = "Bearer " + accessToken + } + return h +} + +// 官方 global 域主机(按 auth 文件 domain 选用,不按 realm 猜)。 +const ( + BaseOfficial = "https://www.codebuddy.ai" // 官方国际站 + BaseWorkBuddy = "https://www.workbuddy.ai" // 旧桌面端国际版 +) + +// BaseForDomain 按 auth 文件的 domain 返回 global 域上游 base: +// +// *.codebuddy.ai → BaseOfficial +// *.workbuddy.ai → BaseWorkBuddy +// 其它/空 → ""(调用方回落配置或默认值,不猜域) +// +// 国际域两套主机名并存(老账号 workbuddy.ai、官方 CLI 新登录 codebuddy.ai), +// 用 realm 决定 base 必然把一半账号打到非其签发域。 +func BaseForDomain(domain string) string { + d := strings.ToLower(strings.TrimSpace(domain)) + switch { + case d == "codebuddy.ai" || strings.HasSuffix(d, ".codebuddy.ai"): + return BaseOfficial + case d == "workbuddy.ai" || strings.HasSuffix(d, ".workbuddy.ai"): + return BaseWorkBuddy + } + return "" +} + +// 官方登录业务码(CLI auth 模块枚举)。语义分两类,混为一谈会让用户在本该立刻 +// 报错的场景白等满 TTL: +// +// 11217 RetryFetchToken / 12151 RetryFetchAccount → 还没登完,继续轮询 +// 12005 LicenseSeatLimit / 11212 LicenseExpired / 11216 TrialExpired → 终态 +const ( + CodeRetryFetchToken = 11217 + CodeRetryFetchAccount = 12151 + CodeLicenseSeatLimit = 12005 + CodeLicenseExpired = 11212 + CodeTrialExpired = 11216 +) + +// CodePending 报告该业务码是否表示「登录进行中,应继续轮询」。 +func CodePending(code int) bool { + return code == CodeRetryFetchToken || code == CodeRetryFetchAccount +} + +// CodeFatal 报告该业务码是否属于官方定义的终态许可错误(SignLicenseError): +// 官方对这三类直接把上游 msg 抛给用户并结束登录,不再轮询。 +func CodeFatal(code int) bool { + switch code { + case CodeLicenseSeatLimit, CodeLicenseExpired, CodeTrialExpired: + return true + } + return false +} + +// DecorateAuthURL 按真机实测补齐授权链接参数(对应官方的 appendHostLoginJourneyParams / +// appendAuthUrlParams / appendLoginPageHintParams): +// +// version= 官方写自己的包版本;CN 授权页会把它转给 +// console/auth/risk-context 并编进回调地址 +// loginSessionId= 官方客户端本地生成的登录会话标识;授权页从 URL 读它, +// 并原样带进 signin-callback +// ww_device_nonce= 官方仅 platform=workbuddy 且拿到设备 nonce 时加 +// +// 2026-11-14 对 CN 5.9.3 的真机链接实测(Chrome 地址栏原文,state/nonce 已脱敏): +// +// /login?platform=workbuddy&state=…&version=5.9.3&loginSessionId= +// &traceparent=00-…-…-01&login_owner_id=&ww_device_nonce= +// +// traceparent / login_owner_id 是客户端自己的链路与宿主标识,本仓没有等价物, +// 不伪造(错值比缺值更容易被判异常)。旧的「不发 version」判断来自 workbuddy.ai +// 的 bundle(那份确实没读),CN 这份读了——所以只有配了 Version 的站点才加。 +// +// 本仓没有桌面端 Turing 设备 SDK,nonce 只能由部署侧提供;为空则不加。 +// raw 解析失败时原样返回。 +func DecorateAuthURL(raw string, s Site, nonce, sessionID string) string { + u, err := url.Parse(raw) + if err != nil { + return raw + } + q := u.Query() + if s.Version != "" && q.Get("version") == "" { + q.Set("version", s.Version) + } + if sessionID != "" && q.Get("loginSessionId") == "" { + q.Set("loginSessionId", sessionID) + } + if s.Platform == "workbuddy" && nonce != "" && q.Get("ww_device_nonce") == "" { + q.Set("ww_device_nonce", nonce) + } + u.RawQuery = q.Encode() + return u.String() +} + +// NewLoginSessionID 生成 uuid v4 形态的登录会话标识。 +// +// 官方由客户端本地生成、只做透传(授权页读它再编进回调),不是服务端签发的凭证, +// 所以本地随机即可;用 v4 形状只是为了与真机同一形态。 +func NewLoginSessionID() string { + var b [16]byte + if _, err := cryptorand.Read(b[:]); err != nil { + return "" + } + b[6] = b[6]&0x0f | 0x40 // version 4 + b[8] = b[8]&0x3f | 0x80 // variant 10 + return fmt.Sprintf("%x-%x-%x-%x-%x", b[0:4], b[4:6], b[6:8], b[8:10], b[10:16]) +} diff --git a/internal/loginsite/loginsite_test.go b/internal/loginsite/loginsite_test.go new file mode 100644 index 0000000000000000000000000000000000000000..bde0d39323462d857fa8d092fa052d8b335e657d --- /dev/null +++ b/internal/loginsite/loginsite_test.go @@ -0,0 +1,360 @@ +package loginsite + +import ( + "net/url" + "regexp" + "testing" +) + +// TestFor 覆盖站点归一化:已知 id 精确命中,空/未知回落国内站(老调用零回归)。 +func TestFor(t *testing.T) { + cases := []struct { + id string + wantID string + wantRealm string + wantAPI string + }{ + {id: "", wantID: SiteCN, wantRealm: RealmCN, wantAPI: "https://copilot.tencent.com"}, + {id: "cn", wantID: SiteCN, wantRealm: RealmCN, wantAPI: "https://copilot.tencent.com"}, + {id: "CN", wantID: SiteCN, wantRealm: RealmCN, wantAPI: "https://copilot.tencent.com"}, + {id: "intl", wantID: SiteIntl, wantRealm: RealmGlobal, wantAPI: "https://www.codebuddy.ai"}, + {id: "workbuddy", wantID: SiteWorkBuddy, wantRealm: RealmGlobal, wantAPI: "https://www.workbuddy.ai"}, + // 未知值不猜域,回落国内站。 + {id: "global", wantID: SiteCN, wantRealm: RealmCN, wantAPI: "https://copilot.tencent.com"}, + {id: "codebuddy.ai", wantID: SiteCN, wantRealm: RealmCN, wantAPI: "https://copilot.tencent.com"}, + } + for _, c := range cases { + s := For(c.id) + if s.ID != c.wantID || s.Realm != c.wantRealm || s.API != c.wantAPI { + t.Errorf("For(%q)={id:%s realm:%s api:%s} want {id:%s realm:%s api:%s}", + c.id, s.ID, s.Realm, s.API, c.wantID, c.wantRealm, c.wantAPI) + } + } +} + +// TestForRealm 覆盖 realm → 站点映射:global 保持历史语义(旧桌面端 workbuddy.ai), +// 官方国际站必须显式 SiteIntl——这是「老脚本零回归 + 新站点可选中」的分界。 +func TestForRealm(t *testing.T) { + cases := []struct { + realm string + wantID string + wantAPI string + }{ + {realm: "", wantID: SiteCN, wantAPI: "https://copilot.tencent.com"}, + {realm: "cn", wantID: SiteCN, wantAPI: "https://copilot.tencent.com"}, + {realm: "global", wantID: SiteWorkBuddy, wantAPI: "https://www.workbuddy.ai"}, + {realm: "GLOBAL", wantID: SiteCN, wantAPI: "https://copilot.tencent.com"}, // 大小写不敏感未覆盖:按未知回落 + } + for _, c := range cases { + s := ForRealm(c.realm) + if s.ID != c.wantID || s.API != c.wantAPI { + t.Errorf("ForRealm(%q)={id:%s api:%s} want {id:%s api:%s}", c.realm, s.ID, s.API, c.wantID, c.wantAPI) + } + } +} + +// TestEndpoints 覆盖三端点拼接:必须同域且 platform 取站点自己的值。 +// Origin 与 API 同域是国际站的约束(跨域 Origin 会被上游按非法请求拒绝); +// 国内站是**已知例外**——API 在 copilot.tencent.com、Origin 在 www.codebuddy.cn +// (与官方客户端一致)。 +// +// platform 取值来自各分发包 product.json 的 authentication.attributes.platform: +// CN=workbuddy(真机实测)、workbuddy.ai=workbuddy-ai(真机实测)、codebuddy.ai=CLI。 +func TestEndpoints(t *testing.T) { + for _, id := range []string{SiteCN, SiteIntl, SiteWorkBuddy} { + s := For(id) + state, token, account, origin := s.Endpoints() + if want := s.API + "/v2/plugin/auth/state?platform=" + s.Platform; state != want { + t.Errorf("%s state=%q want %q", id, state, want) + } + if want := s.API + "/v2/plugin/auth/token?state="; token != want { + t.Errorf("%s token=%q want %q", id, token, want) + } + if want := s.API + "/v2/plugin/login/account?state="; account != want { + t.Errorf("%s account=%q want %q", id, account, want) + } + apiHost := mustHost(t, s.API) + originHost := mustHost(t, origin) + if id == SiteCN { + // 国内站跨域是既定形态,锁死具体值防被「统一同域」误改。 + if apiHost != "copilot.tencent.com" || originHost != "www.codebuddy.cn" { + t.Errorf("cn 站点域被改动:api=%s origin=%s", apiHost, originHost) + } + continue + } + if apiHost != originHost { + t.Errorf("%s Origin 与 API 不同域:api=%s origin=%s", id, apiHost, originHost) + } + } +} + +func mustHost(t *testing.T, raw string) string { + t.Helper() + u, err := url.Parse(raw) + if err != nil { + t.Fatalf("parse %q: %v", raw, err) + } + return u.Host +} + +// TestCodeSemantics 覆盖官方登录码分类:只有 11217/12151 是 pending, +// 12005/11212/11216 是终态。混类会让「席位满」白等满 TTL 才报超时。 +func TestCodeSemantics(t *testing.T) { + pending := []int{CodeRetryFetchToken, CodeRetryFetchAccount} + for _, c := range pending { + if !CodePending(c) { + t.Errorf("CodePending(%d)=false want true", c) + } + if CodeFatal(c) { + t.Errorf("CodeFatal(%d)=true want false(pending 不是终态)", c) + } + } + fatal := []int{CodeLicenseSeatLimit, CodeLicenseExpired, CodeTrialExpired} + for _, c := range fatal { + if !CodeFatal(c) { + t.Errorf("CodeFatal(%d)=false want true", c) + } + if CodePending(c) { + t.Errorf("CodePending(%d)=true want false(终态不该继续轮询)", c) + } + } + // 其它码两类都不属(调用方按「可重试错误」处理)。 + for _, c := range []int{0, 10001, 11102, 14051, 99999} { + if CodePending(c) || CodeFatal(c) { + t.Errorf("code %d 不该被归入 pending 或 fatal", c) + } + } +} + +// TestDecorateAuthURL 覆盖授权链接参数补齐(对齐官方 appendHostLoginJourneyParams / +// appendAuthUrlParams): +// +// - version:只有配了 Site.Version 的站点(目前 CN)才补——2026-11-14 实测 CN 授权页 +// 会读它并转给 console/auth/risk-context;workbuddy.ai 那份 bundle 不读,故不补。 +// - loginSessionId:调用方给了就补(官方便是客户端本地生成后透传)。 +// - ww_device_nonce:只对 platform=workbuddy 的站点且 nonce 非空时补。 +func TestDecorateAuthURL(t *testing.T) { + const base = "https://example.com/login?platform=CLI&state=abc" + const sid = "caf6af35-8aa2-4037-89e8-c8a70ffbda5a" + + // CN 补 version 与 loginSessionId;原有参数一律不动。 + got := DecorateAuthURL(base, For(SiteCN), "", sid) + if !containsParam(t, got, "version", ClientVersionWorkBuddyCN) { + t.Errorf("cn 站未补 version: %s", got) + } + if !containsParam(t, got, "loginSessionId", sid) { + t.Errorf("cn 站未补 loginSessionId: %s", got) + } + // 未配 Version 的站点不补 version(不拿错版本冒充)。 + for _, id := range []string{SiteIntl, SiteWorkBuddy} { + got := DecorateAuthURL(base, For(id), "", sid) + u, err := url.Parse(got) + if err != nil { + t.Fatalf("%s: parse %q: %v", id, got, err) + } + if v := u.Query().Get("version"); v != "" { + t.Errorf("%s 不该补 version,得到 %q", id, v) + } + if !containsParam(t, got, "loginSessionId", sid) { + t.Errorf("%s 未补 loginSessionId: %s", id, got) + } + if s := u.Query().Get("state"); s != "abc" { + t.Errorf("%s state=%q want abc(原有参数被破坏)", id, s) + } + if p := u.Query().Get("platform"); p != "CLI" { + t.Errorf("%s platform=%q want CLI(授权 URL 自带参数不得被改)", id, p) + } + } + + // platform=workbuddy 的站点(= 国内桌面端)带 nonce。 + if got := DecorateAuthURL(base, For(SiteCN), "nonce-1", ""); !containsParam(t, got, "ww_device_nonce", "nonce-1") { + t.Errorf("cn 站(platform=workbuddy)未补 ww_device_nonce: %s", got) + } + for _, id := range []string{SiteIntl, SiteWorkBuddy} { + if got := DecorateAuthURL(base, For(id), "nonce-1", ""); containsParam(t, got, "ww_device_nonce", "") { + t.Errorf("%s 站不该补 ww_device_nonce: %s", id, got) + } + } + // nonce 为空时一律不补(不伪造设备指纹)。 + if got := DecorateAuthURL(base, For(SiteCN), "", ""); containsParam(t, got, "ww_device_nonce", "") { + t.Errorf("nonce 为空时不该补 ww_device_nonce: %s", got) + } + + // 上游已带的值不覆盖(尊重上游口径)。 + if got := DecorateAuthURL(base+"&version=9.9.9&loginSessionId=up", For(SiteCN), "", sid); !containsParam(t, got, "version", "9.9.9") || !containsParam(t, got, "loginSessionId", "up") { + t.Errorf("已有参数被覆盖: %s", got) + } + + // 非法 URL 原样返回(不阻断登录)。 + if got := DecorateAuthURL("://bad", For(SiteCN), "", sid); got != "://bad" { + t.Errorf("非法 URL 未原样返回: %q", got) + } +} + +// NewLoginSessionID 必须是 uuid v4 形态且每次不同(授权页会原样透传进回调地址)。 +func TestNewLoginSessionID(t *testing.T) { + a, b := NewLoginSessionID(), NewLoginSessionID() + if a == "" || a == b { + t.Fatalf("loginSessionId 应非空且每次不同: %q / %q", a, b) + } + if !regexp.MustCompile(`^[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$`).MatchString(a) { + t.Fatalf("不是 uuid v4 形态: %q", a) + } +} + +func containsParam(t *testing.T, raw, key, want string) bool { + t.Helper() + u, err := url.Parse(raw) + if err != nil { + t.Fatalf("parse %q: %v", raw, err) + } + v, ok := u.Query()[key] + if want == "" { + return ok + } + return ok && len(v) == 1 && v[0] == want +} + +// TestBaseForDomain 覆盖按 auth 文件 domain 选上游 base:国际域两套主机名并存, +// 用 realm 决定 base 会把一半账号打到非签发域。 +func TestBaseForDomain(t *testing.T) { + cases := []struct { + domain string + want string + }{ + {domain: "www.codebuddy.ai", want: BaseOfficial}, + {domain: "codebuddy.ai", want: BaseOfficial}, + {domain: "api.codebuddy.ai", want: BaseOfficial}, + {domain: "www.workbuddy.ai", want: BaseWorkBuddy}, + {domain: "workbuddy.ai", want: BaseWorkBuddy}, + {domain: "WWW.CODEBUDDY.AI", want: BaseOfficial}, // 大小写不敏感 + {domain: " www.codebuddy.ai ", want: BaseOfficial}, + // 国内域/空/非法 → 空串(调用方回落配置或默认,不猜域)。 + {domain: "", want: ""}, + {domain: "www.codebuddy.cn", want: ""}, + {domain: "copilot.tencent.com", want: ""}, + {domain: "evil-codebuddy.ai", want: ""}, // 后缀匹配不能误吞 + } + for _, c := range cases { + if got := BaseForDomain(c.domain); got != c.want { + t.Errorf("BaseForDomain(%q)=%q want %q", c.domain, got, c.want) + } + } +} + +// TestValidID 覆盖站点标识校验(CLI flag 解析用)。 +func TestValidID(t *testing.T) { + for _, ok := range []string{"cn", "intl", "workbuddy", "CN", " Intl "} { + if !ValidID(ok) { + t.Errorf("ValidID(%q)=false want true", ok) + } + } + for _, bad := range []string{"", "global", "codebuddy", "www.codebuddy.ai"} { + if ValidID(bad) { + t.Errorf("ValidID(%q)=true want false", bad) + } + } +} + +// TestClientUA 覆盖 UA 与 version 同源(升级版本号时两处不能漂移)。 +func TestClientUA(t *testing.T) { + want := "CLI/" + ClientVersion + " CodeBuddy/" + ClientVersion + if ClientUA != want { + t.Errorf("ClientUA=%q want %q", ClientUA, want) + } +} + +// TestEndpointHeaders 设备码三端点的出站头族必须与真机一致: +// 桌面端 RPC 族 UA、宽松 Accept、X-Product,且**不含**浏览器痕迹。 +// +// 2026-10-30 双版本抓包:auth/state、auth/token、login/account 三条由桌面端 +// node fetch 发出,逐条确认无 Origin / Referer / X-Requested-With; +// UA 是 WorkBuddy 桌面端 RPC 族,不是 `CLI/ CodeBuddy/`。 +// +// 三条端点的差异(x-domain / x-no-* / x-device-token / Bearer)见下面各自的子测试。 +func TestEndpointHeaders(t *testing.T) { + wantGLUA := "workbuddy-ai/" + ClientVersionWorkBuddyGL + " workbuddy-ai/" + ClientVersionWorkBuddyGL + " CLI/" + ClientVersionBuiltinCLI + wantCNUA := "WorkBuddy/" + ClientVersionWorkBuddyCN + " WorkBuddy/" + ClientVersionWorkBuddyCN + " CLI/" + ClientVersionBuiltinCLI + + cases := []struct { + site Site + wantUA string + }{ + {For(SiteCN), wantCNUA}, + {For(SiteIntl), wantGLUA}, + {For(SiteWorkBuddy), wantGLUA}, + } + for _, c := range cases { + h := c.site.EndpointHeaders() + if got := h["User-Agent"]; got != c.wantUA { + t.Errorf("%s User-Agent=%q want %q", c.site.ID, got, c.wantUA) + } + if got := h["X-Product"]; got != "SaaS" { + t.Errorf("%s X-Product=%q want SaaS", c.site.ID, got) + } + if got := h["Accept"]; got != "application/json, text/plain, */*" { + t.Errorf("%s Accept=%q want 宽松值", c.site.ID, got) + } + if got := h["X-Request-ID"]; len(got) != 32 { + t.Errorf("%s X-Request-ID=%q want 32 hex", c.site.ID, got) + } + for _, k := range []string{"Origin", "Referer", "X-Requested-With"} { + if v, ok := h[k]; ok { + t.Errorf("%s 不应出现 %s=%q(真机 node fetch 无此头)", c.site.ID, k, v) + } + } + } +} + +// TestLoginEndpointHeaderVariants 三条端点的差异头(真机逐条核对)。 +// +// auth/state x-domain + 4 个 x-no-* + x-custom-channel-id + x-device-token +// auth/token 4 个 x-no-*(**唯一没有 x-domain 的端点**) +// login/account x-domain + Bearer + 3 个 x-no-*(无 x-no-authorization) +func TestLoginEndpointHeaderVariants(t *testing.T) { + s := For(SiteCN) + + st := s.HeadersForState("v3:abc") + for _, k := range []string{"X-Domain", "X-No-Authorization", "X-No-User-Id", + "X-No-Enterprise-Id", "X-No-Department-Info", "X-Custom-Channel-Id", "X-Device-Token"} { + if st[k] == "" { + t.Errorf("auth/state 缺 %s", k) + } + } + if got := st["X-Domain"]; got != "www.workbuddy.cn" { + t.Errorf("auth/state X-Domain=%q want www.workbuddy.cn(前端主机名,非 API base)", got) + } + // 设备 token 取不到时**不发**该头(不伪造)。 + if got := s.HeadersForState("")["X-Device-Token"]; got != "" { + t.Errorf("无设备 token 时不应发 X-Device-Token,实际 %q", got) + } + + tk := s.HeadersForToken() + if got := tk["X-Domain"]; got != "" { + t.Errorf("auth/token 真机无 X-Domain,实际 %q", got) + } + for _, k := range []string{"X-No-Authorization", "X-No-User-Id", "X-No-Enterprise-Id", "X-No-Department-Info"} { + if tk[k] != "true" { + t.Errorf("auth/token %s=%q want true", k, tk[k]) + } + } + if tk["X-Device-Token"] != "" || tk["X-Custom-Channel-Id"] != "" { + t.Errorf("auth/token 不应带设备头: %v", tk) + } + + ac := s.HeadersForAccount("AT") + if got := ac["Authorization"]; got != "Bearer AT" { + t.Errorf("login/account Authorization=%q want Bearer AT", got) + } + if got := ac["X-Domain"]; got != "www.workbuddy.cn" { + t.Errorf("login/account X-Domain=%q want www.workbuddy.cn", got) + } + if ac["X-No-Authorization"] != "" { + t.Errorf("login/account 已带 Bearer,不应发 X-No-Authorization") + } + for _, k := range []string{"X-No-User-Id", "X-No-Enterprise-Id", "X-No-Department-Info"} { + if ac[k] != "true" { + t.Errorf("login/account %s=%q want true", k, ac[k]) + } + } +} diff --git a/internal/media/strip.go b/internal/media/strip.go new file mode 100644 index 0000000000000000000000000000000000000000..8478ddf2549122a62f540fcde6a03c9e93a09de6 --- /dev/null +++ b/internal/media/strip.go @@ -0,0 +1,326 @@ +// Package media 对上游产出的图片做本地后处理。 +// +// 目前只有一件事:裁掉右下角水印。WorkBuddy / 混元生图会在成品右下角印一行 +// 「AI生成 / WORKBUDD>.」的半透明白字(2026-11 实测:固定贴右边、下边各约 10px, +// 高度 51px(1024~1536 边长档)到约 80px(1344x1792 档))。因此只要图片底部真有 +// 一条留白,把这条留白整条裁掉,水印必然一起消失——不需要识别水印形状,也不需要 +// 知道它的确切尺寸。 +// +// 为什么判定条件要求「行标准差小 **而且** 接近纯白」:整幅竖向渐变(天空、墙面、 +// 纯色背景)的每一行标准差同样很小,只看标准差会把正常画面当留白裁掉。加上亮度 +// 下限,才能把「作者有意留的白边」和「画面本身很平」分开。这也正是提示词里要写 +// 「下方三分之一纯白留白」的原因:模型给得出 25~38% 的真白边时这条链路才成立。 +package media + +import ( + "bytes" + "errors" + "fmt" + "image" + "image/draw" + "image/jpeg" + "image/png" + "math" +) + +const ( + // DefaultMinBlank 判定为「可裁留白」的最小高度(像素)。 + // 水印最高约 80px + 下边距 10px,所以从 90px 起步:比这更矮的留白裁不干净。 + DefaultMinBlank = 90 + // DefaultWhiteLum 留白区平均亮度下限(0-255)。实测白边 253~255,留 5 点余量。 + DefaultWhiteLum = 248.0 + // DefaultJPEGQuality opts.Quality 为 0 时的 JPEG 质量。 + DefaultJPEGQuality = 92 + // MaxPixels 单张图的像素上限,防解码炸内存(1 亿像素解码后约 400MB)。 + MaxPixels = 100_000_000 + // rowStdThreshold 判「这一行有内容」的行标准差阈值(0-255 亮度)。 + // 实测纯白留白区的行标准差 0.1~0.7,画面内容行普遍 > 2。 + rowStdThreshold = 2.0 +) + +// ErrNotImage 输入不是本包能解的图片(只支持 PNG / JPEG)。 +var ErrNotImage = errors.New("不支持的图片格式:只认 PNG / JPEG") + +// ErrTooLarge 图片像素数超过 MaxPixels。 +var ErrTooLarge = errors.New("图片过大:超过像素上限") + +// ErrUniform 整张图都是同一颜色(没有可裁的内容边界)。 +var ErrUniform = errors.New("整张图都是纯色,没有可裁的内容边界") + +// NoBlankError 底部没有足够的纯白留白,裁了会切到画面。 +// +// 带上 Result 是为了让调用方拿到实测数字(底部到底有多少像素、亮度多少), +// 好据此决定是重画、还是先让 edit 模型把下方涂白。 +type NoBlankError struct { + Result Result +} + +func (e *NoBlankError) Error() string { + return fmt.Sprintf("底部留白不足:只有 %dpx(需 ≥%dpx,且平均亮度 ≥%.0f),裁掉会切到画面", + e.Result.BlankPx, e.Result.MinBlank, e.Result.WhiteLum) +} + +// Options 裁切参数。零值即默认(90px 留白断言 + 纯白判定 + 跟随输入格式)。 +type Options struct { + MinBlank int // <=0 用 DefaultMinBlank + WhiteLum float64 // <=0 用 DefaultWhiteLum + KeepBlank int // 裁完在内容下方保留的留白像素(>=0) + Format string // "" = 跟随输入;"png" / "jpeg" + Quality int // JPEG 质量 1-100;<=0 用 DefaultJPEGQuality +} + +// Result 一次裁切的结果(无论成功失败都会填好数字)。 +type Result struct { + Width int `json:"width"` + Height int `json:"height"` + OutWidth int `json:"out_width"` + OutHeight int `json:"out_height"` + Boundary int `json:"boundary"` // 裁切线:保留 [0,boundary) 行 + BlankPx int `json:"blank_px"` // 底部纯白留白高度 + BlankRatio float64 `json:"blank_ratio"` // 留白占原图高度比例 + BlankLum float64 `json:"blank_lum"` // 留白区平均亮度 + MinBlank int `json:"min_blank"` + WhiteLum float64 `json:"white_lum"` + Safe bool `json:"safe"` // 是否判定为可安全裁切 + Format string `json:"format"` // 输出格式 png/jpeg + Data []byte `json:"-"` // 裁好的图片字节(失败时为空) +} + +// Strip 裁掉图片底部的纯白留白。 +// +// 返回的 Result 无论 err 是否为 nil 都带实测数字;err 为 *NoBlankError 时说明底部 +// 留白不够(此时 Result.Data 为空,调用方应让用户先补白边再裁)。 +func Strip(raw []byte, opts Options) (Result, error) { + if opts.MinBlank <= 0 { + opts.MinBlank = DefaultMinBlank + } + if opts.WhiteLum <= 0 { + opts.WhiteLum = DefaultWhiteLum + } + if opts.KeepBlank < 0 { + opts.KeepBlank = 0 + } + if opts.Quality <= 0 { + opts.Quality = DefaultJPEGQuality + } + + // 先只读文件头拿尺寸、查像素上限,再完整解码:解码按声明的尺寸一次分配像素缓冲, + // 几十 KB 的高压缩 PNG 就能声明上亿像素,上限放在解码之后拦不住这次分配。 + cfg, _, err := image.DecodeConfig(bytes.NewReader(raw)) + if err != nil { + return Result{}, fmt.Errorf("%w: %v", ErrNotImage, err) + } + if cfg.Width <= 0 || cfg.Height <= 0 { + return Result{}, fmt.Errorf("%w: 尺寸为 0", ErrNotImage) + } + if int64(cfg.Width)*int64(cfg.Height) > MaxPixels { + return Result{}, ErrTooLarge + } + img, inFormat, err := image.Decode(bytes.NewReader(raw)) + if err != nil { + return Result{}, fmt.Errorf("%w: %v", ErrNotImage, err) + } + b := img.Bounds() + w, h := b.Dx(), b.Dy() + + res := Result{ + Width: w, Height: h, MinBlank: opts.MinBlank, WhiteLum: opts.WhiteLum, + Format: chooseFormat(opts.Format, inFormat), + } + + stats := rowStats(img) + // boundary 取「最下面一行有内容」的下方一行:0 表示整张图没有任何内容边界 + // (纯色/纯渐变),h 表示内容顶到底、没有留白。 + boundary := 0 + for y := h - 1; y >= 0; y-- { + if stats[y].std >= rowStdThreshold { + boundary = y + 1 + break + } + } + if boundary == 0 { + return res, ErrUniform + } + blank := h - boundary + res.Boundary = boundary + res.BlankPx = blank + res.BlankRatio = float64(blank) / float64(h) + if blank > 0 { + res.BlankLum = meanLumOverStats(stats[boundary:]) + } else { + res.BlankLum = meanLumOverStats(stats) + } + + safe := blank >= opts.MinBlank && res.BlankLum >= opts.WhiteLum + res.Safe = safe + if !safe { + return res, &NoBlankError{Result: res} + } + + keep := opts.KeepBlank + cropH := boundary + keep + if cropH > h { + cropH = h + } + if cropH < 1 { + cropH = 1 + } + cropped := cropImage(img, image.Rect(b.Min.X, b.Min.Y, b.Min.X+w, b.Min.Y+cropH)) + out, err := encode(cropped, res.Format, opts.Quality) + if err != nil { + return res, err + } + res.Data = out + res.OutWidth = w + res.OutHeight = cropH + return res, nil +} + +// rowStat 一行亮度统计。 +type rowStat struct { + mean float64 + std float64 +} + +// rowStats 逐行算亮度均值与标准差。带 stdlib 常见图像类型的快路径 +// (JPEG 解出来是 *image.YCbCr,直接读 Y 平面,不逐像素转颜色)。 +func rowStats(img image.Image) []rowStat { + b := img.Bounds() + w, h := b.Dx(), b.Dy() + out := make([]rowStat, h) + + switch m := img.(type) { + case *image.Gray: + for y := 0; y < h; y++ { + off := (y+b.Min.Y-m.Rect.Min.Y)*m.Stride + (b.Min.X - m.Rect.Min.X) + out[y] = statsFromBytes(m.Pix[off : off+w]) + } + return out + case *image.YCbCr: + for y := 0; y < h; y++ { + off := m.YOffset(b.Min.X, b.Min.Y+y) + out[y] = statsFromBytes(m.Y[off : off+w]) + } + return out + case *image.NRGBA: + for y := 0; y < h; y++ { + off := (y+b.Min.Y-m.Rect.Min.Y)*m.Stride + (b.Min.X-m.Rect.Min.X)*4 + out[y] = statsRGB(m.Pix[off : off+w*4]) + } + return out + case *image.RGBA: + for y := 0; y < h; y++ { + off := (y+b.Min.Y-m.Rect.Min.Y)*m.Stride + (b.Min.X-m.Rect.Min.X)*4 + out[y] = statsRGB(m.Pix[off : off+w*4]) + } + return out + } + + // 通用路径:逐像素取灰度(慢,但不是主路径)。 + for y := 0; y < h; y++ { + var sum, sumSq float64 + for x := 0; x < w; x++ { + lum := float64(grayAt(img, b.Min.X+x, b.Min.Y+y)) + sum += lum + sumSq += lum * lum + } + out[y] = finishRow(sum, sumSq, w) + } + return out +} + +// statsFromBytes 单通道(灰度 / Y 平面)行的统计。 +func statsFromBytes(pix []byte) rowStat { + var sum, sumSq float64 + for _, v := range pix { + lum := float64(v) + sum += lum + sumSq += lum * lum + } + return finishRow(sum, sumSq, len(pix)) +} + +// statsRGB 4 字节/像素(RGBA 或 NRGBA)行的统计,按 ITU-R BT.601 亮度。 +func statsRGB(pix []byte) rowStat { + var sum, sumSq float64 + n := len(pix) / 4 + for i := 0; i < n; i++ { + j := i * 4 + lum := 0.299*float64(pix[j]) + 0.587*float64(pix[j+1]) + 0.114*float64(pix[j+2]) + sum += lum + sumSq += lum * lum + } + return finishRow(sum, sumSq, n) +} + +func finishRow(sum, sumSq float64, n int) rowStat { + if n <= 0 { + return rowStat{} + } + mean := sum / float64(n) + variance := sumSq/float64(n) - mean*mean + if variance < 0 { // 浮点误差,别让 NaN 传下去 + variance = 0 + } + return rowStat{mean: mean, std: math.Sqrt(variance)} +} + +// grayAt 通用路径取一点灰度。 +func grayAt(img image.Image, x, y int) uint8 { + r, g, b, _ := img.At(x, y).RGBA() // 16-bit + return uint8((0.299*float64(r) + 0.587*float64(g) + 0.114*float64(b)) / 257.0) +} + +func meanLumOverStats(rows []rowStat) float64 { + if len(rows) == 0 { + return 0 + } + var sum float64 + for _, r := range rows { + sum += r.mean + } + return sum / float64(len(rows)) +} + +// cropImage 裁出 r 区域(统一到 RGBA,保证编码器走的都是快路径)。 +func cropImage(img image.Image, r image.Rectangle) image.Image { + dst := image.NewRGBA(image.Rect(0, 0, r.Dx(), r.Dy())) + draw.Draw(dst, dst.Bounds(), img, r.Min, draw.Src) + return dst +} + +func chooseFormat(want, in string) string { + format := want + if format == "" { + format = in // image.Decode 回报的格式名(png / jpeg) + } + if format == "jpg" { + format = "jpeg" + } + if format != "png" && format != "jpeg" { + format = "png" + } + return format +} + +func encode(img image.Image, format string, quality int) ([]byte, error) { + var buf bytes.Buffer + switch format { + case "jpeg": + if quality < 1 { + quality = 1 + } + if quality > 100 { + quality = 100 + } + if err := jpeg.Encode(&buf, img, &jpeg.Options{Quality: quality}); err != nil { + return nil, err + } + default: + enc := png.Encoder{CompressionLevel: png.BestSpeed} + if err := enc.Encode(&buf, img); err != nil { + return nil, err + } + } + return buf.Bytes(), nil +} diff --git a/internal/media/strip_test.go b/internal/media/strip_test.go new file mode 100644 index 0000000000000000000000000000000000000000..7bf3d9d2a4a391f7f0b46f8900713bda5faf03fc --- /dev/null +++ b/internal/media/strip_test.go @@ -0,0 +1,244 @@ +package media + +import ( + "bytes" + "compress/zlib" + "encoding/binary" + "errors" + "hash/crc32" + "image" + "image/color" + "image/jpeg" + "image/png" + "runtime" + "testing" +) + +// stripTestImg 造一张 w×h 的测试图:y < contentH 是黑白棋盘(每行亮度标准差远大于 +// rowStdThreshold),其余行铺 blank 色。用它模拟「画面 + 底部纯白留白」。 +func stripTestImg(w, h, contentH int, blank color.RGBA) *image.RGBA { + img := image.NewRGBA(image.Rect(0, 0, w, h)) + for y := 0; y < h; y++ { + for x := 0; x < w; x++ { + if y < contentH { + if (x+y)%2 == 0 { + img.SetRGBA(x, y, color.RGBA{R: 12, G: 24, B: 36, A: 255}) + } else { + img.SetRGBA(x, y, color.RGBA{R: 240, G: 236, B: 232, A: 255}) + } + continue + } + img.SetRGBA(x, y, blank) + } + } + return img +} + +func stripTestPNG(t *testing.T, img image.Image) []byte { + t.Helper() + var buf bytes.Buffer + if err := png.Encode(&buf, img); err != nil { + t.Fatalf("png.Encode: %v", err) + } + return buf.Bytes() +} + +func stripTestJPEG(t *testing.T, img image.Image) []byte { + t.Helper() + var buf bytes.Buffer + if err := jpeg.Encode(&buf, img, &jpeg.Options{Quality: 95}); err != nil { + t.Fatalf("jpeg.Encode: %v", err) + } + return buf.Bytes() +} + +func stripDecodeConfig(t *testing.T, raw []byte) image.Config { + t.Helper() + cfg, _, err := image.DecodeConfig(bytes.NewReader(raw)) + if err != nil { + t.Fatalf("DecodeConfig: %v", err) + } + return cfg +} + +func TestStripCropsBlankBottom(t *testing.T) { + raw := stripTestPNG(t, stripTestImg(40, 120, 80, color.RGBA{R: 255, G: 255, B: 255, A: 255})) + res, err := Strip(raw, Options{MinBlank: 20}) + if err != nil { + t.Fatalf("Strip: %v", err) + } + if res.Boundary != 80 || res.BlankPx != 40 || res.OutHeight != 80 { + t.Fatalf("边界/留白/输出高度不对:boundary=%d blank=%d out_h=%d", res.Boundary, res.BlankPx, res.OutHeight) + } + if !res.Safe { + t.Fatal("40px 纯白留白(阈值 20)应判安全") + } + if res.Format != "png" { + t.Fatalf("格式省略时应跟随输入 png:%s", res.Format) + } + if res.BlankLum < 250 { + t.Fatalf("留白平均亮度应接近 255:%.1f", res.BlankLum) + } + if cfg := stripDecodeConfig(t, res.Data); cfg.Width != 40 || cfg.Height != 80 { + t.Fatalf("裁出的图尺寸 %dx%d,应为 40x80", cfg.Width, cfg.Height) + } +} + +func TestStripDefaultThresholds(t *testing.T) { + // 120px 留白 ≥ 默认安全线 90px,零值 Options 也应判安全。 + raw := stripTestPNG(t, stripTestImg(60, 240, 120, color.RGBA{R: 255, G: 255, B: 255, A: 255})) + res, err := Strip(raw, Options{}) + if err != nil { + t.Fatalf("Strip: %v", err) + } + if res.MinBlank != DefaultMinBlank || res.WhiteLum != DefaultWhiteLum { + t.Fatalf("零值应落默认阈值:min_blank=%d white_lum=%.1f", res.MinBlank, res.WhiteLum) + } + if !res.Safe || res.OutHeight != 120 { + t.Fatalf("120px 白留白应安全并裁到 120:safe=%v out_h=%d", res.Safe, res.OutHeight) + } +} + +func TestStripKeepBlank(t *testing.T) { + raw := stripTestPNG(t, stripTestImg(40, 120, 80, color.RGBA{R: 255, G: 255, B: 255, A: 255})) + res, err := Strip(raw, Options{MinBlank: 20, KeepBlank: 6}) + if err != nil { + t.Fatalf("Strip: %v", err) + } + if res.OutHeight != 86 { + t.Fatalf("keep_blank=6 应裁到 80+6=86,实际 %d", res.OutHeight) + } +} + +func TestStripNoBlankIsUnsafe(t *testing.T) { + // 满幅棋盘:底部没有留白,必须拒绝而不是把画面切掉。 + raw := stripTestPNG(t, stripTestImg(40, 120, 120, color.RGBA{R: 255, G: 255, B: 255, A: 255})) + res, err := Strip(raw, Options{MinBlank: 20}) + var nb *NoBlankError + if !errors.As(err, &nb) { + t.Fatalf("留白为 0 应回 NoBlankError,实际 err=%v", err) + } + if res.BlankPx != 0 || res.Safe { + t.Fatalf("拒绝时也应带实测数字:blank=%d safe=%v", res.BlankPx, res.Safe) + } + if nb.Result.BlankPx != 0 { + t.Fatalf("NoBlankError.Result 应带实测留白,实际 %d", nb.Result.BlankPx) + } +} + +func TestStripGrayBlankIsUnsafe(t *testing.T) { + // 灰底留白:std 也小,但亮度不够白 → 不能让调用方以为裁掉了白边。 + raw := stripTestPNG(t, stripTestImg(40, 120, 80, color.RGBA{R: 128, G: 128, B: 128, A: 255})) + res, err := Strip(raw, Options{MinBlank: 20}) + var nb *NoBlankError + if !errors.As(err, &nb) { + t.Fatalf("灰底留白应判不安全,实际 err=%v", err) + } + if res.BlankPx != 40 { + t.Fatalf("留白像素应为 40,实际 %d", res.BlankPx) + } + if res.BlankLum < 120 || res.BlankLum > 140 { + t.Fatalf("灰底留白平均亮度应在 128 附近:%.1f", res.BlankLum) + } +} + +func TestStripUniformImage(t *testing.T) { + raw := stripTestPNG(t, stripTestImg(40, 120, 0, color.RGBA{R: 255, G: 255, B: 255, A: 255})) + if _, err := Strip(raw, Options{}); !errors.Is(err, ErrUniform) { + t.Fatalf("整张纯色应回 ErrUniform,实际 %v", err) + } +} + +func TestStripNotImage(t *testing.T) { + if _, err := Strip([]byte("这不是图片"), Options{}); !errors.Is(err, ErrNotImage) { + t.Fatalf("非图片字节应回 ErrNotImage,实际 %v", err) + } +} + +// bombPNG 手写一张 w×h 的 1 位灰度全黑 PNG:每行只占 w/8 字节、全零压得极小, +// 解码后却是每像素 1 字节的 image.Gray——几十 KB 的文件能要几百 MB 内存。 +func bombPNG(t *testing.T, w, h int) []byte { + t.Helper() + var out bytes.Buffer + chunk := func(typ string, data []byte) { + var n [4]byte + binary.BigEndian.PutUint32(n[:], uint32(len(data))) + out.Write(n[:]) + crc := crc32.NewIEEE() + crc.Write([]byte(typ)) + crc.Write(data) + out.WriteString(typ) + out.Write(data) + binary.BigEndian.PutUint32(n[:], crc.Sum32()) + out.Write(n[:]) + } + out.WriteString("\x89PNG\r\n\x1a\n") + ihdr := make([]byte, 13) + binary.BigEndian.PutUint32(ihdr[0:], uint32(w)) + binary.BigEndian.PutUint32(ihdr[4:], uint32(h)) + ihdr[8] = 1 // 位深 1,颜色类型 0(灰度) + chunk("IHDR", ihdr) + var idat bytes.Buffer + zw := zlib.NewWriter(&idat) + row := make([]byte, 1+(w+7)/8) // 首字节是行过滤类型 0 + for y := 0; y < h; y++ { + if _, err := zw.Write(row); err != nil { + t.Fatal(err) + } + } + if err := zw.Close(); err != nil { + t.Fatal(err) + } + chunk("IDAT", idat.Bytes()) + chunk("IEND", nil) + return out.Bytes() +} + +// 像素上限必须在解码之前查:先解码再比,上限就拦不住它要防的那次内存分配。 +// 12000×12000 超过 MaxPixels;文件只有几十 KB,完整解码要分配约 144MB。 +func TestStripRejectsOversizeBeforeDecode(t *testing.T) { + raw := bombPNG(t, 12000, 12000) + var before, after runtime.MemStats + runtime.GC() + runtime.ReadMemStats(&before) + _, err := Strip(raw, Options{}) + runtime.ReadMemStats(&after) + if !errors.Is(err, ErrTooLarge) { + t.Fatalf("超像素上限应回 ErrTooLarge,实际 %v", err) + } + if alloc := after.TotalAlloc - before.TotalAlloc; alloc > 8<<20 { + t.Fatalf("拒绝超大图前分配了 %d MB:像素上限没在解码前生效", alloc>>20) + } +} + +func TestStripJPEGFollowsInput(t *testing.T) { + raw := stripTestJPEG(t, stripTestImg(40, 120, 80, color.RGBA{R: 255, G: 255, B: 255, A: 255})) + res, err := Strip(raw, Options{MinBlank: 20}) + if err != nil { + t.Fatalf("Strip: %v", err) + } + if res.Format != "jpeg" { + t.Fatalf("JPEG 输入应输出 jpeg:%s", res.Format) + } + if len(res.Data) < 2 || res.Data[0] != 0xFF || res.Data[1] != 0xD8 { + t.Fatal("输出不是 JPEG 字节流") + } + // JPEG 在棋盘/留白交界会有振铃,边界可能上移 1~2 行,允许小幅误差。 + if res.OutHeight < 72 || res.OutHeight > 80 { + t.Fatalf("JPEG 裁切高度应在 72~80,实际 %d", res.OutHeight) + } +} + +func TestStripFormatOverride(t *testing.T) { + raw := stripTestPNG(t, stripTestImg(40, 120, 80, color.RGBA{R: 255, G: 255, B: 255, A: 255})) + res, err := Strip(raw, Options{MinBlank: 20, Format: "jpeg", Quality: 80}) + if err != nil { + t.Fatalf("Strip: %v", err) + } + if res.Format != "jpeg" { + t.Fatalf("显式 format=jpeg 应输出 jpeg:%s", res.Format) + } + if cfg := stripDecodeConfig(t, res.Data); cfg.Height > 80 { + t.Fatalf("输出高度 %d 超过内容高度", cfg.Height) + } +} diff --git a/internal/panel/accounts_slots_test.go b/internal/panel/accounts_slots_test.go new file mode 100644 index 0000000000000000000000000000000000000000..c2413e291a8bfb8a67200959a4f16dd8dae6ec02 --- /dev/null +++ b/internal/panel/accounts_slots_test.go @@ -0,0 +1,164 @@ +package panel + +import ( + "encoding/json" + "os" + "os/exec" + "regexp" + "testing" +) + +// TestAccountsActsSlots 账号池操作列的槽位数:没有冻结账号时不能给「探活」留空列。 +// +// 为什么需要:八个动作按固定槽位输出(缺位留空 span),整列才能逐行对齐。「探活」是 +// 冻结态专属,如果无条件占位,29 个健康账号每行都在「任务」和「暂停选号」之间空出 +// 一条 64px 的缝(用户反馈「中间留白难受」)。反过来也不能直接删——有冻结行时少一列, +// 8 个孩子塞进 7 个 grid 轨道会折出隐式第二行,按钮整体错位。两条都看不见失败,所以 +// 用 node 跑真实 renderAccounts 数槽位。 +func TestAccountsActsSlots(t *testing.T) { + node, err := exec.LookPath("node") + if err != nil { + t.Skip("node not installed; accounts slots test skipped") + } + script := `const fs = require('fs'), vm = require('vm'); +const src = fs.readFileSync(process.argv[2], 'utf8'); +const s = src.indexOf('function renderAccounts(list) {'); +const e = src.indexOf('// renderModelLocks'); +if (s < 0 || e < 0) throw new Error('renderAccounts block not found'); + +// 只测操作列槽位,其余渲染依赖全部打桩。 +const stubs = { + document: { activeElement: null }, + lastAccountsList: [], accRealmFilter: 'all', + accGroupFilter: '', lastVisibleAccounts: [], syncGroupFilter: () => {}, + esc: x => String(x == null ? '' : x), + remarkName: (uid, name) => name, + rateLimitRowsHtml: () => '', + disabledKind: () => null, disabledAge: () => '', + ago: () => '刚刚', dur: () => '1m', + formatTokenCount: () => '0', formatLatency: () => '-', formatRate: () => '-', + accountProxyHTML: () => '', + els: {}, +}; +const el = k => (stubs.els[k] = stubs.els[k] || { textContent: '', value: '', innerHTML: '', querySelectorAll: () => [] }); +Object.assign(stubs, { $: el, setHTML: (node, html) => { node.innerHTML = html; } }); +vm.createContext(stubs); +vm.runInContext('let lastAccountsList = []; let accRealmFilter = "all";\n' + src.slice(s, e) + + '\nthis.render = renderAccounts;', stubs); + +const acct = (uid, extra) => Object.assign({ + uid, nickname: uid, realm: 'cn', credits: 100, credits_total: 200, + success_count: 1, err_total: 0, in_flight: 0, +}, extra || {}); + +// 操作列内每个槽位(按钮或空 span)算一个 +function slots(html) { + const out = []; + const re = /
([\s\S]*?)<\/div>/g; + let m; + while ((m = re.exec(html))) { + const seg = m[2]; + out.push({ + cls: m[1].trim(), + n: (seg.match(/= 0, + }); + } + return out; +} + +const out = {}; +// 三个健康账号:不该有探活 & 不该有 .with-probe +stubs.render([acct('u1'), acct('u2'), acct('u3')]); +out.healthy = slots(el('accBody').innerHTML); +// 一个禁用 + 一个冷却中的普通账号 +stubs.render([acct('u1'), acct('u2', { disabled: true }), acct('u3', { cool_remaining_sec: 60 })]); +out.frozen = slots(el('accBody').innerHTML); +process.stdout.write(JSON.stringify(out));` + + f, err := os.CreateTemp(t.TempDir(), "accslots-*.cjs") + if err != nil { + t.Fatalf("temp file: %v", err) + } + if _, err := f.WriteString(script); err != nil { + t.Fatalf("write script: %v", err) + } + f.Close() + + out, err := exec.Command(node, f.Name(), "app.js").CombinedOutput() + if err != nil { + t.Fatalf("node failed: %v\n%s", err, out) + } + type row struct { + Cls string `json:"cls"` + N int `json:"n"` + Probe bool `json:"probe"` + } + var got struct { + Healthy []row `json:"healthy"` + Frozen []row `json:"frozen"` + } + if err := json.Unmarshal(out, &got); err != nil { + t.Fatalf("bad json: %v\n%s", err, out) + } + + if len(got.Healthy) != 3 { + t.Fatalf("健康池应渲染 3 行,实际 %d", len(got.Healthy)) + } + for i, r := range got.Healthy { + if r.Cls != "" { + t.Errorf("健康池不该带 with-probe(第 %d 行: %q)", i+1, r.Cls) + } + if r.N != 7 { + t.Errorf("健康行槽位应为 7(签到/余额/任务/选号/禁用/备注/移除),第 %d 行实际 %d", i+1, r.N) + } + if r.Probe { + t.Errorf("健康账号不该出现探活按钮(第 %d 行)", i+1) + } + } + + if len(got.Frozen) != 3 { + t.Fatalf("含冻结账号的池应渲染 3 行,实际 %d", len(got.Frozen)) + } + for i, r := range got.Frozen { + if r.Cls != "with-probe" { + t.Errorf("有冻结账号时整表都要带 with-probe(第 %d 行: %q)", i+1, r.Cls) + } + if r.N != 8 { + t.Errorf("含冻结账号时每行槽位应为 8,第 %d 行实际 %d(少一个会让 grid 折行、整列错位)", i+1, r.N) + } + } + if got.Frozen[1].Probe == false { + t.Error("禁用账号必须渲染探活按钮") + } + if got.Frozen[2].Probe == false { + t.Error("冷却中的账号也必须渲染探活按钮") + } + if got.Frozen[0].Probe { + t.Error("健康账号在有冻结邻居时也不该自己渲染探活") + } +} + +// TestActsInnerGridTracks CSS 的轨道数必须和上面对得上:默认 7 列,with-probe 8 列。 +func TestActsInnerGridTracks(t *testing.T) { + raw, err := os.ReadFile("index.html") + if err != nil { + t.Fatalf("read index.html: %v", err) + } + base := regexp.MustCompile(`\.acts-inner \{ display: grid; grid-template-columns: ([^;]+);`). + FindStringSubmatch(string(raw)) + if base == nil { + t.Fatal(".acts-inner grid 规则不见了") + } + if base[1] != "repeat(3, 54px) 68px repeat(3, 54px)" { + t.Errorf("默认轨道应为 7 个槽(签到/余额/任务/选号 68px/禁用/备注/移除),实际: %s", base[1]) + } + with := regexp.MustCompile(`\.acts-inner\.with-probe \{ grid-template-columns: ([^;]+);`). + FindStringSubmatch(string(raw)) + if with == nil { + t.Fatal(".acts-inner.with-probe 规则不见了 —— 有冻结账号时会缺一列") + } + if with[1] != "repeat(4, 54px) 68px repeat(3, 54px)" { + t.Errorf("with-probe 应为 8 个槽(多一个探活),实际: %s", with[1]) + } +} diff --git a/internal/panel/apikey.go b/internal/panel/apikey.go new file mode 100644 index 0000000000000000000000000000000000000000..82dd4162e4055eebc33e2e6669bc6be6a35dc03c --- /dev/null +++ b/internal/panel/apikey.go @@ -0,0 +1,142 @@ +// apikey.go 面板「添加 API Key 账号」:CodeBuddy 平台签发的静态 API Key +// (ck_/pt_ 前缀)直接可用,无需 OAuth 设备流。 +// +// 落盘形态与 OAuth 账号完全一致(auths/workbuddy-.json,嵌套形,0600), +// 区别仅在没有 refreshToken / expiresAt 与 enterpriseId——静态凭证不可刷新、无过期, +// 也没有个人账号身份,额度走企业口径端点(见 auth.UsesEnterpriseBilling 与 +// upstream.Client.UserResourceSnapshot 的分流)。 +package panel + +import ( + "encoding/json" + "fmt" + "log" + "net/http" + "os" + "path/filepath" + "strings" + + "github.com/misakano7545/workbuddy2api-panel/internal/auth" +) + +// apiKeyUIDMaxLen 派生/显式 uid 的长度上限(与 validImportUID 同口径:拼文件名的兜底)。 +const apiKeyUIDMaxLen = 64 + +// apiKeyPrefixes 静态 API Key 前缀集合,用于派生 uid 时剥前缀。 +// 前缀合法性判定走 auth.IsAPIKey()(单一判据来源),此处仅作字符串裁剪。 +var apiKeyPrefixes = []string{"ck_", "pt_"} + +// addAPIKey 添加一个静态 API Key 账号。 +// +// POST /panel/api/accounts/add_apikey +// body: {"access_token":"ck_...","nickname":"","uid":""} +// +// 流程:校验前缀 → 解析/派生 uid → 用企业额度端点探测 key 是否有效(无效即 400、 +// 不落盘)→ 落盘 → 热加载进池并写入探测到的额度。 +// +// 为什么必须先探测:静态 Key 没有任何本地可验证的签名字段,唯一可靠的验证就是拿它 +// 打一次真实端点。探测失败就落盘等于把一个坏号塞进池子,选号侧会反复选中它、 +// 每次失败都要冷却换号,表象是「网关时好时坏」。 +func (p *Panel) addAPIKey(w http.ResponseWriter, r *http.Request) { + var body struct { + AccessToken string `json:"access_token"` + Nickname string `json:"nickname"` + UID string `json:"uid"` + } + if err := json.NewDecoder(r.Body).Decode(&body); err != nil { + writeErr(w, http.StatusBadRequest, "invalid json: "+err.Error()) + return + } + key := strings.TrimSpace(body.AccessToken) + // 前缀判据复用 auth:构造一个只带 token 的临时 Auth 走 IsAPIKey,避免前缀 + // 集合在 panel 与 auth 两处各写一遍(漂移会让「能加进去」与「能正常用」脱节)。 + if !(&auth.Auth{AccessToken: key}).IsAPIKey() { + writeErr(w, http.StatusBadRequest, "access_token 必须是 ck_/pt_ 前缀的 API Key") + return + } + uid, err := resolveAPIKeyUID(body.UID, key) + if err != nil { + writeErr(w, http.StatusBadRequest, err.Error()) + return + } + + // 探测 key 是否有效:静态 Key 的额度只能走企业口径端点(个人 get-user-resource + // 对它恒返回空 Accounts)。探测失败(无效 Key / 上游报错)即 400,不落盘。 + probe := &auth.Auth{AccessToken: key} + remain, total, expiring, earliestAt, earliestRemaining, err := p.cfg.Upstream.UserResourceDetailedWithExpiry(probe, p.expiringSoonWindow()) + if err != nil { + writeErr(w, http.StatusBadRequest, "API Key 无效或额度查询失败:"+err.Error()) + return + } + + a := &auth.Auth{ + AccessToken: key, + // RefreshToken 留空:静态 Key 无法 refresh(refresh 端点只认 OAuth 设备流); + // ExpiresAt 留 0(静态凭证无过期),EnterpriseID 留空(无企业身份,也不注入 + // X-Enterprise-Id / X-Tenant-Id)。 + UID: uid, + Nickname: strings.TrimSpace(body.Nickname), + FilePath: filepath.Join(p.cfg.AuthDir, fmt.Sprintf("workbuddy-%s.json", uid)), + } + // realm 按现有约定补全(静态 Key 恒 CN;与 LoadDir 存量迁移同口径)。 + _, _ = a.BackfillRealm() + if err := os.MkdirAll(p.cfg.AuthDir, 0o755); err != nil { + writeErr(w, http.StatusInternalServerError, "mkdir auth dir: "+err.Error()) + return + } + if err := a.SaveAtomic(); err != nil { + writeErr(w, http.StatusInternalServerError, "save auth: "+err.Error()) + return + } + // 入池这一步与目录热重载串行化(issue #199 风险 3):重载刚扫完、还没 upsert + // 完时插进来的 Add,可能被同一轮的删除判据当成「文件不存在」而抹掉。 + p.reloadMu.Lock() + p.cfg.Pool.Add(a) // upsert:已存在则覆盖凭证、保留原池状态 + p.reloadMu.Unlock() + p.cfg.Pool.SetCreditsDetailed(uid, remain, total, expiring, earliestAt, earliestRemaining) + log.Printf("panel: 添加 API Key 账号 uid=%s nickname=%q credits=%d/%d", uid, a.Nickname, remain, total) + writeJSON(w, http.StatusOK, map[string]any{"ok": true, "uid": uid, "nickname": a.Nickname, "api_key": true}) +} + +// resolveAPIKeyUID 解析落盘用 uid:显式传入时按字符白名单校验(拒绝路径穿越); +// 缺省时取 key 的 段(ck_. 的 id)拼成 apikey-,非法字符剔除。 +func resolveAPIKeyUID(explicit, key string) (string, error) { + if e := strings.TrimSpace(explicit); e != "" { + if !validImportUID(e) { + return "", fmt.Errorf("uid 只能包含字母、数字、下划线、连字符(≤%d 字符)", apiKeyUIDMaxLen) + } + return e, nil + } + id := apiKeyID(key) + if id == "" { + return "", fmt.Errorf("无法从 key 解析 id 段,请显式指定 uid") + } + uid := "apikey-" + id + if len(uid) > apiKeyUIDMaxLen { + uid = uid[:apiKeyUIDMaxLen] + } + return uid, nil +} + +// apiKeyID 取 ck_. 的 段(剥前缀、截到首个点之前),只保留 +// [A-Za-z0-9_-]——拼文件名前必须净化,避免路径穿越。 +func apiKeyID(key string) string { + s := key + for _, p := range apiKeyPrefixes { + if strings.HasPrefix(s, p) { + s = s[len(p):] + break + } + } + if i := strings.IndexByte(s, '.'); i >= 0 { + s = s[:i] + } + var b strings.Builder + for _, c := range s { + switch { + case c >= 'a' && c <= 'z', c >= 'A' && c <= 'Z', c >= '0' && c <= '9', c == '-', c == '_': + b.WriteRune(c) + } + } + return b.String() +} diff --git a/internal/panel/apikey_test.go b/internal/panel/apikey_test.go new file mode 100644 index 0000000000000000000000000000000000000000..6575fa28b8bdefdaace0f42b1262c57d3b1a0179 --- /dev/null +++ b/internal/panel/apikey_test.go @@ -0,0 +1,185 @@ +package panel + +import ( + "encoding/json" + "io" + "net/http" + "net/http/httptest" + "os" + "strings" + "testing" + + "github.com/misakano7545/workbuddy2api-panel/internal/auth" + "github.com/misakano7545/workbuddy2api-panel/internal/pool" + "github.com/misakano7545/workbuddy2api-panel/internal/upstream" +) + +// apiKeyPanel 造一个只认企业额度端点的假上游,用于「添加 API Key 账号」测试。 +// calls 记录打到的路径,供断言「探测确实走了企业口径、且没有多余请求」。 +func apiKeyPanel(t *testing.T, respBody string) (*Panel, *pool.Pool, *[]string) { + t.Helper() + var calls []string + up := &upstream.Client{ + HTTP: &http.Client{Transport: roundTripFunc2(func(r *http.Request) (*http.Response, error) { + calls = append(calls, r.URL.Path) + return &http.Response{ + StatusCode: 200, + Header: http.Header{"Content-Type": []string{"application/json"}}, + Body: io.NopCloser(strings.NewReader(respBody)), + }, nil + })}, + ChatBaseCN: "https://cn.example", + BillingBaseCN: "https://cn.example", + } + p := pool.New("") + pn := New(Config{Version: "test", Pool: p, Upstream: up, AuthDir: t.TempDir()}) + return pn, p, &calls +} + +type roundTripFunc2 func(*http.Request) (*http.Response, error) + +func (f roundTripFunc2) RoundTrip(r *http.Request) (*http.Response, error) { return f(r) } + +// enterpriseUsageOK 企业口径额度答复:上游的 credit 是**已用**量,limitNum 是分配上限, +// 剩余 = limit - used(个人口径的 credit 反而是剩余,两套语义不同,取错方向会让 +// 面板显示「剩 120」而实际只剩 380)。 +const enterpriseUsageOK = `{"code":0,"msg":"OK","data":{"credit":120,"limitNum":500,"cycleEndTime":"2026-11-01 00:00:00"}}` + +func postAPIKey(t *testing.T, pn *Panel, body string) *httptest.ResponseRecorder { + t.Helper() + rec := httptest.NewRecorder() + pn.ServeHTTP(rec, httptest.NewRequest("POST", "/panel/api/accounts/add_apikey", strings.NewReader(body))) + return rec +} + +// TestAddAPIKeySavesAndLoadsIntoPool 正常路径:探测成功 → 落盘(无 refreshToken)→ +// 入池且额度为探测值。落盘形态必须与 OAuth 账号一致,否则 LoadDir 重启后读不出来。 +func TestAddAPIKeySavesAndLoadsIntoPool(t *testing.T) { + pn, p, calls := apiKeyPanel(t, enterpriseUsageOK) + rec := postAPIKey(t, pn, `{"access_token":"ck_abc123.secretpart","nickname":"我的Key"}`) + if rec.Code != 200 { + t.Fatalf("code=%d body=%s", rec.Code, rec.Body) + } + var resp map[string]any + if err := json.Unmarshal(rec.Body.Bytes(), &resp); err != nil { + t.Fatalf("resp not json: %v", err) + } + if resp["api_key"] != true { + t.Errorf("应标记 api_key=true:%v", resp) + } + uid, _ := resp["uid"].(string) + if uid != "apikey-abc123" { + t.Fatalf("uid=%q want apikey-abc123(由 key 的 id 段派生)", uid) + } + + // 探测必须走企业口径端点(静态 Key 的个人资源包恒为空)。 + if len(*calls) == 0 || !strings.Contains((*calls)[0], "get-enterprise-user-usage") { + t.Fatalf("探测应走 get-enterprise-user-usage,实际 %v", *calls) + } + + // 入池且额度写入。 + a := p.AuthByUID(uid) + if a == nil { + t.Fatal("添加后账号应已入池") + } + if !a.IsAPIKey() { + t.Errorf("入池账号应判为 API Key:%+v", a) + } + if a.RefreshTokenValue() != "" { + t.Errorf("静态 Key 不该带 refreshToken:%q", a.RefreshTokenValue()) + } + st, ok := p.Status(uid) + if !ok { + t.Fatal("状态查询不到该账号") + } + if !st.APIKey { + t.Errorf("状态应带 api_key 标记(面板据此隐藏签到/任务按钮):%+v", st) + } + // credit 是已用量(120),故剩余 380 / 总额 500。 + if st.Credits != 380 || st.CreditsTotal != 500 { + t.Errorf("额度 credits=%d total=%d want 380/500", st.Credits, st.CreditsTotal) + } + + // 落盘 → 重载:重启后账号仍然可用(这是「添加成功」的最终判据)。 + dir := pn.cfg.AuthDir + auths, err := auth.LoadDir(dir) + if err != nil { + t.Fatalf("LoadDir: %v", err) + } + if len(auths) != 1 || !auths[0].IsAPIKey() || auths[0].UID != uid { + t.Fatalf("落盘账号不可重载:%+v", auths) + } +} + +// TestAddAPIKeyRejectsBadInput 三条拒绝路径都不落盘:前缀不对 / uid 非法 / 探测失败。 +// 落盘了坏 Key 的后果是选号侧反复选中它、每次都要冷却换号,表象是「网关时好时坏」。 +func TestAddAPIKeyRejectsBadInput(t *testing.T) { + cases := []struct { + name string + body string + }{ + {"非 Key 前缀", `{"access_token":"eyJhbGciOiJSUzI1NiJ9.eyJ9.sig"}`}, + {"空 token", `{"access_token":" "}`}, + {"uid 路径穿越", `{"access_token":"ck_abc.def","uid":"../../etc/passwd"}`}, + } + for _, c := range cases { + t.Run(c.name, func(t *testing.T) { + pn, p, _ := apiKeyPanel(t, enterpriseUsageOK) + rec := postAPIKey(t, pn, c.body) + if rec.Code != 400 { + t.Fatalf("code=%d body=%s(want 400)", rec.Code, rec.Body) + } + if n := len(p.List()); n != 0 { + t.Fatalf("被拒绝的请求不该入池:%d 个账号", n) + } + entries, _ := os.ReadDir(pn.cfg.AuthDir) + if len(entries) != 0 { + t.Fatalf("被拒绝的请求不该落盘:%v", entries) + } + }) + } +} + +// 上游探测失败(无效 Key → 401 业务信封)必须 400 且不落盘。 +func TestAddAPIKeyInvalidKeyNotPersisted(t *testing.T) { + pn, p, _ := apiKeyPanel(t, `{"code":401,"msg":"invalid api key","data":null}`) + rec := postAPIKey(t, pn, `{"access_token":"ck_dead.dead","nickname":""}`) + if rec.Code != 400 { + t.Fatalf("code=%d body=%s(want 400)", rec.Code, rec.Body) + } + if !strings.Contains(rec.Body.String(), "API Key") { + t.Errorf("错误文案应指明是 API Key 的问题:%s", rec.Body) + } + if n := len(p.List()); n != 0 { + t.Fatalf("探测失败不该入池:%d", n) + } + entries, _ := os.ReadDir(pn.cfg.AuthDir) + if len(entries) != 0 { + t.Fatalf("探测失败不该落盘:%v", entries) + } +} + +// 显式 uid 走白名单校验;派生 uid 时长超限要截断(拼文件名前的兜底)。 +func TestResolveAPIKeyUID(t *testing.T) { + if uid, err := resolveAPIKeyUID("my-key_1", "ck_abc.def"); err != nil || uid != "my-key_1" { + t.Fatalf("显式 uid 应原样使用:%q %v", uid, err) + } + if _, err := resolveAPIKeyUID("bad uid", "ck_abc.def"); err == nil { + t.Fatal("含空格的 uid 应被拒") + } + if uid, err := resolveAPIKeyUID("", "pt_zzz.999"); err != nil || uid != "apikey-zzz" { + t.Fatalf("派生 uid=%q err=%v want apikey-zzz", uid, err) + } + // 无 id 段(前缀后直接是点)→ 必须报错而不是造出 "apikey-"。 + if _, err := resolveAPIKeyUID("", "ck_.secret"); err == nil { + t.Fatal("无 id 段应报错,请显式指定 uid") + } + long := "ck_" + strings.Repeat("a", 200) + ".s" + uid, err := resolveAPIKeyUID("", long) + if err != nil { + t.Fatalf("超长 id 应截断而非报错:%v", err) + } + if len(uid) > apiKeyUIDMaxLen { + t.Fatalf("派生 uid 长度=%d 超过上限 %d", len(uid), apiKeyUIDMaxLen) + } +} diff --git a/internal/panel/app.js b/internal/panel/app.js index d4be786c39d3d41d367ea079f24d951da8275177..8f7c90cb6468569972d7330317ff7e20599feb0b 100644 --- a/internal/panel/app.js +++ b/internal/panel/app.js @@ -1,2809 +1,6345 @@ -'use strict'; -/* ── 状态 ─────────────────────────────────────────────────────────── */ -const LS_KEY = 'wb2api.key', LS_THEME = 'wb2api.theme'; -let theme = localStorage.getItem(LS_THEME) || 'auto'; // auto | light | dark -let view = 'accounts'; -let overviewData = null, cfgLoaded = null; -let logPin = true, loginState = null, loginTimer = null; -let refTimer = null; -/* 视图级筛选状态(模块级声明放在文件顶部,避免顶层 go() 早于声明执行时踩 TDZ)。 */ -let mdFilter = { q: '', realm: '', cap: '', effort: '', promo: '', sort: 'default' }; -let mdAll = [], mdProbes = {}, mdProbeOf = () => undefined; -let reqFilter = { q: '', outcome: '' }; -let reqEntries = []; -let usDim = 'account', usCreditDim = 'account', usSort = 'total'; -let usageData = null; -let reqRangeState = null; // 请求记录的时间范围(用量页的见 trangeState) - -const $ = id => document.getElementById(id); - -/* ── 主题 ─────────────────────────────────────────────────────────── */ -/* 两态翻转(浅/深),首次访问跟随系统偏好;点击总是切换可见外观,符合直觉。 */ -function effTheme() { - return theme === 'auto' ? (matchMedia('(prefers-color-scheme: light)').matches ? 'light' : 'dark') : theme; -} -function applyTheme() { - const eff = effTheme(); - document.documentElement.dataset.theme = eff; - $('icoTheme').innerHTML = eff === 'light' - ? '' - : ''; - $('btnTheme').title = eff === 'light' ? '切换到深色' : '切换到浅色'; -} -addEventListener('change', applyTheme); -$('btnTheme').onclick = () => { - theme = effTheme() === 'light' ? 'dark' : 'light'; - localStorage.setItem(LS_THEME, theme); - applyTheme(); -}; -applyTheme(); - -/* ── 请求 ─────────────────────────────────────────────────────────── */ -async function api(path, opts = {}) { - const h = Object.assign({}, opts.headers || {}); - const k = localStorage.getItem(LS_KEY); - if (k) h['Authorization'] = 'Bearer ' + k; - if (opts.body) h['Content-Type'] = 'application/json'; - const r = await fetch('/panel/api/' + path, Object.assign({}, opts, { headers: h })); - if (r.status === 401) { openKey(); throw new Error('密钥无效或未填写'); } - const d = await r.json().catch(() => ({})); - if (!r.ok) throw new Error(d.error || ('HTTP ' + r.status)); - return d; -} -function toast(msg, cls) { - const el = document.createElement('div'); - el.className = 'tst ' + (cls || ''); - el.textContent = msg; - $('toasts').appendChild(el); - setTimeout(() => el.remove(), 3600); -} -// esc 文本/属性双安全转义。不能只用 div.innerHTML(它转义 <>& 但不转义引号), -// 否则字符串拼进 HTML 属性(如 title="uid: ...")时引号可闭合属性并注入事件处理器。 -// 显式替换 5 个字符:& < > " '(& 必须最先,避免二次转义)。 -function esc(s) { - return String(s == null ? '' : s) - .replace(/&/g, '&') - .replace(//g, '>') - .replace(/"/g, '"') - .replace(/'/g, '''); -} -function ago(iso) { - if (!iso || iso.startsWith('0001-')) return '—'; - const s = (Date.now() - new Date(iso)) / 1000; - if (s < 0) return '刚刚'; - if (s < 60) return Math.floor(s) + ' 秒前'; - if (s < 3600) return Math.floor(s / 60) + ' 分钟前'; - if (s < 86400) return Math.floor(s / 3600) + ' 小时前'; - return Math.floor(s / 86400) + ' 天前'; -} -function dur(sec) { - sec = Math.max(0, Math.round(sec)); - const h = Math.floor(sec / 3600), m = Math.floor(sec % 3600 / 60), s = sec % 60; - return h ? h + '时' + String(m).padStart(2, '0') + '分' : m ? m + '分' + String(s).padStart(2, '0') + '秒' : s + '秒'; -} -function parseAPITime(value) { - const text = String(value || ''); - if (!text || text.startsWith('0001-')) return 0; - const ms = Date.parse(text); - return Number.isFinite(ms) ? ms : 0; -} -function fmtLocalDateTime(ms) { - const d = new Date(ms); - const p = n => String(n).padStart(2, '0'); - return d.getFullYear() + '-' + p(d.getMonth() + 1) + '-' + p(d.getDate()) + ' ' + - p(d.getHours()) + ':' + p(d.getMinutes()); -} - -/* ── 时间范围控件(用量 / 请求记录共用)──────────────────────────────── - 预设项:今天 / 近 24 小时 / 近 3 天 / 近 7 天 / 近 30 天 / 全部历史 / 自定义。 - - 为什么区间一律由前端算好再发: - - 「今天」必须是**浏览器本地时区**的 00:00 起。服务端时区未必与浏览器一致 - (容器常挂 TZ=Asia/Shanghai,而浏览器可能在任何时区),让服务端算"今天" - 会在跨时区时切错日子。 - - 「自定义」本来就是用户挑的具体时刻,没有任何服务端推导空间。 - - 滚动预设(近 N 小时/天)则保留 hours 参数:服务端按整点对齐的滚动窗口与旧 - 行为逐位一致,前端自己减 N 小时会多算/少算一个边界桶。 */ -const TRANGE_PRESETS = [ - ['today', '今天'], - ['24', '近 24 小时'], - ['72', '近 3 天'], - ['168', '近 7 天'], - ['720', '近 30 天'], - ['0', '全部历史'], - ['custom', '自定义…'], -]; -const TRANGE_DEFAULT = '72'; -const trangeStates = new Map(); // hostId → { preset, from: Date|null, to: Date|null } - -// dtLocalValue / dtLocalParse 与 的取值格式互转 -// (YYYY-MM-DDTHH:mm,本地时区;ES 里"带时间的日期串"按本地解析,正是我们要的)。 -function dtLocalValue(d) { - const p = n => String(n).padStart(2, '0'); - return d.getFullYear() + '-' + p(d.getMonth() + 1) + '-' + p(d.getDate()) + 'T' + - p(d.getHours()) + ':' + p(d.getMinutes()); -} -function dtLocalParse(s) { - if (!s) return null; - const d = new Date(s); - return isNaN(d.getTime()) ? null : d; -} - -// trangeMidnight 今天 00:00(本地时区)。 -function trangeMidnight() { - const d = new Date(); - d.setHours(0, 0, 0, 0); - return d; -} - -function trangeState(id) { - if (!trangeStates.has(id)) { - // 「自定义」的初始值给一段有意义的默认:今天 00:00 → 现在。 - trangeStates.set(id, { preset: TRANGE_DEFAULT, from: trangeMidnight(), to: new Date() }); - } - return trangeStates.get(id); -} - -// trangeRender 画出控件骨架(幂等:重复调用会保留当前状态)。 -function trangeRender(id) { - const host = $(id); - if (!host) return; - const st = trangeState(id); - const custom = st.preset === 'custom'; - host.innerHTML = - '' + - '' + - '' + - '→' + - '' + - ''; - const preset = host.querySelector('.tr-preset'); - if (preset) preset.onchange = () => { - st.preset = preset.value; - // 从别的预设切到自定义时,把区间重置为"今天 00:00 → 现在", - // 免得用户上次留下的半年区间被无声沿用。 - if (st.preset === 'custom' && (!st.from || !st.to)) { st.from = trangeMidnight(); st.to = new Date(); } - trangeRender(id); - trangeEmit(id); - }; - const fromEl = host.querySelector('.tr-from'); - const toEl = host.querySelector('.tr-to'); - const readCustom = () => { - st.from = dtLocalParse(fromEl.value); - st.to = dtLocalParse(toEl.value); - // 起止颠倒就地标红(不静默纠正:用户可能正输到一半)。 - const bad = st.from && st.to && st.from > st.to; - fromEl.classList.toggle('tr-bad', !!bad); - toEl.classList.toggle('tr-bad', !!bad); - if (bad) return; - trangeEmit(id); - }; - if (fromEl) fromEl.onchange = readCustom; - if (toEl) toEl.onchange = readCustom; -} - -const trangeHandlers = new Map(); -// trangeBind 渲染控件并登记变化回调。**不**在绑定时触发回调:各视图的首次加载 -// 由 go() 统一驱动,这里再触发一次会让打开页面时打两遍接口。 -function trangeBind(id, onChange, preset) { - trangeHandlers.set(id, onChange); - if (preset) trangeState(id).preset = preset; - trangeRender(id); -} -function trangeEmit(id) { - const fn = trangeHandlers.get(id); - if (fn) fn(); -} - -// trangeQuery 把当前选择翻译成查询参数。 -// rolling=true → 滚动预设发 hours(服务端整点对齐),今天/自定义发 from/to -// rolling=false → 一律发 from/to(归档是线性日志,前端算区间更直观) -// 「全部历史」两者都不发。 -function trangeQuery(id, rolling) { - const st = trangeState(id); - const q = new URLSearchParams(); - const sec = d => Math.floor(d.getTime() / 1000); - if (st.preset === 'custom') { - if (st.from) q.set('from', sec(st.from)); - if (st.to) q.set('to', sec(st.to)); - return q; - } - if (st.preset === 'today') { - q.set('from', sec(trangeMidnight())); - return q; - } - if (st.preset === '0') return q; - if (rolling) { q.set('hours', st.preset); return q; } - q.set('from', sec(new Date(Date.now() - Number(st.preset) * 3600 * 1000))); - return q; -} - -// trangeLabel 人读口径,用于「用量总览」右上角这类需要回显区间的位置。 -function trangeLabel(id) { - const st = trangeState(id); - const found = TRANGE_PRESETS.find(p => p[0] === st.preset); - if (st.preset !== 'custom') return found ? found[1] : ''; - if (!st.from && !st.to) return '自定义'; - const f = d => d ? (d.getMonth() + 1) + '-' + String(d.getDate()).padStart(2, '0') + ' ' + - String(d.getHours()).padStart(2, '0') + ':' + String(d.getMinutes()).padStart(2, '0') : '…'; - return f(st.from) + ' → ' + f(st.to); -} -function rateLimitMeta(row, now) { - const model = String(row && row.model || '未知模型'); - const kind = String(row && row.kind || 'rate_limit'); - const resetAt = parseAPITime(row && row.reset_at); - const until = parseAPITime(row && row.until); - const deadline = resetAt || until; - const remaining = deadline > now ? Math.round((deadline - now) / 1000) : 0; - if (kind === 'model_unavailable') { - return { - model, - kind, - detail: remaining ? '预计 ' + dur(remaining) + ' 后重试' : '等待重新探测', - title: model + '\n模型当前不可用' + (deadline ? '\n最早重试:' + fmtLocalDateTime(deadline) : ''), - }; - } - let detail = resetAt - ? '预计 ' + fmtLocalDateTime(resetAt) + ' 解封' + (remaining ? '(剩余 ' + dur(remaining) + ')' : '') - : (until ? '预计 ' + fmtLocalDateTime(until) + ' 恢复(剩余 ' + dur(remaining) + ')' : '预计解封时间未知'); - const title = [model, resetAt ? '上游重置:' + fmtLocalDateTime(resetAt) : '上游重置:时间未知']; - if (until && resetAt && until < resetAt) { - detail += ' · 网关最快 ' + dur(Math.max(0, Math.round((until - now) / 1000))) + ' 后重试'; - title.push('网关最早重试:' + fmtLocalDateTime(until)); - } - return { model, kind, detail, title: title.join('\n') }; -} -function rateLimitRowsHtml(rows, now) { - const list = Array.isArray(rows) ? rows.filter(row => row && row.model) : []; - if (!list.length) return ''; - return '
' + list.map(row => { - const m = rateLimitMeta(row, now); - return '
' + esc(m.model) + '' + esc(m.detail) + '
'; - }).join('') + '
'; -} - -function formatTokenCount(tokens) { - if (tokens == null || tokens === '') return '—'; - const n = Number(tokens); - if (!Number.isFinite(n) || n < 0) return '—'; - if (n < 1000) return String(Math.round(n)); - const units = [['k', 1e3], ['m', 1e6], ['b', 1e9]]; - let unit = units[0]; - for (const candidate of units) { - if (n >= candidate[1]) unit = candidate; - } - let value = n / unit[1]; - let rounded = Number(value.toFixed(1)); - // 999999 → 1m,而不是 1000k;四舍五入后自动升级单位。 - const next = units[units.indexOf(unit) + 1]; - if (next && rounded >= 1000) { - unit = next; - value = n / unit[1]; - rounded = Number(value.toFixed(1)); - } - return rounded + unit[0]; -} - -function formatLatency(ms) { - if (ms == null || ms === '') return '—'; - const n = Number(ms); - if (!Number.isFinite(n) || n <= 0) return '—'; - return n < 1000 ? Math.round(n) + 'ms' : (n / 1000).toFixed(1).replace(/\.0$/, '') + 's'; -} -function formatRate(rate) { - if (rate == null || rate === '') return '—'; - const n = Number(rate); - if (!Number.isFinite(n) || n < 0) return '—'; - return n.toFixed(1) + 'tok/s'; -} - -/* ── 密钥门 ───────────────────────────────────────────────────────── */ -function openKey() { $('keyVeil').classList.add('on'); setTimeout(() => $('keyInput').focus(), 60); } -$('btnKey').onclick = async () => { - const v = $('keyInput').value.trim(); - if (!v) return; - localStorage.setItem(LS_KEY, v); - try { - await api('overview'); - $('keyErr').hidden = true; - $('keyVeil').classList.remove('on'); - start(); - } catch (e) { $('keyErr').hidden = false; } -}; -$('keyInput').addEventListener('keydown', e => { if (e.key === 'Enter') $('btnKey').click(); }); - -/* ── 路由 ─────────────────────────────────────────────────────────── */ -/* 积分包明细共享缓存:「积分构成」视图与首页「积分到期提醒」卡片共用同一份 - /panel/api/packages 数据(逐账号实时查上游,能省一次是一次)。声明在路由区 - 是因为 go() 的初始调用就会触发首页卡片的渲染,必须先于它就位。 */ -let lastPackages = null; -let lastPackagesAt = 0; -let expFetching = false; // 到期卡片在途标记(防重复打上游) -const EXP_FRESH_MS = 2 * 60 * 1000; // 缓存新鲜窗口:2 分钟内复用 - -const TITLES = { accounts: '账号池', usage: '用量', packages: '积分构成', taskscenter: '任务中心', models: '模型与档位', config: '配置', logs: '运行日志' }; -function go(v) { - view = v; - document.querySelectorAll('.view').forEach(s => s.hidden = s.id !== 'view-' + v); - document.querySelectorAll('.nav a').forEach(a => a.classList.toggle('on', a.dataset.view === v)); - $('ttl').textContent = TITLES[v]; - if (v === 'models' && !$('mdBody').children.length) loadModels(); - if (v === 'config') loadConfig(); - if (v === 'logs') loadLogs(); - if (v === 'usage') loadUsage(); - if (v === 'packages') loadPackages(); - if (v === 'accounts') loadExpiry(); - if (v === 'taskscenter') reattachQueueView(); -} -document.querySelectorAll('.nav a').forEach(a => a.onclick = e => { e.preventDefault(); go(a.dataset.view); history.replaceState(null, '', '#' + a.dataset.view); }); -/* 首次进入延到本轮脚本求值之后再 go()。 - 原因:go() 会同步触发视图的数据加载(loadUsage/loadLogs/loadPackages…),而这些 - 函数读到的模块级 let/const(usageRateWarmAt、PK_* 等)在文件后半段才初始化—— - 直接深链 #usage / #packages 打开页面时会踩 TDZ("Cannot access 'x' before - initialization"),表现为该页永远显示"读取失败",而点导航进去一切正常。 - 延迟 0ms 让整份脚本先求值完,是修这一类问题最省事也最不容易再犯的办法。 */ -setTimeout(() => { - const hash = (location.hash || '#accounts').slice(1); - go(hash in TITLES ? hash : 'accounts'); -}, 0); - -/* ── 账号池 ───────────────────────────────────────────────────────── */ -function renderAccounts(list) { - const tb = $('accBody'); - if (!list.length) { - tb.innerHTML = '
账号池是空的
点击右上角「添加账号」,用浏览器登录一个 WorkBuddy 账号
'; - return; - } - // 有总额度(credits_total)→ 进度条按自身 剩余/总额 百分比;旧数据无总额 → 退回池内最高=100% - const maxCred = Math.max(1, ...list.map(s => s.credits || 0)); - tb.innerHTML = list.map(s => { - const bl = (new Date(s.breaker_until || 0) - Date.now()) / 1000; - const dg = (new Date(s.degrade_until || 0) - Date.now()) / 1000; - const cool = Math.max(s.cool_remaining_sec || 0, bl > 0 ? bl : 0, dg > 0 ? dg : 0); - let cls = '', tag; - if (s.disabled) { cls = 'off'; tag = '已禁用'; } - else if (s.paused) { cls = 'off'; tag = '已暂停选号'; } - else if (cool > 0) { - cls = 'cool'; - const kind = bl > Math.max(s.cool_remaining_sec || 0, dg > 0 ? dg : 0) ? '熔断' - : (dg > (s.cool_remaining_sec || 0) ? '连败降权' : (s.cool_kind === 'hard_credit' ? '积分冷却' : '限流冷却')); - tag = '' + kind + ' · ' + dur(cool) + ''; - } else tag = '可用' + (s.in_flight ? '' : ''); - const note = s.reason ? '
' + esc(s.reason) + '
' : ''; - const rateLimits = rateLimitRowsHtml(s.rate_limited_models, Date.now()); - const short = s.uid.length > 16 ? s.uid.slice(0, 16) + '…' : s.uid; - const cred = s.credits == null ? '—' : (s.credits_total > 0 ? s.credits + '/' + s.credits_total + '' : String(s.credits)); - const pct = s.credits_total > 0 - ? Math.min(100, Math.round((s.credits || 0) / s.credits_total * 100)) - : Math.round((s.credits || 0) / maxCred * 100); - // 成本台账 tooltip(model_costs):每模型实测单价(≤0 = 实测免费),运维据此 - // 看「为什么总选它」——免费号垄断 / 单价排序一眼可见。 - let credTip = s.credits_total > 0 ? '剩余 ' + s.credits + ' / 总额 ' + s.credits_total + '(' + pct + '%)' : '积分(相对池内最高)'; - const costs = (s.model_costs || []).filter(c => c.model); - if (costs.length) { - credTip += '\n实测单价(credits/1K):\n' + costs.map(c => - ' ' + c.model + ':' + (c.cost_per_1k <= 0 ? '免费' : c.cost_per_1k)).join('\n'); - } - const frozen = s.disabled || cool > 0; - const tu = s.token_usage || {}; - const req = tu.request_count || 0; - const totalTok = formatTokenCount(tu.total_tokens); - const totalTokUnit = totalTok === '—' ? '' : 'tok'; - const latency = formatLatency(tu.last_latency_ms); - const rate = formatRate(tu.last_tokens_per_second); - const usageTitle = '最近一次:' + req + ' 次 / ' + totalTok + ' / 延迟 ' + latency + ' / ' + rate; - return '' + - '' + - '
' + (s.nickname ? esc(s.nickname) : '未命名') + (s.realm === 'global' ? ' 国际版' : '') + '
' + esc(short) + '
' + - '' + tag + note + rateLimits + '' + - '
' + cred + '
' + - '' + (s.success_count || 0) + ' / ' + (s.err_total || 0) + '' + - '' + (s.in_flight || 0) + '' + - '' + - '' + req + '次' + - '' + totalTok + '' + totalTokUnit + '' + - '' + latency + '' + - '' + rate + '' + - '' + - '' + ago(s.last_success) + '' + - '' + - '' + - '' + - '' + - (frozen ? '' - : (s.paused ? '' - : '')) + - (s.disabled ? '' : '') + - '' + - ''; - }).join(''); -} - -// renderModelLocks 模型锁池:哪些模型不能用、锁了几个号、还要锁多久。 -// 后端 model_locks 已按「整池不可用 → 没号可用 → 部分限流」排好序,这里只做展示。 -function renderModelLocks(rows) { - const tb = $('mlBody'); - if (!tb) return; - const note = $('mlNote'); - if (!rows || !rows.length) { - tb.innerHTML = '
当前没有模型级限流 —— 所有模型均可选
'; - if (note) note.textContent = ''; - return; - } - const STATE = { locked: ['bad', '整池不可用'], starved: ['warn', '没号可用'], partial: ['warn', '部分限流'] }; - const left = iso => { - const ms = parseAPITime(iso); - return ms ? dur(Math.max(0, Math.round((ms - Date.now()) / 1000))) : '—'; - }; - tb.innerHTML = rows.map(r => { - const st = STATE[r.state] || ['mute', r.state || '—']; - const realm = r.realm === 'global' ? '国际版' : '国内版'; - return '' + - '' + esc(r.model) + '' + - '' + realm + '' + - '' + st[1] + '' + - '' + (r.servable || 0) + ' / ' + (r.total || 0) + '' + - '' + (r.locked || 0) + '' + - '' + left(r.unlock_at || r.fully_unlock_at) + '' + - '' + left(r.fully_unlock_at) + '' + - '' + (r.reason ? '
' + esc(r.reason) + '
' : '—') + '' + - ''; - }).join(''); - if (note) { - const bad = rows.filter(r => r.state === 'locked' || r.state === 'starved').length; - note.textContent = bad ? bad + ' 个模型整池不可用' : rows.length + ' 个模型部分限流'; - } -} - -async function loadOverview(quiet) { - try { - const d = await api('overview'); - overviewData = d; - $('sTotal').textContent = d.total; - $('sHealthy').textContent = d.healthy; - $('sCooling').textContent = d.cooling; - $('sDisabled').textContent = d.disabled; - const remSum = (d.accounts || []).reduce((a, s) => a + (s.credits || 0), 0); - const totSum = (d.accounts || []).reduce((a, s) => a + (s.credits_total || 0), 0); - $('sCredits').textContent = totSum > 0 ? remSum + ' / ' + totSum : remSum; - $('sSticky').textContent = d.sticky_sessions; - $('navSub').textContent = 'v' + d.version; - $('navVer').textContent = 'v' + d.version; - $('navRedis').textContent = d.redis_mode === 'upstash' ? 'Redis 镜像' : '本地内存'; - $('navState').textContent = d.healthy > 0 ? '服务正常' : (d.total ? '无可用账号' : '待添加账号'); - const p = $('navPulse'); - p.className = 'pulse' + (d.healthy > 0 ? '' : (d.total ? ' warn' : ' bad')); - $('accNote').textContent = d.in_flight_full ? d.in_flight_full + ' 个账号在途占满' : ''; - const up = Math.floor(d.uptime_sec); - $('subMeta').textContent = '运行 ' + (up >= 86400 ? Math.floor(up / 86400) + ' 天 ' : '') + Math.floor(up % 86400 / 3600) + ' 时 ' + Math.floor(up % 3600 / 60) + ' 分'; - renderAccounts(d.accounts || []); - renderModelLocks(d.model_locks); - } catch (e) { if (!quiet) toast(e.message, 'err'); } -} - -$('accBody').addEventListener('click', async ev => { - const b = ev.target.closest('button[data-a]'); - if (!b) return; - const u = b.dataset.u, a = b.dataset.a; - if (a === 'remove' && !confirm('移除账号将删除池状态与 auths/ 下的凭证文件,且不可恢复。确认移除?')) return; - if (a === 'disable' && !confirm('禁用后该账号不再参与选号(保号任务默认也跳过),需手动解冻才能恢复。若只是想临时让位、仍要保号,请改用「暂停选号」。确认禁用?')) return; - b.disabled = true; - try { - if (a === 'checkin') { - const r = await api('accounts/' + encodeURIComponent(u) + '/checkin', { method: 'POST' }); - toast('签到完成' + (r.credits != null ? ',积分 ' + r.credits + (r.credits_total > 0 ? '/' + r.credits_total : '') : '') + (r.checkin_message ? '(' + r.checkin_message + ')' : ''), 'ok'); - } else if (a === 'balance') { - const r = await api('accounts/' + encodeURIComponent(u) + '/balance', { method: 'POST' }); - toast('余额已更新:' + r.credits + (r.credits_total > 0 ? ' / ' + r.credits_total : ''), 'ok'); - } else if (a === 'revive') { - await api('accounts/' + encodeURIComponent(u) + '/revive', { method: 'POST' }); - toast('已解冻', 'ok'); - } else if (a === 'disable') { - await api('accounts/' + encodeURIComponent(u) + '/disable', { method: 'POST' }); - toast('已禁用', 'ok'); - } else if (a === 'pause') { - await api('accounts/' + encodeURIComponent(u) + '/pause', { method: 'POST' }); - toast('已暂停选号(签到 / 保活照常)', 'ok'); - } else if (a === 'resume') { - await api('accounts/' + encodeURIComponent(u) + '/resume', { method: 'POST' }); - toast('已恢复选号', 'ok'); - } else if (a === 'tasks') { - openTasks(u); - } else if (a === 'remove') { - const r = await api('accounts/' + encodeURIComponent(u) + '/remove', { method: 'POST' }); - toast(r.file_error ? '已移除(凭证文件删除失败:' + r.file_error + ')' : '已移除', 'ok'); - } - } catch (e) { toast(e.message, 'err'); } - finally { b.disabled = false; loadOverview(true); } -}); - -$('btnCheckinAll').onclick = async () => { - try { await api('checkin_all', { method: 'POST' }); toast('全部签到已开始,结果见日志', 'ok'); } - catch (e) { toast(e.message, 'err'); } -}; -$('btnKeepaliveAll').onclick = async () => { - try { await api('keepalive_all', { method: 'POST' }); toast('全部保活已开始,结果见日志', 'ok'); } - catch (e) { toast(e.message, 'err'); } -}; -$('btnTravelAll').onclick = async () => { - try { await api('travel_all', { method: 'POST' }); toast('旅行巡检已开始(含领养链路),结果见日志', 'ok'); } - catch (e) { toast(e.message, 'err'); } -}; -$('btnActivityAll').onclick = async () => { - try { await api('activity_all', { method: 'POST' }); toast('活跃上报已开始,结果见日志', 'ok'); } - catch (e) { toast(e.message, 'err'); } -}; - -/* ── 模型 ─────────────────────────────────────────────────────────── */ -/* 实测上限标注:scripts/probe_max_tokens.py --panel-out 写入探测结果, - /panel/api/model_probes 只读透传。探测键带域前缀(cn:glm-5.2),模型表 - 显示裸名,按「精确命中或 :后缀」关联。无数据时本列退回上游声称值。 */ -function fmtK(n) { n = Number(n || 0); return n >= 1000 ? Math.round(n / 1000) + 'K' : String(n); } -function probeDays(ts) { - if (!ts) return null; - const t = new Date(String(ts).replace(' ', 'T')); - const d = (Date.now() - t.getTime()) / 86400000; - return isNaN(d) ? null : Math.floor(d); -} -function outCell(m, pr) { - if (!pr) return '' + (m.max_output_tokens ? fmtK(m.max_output_tokens) : '—') + ''; - const tip = '声称 ' + (pr.claimed ? fmtK(pr.claimed) : '?') + ' · 实测 ' + (pr.measured ? fmtK(pr.measured) : '?') + - (pr.note ? ' · ' + pr.note : '') + (pr.tested_at ? ' · 探测于 ' + pr.tested_at : ''); - const days = probeDays(pr.tested_at); - const stale = days !== null && days > 30 ? ' · ' + days + ' 天前' : ''; - if (pr.verdict === 'clamped' && pr.measured) { - if (pr.claimed && pr.measured < pr.claimed) { - const x = pr.claimed / pr.measured; - const xs = (x >= 10 ? Math.round(x) : Math.round(x * 10) / 10) + '×'; - return '' + - fmtK(pr.measured) + ' ⚠
钳制 ' + xs + stale + '
'; - } - return '' + fmtK(pr.measured) + - (pr.claimed && pr.measured > pr.claimed ? ' ↑' : ' ✓') + ''; - } - if (pr.verdict === 'at_least' && pr.measured) - return '≥' + fmtK(pr.measured) + ''; - return '?
未测出' + stale + '
'; -} - -/* rateCell 倍率列:牌价 vs 生效价。上游 credits 是牌价(转正后基准倍率), - modelPromotions 给当前生效折扣(限时免费 factor=0 / 夜间五折 0.5 等)—— - WorkBuddy 客户端显示的正是生效价。有折扣:生效价大字 + 标签 + 划线牌价, - 悬停带时段说明;无 factor 只有标签(错峰类):牌价 + 标签。 */ -function rateCell(m) { - const tip = m.promo_note ? ' title="' + esc(m.promo_note) + '"' : ''; - if (m.promo_factor != null && m.promo_credits) { - const base = m.credits ? ' ' + esc(m.credits) + '' : ''; - const label = m.promo_label ? ' ' + esc(m.promo_label) + '' : ''; - return '' + esc(m.promo_credits) + '' + label + base + ''; - } - if (m.promo_label) { - return '' + (m.credits ? esc(m.credits) : '—') + - ' ' + esc(m.promo_label) + ''; - } - return m.credits ? esc(m.credits) : '—'; -} - -async function loadModels() { - const tb = $('mdBody'); - tb.innerHTML = '
正在向上游查询…
'; - try { - // 探测数据是可选增强:拉取失败不影响模型列表本身 - const [d, pr] = await Promise.all([api('models'), api('model_probes').catch(() => ({}))]); - mdAll = d.models || []; - mdProbes = pr.probes || {}; - if (!mdAll.length) { - tb.innerHTML = '
上游未返回模型
'; - $('mdCount').textContent = ''; - $('mdNote').textContent = '上游未返回模型'; - return; - } - // 探测键带域前缀(cn:glm-5.2),模型表显示裸名,按「精确命中或 :后缀」关联。 - const probeKeys = Object.keys(mdProbes); - mdProbeOf = id => mdProbes[id] || mdProbes[probeKeys.find(k => k.endsWith(':' + id))]; - const hit = mdAll.filter(m => mdProbeOf(m.id)).length; - $('mdNote').textContent = mdAll.length + ' 个模型 · 已刷新降级缓存' + (hit ? ' · ' + hit + ' 个有实测上限' : ''); - renderModels(); - } catch (e) { - mdAll = []; - tb.innerHTML = '
' + esc(e.message) + '
'; - $('mdCount').textContent = ''; - } -} - -/* ── 模型筛选(按条件查询)─────────────────────────────────────────── - 模型目录一次拉全(几十条),筛选与排序全部在前端完成:改条件零延迟,且不会 - 因为调一次筛选就打一次上游——/panel/api/models 是直连上游的实时查询,很贵。 - 条件之间是 AND;每个条件为空即不参与判定。 */ -// mdRateValue 当前生效的积分倍率数值:优先促销价(限时免费 = 0),无倍率记为 -// Infinity 排到最后(排序时"没有价格"不该冒充最便宜)。 -function mdRateValue(m) { - const raw = (m.promo_credits != null && m.promo_credits !== '') ? m.promo_credits : m.credits; - const n = parseFloat(String(raw == null ? '' : raw).replace(/[^\d.]/g, '')); - return Number.isFinite(n) ? n : Infinity; -} - -// mdSearchText 参与关键字搜索的字段(ID / 展示名 / 厂商 / 描述 / 标签)。 -function mdSearchText(m) { - return [m.id, m.name, m.vendor, m.description, (m.tags || []).join(' ')] - .filter(Boolean).join(' ').toLowerCase(); -} - -// mdMatch 单个模型是否满足全部筛选条件。 -function mdMatch(m, f) { - f = f || mdFilter; - if (f.q) { - const text = mdSearchText(m); - // 空格分词后逐个匹配:多关键词是 AND,便于"cn 视觉"这类组合查询。 - for (const kw of f.q.toLowerCase().split(/\s+/).filter(Boolean)) { - if (!text.includes(kw)) return false; - } - } - if (f.realm && !String(m.id || '').startsWith(f.realm + ':')) return false; - if (f.cap === 'tool' && !m.supports_tool_call) return false; - if (f.cap === 'vision' && !m.supports_images) return false; - if (f.cap === 'reasoning' && !m.supports_reasoning) return false; - if (f.cap === 'default' && !m.is_default) return false; - if (f.effort === 'off') { - if (!m.can_disable_thinking) return false; - } else if (f.effort && !(m.supported_efforts || []).includes(f.effort)) { - return false; - } - const factor = m.promo_factor == null ? null : Number(m.promo_factor); - if (f.promo === 'promo' && factor == null && !m.promo_label) return false; - if (f.promo === 'free' && !(factor === 0)) return false; - if (f.promo === 'discount' && !(factor != null && factor > 0)) return false; - return true; -} - -// mdSortList 按当前排序条件返回新数组(不改动入参,保持上游原始顺序可回溯)。 -function mdSortList(list, f) { - f = f || mdFilter; - const out = list.slice(); - const num = v => { const n = Number(v || 0); return Number.isFinite(n) ? n : 0; }; - if (f.sort === 'rate') out.sort((a, b) => mdRateValue(a) - mdRateValue(b)); - else if (f.sort === 'context') out.sort((a, b) => num(b.context_length) - num(a.context_length)); - else if (f.sort === 'output') out.sort((a, b) => num(b.max_output_tokens) - num(a.max_output_tokens)); - else if (f.sort === 'name') out.sort((a, b) => String(a.id || '').localeCompare(String(b.id || ''))); - return out; -} - -// mdRowHtml 单个模型行(纯渲染,便于独立测试)。 -function mdRowHtml(m, pr) { - const eff = (m.supported_efforts || []).slice(); - if (m.can_disable_thinking && eff.length && !eff.includes('off')) eff.push('off(可关)'); - const effs = eff.length ? eff.map(e => '' + esc(e) + '').join(' ') - : '' + (m.supports_reasoning ? '固定档 · 默认 ' + esc(m.default_effort || '?') : '不支持思考') + ''; - // 能力徽标:默认模型 / 工具调用 / 视觉 / 纯推理(上游目录全字段透出,缺失不显示) - const caps = []; - if (m.is_default) caps.push('默认'); - if (m.supports_tool_call) caps.push('工具'); - if (m.supports_images) caps.push('视觉'); - if (m.supports_reasoning && !m.can_disable_thinking) caps.push('思考常开'); - const capHtml = caps.length ? '
' + caps.join(' ') + '
' : ''; - const tip = m.description ? ' title="' + esc(m.description) + '"' : ''; - return '
' + esc(m.id) + '
' + esc(m.name || '') + '
' + capHtml + '' + - '' + rateCell(m) + '' + - '' + (m.default_effort ? '' + esc(m.default_effort) + '' : '—') + '' + - '' + effs + '' + - '' + (m.context_length ? Math.round(m.context_length / 1000) + 'K' : '—') + '' + - outCell(m, pr) + ''; -} - -function renderModels() { - const tb = $('mdBody'); - const list = mdSortList(mdAll.filter(m => mdMatch(m))); - if (!list.length) { - tb.innerHTML = '
没有符合当前筛选条件的模型
'; - } else { - tb.innerHTML = list.map(m => mdRowHtml(m, mdProbeOf(m.id))).join(''); - } - const filtered = list.length !== mdAll.length; - $('mdCount').textContent = !mdAll.length ? '' - : filtered ? '命中 ' + list.length + ' / ' + mdAll.length + ' 个模型' - : mdAll.length + ' 个模型'; - $('mdCount').className = filtered ? 'note src-off' : 'note'; -} - -function resetModelFilter() { - mdFilter = { q: '', realm: '', cap: '', effort: '', promo: '', sort: 'default' }; - $('mdQ').value = ''; $('mdRealm').value = ''; $('mdCap').value = ''; - $('mdEffort').value = ''; $('mdPromo').value = ''; $('mdSort').value = 'default'; - renderModels(); -} - -// 筛选控件:输入框防抖 120ms(长列表逐字符重排不必每键一次),下拉即时。 -let mdQTimer = null; -$('mdQ').oninput = () => { - clearTimeout(mdQTimer); - mdQTimer = setTimeout(() => { mdFilter.q = $('mdQ').value.trim(); renderModels(); }, 120); -}; -for (const [id, key] of [['mdRealm', 'realm'], ['mdCap', 'cap'], ['mdEffort', 'effort'], ['mdPromo', 'promo'], ['mdSort', 'sort']]) { - const el = $(id); - if (!el) continue; - el.onchange = () => { mdFilter[key] = el.value; renderModels(); }; -} -$('mdReset').onclick = resetModelFilter; -$('btnModels').onclick = loadModels; - -/* ── 日志(频道:全部/任务/对话/系统) ─────────────────────────────── */ -let logCh = 'all'; -$('logChips').addEventListener('click', ev => { - const b = ev.target.closest('button[data-ch]'); - if (!b) return; - logCh = b.dataset.ch; - document.querySelectorAll('#logChips .chip').forEach(c => c.classList.toggle('on', c === b)); - loadLogs(); -}); -async function loadLogs() { - const box = $('logBox'); - const atEnd = box.scrollTop + box.clientHeight >= box.scrollHeight - 24; - const limit = ($('reqLimit') && $('reqLimit').value) || 100; - // 时间范围由归档侧过滤(不是前端筛已拉取的条目):区间落在更早的时间段时, - // 「最近 N 条」里根本不会有那些记录,必须让服务端按时间取。 - const rq = trangeQuery('reqRange', false); - rq.set('limit', limit); - try { - const [d, metrics, requestRows] = await Promise.all([ - api('logs'), - api('request_metrics').catch(() => ({})), - api('request_logs?' + rq.toString()).catch(() => ({ entries: [] })), - ]); - // 归档开启时以归档为准——「区间内没有记录」是一个真实结果,不能回落成内存里 - // 的最近 100 条(那会把筛选条件之外、时间范围之外的请求显示出来)。 - // 只有归档关闭时才回落到内存指标,保证没有归档的部署仍能看到最近请求。 - const archiveOn = !!(metrics && metrics.archive && metrics.archive.enabled); - const recent = archiveOn ? (requestRows.entries || []) : (metrics.recent || []); - renderRequestMetrics(metrics, recent); - const entries = (d.entries || []).filter(e => logCh === 'all' || e.ch === logCh); - box.innerHTML = entries.length - ? entries.map(e => { - const lvl = /error|失败|错误/.test(e.text) ? ' e' : /warn|冷却|熔断/.test(e.text) ? ' w' : ''; - const t = e.ts ? new Date(e.ts).toLocaleTimeString('zh-CN', { hour12: false }) : ''; - const ch = logCh === 'all' ? '' + ({ task: '任务', chat: '对话', sys: '系统' }[e.ch] || e.ch) + '' : ''; - return '' + ch + esc(t + ' ' + e.text) + ''; - }).join('') - : '暂无日志'; - if (logPin && atEnd) box.scrollTop = box.scrollHeight; - const counts = {}; - for (const e of (d.entries || [])) counts[e.ch] = (counts[e.ch] || 0) + 1; - $('logNote').textContent = logCh === 'all' - ? '任务 ' + (counts.task || 0) + ' · 对话 ' + (counts.chat || 0) + ' · 系统 ' + (counts.sys || 0) - : (logCh === 'task' ? '任务' : logCh === 'chat' ? '对话' : '系统') + ' ' + entries.length + ' 行'; - } catch (e) { /* 概览已提示 */ } -} - -function renderRequestMetrics(m, entries) { - m = m || {}; - const a = m.archive || {}; - $('reqSummary').textContent = - '已完成 ' + fmtTok(m.completed) + - ' · 成功 ' + (m.success_rate == null ? '—' : Number(m.success_rate).toFixed(1) + '%') + - ' · HTTP ' + (m.http_success_rate == null ? '—' : Number(m.http_success_rate).toFixed(1) + '%') + - ' · 平均 ' + fmtMs(m.avg_duration_ms) + - ' · 进行中 ' + String(m.in_flight || 0); - $('reqNote').textContent = a.enabled - ? 'JSONL 归档 ' + fmtBytes(a.bytes) + (a.dropped_writes ? ' · 丢弃 ' + a.dropped_writes + ' 条' : '') + - (a.last_error ? ' · 错误:' + a.last_error : '') - : '仅内存指标,JSONL 归档已关闭'; - - reqEntries = entries || []; - renderRequestTable(); -} - -/* reqMatch 请求记录筛选:q 对 IP/UA/模型/账号/请求 ID 做空格分词的 AND 包含匹配, - outcome 精确匹配。两者都在已拉取的条目上做(最多 1000 条),不发新请求。 */ -function reqMatch(e, f) { - f = f || reqFilter; - if (f.outcome && String(e && e.outcome || '') !== f.outcome) return false; - if (f.q) { - const text = [e && e.client_ip, e && e.user_agent, e && e.model, e && e.account, e && e.request_id] - .filter(Boolean).join(' ').toLowerCase(); - for (const kw of f.q.toLowerCase().split(/\s+/).filter(Boolean)) { - if (!text.includes(kw)) return false; - } - } - return true; -} - -function reqOutcomeTag(e) { - const outcome = String(e && e.outcome || ''); - const label = { success: '成功', http_error: 'HTTP 错误', stream_error: '流错误', interrupted: '中断' }[outcome] || outcome || '—'; - const cls = outcome === 'success' ? 'ok' - : outcome === 'interrupted' ? 'warn' - : outcome ? 'bad' : 'mute'; - return '' + esc(String(e && e.status || '—') + ' ' + label) + ''; -} - -function reqTokenCell(e) { - const total = Number(e && e.total_tokens || 0) || - (Number(e && e.prompt_tokens || 0) + Number(e && e.completion_tokens || 0)); - return total ? fmtTok(total) : '—'; -} - -function reqCreditCell(e) { - if (!e || !e.credit_known) return '—'; - const v = Number(e.credit); - return Number.isFinite(v) ? trimFixed(v.toFixed(2)) : '—'; -} - -/* renderRequestTable 渲染请求记录表。来源列是这一版的重点:IP 用等宽字体方便扫, - UA 单行截断(完整值在 title 里,行本身用 requestLogText 作 tooltip)。 */ -function renderRequestTable() { - const list = reqEntries.filter(e => reqMatch(e)); - const tb = $('reqBody'); - if (!tb) return; - tb.innerHTML = list.map(e => { - const when = e && e.time ? new Date(e.time).toLocaleTimeString('zh-CN', { hour12: false }) : '—'; - const ip = e && e.client_ip ? e.client_ip : ''; - const ua = e && e.user_agent ? e.user_agent : ''; - const rid = e && e.request_id ? e.request_id : ''; - return '' + - '' + esc(when) + '' + - '' + reqOutcomeTag(e) + '' + - '' + esc(e && e.model || '—') + '' + - '' + esc(e && e.account || '—') + '' + - '' + (ip ? '' + esc(ip) + '' : '—') + '' + - '' + (ua ? '' + esc(ua) + '' : '—') + '' + - '' + fmtMs(e && e.duration_ms) + '' + - '' + reqTokenCell(e) + '' + - '' + reqCreditCell(e) + '' + - '' + (rid ? '' + esc(rid) + '' : '—') + '' + - ''; - }).join('') || '' + - (reqEntries.length ? '没有符合当前筛选条件的请求记录' : '暂无请求记录') + ''; - - const filtered = list.length !== reqEntries.length; - // 归档里的旧条目没有来源字段(该功能上线前写入):这时提示开关/历史原因, - // 而不是让人以为筛选坏了。 - const hasSource = reqEntries.some(e => e && (e.client_ip || e.user_agent)); - $('reqCount').textContent = !reqEntries.length ? '' - : (filtered ? '命中 ' + list.length + ' / ' + reqEntries.length + ' 条' : reqEntries.length + ' 条') + - (hasSource ? '' : ' · 来源未记录'); - $('reqCount').className = (filtered || !hasSource) ? 'note src-off' : 'note'; -} - -/* 请求记录筛选控件。搜索框防抖 150ms:最多 1000 行重渲染,不必每键一次。 - 这段顶层绑定放在 requestLogText 之前,是为了让"纯函数切片"式前端测试 - (slice requestLogText → fmtBytes)只拿到无副作用的格式化函数。 */ -let reqQTimer = null; -if ($('reqQ')) $('reqQ').oninput = () => { - clearTimeout(reqQTimer); - reqQTimer = setTimeout(() => { reqFilter.q = $('reqQ').value.trim(); renderRequestTable(); }, 150); -}; -if ($('reqOutcome')) $('reqOutcome').onchange = () => { - reqFilter.outcome = $('reqOutcome').value; - renderRequestTable(); -}; -if ($('reqLimit')) $('reqLimit').onchange = loadLogs; -if ($('btnReqReload')) $('btnReqReload').onclick = loadLogs; -// 时间范围:默认「全部历史」——请求记录页的历史行为就是"取最近 N 条", -// 加一个默认收窄的区间会让打开页面时看到的条数凭空变少。 -if ($('reqRange')) trangeBind('reqRange', loadLogs, '0'); - -function requestLogText(e) { - const when = e && e.time ? new Date(e.time).toLocaleTimeString('zh-CN', { hour12: false }) : '—'; - const outcomeLabel = { success: '成功', http_error: 'HTTP 错误', stream_error: '流错误', interrupted: '中断' }; - const token = Number(e && e.total_tokens || 0) || - (Number(e && e.prompt_tokens || 0) + Number(e && e.completion_tokens || 0)); - let credit = 'credit —'; - if (e && e.credit_known) { - const value = Number(e.credit); - if (Number.isFinite(value)) credit = String(Number(value.toFixed(2))) + ' credit'; - } - return [ - when, - String(e && e.status || '—') + ' ' + (outcomeLabel[e && e.outcome] || (e && e.outcome) || '—'), - e && e.model || '—', - e && e.account || '—', - e && e.client_ip || '—', - e && e.user_agent || '—', - fmtMs(e && e.duration_ms), - fmtTok(token) + ' tok', - credit, - cacheRateText(e && e.cache_hit_tokens, e && e.cache_miss_tokens) === '—' ? '' : '命中 ' + cacheRateText(e && e.cache_hit_tokens, e && e.cache_miss_tokens), - e && e.request_id || '—', - ].filter(Boolean).join(' | '); -} - -/* 缓存命中率纯文本(issue #92):requestLogText 与积分表/kpi 卡共用。 - 自包含(不依赖 trimFixed):前端纯函数切片测试只截取本段。 */ -function cacheRateText(hit, miss) { - const h = Number(hit || 0), m = Number(miss || 0), total = h + m; - if (!total) return '—'; - return String(Math.round(h / total * 1000) / 10) + '%'; -} - -function fmtBytes(bytes) { - const n = Number(bytes || 0); - if (n < 1024) return n + ' B'; - if (n < 1024 * 1024) return (n / 1024).toFixed(1) + ' KB'; - return (n / 1024 / 1024).toFixed(1) + ' MB'; -} -$('btnLogPin').onclick = () => { - logPin = !logPin; - $('btnLogPin').textContent = '自动滚动:' + (logPin ? '开' : '关'); -}; - -/* ── 配置 ─────────────────────────────────────────────────────────── */ -const CFG_MAP = { - listen: ['listen'], api_key: ['api_key'], - package_detail_limit: ['panel', 'package_detail_limit'], - checkin_hours: ['schedule', 'checkin_hours'], checkin_enabled: ['schedule', 'checkin_enabled'], growth_hours: ['schedule', 'growth_hours'], growth_enabled: ['schedule', 'growth_enabled'], - travel_hours: ['schedule', 'travel_hours'], travel_enabled: ['schedule', 'travel_enabled'], - activity_hours: ['schedule', 'activity_hours'], activity_enabled: ['schedule', 'activity_enabled'], - keepalive_hours: ['schedule', 'keepalive_hours'], keepalive_enabled: ['schedule', 'keepalive_enabled'], - balance_refresh_enabled: ['schedule', 'balance_refresh_enabled'], balance_refresh_minutes: ['schedule', 'balance_refresh_minutes'], - include_disabled_in_tasks: ['schedule', 'include_disabled_in_tasks'], - max_in_flight: ['pool', 'max_in_flight'], max_in_flight_global: ['pool', 'max_in_flight_global'], - breaker_threshold: ['pool', 'breaker_threshold'], - degrade_threshold: ['pool', 'degrade_threshold'], degrade_cooldown: ['pool', 'degrade_cooldown'], - degrade_cooldown_max: ['pool', 'degrade_cooldown_max'], - cost_explore_interval: ['pool', 'cost_explore_interval'], - credit_floor: ['pool', 'credit_floor'], - prefer_expiring: ['pool', 'prefer_expiring'], expiring_soon: ['pool', 'expiring_soon'], - soft_rate: ['cooldown', 'soft_rate'], soft_rate_max: ['cooldown', 'soft_rate_max'], - breaker_cooldown: ['pool', 'breaker_cooldown'], breaker_cooldown_max: ['pool', 'breaker_cooldown_max'], - idle_weight_per_hour: ['pool', 'idle_weight_per_hour'], idle_weight_max: ['pool', 'idle_weight_max'], - ttl: ['session_sticky', 'ttl'], - timeout_seconds: ['upstream', 'timeout_seconds'], header_timeout_seconds: ['upstream', 'header_timeout_seconds'], - idle_timeout_seconds: ['upstream', 'idle_timeout_seconds'], user_agent: ['upstream', 'user_agent'], - prompt_mode: ['prompt', 'mode'], prompt_file: ['prompt', 'file'], - sanitize_blacklist_fingerprints: ['features', 'sanitize_blacklist_fingerprints'], - session_sticky_enabled: ['session_sticky', 'enabled'], - request_client_info: ['logging', 'request_client_info'], -}; -/* 「覆盖型」文本字段:空串本身是有意义的取值(= 回落到内置默认),必须照发。 - * - * 其余文本字段保持「空 = 不下发」的既有语义——那是防误清空的保护,不是 bug: - * 表单里某个框没填,通常意味着"没改",把它当成"请清空"会静默抹掉配置。 - * - * 但覆盖型字段正好相反:清空 = 明确要求回到默认。漏发它们会让面板显示"已保存" - * 而值其实没变(issue #102 附带发现 2:user_agent 清空后 config.json 里仍是旧值)。 - * - * 刻意不含 api_key:清空它 = 关闭整个鉴权,误触代价是网关变成无鉴权公开服务。 - * 该字段(以及提示文案"留空 = 不鉴权"与现状不符的问题)单独处理。 - */ -const CLEARABLE_CFG = new Set(['user_agent', 'prompt_file']); - -function dig(obj, path) { return path.reduce((o, k) => (o == null ? undefined : o[k]), obj); } -function put(obj, path, val) { - let o = obj; - for (let i = 0; i < path.length - 1; i++) { if (typeof o[path[i]] !== 'object' || o[path[i]] === null) o[path[i]] = {}; o = o[path[i]]; } - o[path[path.length - 1]] = val; -} - -async function loadConfig() { - try { - const d = await api('config'); - cfgLoaded = d.config; - $('cfgPath').textContent = d.path || ''; - const f = $('cfgForm'); - for (const [name, path] of Object.entries(CFG_MAP)) { - const el = f.elements[name]; - if (!el) continue; - const v = dig(cfgLoaded, path); - if (el.type === 'checkbox') el.checked = !!v; - else if (Array.isArray(v)) el.value = v.join(', '); - else el.value = v == null ? '' : v; - } - markDurationFields(); // 回填后重置校验态(清掉残留红框;现值来自后端必然合法) - $('cfgNote').textContent = ''; - } catch (e) { toast('读取配置失败:' + e.message, 'err'); } -} -function collectConfig() { - const f = $('cfgForm'), out = {}; - for (const [name, path] of Object.entries(CFG_MAP)) { - const el = f.elements[name]; - if (!el) continue; - let v; - if (el.type === 'checkbox') v = el.checked; - else if (el.type === 'number') { v = el.value.trim() === '' ? undefined : Number(el.value); } - else { - const raw = el.value.trim(); - // 覆盖型字段空串照发(见 CLEARABLE_CFG);其余空 = 不下发。 - if (raw === '') v = CLEARABLE_CFG.has(name) ? '' : undefined; - else if (name.endsWith('_hours')) v = raw.split(/[,,\s]+/).filter(Boolean).map(Number); - else v = raw; - } - if (v !== undefined) put(out, path, v); - } - return out; -} -/* Go 时长字段即时校验:空 = 沿用现值(collectConfig 跳过发送);非空必须是 - ParseDuration 语法(30m / 2h / 600s / 1h30m,可组合可带小数)。与后端 - config.go normalize() 的 time.ParseDuration 同口径,脏值在前端就地标红, - 不再等到保存被拒。 */ -const DURATION_RE = /^(\d+(\.\d+)?(ns|us|µs|ms|s|m|h))+$/; -const DURATION_FIELDS = ['soft_rate', 'soft_rate_max', 'breaker_cooldown', 'breaker_cooldown_max', - 'degrade_cooldown', 'degrade_cooldown_max', 'cost_explore_interval', 'expiring_soon', 'ttl']; -const DURATION_TIP = '格式应为 Go 时长:30m / 2h / 600s / 1h30m'; -function durationBad(name) { - const el = $('cfgForm').elements[name]; - if (!el) return false; - const v = el.value.trim(); - return v !== '' && !DURATION_RE.test(v); -} -function markDurationFields() { - for (const name of DURATION_FIELDS) { - const el = $('cfgForm').elements[name]; - if (!el) continue; - const bad = durationBad(name); - el.classList.toggle('invalid', bad); - el.title = bad ? DURATION_TIP : ''; - } -} -$('cfgForm').addEventListener('input', ev => { - if (DURATION_FIELDS.includes(ev.target.name)) markDurationFields(); -}); -$('btnEye').onclick = () => { - const el = $('cfgKey'); - const show = el.type === 'password'; - el.type = show ? 'text' : 'password'; - $('btnEye').textContent = show ? '隐藏' : '显示'; -}; -$('btnCfgReload').onclick = loadConfig; -$('cfgForm').onsubmit = async ev => { - ev.preventDefault(); - // 时长字段脏值拦截:标红 + toast 点名,不发保存请求(后端同样会拒,这里前置)。 - markDurationFields(); - const firstBad = DURATION_FIELDS.find(durationBad); - if (firstBad) { - const el = $('cfgForm').elements[firstBad]; - el.focus(); - toast('「' + (el.closest('.fld')?.querySelector('.lb')?.textContent || firstBad) + '」' + DURATION_TIP, 'err'); - return; - } - const btn = $('btnCfgSave'); - btn.disabled = true; btn.textContent = '保存中…'; - try { - const r = await api('config', { method: 'POST', body: JSON.stringify(collectConfig()) }); - const n = (r.restart_required || []).length; - toast(n ? '配置已保存,其中 ' + n + ' 项需重启进程生效' : '配置已保存并立即生效', 'ok'); - // 密钥可能已改:本次会话沿用新值,避免下一次轮询被 401。 - const k = $('cfgKey').value.trim(); - if (k) localStorage.setItem(LS_KEY, k); - loadConfig(); - loadOverview(true); - } catch (e) { toast('保存失败:' + e.message, 'err'); } - finally { btn.disabled = false; btn.textContent = '保存配置'; } -}; - -/* ── 添加账号 ─────────────────────────────────────────────────────── */ -function openAdd() { - $('addVeil').classList.add('on'); - // 重置到登录标签 - switchAddTab('login'); - $('addPick').hidden = false; - $('addLoad').hidden = true; $('addReady').hidden = true; - $('addDone').hidden = true; $('addErr').hidden = true; - $('importDone').hidden = true; $('importErr').hidden = true; - $('btnCopyUrl').hidden = true; $('btnOpenUrl').hidden = true; - $('btnStartLogin').hidden = false; $('btnStartLogin').disabled = false; - stopPoll(); -} -function switchAddTab(tab) { - document.querySelectorAll('#addTabs .tab').forEach(b => b.classList.toggle('on', b.dataset.tab === tab)); - $('addTabLogin').hidden = tab !== 'login'; - $('addTabImport').hidden = tab !== 'import'; -} -document.querySelectorAll('#addTabs .tab').forEach(b => { - b.onclick = () => switchAddTab(b.dataset.tab); -}); -function startAddLogin() { - const realm = (document.querySelector('input[name="addRealm"]:checked') || {}).value || 'cn'; - $('btnStartLogin').disabled = true; - $('addLoad').hidden = false; $('addErr').hidden = true; - api('login/start', { method: 'POST', body: JSON.stringify({ realm }) }).then(r => { - loginState = r.state; - $('addUrl').textContent = r.url; - $('addPick').hidden = true; // 选域锁定(会话已按该域发起) - $('addLoad').hidden = true; $('addReady').hidden = false; - $('btnStartLogin').hidden = true; - $('btnCopyUrl').hidden = false; $('btnOpenUrl').hidden = false; - loginTimer = setInterval(pollLogin, 3000); - }).catch(e => { - $('addLoad').hidden = true; - $('btnStartLogin').disabled = false; - $('addErr').hidden = false; - $('addErr').textContent = e.message; - }); -} -function stopPoll() { if (loginTimer) { clearInterval(loginTimer); loginTimer = null; } } -async function pollLogin() { - if (!loginState) return; - try { - const r = await api('login/poll?state=' + encodeURIComponent(loginState)); - if (r.done) { - stopPoll(); - $('addReady').hidden = true; - $('addDone').hidden = false; - $('addDone').textContent = '已添加 ' + (r.nickname || r.uid) + (r.realm === 'global' ? '(国际版)' : '') + (r.credits >= 0 ? ' · 积分 ' + r.credits + (r.credits_total > 0 ? '/' + r.credits_total : '') : '') + ',账号已载入池中'; - setTimeout(() => { closeAdd(); loadOverview(true); }, 1600); - } - } catch (e) { - stopPoll(); - $('addReady').hidden = true; - $('addErr').hidden = false; - $('addErr').textContent = e.message + '(关闭后重新添加)'; - } -} -function closeAdd() { stopPoll(); loginState = null; $('addVeil').classList.remove('on'); } -$('btnCloseAdd').onclick = closeAdd; -$('btnStartLogin').onclick = startAddLogin; -$('btnOpenUrl').onclick = () => open($('addUrl').textContent, '_blank'); -$('btnCopyUrl').onclick = () => navigator.clipboard.writeText($('addUrl').textContent) - .then(() => toast('链接已复制', 'ok'), () => toast('复制失败,请手动选择复制', 'err')); -$('importFile').onchange = async () => { - const file = $('importFile').files[0]; - if (!file) return; - $('importDone').hidden = true; $('importErr').hidden = true; - const fd = new FormData(); - fd.append('file', file); - const h = {}; - const k = localStorage.getItem(LS_KEY); - if (k) h['Authorization'] = 'Bearer ' + k; - try { - const r = await fetch('/panel/api/import/cockpit', { method: 'POST', body: fd, headers: h }); - const d = await r.json(); - if (!r.ok) throw new Error(d.error || ('HTTP ' + r.status)); - $('importDone').hidden = false; - $('importDone').textContent = '导入完成:成功 ' + d.imported + ' 个' + (d.skipped ? ',跳过 ' + d.skipped + ' 个' : ''); - if (d.errors && d.errors.length) { - console.warn('import errors:', d.errors); - } - loadOverview(true); - } catch (e) { - $('importErr').hidden = false; - $('importErr').textContent = '导入失败:' + e.message; - } - $('importFile').value = ''; -}; - -/* ── 顶部动作 ─────────────────────────────────────────────────────── */ -$('btnAdd').onclick = openAdd; -$('btnRefresh').onclick = async () => { - const b = $('btnRefresh'); - b.disabled = true; b.textContent = '刷新中…'; - try { - await api('balance_all', { method: 'POST' }); - await loadOverview(true); - toast('余额已从上游刷新', 'ok'); - } catch (e) { toast('刷新失败:' + e.message, 'err'); await loadOverview(true); } - finally { b.disabled = false; b.textContent = '刷新'; } - if (view === 'logs') loadLogs(); -}; - -/* ── 轮询 ─────────────────────────────────────────────────────────── */ -function refreshVisible() { - if (view === 'accounts') loadOverview(true); - else if (view === 'logs') loadLogs(); - else if (view === 'taskscenter') reattachQueueView(); -} -function start() { - loadOverview(true); - if (refTimer) clearInterval(refTimer); - refTimer = setInterval(refreshVisible, 5000); - checkAuthGate(); -} -async function checkAuthGate() { - try { await api('overview'); } - catch (e) { if (String(e.message).includes('密钥') || String(e.message).includes('api_key')) return; } -} -start(); - -/* ── 积分任务 ─────────────────────────────────────────────────────── */ -let taskUID = null; - -// 可自动完成的任务(与后端 autoActions 表一致):判据为行为事件、可经网关复现。 -// 其余任务需在官方客户端内交互,面板只展示指引(行 title 提示)。 -// 注意:键含点号(Model_chat_GLM5.2)必须加引号,否则会被解析成属性访问 + 数字字面量。 -const AUTO_TASKS = { - 'chat_5': '上报 5 条对话活跃事件(自动补足差额)', - 'first_buddy': '上报解锁 → 同意协议 → 领取第一只 Buddy', - 'Model_chat_GLM5.2': '接受任务 → glm-5.2 真实对话一次 → 对齐模型上报', - 'RichMeow_Chat': '桌面指纹事件链上报(已验证可点亮)', - 'Buddy_App': '上报「进入 Buddy 应用」事件链(已验证可点亮)', - 'Buddy_App_QQ': '上报「进入企鹅教师助手」事件链(已验证可点亮)', - 'automation_1': '上报「定时任务创建」事件(已验证可点亮)', - 'Library_read': '上报「读资料库介绍」事件(已验证可点亮)', - 'template_5': '上报「使用模板创建任务」事件组 ×5(三账号实测点亮)', - 'playbook_prompt': '上报「灵感案例做同款发送 Prompt」事件组(三账号实测点亮)', - 'create_canvas': '上报「设计创意画布创建」事件组(三账号实测点亮,+300 分)', - 'expert_5': '真实专家召唤+使用链 ×5(专家市场+真实 chat,三账号实测点亮)', - 'Expert_team_use_3': '真实专家团召唤+使用链 ×3(三账号实测点亮)', - 'Hp_Appearance': '设置主题 API + 皮肤生效事件(两账号实测点亮)', - 'black_cat': '夜猫子:23:00–08:00 窗口内 glm-5.2 对话补足(窗口外提示等 23 点排程)', - 'Expert_lighthouse': '真实轻量云专家召唤+使用链(真实对话 requestId,两账号实测点亮)', - 'skill_1': '真实对话 + skill_info 技能加载事件(实测点亮)', - 'school_season': '校园日(小程序口径):accept → mini 对话+activityId 上报 → 领奖(+100c+5e)', - 'Sequential_Tasks_1': '小程序首对话(小程序口径):accept → mini 对话上报 → 领奖(+100c+5e)', - 'Sequential_Tasks_2': '小程序选专家对话(小程序口径):市场专家 id → accept → expert_actual_use 上报 → 领奖(+200c+5e)', - 'Sequential_Tasks_3': '小程序五次对话(小程序口径):accept → mini 对话上报 ×5(自动补差额)→ 领奖(+300c+5e)', - 'Sequential_Tasks_4': '小程序定时任务(预留,每日零点解锁一环):accept → 定时任务创建事件 → 领奖(判据待解锁验证)', - 'Sequential_Tasks_5': '小程序使用 GLM5.2(预留):accept → 带模型字段的 mini 对话上报 → 领奖(判据待解锁验证)', - 'Sequential_Tasks_6': '小程序十次对话(预留):accept → mini 对话上报 ×target(自动补差额)→ 领奖', - 'Sequential_Tasks_7': '体验灵感功能(预留,疑 PC 口径):accept → 灵感事件组(PC+mp 双形态)→ 领奖(判据待解锁验证)' -}; - -function openTasks(uid) { - taskUID = uid; - $('taskWho').textContent = uid.slice(0, 16); - $('taskVeil').classList.add('on'); - $('btnTaskReload').hidden = false; - loadTasks(); -} -function closeTasks() { $('taskVeil').classList.remove('on'); taskUID = null; } -$('btnCloseTask').onclick = closeTasks; -$('btnTaskReload').onclick = loadTasks; - -// 全部接受:把该账号未接受的任务一次性报名(幂等,跳过已接受/已领取)。 -$('btnTaskAcceptAll').onclick = async () => { - if (!taskUID) return; - const btn = $('btnTaskAcceptAll'); - btn.disabled = true; btn.textContent = '接受中…'; - try { - const r = await api('accounts/' + encodeURIComponent(taskUID) + '/tasks/accept_all', { method: 'POST' }); - const n = r.accepted || 0; - if (r.failed && r.failed.length) { - toast(`已接受 ${n} 个,${r.failed.length} 个被上游拒绝(可重试)`, 'err'); - } else { - toast(n ? `已接受 ${n} 个任务` : (r.message || '所有任务均已接受'), 'ok'); - } - } catch (e) { toast(e.message, 'err'); } - finally { btn.disabled = false; btn.textContent = '全部接受'; loadTasks(); } -}; - -// 一键完成全部可自动任务(耗时较长:含真实对话,逐项回读验证)。 -$('btnTaskAutoAll').onclick = async () => { - if (!taskUID) return; - const btn = $('btnTaskAutoAll'); - if (!confirm('将依次执行:补报对话事件、领取 Buddy、glm-5.2 对话、尝试上报。\n过程约 1-2 分钟(含真实对话),确认继续?')) return; - btn.disabled = true; btn.textContent = '执行中…'; - try { - const r = await api('accounts/' + encodeURIComponent(taskUID) + '/tasks/auto_all', { method: 'POST' }); - const okN = (r.results || []).filter(x => x.status === 'done').length; - const skipN = (r.results || []).filter(x => x.status === 'skipped').length; - const errN = (r.results || []).filter(x => x.status === 'error').length; - toast(`执行完成:成功 ${okN} 项,跳过 ${skipN} 项${errN ? ',失败 ' + errN + ' 项' : ''}`, errN ? 'err' : 'ok'); - console.log('auto_all results:', r.results); - } catch (e) { toast(e.message, 'err'); } - finally { btn.disabled = false; btn.textContent = '一键完成可自动任务'; loadTasks(); } -}; - -async function loadTasks() { - if (!taskUID) return; - const st = $('taskState'), tb = $('taskTable'); - st.hidden = false; - st.className = 'state'; - st.innerHTML = '查询中'; - tb.hidden = true; - try { - const d = await api('accounts/' + encodeURIComponent(taskUID) + '/tasks'); - const list = d.tasks || []; - if (!list.length) { - st.className = 'state'; - st.textContent = '该账号暂无任务'; - return; - } - // 有进度或可领取的排前面,已领取沉底——一眼看到"现在该做什么"。 - list.sort((a, b) => (a.claimed - b.claimed) || (b.claimable - a.claimable) || String(a.task_code).localeCompare(String(b.task_code))); - $('taskBody').innerHTML = list.map(t => { - // 进度:current 可能缺失(0 或被上游省略)——用 ?? 兜底,避免渲染成 "undefined / N" - const cur = t.current ?? 0, tgt = t.target ?? 0; - const prog = tgt ? cur + ' / ' + tgt : (tgt === 0 && cur > 0 ? String(cur) : '—'); - const parts = []; - if (t.credit) parts.push('+' + t.credit + ' 分'); - if (t.energy) parts.push('+' + t.energy + ' 能'); - if (t.reward_buddy) parts.push('Buddy'); - const reward = parts.length ? parts.join(' ') : '—'; - const badge = t.claimed ? '已领取' - : t.claimable ? '可领取' - : t.locked ? '未解锁' - : t.accept_status === 'accepted' ? '进行中' - : '未接受'; - const acted = t.claimed || t.locked ? '' - : t.claimable ? '' - : AUTO_TASKS[t.task_code] ? '' - : t.accept_status === 'accepted' ? '' - : ''; - // 操作指引(description/task_desc)挂 title 提示:如何完成交给用户看 - const tip = [t.title, t.task_desc || t.description, t.jump_url ? '跳转:' + t.jump_url : ''].filter(Boolean).join('\n'); - return '' + - '
' + esc(t.title || t.task_code) + '
' + esc(t.task_code) + (t.tag ? ' · ' + esc(t.tag) : '') + '
' + - '' + esc(prog) + '' + - '' + esc(reward) + '' + - '' + badge + '' + - '' + acted + ''; - }).join(''); - st.hidden = true; - tb.hidden = false; - } catch (e) { - st.className = 'state err'; - st.textContent = e.message; - } -} - -$('taskBody').addEventListener('click', async ev => { - const b = ev.target.closest('button[data-t]'); - if (!b || !taskUID) return; - const kind = b.dataset.t, code = b.dataset.c; - b.disabled = true; - try { - if (kind === 'auto') { - // 一键完成:后端执行动作 → 回读进度 → 汇报(耗时可到分钟级,含真实对话) - b.textContent = '执行中…'; - const r = await api('accounts/' + encodeURIComponent(taskUID) + '/tasks/auto', { - method: 'POST', body: JSON.stringify({ task_code: code }) - }); - if (r.skipped) { - toast(r.message || '已跳过', 'ok'); - } else { - const advanced = r.progress_before !== r.progress_after; - let msg = r.message || '已执行'; - if (r.progress_after) msg += `(进度 ${r.progress_before} → ${r.progress_after})`; - if (r.claimed) msg += ',奖励已自动到账'; - else if (r.claimable) msg += r.claim_error ? ',可点「领取」重试' : ''; - else if (r.attempt && !advanced) msg += ';进度未动,该任务可能需要官方客户端'; - toast(msg, (r.claimed || advanced) ? 'ok' : 'err'); - } - loadOverview(true); - } else { - const path = 'accounts/' + encodeURIComponent(taskUID) + '/tasks/' + (kind === 'claim' ? 'claim' : 'accept'); - const body = kind === 'claim' ? { task_code: code } : { task_codes: [code] }; - await api(path, { method: 'POST', body: JSON.stringify(body) }); - toast(kind === 'claim' ? '已领取奖励' : '已接受任务', 'ok'); - if (kind === 'claim') loadOverview(true); - } - } catch (e) { toast(e.message, 'err'); } - finally { loadTasks(); } -}); - -/* ── 任务中心:开学季 + 全账号扫描/队列 ──────────────────────────── */ -// 开学季任务单元:✓ 已领(绿)|◐ x/y 进行中(琥珀)|○ 未做(灰) -function staskHTML(t) { - if (!t) return '·—'; - if (t.status === 'claimed') return '✓已领'; - if (t.status === 'completed') return '◆可领'; - if (t.status === 'in_progress') { - const fr = t.target_count ? '' + t.progress + '/' + t.target_count + '' : ''; - return '◐' + fr + ''; - } - return '○未做'; -} -const LUCK_SVG = ''; -const SCHOOL_TITLES = { - share_invite: '分享活动 +100c', desktop_chat_1_time: '桌面端体验 +100c(单次)', - chat_3_times: '和 AI 对话 3 次 +50c', expert_use: '召唤开学季专家 +50c', - task_student_verify: '学生认证 +100c(需真实认证,不做)', -}; - -/* ── 精简 QR 编码器(券码二维码用)──────────────────────────────────── - 规格子集:byte 模式、ECC L、版本 1-5(全部单纠错块,免块交织)、固定掩码 0。 - 完整性:规范允许任选掩码(解码器按格式信息位自行去掩码),固定掩码不影响 - 可扫描性;已用 python qrcode 库对多输入多版本做逐像素交叉验证(强制 byte - 模式 + mask 0,5/5 全部 diff=0)。面板 CSP 只允许 self,外链 QR 服务不可用。 */ -// qr_gen.js —— 精简 QR 编码器(浏览器用 + node 可跑交叉验证) -// 规格子集:byte 模式、ECC L、版本 1-5(全部单纠错块,免块交织)、固定掩码 0。 -// 完整性说明:规范允许编码器任选掩码(解码器按格式信息位自行去掩码), -// 固定掩码不影响可扫描性;券码为短文本,v1-5(26 字节起)绰绰有余。 - -// GF(256) 对数/指数表(本原多项式 0x11d) -const QR_EXP = new Array(512), QR_LOG = new Array(256); -(() => { - let x = 1; - for (let i = 0; i < 255; i++) { QR_EXP[i] = x; QR_LOG[x] = i; x <<= 1; if (x & 0x100) x ^= 0x11d; } - for (let i = 255; i < 512; i++) QR_EXP[i] = QR_EXP[i - 255]; -})(); -const gmul = (a, b) => (a && b) ? QR_EXP[QR_LOG[a] + QR_LOG[b]] : 0; - -// 各版本参数(下标 = 版本-1):[数据码字数, 纠错码字数],ECC L 单块 -const QR_V = [[19, 7], [34, 10], [55, 15], [80, 20], [108, 26]]; -// 对齐图案中心坐标(v2+;与定位图案重叠的位置在放置时跳过) -const QR_ALIGN = [[], [6, 18], [6, 22], [6, 26], [6, 30]]; -const QR_MASK = (r, c) => (r + c) % 2 === 0; // 掩码模式 0 - -// 生成多项式(最高次系数在前,g[0] 恒为 1) -function qrGenPoly(deg) { - let g = [1]; - for (let i = 0; i < deg; i++) { - const a = QR_EXP[i], ng = new Array(g.length + 1).fill(0); - ng[0] = g[0]; - for (let j = 1; j < g.length; j++) ng[j] = g[j] ^ gmul(a, g[j - 1]); - ng[g.length] = gmul(a, g[g.length - 1]); - g = ng; - } - return g; -} - -// Reed-Solomon 求余(综合除法),返回 deg 个纠错码字 -function rsRem(data, deg) { - const g = qrGenPoly(deg); - const res = data.concat(new Array(deg).fill(0)); - for (let i = 0; i < data.length; i++) { - const f = res[i]; - if (f) for (let j = 0; j < g.length; j++) res[i + j] ^= gmul(g[j], f); - } - return res.slice(data.length); -} - -// 文本 → 码字流(byte 模式:0100 + 8 位计数 + 数据 + 终止符 + 0xEC/0x11 填充) -function qrDataCodewords(text, dataCap) { - const bytes = Array.from(new TextEncoder().encode(text)); - const bits = []; - const push = (val, n) => { for (let i = n - 1; i >= 0; i--) bits.push((val >> i) & 1); }; - push(4, 4); // byte 模式 - push(bytes.length, 8); // v1-9 计数 8 位 - for (const b of bytes) push(b, 8); - const cap = dataCap * 8; - push(0, Math.min(4, cap - bits.length)); // 终止符 - while (bits.length % 8) bits.push(0); - const out = []; - for (let i = 0; i < bits.length; i += 8) { - let v = 0; for (const b of bits.slice(i, i + 8)) v = (v << 1) | b; - out.push(v); - } - for (let p = 0; out.length < dataCap; p ^= 1) out.push(p ? 0x11 : 0xEC); - return out; -} - -// 主入口:text → 布尔矩阵(true=深色模块) -function qrMatrix(text) { - const bytes = Array.from(new TextEncoder().encode(text)); - // 版本选择:需求 ≈ 2 码字头 + 文本长度,取首个放得下的版本 - let ver = 0; - for (let v = 0; v < QR_V.length; v++) { if (bytes.length + 2 <= QR_V[v][0]) { ver = v + 1; break; } } - if (!ver) throw new Error('QR: text too long (>' + QR_V[4][0] + ' bytes)'); - const [dataCap, ecCap] = QR_V[ver - 1]; - const n = 17 + 4 * ver; - - const M = Array.from({ length: n }, () => new Array(n).fill(false)); - const F = Array.from({ length: n }, () => new Array(n).fill(false)); // 功能模块占位 - - const setF = (r, c, v) => { M[r][c] = v; F[r][c] = true; }; - // 定位图案 + 分隔带 - const finder = (r0, c0) => { - for (let r = -1; r <= 7; r++) for (let c = -1; c <= 7; c++) { - const rr = r0 + r, cc = c0 + c; - if (rr < 0 || cc < 0 || rr >= n || cc >= n) continue; - const dark = r >= 0 && r <= 6 && c >= 0 && c <= 6 && (r === 0 || r === 6 || c === 0 || c === 6 || (r >= 2 && r <= 4 && c >= 2 && c <= 4)); - setF(rr, cc, dark); - } - }; - finder(0, 0); finder(0, n - 7); finder(n - 7, 0); - // 校正图形(仅贯穿两定位图案之间:8..n-9,不得覆盖定位图案本体) - for (let r = 8; r <= n - 9; r++) setF(r, 6, r % 2 === 0); - for (let c = 8; c <= n - 9; c++) setF(6, c, c % 2 === 0); - // 对齐图案(v2+,跳过与定位重叠处) - const align = QR_ALIGN[ver - 1] || []; - for (const ar of align) for (const ac of align) { - if (F[ar][ac]) continue; - for (let r = -2; r <= 2; r++) for (let c = -2; c <= 2; c++) - setF(ar + r, ac + c, Math.max(Math.abs(r), Math.abs(c)) !== 1); - } - // 暗模块 + 格式信息(ECC L=01,掩码 0)——BCH(15,5) + 0x5412 异或。 - // 位序遵循规范(与 python qrcode 逐位对齐验证):bit i 从 LSB 起数, - // 副本一走左上角 L 形、副本二走右下 L 形。 - let fmt = (1 << 3) | 0; // L<<3 | mask - let rem = fmt << 10; - for (let i = 14; i >= 10; i--) if ((rem >> i) & 1) rem ^= 0x537 << (i - 10); - fmt = ((fmt << 10) | rem) ^ 0x5412; // 15 位 - const fb = i => (fmt >> i) & 1; - // 副本一(左上):位 0..5 → (i,8);6 → (7,8);7 → (8,8) - for (let i = 0; i <= 5; i++) setF(i, 8, !!fb(i)); - setF(7, 8, !!fb(6)); setF(8, 8, !!fb(7)); - // 副本一续 + 副本二(右下):位 8..14 → (n-15+i, 8);位 0..7 → (8, n-1-i);8 → (8,7);9..14 → (8,14-i) - for (let i = 8; i <= 14; i++) setF(n - 15 + i, 8, !!fb(i)); - for (let i = 0; i <= 7; i++) setF(8, n - 1 - i, !!fb(i)); - setF(8, 7, !!fb(8)); - for (let i = 9; i <= 14; i++) setF(8, 14 - i, !!fb(i)); - // 暗模块(恒为深色,位于副本一垂直段末端) - setF(n - 8, 8, true); - - - // 数据码字 + 纠错码字 → 位流 - const dcw = qrDataCodewords(text, dataCap); - const cw = dcw.concat(rsRem(dcw, ecCap)); - const bits = []; - for (const b of cw) for (let i = 7; i >= 0; i--) bits.push((b >> i) & 1); - - // 蛇形放置(成对列,从右向左,跳过第 6 列),写数据时直接异或掩码 - let bi = 0, up = true; - for (let x = n - 1; x > 0; x -= 2) { - if (x === 6) x--; - for (let i = 0; i < n; i++) { - const r = up ? n - 1 - i : i; - for (const c of [x, x - 1]) { - if (F[r][c]) continue; - const bit = bi < bits.length ? bits[bi++] : 0; - M[r][c] = bit ? !QR_MASK(r, c) : QR_MASK(r, c); - } - } - up = !up; - } - return M; -} - -// 矩阵 → SVG(quiet zone 4 模块) -function qrSVG(M, px) { - const n = M.length, q = 4, total = n + q * 2; - let s = ''; - for (let r = 0; r < n; r++) for (let c = 0; c < n; c++) - if (M[r][c]) s += ''; - return s + ''; -} - -/* ── 开学季券码查询(弹窗,仿活动页 #/prizes?tab=vouchers)──────────── */ -/* copyText:clipboard API 只在 secure context(https/localhost)可用, - 远程 http 面板会拿不到 navigator.clipboard → 降级 execCommand。 */ -function copyText(text) { - if (navigator.clipboard && window.isSecureContext) return navigator.clipboard.writeText(text); - return new Promise((resolve, reject) => { - const ta = document.createElement('textarea'); - ta.value = text; - ta.style.cssText = 'position:fixed;opacity:0'; - document.body.appendChild(ta); - ta.select(); - try { document.execCommand('copy') ? resolve() : reject(new Error('copy failed')); } - catch (e) { reject(e); } - finally { ta.remove(); } - }); -} - -function vcCard(v) { - const expired = v.valid_to && new Date(v.valid_to) < new Date(); - return '
' + - '
' + esc(v.prize_name || v.sku_code || '券') + '' + - (expired ? '已过期' : '可使用') + '
' + - '
' + - (v.valid_to ? '有效期至 ' + esc(v.valid_to) : '长期有效') + - (v.granted_at ? ' · ' + esc(v.granted_at.slice(0, 10)) + ' 抽中' : '') + - '
' + - '
' + - '
券码' + esc(v.code || '-') + '' + - '' + - (v.code ? '' : '') + - '' + - '
' + - '
'; -} - -async function loadSchoolVouchers() { - const body = $('vcBody'); - $('vcVeil').classList.add('on'); - body.innerHTML = '
查询中
'; - $('vcNote').textContent = ''; - try { - const d = await api('school/vouchers'); - const arr = d.accounts || []; - const ok = arr.filter(a => !a.error); - const total = ok.reduce((n, a) => n + (a.vouchers || []).length, 0); - body.innerHTML = ok.filter(a => (a.vouchers || []).length).map(a => - '
' + esc(a.nickname || a.uid) + '' + - '' + a.vouchers.length + ' 张
' + - a.vouchers.map(vcCard).join('') - ).join('') || '
🎟️
还没有抽到券
'; - $('vcNote').textContent = total ? total + ' 张券 · ' + ok.filter(a => !(a.vouchers || []).length).length + ' 个账号未抽中' : ''; - const errs = arr.filter(a => a.error); - if (errs.length) { - body.insertAdjacentHTML('beforeend', '
查询失败:' + - errs.map(a => esc(a.nickname || a.uid.slice(0, 8)) + '(' + esc(a.error) + ')').join('、') + '
'); - } - body.querySelectorAll('button[data-copy]').forEach(b => b.onclick = async () => { - try { await copyText(b.dataset.copy); toast('券码已复制', 'ok'); } - catch (e) { toast('复制失败,请手动选择券码', 'err'); } - }); - // 二维码:券码本体编码为 QR(到店出示扫描),点击切换显示/隐藏 - body.querySelectorAll('button[data-qr]').forEach(b => b.onclick = () => { - const card = b.closest('.vc'); - const old = card.querySelector('.vc-qr'); - if (old) { old.remove(); return; } - const box = document.createElement('div'); - box.className = 'vc-qr'; - try { box.innerHTML = qrSVG(qrMatrix(b.dataset.qr), 148); } - catch (e) { box.innerHTML = '二维码生成失败:' + esc(e.message) + ''; } - card.appendChild(box); - }); - } catch (e) { - body.innerHTML = '
' + esc(e.message) + '
'; - } -} -$('btnSchoolVouchers').onclick = loadSchoolVouchers; -$('btnVcClose').onclick = () => $('vcVeil').classList.remove('on'); -$('btnVcRefresh').onclick = loadSchoolVouchers; - -/* 成长任务队列。lastQueueSeq 记录本页启动过的队列代次:执行结束后的残留 items - (running=false 但 seq 停在旧值)不再回写视图——否则扫描结果 3 秒后被上一轮 - 队列状态覆盖。 */ -let queueTimer = null, lastQueueSeq = 0; -const GROWTH_TITLES = {}; // code → 展示名(扫描时从任务列表带出) -$('btnScanAll').onclick = async () => { - const b = $('btnScanAll'); - // 停掉队列轮询:显式扫描 = 切到待办视图。否则在途队列的下一 tick 会把扫描 - // 结果冲掉重渲染回队列视图(服务端执行不受影响,只是不再实时回写本视图)。 - if (queueTimer) { clearInterval(queueTimer); queueTimer = null; } - b.disabled = true; b.textContent = '扫描中…'; - try { - const d = await api('tasks/scan_all', { method: 'POST' }); - renderQueue(groupItems(d), null, '没有待办任务 🎉', '全部账号的成长任务与开学季活动都已完成,明日再来。'); - } catch (e) { toast(e.message, 'err'); } - finally { b.disabled = false; b.textContent = '扫描待办'; } -}; -$('btnRunQueue').onclick = async () => { - const conc = Number($('qcConc').value) || 1; - if (!confirm('扫描全部账号待办并排队执行(账号并发 ' + conc + ',账号内串行)。\n含真实对话的任务耗时较长,确认继续?')) return; - const b = $('btnRunQueue'); - b.disabled = true; b.textContent = '启动中…'; - try { - const r = await api('tasks/run_queue', { method: 'POST', body: JSON.stringify({ concurrency: conc }) }); - if (!r.started) { toast(r.message || '没有待办任务', 'ok'); return; } - lastQueueSeq = r.seq || 0; - toast('队列已启动:' + r.total + ' 项(并发 ' + conc + ')', 'ok'); - startQueuePolling(); - } catch (e) { toast(e.message, 'err'); } - finally { b.disabled = false; b.textContent = '执行全部待办'; } -}; -// 扫描结果 → 分组条目(无执行状态) -function groupItems(d) { - const groups = []; - for (const a of (d.accounts || [])) { - const rows = []; - for (const t of (a.growth || [])) { - GROWTH_TITLES[t.task_code] = t.title || t.task_code; - rows.push({ kind: 'growth', code: t.task_code, prog: t.target ? t.current + '/' + t.target : '—', status: 'scan' }); - } - if (rows.length) groups.push({ uid: a.uid, nick: a.nickname, rows }); - } - return groups; -} -const ST_WORDS = { done: '完成', running: '执行中', error: '失败', skipped: '跳过', pending: '排队', scan: '待执行' }; -function qrowHTML(it) { - const isSchool = it.kind === 'school'; - const title = isSchool ? '开学季闭环' : (GROWTH_TITLES[it.code] || it.code); - const dotCls = it.status === 'scan' ? 'wait' : it.status === 'running' ? 'run' : it.status === 'error' ? 'err' : it.status === 'skipped' ? 'skip' : it.status === 'done' ? 'done' : 'wait'; - const stWord = it.status === 'scan' ? '待执行' : (ST_WORDS[it.status] || it.status); - return '
' + - '' + esc(it.code) + '' + - '' + esc(title) + '' + (isSchool ? '开学季' : '') + '' + - '' + esc(it.prog || '') + '' + - '' + stWord + '' + - '' + esc(it.message || '') + '' + - '
'; -} -function renderQueue(groups, progress, emptyTitle, emptyDesc) { - const empty = $('tcEmpty'), list = $('qcList'); - if (!groups.length) { - empty.style.display = ''; - if (emptyTitle) empty.querySelector('.t').textContent = emptyTitle; - if (emptyDesc) empty.querySelector('.d').textContent = emptyDesc; - list.innerHTML = ''; - $('qProg').hidden = true; $('qcSummary').textContent = ''; - return; - } - empty.style.display = 'none'; - empty.style.display = 'none'; - let total = 0; - list.innerHTML = groups.map(g => { - total += g.rows.length; - return '
' + esc(g.nick || g.uid.slice(0, 12)) + '' + g.rows.length + ' 项待办
' + - g.rows.map(qrowHTML).join('') + '
'; - }).join(''); - $('qcSummary').textContent = total + ' 项'; - updateProgress(progress); -} -function updateProgress(q) { - if (!q || !q.items) { $('qProg').hidden = true; return; } - const total = q.items.length; - const done = q.items.filter(it => it.status === 'done' || it.status === 'error' || it.status === 'skipped').length; - $('qProg').hidden = false; - $('qBarFill').style.width = (total ? Math.round(done / total * 100) : 0) + '%'; - $('qProgText').textContent = (q.running ? '执行中 ' : '已结束 ') + done + ' / ' + total; -} -// 队列状态 → 分组(执行时轮询) -function groupsFromQueue(items) { - const by = new Map(); - for (const it of items) { - if (!by.has(it.uid)) by.set(it.uid, { uid: it.uid, nick: it.nickname, rows: [] }); - by.get(it.uid).rows.push({ - kind: it.kind, code: it.code, - prog: it.kind === 'school' ? '—' : '', - status: it.status, message: it.message, - }); - } - return Array.from(by.values()); -} -function startQueuePolling() { - if (queueTimer) clearInterval(queueTimer); - queueTimer = setInterval(async () => { - let q; - try { q = await api('tasks/queue'); } catch (e) { return; } - if (!q.started) return; - // 只渲染本页启动过的那轮队列(刷新页面后不再接管旧队列)。 - if (lastQueueSeq && q.seq !== lastQueueSeq) return; - if (q.running) { - renderQueue(groupsFromQueue(q.items || []), q); - return; - } - // 结束:终态只渲染这一次,随即停表。此后残留的 items(running=false)不再 - // 回写视图——曾把用户刚点开的「扫描待办」结果在下一个 tick 冲掉。 - renderQueue(groupsFromQueue(q.items || []), q); - clearInterval(queueTimer); queueTimer = null; - toast('任务队列执行结束', 'ok'); - }, 3000); -} -// reattachQueueView 切回任务中心视图时恢复队列进度:仅当本页启动的队列仍在 -// 执行才重新开轮询(残留态/别页队列不接管——视图不被旧结果冲掉)。 -function reattachQueueView() { - // 全程异步:go() 在顶层(app.js ~143 行)被调用时,本文件下方 let/const - //(queueTimer/lastQueueSeq 等)尚未初始化——同步读取即 TDZ ReferenceError - // 使整个脚本中断。await 之后才碰它们(旧 pollQueueOnce 正是靠开头的 await - // 侥幸安全)。queueTimer 的"已在跑"判定也挪到 await 后,语义不变。 - (async () => { - try { - const q = await api('tasks/queue'); - if (queueTimer) return; // 轮询已在跑(跨视图不中断) - if (q.started && q.running && (!lastQueueSeq || q.seq === lastQueueSeq)) startQueuePolling(); - } catch (e) { /* 静默 */ } - })(); -} - -/* ── 用量 ─────────────────────────────────────────────────────────── */ -/* 图表用原生 SVG 手绘:面板是 go:embed 单文件、无构建步骤,引入图表库 - 就得带上打包器,得不偿失。这里只需要堆叠柱状图,二十行足够。 */ - -function fmtTok(n) { - n = Number(n || 0); - if (n >= 1e9) return (n / 1e9).toFixed(2) + 'B'; - if (n >= 1e6) return (n / 1e6).toFixed(2) + 'M'; - if (n >= 1e3) return (n / 1e3).toFixed(1) + 'k'; - return String(n); -} -function fmtMs(ms) { - ms = Number(ms || 0); - if (!ms) return '—'; - if (ms >= 1000) return (ms / 1000).toFixed(2) + 's'; - return Math.round(ms) + 'ms'; -} -function fmtRate(r) { return r ? Number(r).toFixed(1) + ' tok/s' : '—'; } -function trimFixed(s) { - if (!String(s).includes('.')) return String(s); - return String(s).replace(/0+$/, '').replace(/\.$/, ''); -} -function fmtCredit(n) { - const v = Number(n || 0); - if (!Number.isFinite(v)) return '—'; - return trimFixed(v.toFixed(2)); -} -function fmtCreditRatio(v, samples, tokens) { - if (!samples || !tokens) return '—'; - const n = Number(v || 0); - if (!Number.isFinite(n)) return '—'; - return trimFixed(n.toFixed(4)) + ' / 1M'; -} -function fmtModelRate(rate) { - const s = String(rate || '').trim(); - return s ? 'x' + s : '—'; -} - -function usStat(v, k, cls) { - return '
' + esc(v) + - '
' + esc(k) + '
'; -} - -/* usKpi 用量页的指标卡。比账号池的 .stat 多两样:语义色轨(cls)与副标题(sub, - 放"占比 / 均速率"这类解释性数字);bar 是卡片内的构成条 HTML,只有需要时才传。 */ -function usKpi(v, k, cls, sub, bar) { - return '
' + - '
' + esc(k) + '
' + - '
' + esc(v) + '
' + - (bar || '') + - (sub ? '
' + esc(sub) + '
' : '') + - '
'; -} - -/* usMixBar prompt/completion 占比条。宽度按百分比而不是固定像素:表列宽随窗口变化, - 像素宽度在窄屏会溢出、宽屏又显得没信息。 */ -function usMixBar(prompt, completion, total) { - const t = Number(total || 0); - if (!t) return ''; - const pp = Math.max(0, Math.min(100, Number(prompt || 0) / t * 100)); - const pc = Math.max(0, Math.min(100, Number(completion || 0) / t * 100)); - return '' + - '' + - '' + - ''; -} - -/* usPct 占比文案(0 值不显示 "0.0%",直接 —,避免一行全是零)。 */ -function usPct(part, total) { - const t = Number(total || 0); - if (!t) return '—'; - return (Number(part || 0) / t * 100).toFixed(1) + '%'; -} - -/* usRow 生成一行。mid 是插在「名称」之后、请求数之前的额外单元格(如「域」列)。 - withPerf 控制延迟/速率两列;列开关显式传入,避免调用方改动后与表头错列。 */ -function usRow(name, sub, a, mid, withPerf) { - return '' + - '' + - '' + esc(name) + (sub ? '
' + esc(sub) + '
' : '') + '' + - (mid || '') + - '' + fmtTok(a.requests) + '' + - '' + (a.errors ? '' + fmtTok(a.errors) + '' : '—') + '' + - '' + fmtTok(a.prompt_tokens) + '' + - '' + fmtTok(a.completion_tokens) + '' + - '' + fmtTok(a.total_tokens) + - usMixBar(a.prompt_tokens, a.completion_tokens, a.total_tokens) + '' + - (withPerf - ? '' + fmtMs(a.avg_latency_ms) + '' + - '' + fmtRate(a.avg_tokens_per_second) + '' - : '') + - ''; -} - -/* ── 用量明细:三个维度共用一张表 + 页内切换 ────────────────────────── - 账号 / 模型 / 域三张表此前各自占一个 box,页面纵向拉得很长且表头结构几乎一样。 - 现在合成一个 box:表头由维度定义生成,行渲染复用 usRow,切换零请求。 */ -const US_DIMS = { - account: { key: 'by_account', title: '账号', withRealm: true, withPerf: true, span: 10 }, - model: { key: 'by_model', title: '模型', withRealm: false, withPerf: false, span: 7 }, - realm: { key: 'by_realm', title: 'realm', withRealm: false, withPerf: false, span: 7 }, -}; - -// usSortRows 按当前排序字段降序(默认合计 Token,最大者最相关)。 -function usSortRows(rows, sort) { - const out = rows.slice(); - const num = v => { const n = Number(v || 0); return Number.isFinite(n) ? n : 0; }; - const val = a => sort === 'requests' ? num(a.requests) - : sort === 'errors' ? num(a.errors) - : sort === 'latency' ? num(a.avg_latency_ms) - : num(a.total_tokens); - out.sort((a, b) => val(b) - val(a)); - return out; -} - -function usDimHead(dim) { - const m = US_DIMS[dim] || US_DIMS.account; - return '' + esc(m.title) + '' + - (m.withRealm ? '域' : '') + - '请求失败' + - 'PromptCompletion合计' + - (m.withPerf ? '均延迟均速率' : '') + - ''; -} - -/* usTabsHtml 维度切换按钮(带条数徽标)。整段 innerHTML 重写而不是逐个改 class: - 容器的 click 监听是委托式的,换掉子节点不会丢事件,代码也更短。 */ -function usTabsHtml(dims, active, counts) { - return dims.map(([k, label]) => { - const n = counts ? counts[k] : null; - return ''; - }).join(''); -} - -const US_DIM_TABS = [['account', '按账号'], ['model', '按模型'], ['realm', '按域']]; - -function renderUsageDim() { - const d = usageData || {}; - const m = US_DIMS[usDim] || US_DIMS.account; - const rows = usSortRows(d[m.key] || [], usSort); - $('usDimTabs').innerHTML = usTabsHtml(US_DIM_TABS, usDim, { - account: (d.by_account || []).length, - model: (d.by_model || []).length, - realm: (d.by_realm || []).length, - }); - $('usDimHead').innerHTML = usDimHead(usDim); - $('usDimBody').innerHTML = rows.map(x => - usRow(usDim === 'account' ? String(x.key || '').slice(0, 8) : x.key, - usDim === 'account' ? (x.extra || '') : '', - x, - usDim === 'account' ? '' + esc(x.realm || '') + '' : '', - m.withPerf) - ).join('') || '暂无数据'; - $('usDimNote').textContent = rows.length + ' 行 · 请求数含失败尝试'; -} - -/* 积分扣除:按账号 / 按模型两个维度共用一张表(同上,两个 box 合成一个)。 */ -function usCreditHead(dim) { - return dim === 'model' - ? '模型积分倍率' + - '请求扣除积分' + - '有效样本 Token积分 / 1M Token缓存命中率' - : '账号' + - '请求扣除积分' + - '有效样本 Token积分 / 1M Token缓存命中率'; -} - -/* 缓存命中率(issue #92):颜色即健康度——≥90% 绿 / 80–90% 黄 / <80% 红, - 样本不足灰。title 带命中/未命中绝对量,供逐项核对。 */ -function cacheRateCell(hit, miss) { - const h = Number(hit || 0), m = Number(miss || 0), total = h + m; - if (!total) return '—'; - const pct = h / total * 100; - const color = pct >= 90 ? 'var(--ok)' : (pct >= 80 ? 'var(--warn)' : 'var(--bad)'); - const txt = trimFixed(pct.toFixed(1)) + '%'; - return '' + txt + ''; -} - -function renderCreditDim() { - const d = usageData || {}; - $('usCreditHead').innerHTML = usCreditHead(usCreditDim); - const empty = '暂无积分扣除记录;升级前仅含 Token 的历史不会伪造积分。'; - if (usCreditDim === 'model') { - const models = d.credit_by_model || []; - $('usCreditBody').innerHTML = models.map(row => - '' + - '' + - '' + esc(row.key || '—') + '' + - '' + esc(fmtModelRate(row.rate)) + '' + - '' + fmtTok(row.requests) + '' + - '' + fmtCredit(row.credits) + '' + - '' + fmtTok(row.credit_tokens) + '' + - '' + fmtCreditRatio(row.credits_per_1m_tokens, row.credit_samples, row.credit_tokens) + '' + - '' + cacheRateCell(row.cache_hit_tokens, row.cache_miss_tokens) + '' + - '' - ).join('') || '' + empty + ''; - } else { - const accounts = d.credit_by_account || []; - $('usCreditBody').innerHTML = accounts.map(row => { - const uid = String(row.key || ''); - const account = row.nickname || uid.slice(0, 8) || '—'; - return '' + - '' + - '' + esc(account) + '
' + esc(row.realm || '') + ' · ' + esc(uid.slice(0, 8)) + '
' + - '' + fmtTok(row.requests) + '' + - '' + fmtCredit(row.credits) + '' + - '' + fmtTok(row.credit_tokens) + '' + - '' + fmtCreditRatio(row.credits_per_1m_tokens, row.credit_samples, row.credit_tokens) + '' + - '' + cacheRateCell(row.cache_hit_tokens, row.cache_miss_tokens) + '' + - ''; - }).join('') || '' + empty + ''; - } - $('usCreditTabs').innerHTML = usTabsHtml([['account', '按账号'], ['model', '按模型']], usCreditDim, { - account: (d.credit_by_account || []).length, - model: (d.credit_by_model || []).length, - }); -} - -function renderUsage(d) { - usageData = d || {}; - const t = usageData.totals || {}; - const total = Number(t.total_tokens || 0); - const pt = Number(t.prompt_tokens || 0); - const ct = Number(t.completion_tokens || 0); - const reqs = Number(t.requests || 0); - const errs = Number(t.errors || 0); - const okRate = reqs ? (reqs - errs) / reqs * 100 : null; - // 构成条要的是合法 CSS 宽度,usPct 在无样本时返回 "—",不能直接拼进 style。 - const pctW = (part) => total ? Math.max(0, Math.min(100, Number(part || 0) / total * 100)).toFixed(2) + '%' : '0%'; - // 六张卡:主指标用强调色,completion 用成功色(与图表里的绿柱呼应), - // 失败/延迟只在有值时上语义色——全绿全黄的仪表盘等于没有重点。 - $('usStats').innerHTML = - usKpi(fmtTok(reqs), '请求数', 'c-accent', - errs ? '其中失败 ' + errs + ' 次' : '全部成功') + - usKpi(fmtTok(total), '总 token', 'c-accent', - 'prompt ' + usPct(pt, total) + ' · completion ' + usPct(ct, total), - '
' + - '
') + - usKpi(fmtTok(pt), 'prompt', 'c-soft', '占比 ' + usPct(pt, total)) + - usKpi(fmtTok(ct), 'completion', 'c-ok', '占比 ' + usPct(ct, total)) + - usKpi(String(errs), '失败尝试', errs ? 'c-warn' : 'c-mute', - okRate == null ? '—' : (errs ? '成功率 ' + okRate.toFixed(1) + '%' : '成功率 100%')) + - usKpi(fmtMs(t.avg_latency_ms), '平均延迟', 'c-soft', - t.avg_tokens_per_second ? '吐字 ' + fmtRate(t.avg_tokens_per_second) : '无速率样本'); - - // 卡片、明细表与时序图全部按所选窗口统计(切窗口数字随之变化); - // 「全部历史」含 90 天前折叠出的日桶。这里标注当前口径与数据起点。 - const winLabel = trangeLabel('usRange'); - // 服务端回显的实际区间优先(自定义区间下它就是权威口径);滚动窗口没有回显, - // 用控件自己的标签。 - const rangeEcho = usageData.window_from - ? String(usageData.window_from).replace('T', ' ').slice(0, 16) + - (usageData.window_to ? ' → ' + String(usageData.window_to).replace('T', ' ').slice(0, 16) : ' → 现在') - : ''; - const note = (rangeEcho || winLabel ? (rangeEcho || winLabel) + ' · ' : '') + - (usageData.buckets || 0) + ' 个分桶' + - (usageData.since ? ' · 数据自 ' + usageData.since.replace('T', ' ') : '') + - (usageData.file_bytes ? ' · 文件 ' + (usageData.file_bytes / 1024).toFixed(1) + ' KB' : ''); - $('usNote').textContent = note; - $('usNote').title = note; // 窄屏单行截断时靠悬停看全 - - // 积分扣除的四张卡片与说明。 - $('usCreditStats').innerHTML = - usKpi(fmtCredit(t.credits), '扣除积分', 'c-accent', '按上游 usage.credit 累计') + - usKpi(fmtTok(t.credit_tokens), '匹配 Token', 'c-mute', '与积分同时观测到的 Token') + - usKpi(fmtCreditRatio(t.credits_per_1m_tokens, t.credit_samples, t.credit_tokens), - '平均积分 / 1M Token', 'c-ok', '越低越划算') + - usKpi(String(t.credit_samples || 0), '有效积分样本', 'c-mute', '缺字段的历史不参与折算') + - usKpi(cacheRateText(t.cache_hit_tokens, t.cache_miss_tokens), '缓存命中率', 'c-mute', - '上游前缀缓存命中 / (命中+未命中);低命中意味着费用数倍放大'); - $('usCreditNote').textContent = - (usageData.credit_by_account || []).length + ' 个账号 · ' + - (usageData.credit_by_model || []).length + ' 个模型倍率分组 · 仅统计与积分同时观测到的 Token'; - - renderUsageDim(); - renderCreditDim(); - renderUsageChart(usageData.series || []); -} - -// 维度切换 / 排序控件。 -if ($('usDimTabs')) $('usDimTabs').addEventListener('click', ev => { - const b = ev.target.closest('button[data-dim]'); - if (!b) return; - usDim = b.dataset.dim; - renderUsageDim(); -}); -if ($('usCreditTabs')) $('usCreditTabs').addEventListener('click', ev => { - const b = ev.target.closest('button[data-dim]'); - if (!b) return; - usCreditDim = b.dataset.dim; - renderCreditDim(); -}); -if ($('usSort')) $('usSort').onchange = () => { - usSort = $('usSort').value; - renderUsageDim(); -}; - -/* renderUsageChart 画堆叠柱状图。 - * - * x 轴是**真实时间轴**,不是按序号等距。这一点很重要:数据里存在 1 小时的 - * 间隔,也存在 6~8 小时的断档(没请求的时段不产生桶),等距排布会把 8 小时 - * 画得和 1 小时一样宽,让「什么时候用的」完全失真。 - * - * 另外不再用 preserveAspectRatio="none":那会把 viewBox 横向拉伸到容器宽度, - * 柱子和文字都变形。改为固定比例、按容器宽度自适应高度。 - * - * viewBox 取 1200×200(原 760×180):SVG 以 width:100% 渲染,高宽比决定实际 - * 高度——旧比例在 1500px 宽的主区里会撑到 ~355px,只有一两根柱子时整块几乎是 - * 空白。宽 viewBox 把同宽度下的高度压到 ~250px,与下方表格的视觉重量相当。 - * - * 时间轴用本地时间解析(后端返回的就是本地时区),day 点按当天 00:00 参与定位, - * 与 hour 点在同一个连续轴上——日桶本来就是他那天所有小时的聚合。 - */ - -/* parsePointTime 把后端的 t 解析成毫秒时间戳。 */ -function parsePointTime(p) { - // hour: "2026-09-16T13" day: "2026-09-16" - const s = p.t.length === 13 ? p.t + ':00:00' : p.t + 'T00:00:00'; - const d = new Date(s); - return isNaN(d.getTime()) ? null : d.getTime(); -} - -/* fmtTokTimeLabel 时间桶的短标签,与 x 轴刻度同一口径(日桶 MM-DD,小时桶 HH:00)。 */ -function fmtTokTimeLabel(p) { - const d = new Date(p.t); - return p.scope === 'day' - ? (d.getMonth() + 1) + '-' + String(d.getDate()).padStart(2, '0') - : String(d.getHours()).padStart(2, '0') + ':00'; -} - -function renderUsageChart(series) { - const host = $('usChart'); - - // 丢掉时间解析不出来的点,而不是让 NaN 传染整张图。 - const pts = []; - for (const p of series) { - const t = parsePointTime(p); - if (t === null) continue; - const pt = Number(p.prompt_tokens || 0); - const ct = Number(p.completion_tokens || 0); - pts.push({ t, scope: p.scope, raw: p.t, pt, ct, tt: Number(p.total_tokens || 0) || (pt + ct), - req: p.requests || 0 }); - } - if (!pts.length) { - host.innerHTML = '
暂无用量数据。发起一次对话后再刷新。
'; - $('usChartNote').textContent = '—'; - return; - } - - const W = 1200, H = 200, PL = 58, PR = 14, PT = 18, PB = 30; - const iw = W - PL - PR, ih = H - PT - PB; - - const t0 = pts[0].t; - const t1 = pts[pts.length - 1].t; - const span = Math.max(1, t1 - t0); - - const max = Math.max(1, ...pts.map(p => p.tt)); - const peak = pts.reduce((a, b) => (b.tt > a.tt ? b : a), pts[0]); - const avg = pts.reduce((s, p) => s + p.tt, 0) / pts.length; - $('usChartNote').textContent = - pts.length + ' 个点 · 峰值 ' + fmtTok(peak.tt) + ' @ ' + fmtTokTimeLabel(peak) + - ' · 均值 ' + fmtTok(avg); - - // 柱宽取「最小真实间隔」的 70%,并夹在合理区间内——窗口拉到 30 天时柱子会 - // 变细,但不会细到看不见。 - let minGap = Infinity; - for (let i = 1; i < pts.length; i++) minGap = Math.min(minGap, pts[i].t - pts[i - 1].t); - if (!isFinite(minGap) || minGap <= 0) minGap = span; - const slot = iw * (minGap / span); - const bw = Math.max(2, Math.min(30, slot * 0.7)); - - // 首尾各让出半个柱宽:否则第一个点和最后一个点的柱子会各有一半跑到绘图区外 - // (末点柱子贴着卡片右边缘被切掉),刻度仍用同一个 xOf,标签与柱子始终对齐。 - const xOf = t => PL + bw / 2 + (t - t0) / span * Math.max(1, iw - bw); - const yOf = v => PT + ih - ih * (v / max); - - let out = ''; - - // 柱体渐变:顶部实、底部略透,堆叠时两段仍能一眼分清(纯色块并排会糊成一片)。 - // 注意 stop-color 必须走 style 而不是 presentation 属性——Blink/WebKit 不解析 - // 属性里的 var(),写成 stop-color="var(--accent)" 会整条渐变失效(柱子全透明)。 - out += '' + - '' + - '' + - '' + - '' + - '' + - '' + - ''; - - // y 轴网格 + 刻度 - for (let i = 0; i <= 4; i++) { - const y = PT + ih - (ih * i / 4); - out += ''; - out += '' + fmtTok(max * i / 4) + ''; - } - - // 均值参考线:一眼看出"这根是不是异常高",比只给刻度省心。 - // 标签放左侧:右侧常被峰值柱占用(峰值柱往往就是最后一根),贴左不会被压住。 - if (avg > 0 && avg < max) { - const y = yOf(avg); - out += ''; - out += '均值 ' + fmtTok(avg) + ''; - } - - // 柱子 - const yBase = PT + ih; - for (const p of pts) { - const x = xOf(p.t) - bw / 2; - const hTot = ih * (p.tt / max); - const hP = p.tt ? hTot * (p.pt / p.tt) : 0; - const hC = Math.max(p.tt && p.ct ? 1 : 0, hTot - hP); - // 圆角只给堆叠顶端(贴轴的底边保持方角,柱子才像"立"在基线上)。 - // 类名用 usbar 而不是 bar:账号池的积分条是 .bar{height:3px},而 SVG2 里 - // height 是 rect 的 CSS 几何属性,同名类会把每根柱子压成 3px 高(踩过)。 - if (hP > 0) out += ' 0 ? '' : ' rx="1.5"') + '/>'; - if (hC > 0) out += ''; - out += '' + esc(p.raw) + ' ' + fmtTok(p.pt) + ' prompt / ' + - fmtTok(p.ct) + ' completion / ' + p.req + ' 次'; - } - - // 峰值标注:柱子够窄时文字压在柱顶,够宽时贴右侧避免和柱体重叠。 - { - const px = xOf(peak.t); - const py = yOf(peak.tt); - const anchor = px > W - PR - 90 ? 'end' : 'middle'; - out += '' + - '峰值 ' + fmtTok(peak.tt) + ''; - } - - // x 轴基线画在柱子之后,避免压在柱底 - out += ''; - - // x 轴刻度:按真实时间等距取 6 个位置,取该位置**最近的实际柱子**做标签, - // 所以标签永远落在有数据的点上,不会指到空档里。 - const TICKS = Math.min(6, pts.length); - const usedLabel = new Set(); - for (let k = 0; k < TICKS; k++) { - const target = t0 + span * (TICKS === 1 ? 0.5 : k / (TICKS - 1)); - let bi = 0, best = Infinity; - for (let i = 0; i < pts.length; i++) { - const d = Math.abs(pts[i].t - target); - if (d < best) { best = d; bi = i; } - } - if (usedLabel.has(bi)) continue; - usedLabel.add(bi); - const p = pts[bi]; - // 首尾标签靠边对齐,避免被裁掉 - const cx = xOf(p.t); - const anchor = cx < PL + 14 ? 'start' : (cx > W - PR - 14 ? 'end' : 'middle'); - out += '' + esc(fmtTokTimeLabel(p)) + ''; - } - - // 跨天时补一条日期分隔线,让「日界」在长窗口里可见 - let prevDay = null; - for (const p of pts) { - const d = new Date(p.t).getDate(); - if (prevDay !== null && d !== prevDay) { - const x = xOf(p.t).toFixed(1); - out += ''; - } - prevDay = d; - } - - out += ''; - host.innerHTML = out; -} - -function fmtTokTip(v) { return fmtTok(v); } - -let usageRateWarmAt = 0; -async function warmUsageModelRates() { - if (Date.now() - usageRateWarmAt < 10 * 60 * 1000) return; - try { - await api('models'); - } catch (e) { - // 倍率回填是可选增强;失败不阻塞用量统计,10 分钟后再试。 - } - usageRateWarmAt = Date.now(); -} - -async function loadUsage() { - const q = trangeQuery('usRange', true); - try { - await warmUsageModelRates(); - const d = await api('usage?' + q.toString()); - renderUsage(d); - } catch (e) { - // 失败时三块都要清干净:只改图表会留下上一次窗口的数字,看起来像"刷新成功"。 - usageData = null; - $('usChart').innerHTML = '
读取用量失败:' + esc(e.message) + '
'; - $('usChartNote').textContent = '—'; - $('usStats').innerHTML = ''; - $('usCreditStats').innerHTML = ''; - $('usNote').textContent = '—'; - $('usCreditNote').textContent = '—'; - $('usDimNote').textContent = '—'; - $('usDimHead').innerHTML = ''; - $('usCreditHead').innerHTML = ''; - $('usDimTabs').innerHTML = usTabsHtml(US_DIM_TABS, usDim, null); - $('usCreditTabs').innerHTML = usTabsHtml([['account', '按账号'], ['model', '按模型']], usCreditDim, null); - $('usDimBody').innerHTML = '读取用量失败'; - $('usCreditBody').innerHTML = '读取用量失败'; - } -} - -if ($('btnUsage')) $('btnUsage').onclick = loadUsage; -// 时间范围控件绑定:任何改动(预设切换 / 自定义起止)都重新拉一次用量。 -if ($('usRange')) trangeBind('usRange', loadUsage); - -/* ── 积分构成 ─────────────────────────────────────────────────────── */ -/* 一个账号的余额是若干积分包之和。包按来源命名(「国内运营裂变包」「拉新权益包」 - 「个人体验版」…),面额从 6 到 1500 不等,且**按次发放**。所以两个任务完成度 - 完全一致的账号,余额可能差上千——差别只在包里。这里把逐包明细摊开,并给每个 - 包名一个稳定配色,跨账号对比时同色即同类。 */ - -const PK_COLORS = ['#4f8cff', '#25b08b', '#e8a33d', '#c96bd6', '#e2607a', - '#5aa9e6', '#8fbf3f', '#b58b5a', '#7d8fa8', '#d4785c']; -const PK_ACCOUNT_COLORS = ['#4f8cff', '#25b08b', '#e8a33d', '#c96bd6', - '#e2607a', '#20a4a4', '#8fbf3f', '#d4785c', - '#7c83db', '#c48a2f', '#b45f8c', '#5aa9e6']; - -function pkColor(i) { return PK_COLORS[i % PK_COLORS.length]; } - -// pkAccountColorMap 按 UID 稳定分配颜色:排序后分配,账号刷新/重排不会换色。 -function pkAccountColorMap(list) { - const uids = (list || []) - .filter(a => a && !a.error && a.uid) - .map(a => String(a.uid)) - .sort(); - const colors = new Map(); - uids.forEach((uid, i) => colors.set(uid, PK_ACCOUNT_COLORS[i % PK_ACCOUNT_COLORS.length])); - return colors; -} - -/* pkBySource 把包按名称归并,得到「来源 → 面额/余额/个数」。这是对比的关键视图: - 两个号的差异一定体现在某几个来源的面额上。 */ -function pkBySource(packs) { - const m = new Map(); - for (const p of packs) { - // 分组键用 code + name,而不是只 name:上游给「首登赠送」和普通活动包用了 - // **同一个 PackageName 和同一个 PackageCode**,只按 name 会把两类混成一类, - // 那正是当初「两个号为何差 1500」看不出来的原因。这里至少把 code 带进键里, - // 并在卡片上显示最早的发放时间。 - const k = (p.package_code || '') + '|' + (p.name || '(未命名)'); - const e = m.get(k) || { - key: k, name: p.name || '(未命名)', code: p.package_code || '', - n: 0, remain: 0, size: 0, used: 0, minEnd: '', minCreated: '', - }; - e.n += 1; - e.remain += Number(p.remain || 0); - e.size += Number(p.size || 0); - e.used += Number(p.used || 0); - const t = (p.end_time || '').slice(0, 10); - if (t && (!e.minEnd || t < e.minEnd)) e.minEnd = t; - const c = (p.created_at || '').slice(0, 10); - if (c && (!e.minCreated || c < e.minCreated)) e.minCreated = c; - m.set(k, e); - } - return [...m.values()].sort((a, b) => b.size - a.size); -} - -const PK_DEFAULT_DETAIL_LIMIT = 5; - -function pkDetailLimitValue(raw) { - const n = Number(raw); - return Number.isFinite(n) && n > 0 ? Math.floor(n) : PK_DEFAULT_DETAIL_LIMIT; -} - -function pkDetailLimit(cfg) { - return pkDetailLimitValue(cfg && cfg.panel && cfg.panel.package_detail_limit); -} - -const PK_DAY_MS = 24 * 3600 * 1000; - -function pkExpiryMs(p) { - const raw = Number(p && p.expires_at); - if (Number.isFinite(raw) && raw > 0) return raw; - const text = String((p && p.end_time) || '').trim(); - if (!text) return null; - let iso = text.includes('T') ? text : text.replace(' ', 'T'); - if (!/(?:Z|[+-]\d\d:\d\d)$/.test(iso)) iso += '+08:00'; - const parsed = Date.parse(iso); - return Number.isFinite(parsed) ? parsed : null; -} - -// pkDetailCompare 只服务单账号逐包明细:正余额包先按到期时间挑选默认展示项, -// 其余正余额包与已用完包分别折叠;同一到期时间按面额降序。主键跟随视图排序 -// 模式(pkSortMode,声明在本区块末尾的绑定块):end_asc 到期升序、size_desc -// 面额降序(同面额按到期升序)。typeof 守卫:前端 harness 的区域切片求值里 -// 没有该全局,回落 end_asc(= 上游原有语义,切片测试的期望序不受影响)。 -function pkDetailCompare(a, b) { - const sizeOf = p => { - const n = Number(p && p.size); - return Number.isFinite(n) ? n : 0; - }; - const mode = (typeof pkSortMode === 'string' && pkSortMode) || 'end_asc'; - if (mode === 'size_desc') { - const d = sizeOf(b) - sizeOf(a); - if (d !== 0) return d; - } - const ea = pkExpiryMs(a), eb = pkExpiryMs(b); - if (ea == null && eb != null) return 1; - if (ea != null && eb == null) return -1; - if (ea != null && eb != null && ea !== eb) return ea - eb; - return sizeOf(b) - sizeOf(a); -} - -function pkDetailGroups(packs, limit) { - const active = [], used = []; - let usedSize = 0, restSize = 0, restRemain = 0; - for (const p of packs || []) { - const remain = Number(p && p.remain); - if (remain > 0) { - active.push(p); - continue; - } - used.push(p); - const size = Number(p && p.size); - if (Number.isFinite(size)) usedSize += size; - } - active.sort(pkDetailCompare); - used.sort(pkDetailCompare); - const visible = active.slice(0, pkDetailLimitValue(limit)); - const rest = active.slice(visible.length); - for (const p of rest) { - const size = Number(p && p.size); - if (Number.isFinite(size)) restSize += size; - const remain = Number(p && p.remain); - if (Number.isFinite(remain)) restRemain += remain; - } - return { visible, rest, used, restSize, restRemain, usedSize }; -} - -function pkCreditOpacity(days) { - if (days == null || !Number.isFinite(Number(days))) return 1; - return 0.25 + 0.75 * Math.max(0, Math.min(29, Number(days) - 1)) / 29; -} - -function pkExpiryText(expiresAt) { - if (!expiresAt) return '无到期时间'; - const diff = expiresAt - Date.now(); - if (diff <= 0) return '已到期'; - const minutes = Math.max(1, Math.ceil(diff / 60000)); - if (minutes < 60) return '剩余 ' + minutes + ' 分钟'; - const hours = Math.ceil(diff / 3600000); - if (hours < 24) return '剩余 ' + hours + ' 小时'; - return '剩余 ' + Math.ceil(diff / PK_DAY_MS) + ' 天'; -} - -function pkExpiryDateTime(expiresAt) { - if (!expiresAt) return '—'; - return new Date(expiresAt).toLocaleString('zh-CN', { - timeZone: 'Asia/Shanghai', hour12: false, - year: 'numeric', month: '2-digit', day: '2-digit', - hour: '2-digit', minute: '2-digit', second: '2-digit', - }); -} - -function pkAccountSegments(a, now) { - let balance = Math.max(0, Number(a.remain || 0)); - const out = []; - for (const p of a.packages || []) { - const remain = Number(p.remain || 0); - if (!Number.isFinite(remain) || remain <= 0 || balance <= 0) continue; - const amount = Math.min(balance, remain); - const expiresAt = pkExpiryMs(p); - out.push({ - amount, - expiresAt, - days: expiresAt == null ? null : Math.max(0, Math.ceil((expiresAt - now) / PK_DAY_MS)), - source: p.name || '积分', - uid: String(a.uid || ''), - accountName: a.nickname || String(a.uid || '').slice(0, 8) || '未命名账号', - }); - balance -= amount; - } - return out.sort((x, y) => { - if (x.expiresAt == null && y.expiresAt != null) return 1; - if (x.expiresAt != null && y.expiresAt == null) return -1; - return (x.expiresAt || 0) - (y.expiresAt || 0); - }); -} - -// summarizeCreditDays 对齐 WorkDaddy:按精确剩余天数逐行聚合,无有效到期时间的余额 -// 不进入图表,也不猜测到期日。账号内先按总余额约束逐包金额,避免上游重复记录膨胀。 -function summarizeCreditDays(list, now) { - const buckets = new Map(); - let unavailable = 0; - for (const a of list || []) { - if (a.error || !Number.isFinite(Number(a.remain))) { - unavailable++; - continue; - } - for (const segment of pkAccountSegments(a, now)) { - if (segment.days == null) continue; - let row = buckets.get(segment.days); - if (!row) { - row = { days: segment.days, credits: 0, segments: [] }; - buckets.set(segment.days, row); - } - row.credits += segment.amount; - row.segments.push(segment); - } - } - const rows = [...buckets.values()].sort((a, b) => a.days - b.days); - for (const row of rows) { - row.segments.sort((a, b) => - (a.expiresAt || Infinity) - (b.expiresAt || Infinity) || - a.accountName.localeCompare(b.accountName) || - a.source.localeCompare(b.source)); - } - return { rows, accountCount: (list || []).length, unavailable }; -} - -function renderExpiryDistribution(list, now) { - const summary = summarizeCreditDays(list, now); - const colors = pkAccountColorMap(list); - const rows = summary.rows.map(row => { - const total = row.credits || 1; - const nodes = row.segments.map(segment => { - const color = colors.get(segment.uid) || 'var(--accent)'; - const title = segment.source + '\n' + fmtTok(segment.amount) + ' 积分\n到期时间 ' + - pkExpiryDateTime(segment.expiresAt) + '(' + pkExpiryText(segment.expiresAt) + ')\n' + - segment.accountName; - return ''; - }).join(''); - return '
' + esc(row.days === 0 ? '已到期' : row.days + ' 天') + - '
' + nodes + '
' + esc(fmtTok(row.credits)) + - '
'; - }).join(''); - const foot = summary.accountCount + ' 个账号' + - (summary.unavailable ? ' · ' + summary.unavailable + ' 个未获取余额' : ''); - const legend = (list || []).filter(a => - a && !a.error && a.uid && pkAccountSegments(a, now).some(s => s.days != null) - ).map(a => '' + esc(a.nickname || String(a.uid).slice(0, 8)) + '').join(''); - const hdr = '
剩余天数各账号该批剩余剩余积分
'; - $('pkExpiry').innerHTML = (rows - ? hdr + '
' + rows + '
' - : '
暂无可汇总积分
') + - (legend ? '
' + legend + '
' : '') + - '
' + esc(foot) + '
'; -} - -function renderPackages(d, detailLimit) { - const list = (d.accounts || []); - const now = Date.now(); - const expiryColors = pkAccountColorMap(list); - renderExpiryDistribution(list, now); - if (!list.length) { - $('pkSummary').innerHTML = '
没有账号
'; - return; - } - - // 包名 → 稳定色号(跨账号一致,方便肉眼对齐) - const names = []; - for (const a of list) for (const s of pkBySource(a.packages || [])) { - if (!names.includes(s.key)) names.push(s.key); - } - names.sort((x, y) => { - const sz = n => Math.max(...list.map(a => { - const f = pkBySource(a.packages || []).find(s => s.key === n); - return f ? f.size : 0; - })); - return sz(y) - sz(x); - }); - const colorOf = n => pkColor(names.indexOf(n)); - // 键 → 展示名,供卡片与明细表共用(同一来源必然同色同名)。 - const labelOf = {}; - for (const a of list) for (const s of pkBySource(a.packages || [])) labelOf[s.key] = s; - - const maxRemain = Math.max(1, ...list.map(a => Number(a.remain || 0))); - - $('pkSummary').innerHTML = list.map(a => { - if (a.error) { - return '
' + - esc((a.nickname || a.uid.slice(0, 8))) + '' + - '' + esc(a.realm || '') + '
' + - '
查询失败:' + esc(a.error) + '
'; - } - const srcs = pkBySource(a.packages || []); - const total = Math.max(1, Number(a.size || 0)); - const bar = srcs.map(s => - '' - ).join(''); - const legend = srcs.map(s => - '' + - esc(s.name.replace(/^CodeBuddy/, '')) + ' x' + s.n + ' · ' + fmtTok(s.size) + - (s.minCreated ? ' · 首发 ' + esc(s.minCreated.slice(5)) : '') + '' - ).join(''); - const expiry = pkAccountSegments(a, now); - const expiryTotal = Math.max(1, expiry.reduce((sum, s) => sum + s.amount, 0)); - const expiryColor = expiryColors.get(String(a.uid)) || 'var(--accent)'; - const expiryBar = expiry.length ? '' : ''; - return '
' + - '
' + esc(a.nickname || a.uid.slice(0, 8)) + '' + - '' + esc(a.realm || '') + '
' + - '
' + fmtTok(a.remain) + '
' + - '
共 ' + fmtTok(a.size) + ' · ' + (a.packages || []).length + - ' 个包 · 占最高 ' + (Number(a.remain || 0) / maxRemain * 100).toFixed(0) + '%
' + - '
' + bar + '
' + - expiryBar + - '
' + legend + '
' + - '
'; - }).join(''); - - $('pkNote').textContent = list.length + ' 个账号 · 实时查询上游'; - - // 逐包明细:每个账号一个表,排序规则由视图顶部的选择器决定(默认到期近的在前) - $('pkDetail').innerHTML = list.map(a => { - if (a.error) return ''; - const groups = pkDetailGroups(a.packages || [], detailLimit); - const rowOf = (p, rowGroup) => { - const k = (p.package_code || '') + '|' + (p.name || '(未命名)'); - const sub = (p.sub_product_code || '').replace(/^sp_tcaca_codebuddyide_?/, '') || - (p.package_code || '').replace(/^TCACA_/, ''); - return '' + - '' + esc(p.name || '(未命名)') + - (sub ? '
' + esc(sub) + '
' : '') + '' + - '' + fmtTok(p.size) + '' + - '' + fmtTok(p.remain) + '' + - '' + fmtTok(p.used) + '' + - '' + esc((p.created_at || '').slice(0, 16).replace('T', ' ') || '—') + '' + - '' + esc((p.end_time || '').slice(0, 10) || '—') + '' + - ''; - }; - const groupSummary = (group, label, count, size, remain) => - ''; - const rows = groups.visible.map(p => rowOf(p, '')).join(''); - const restSummary = groups.rest.length - ? groupSummary('rest', '其余未用完 ' + groups.rest.length + ' 个包(面额合计 ' + - fmtTok(groups.restSize) + ' · 剩余 ' + fmtTok(groups.restRemain) + ')', - groups.rest.length, groups.restSize, groups.restRemain) + - groups.rest.map(p => rowOf(p, 'rest')).join('') - : ''; - const usedSummary = groups.used.length - ? groupSummary('used', '已用完 ' + groups.used.length + ' 个包(面额合计 ' + - fmtTok(groups.usedSize) + ')', groups.used.length, groups.usedSize, 0) + - groups.used.map(p => rowOf(p, 'used')).join('') - : ''; - return '

' + - esc(a.nickname || a.uid.slice(0, 8)) + ' · ' + esc(a.realm || '') + - '

余额 ' + fmtTok(a.remain) + - ' / 总额 ' + fmtTok(a.size) + ' · 可用 ' + (groups.visible.length + groups.rest.length) + ' 个包' + - (groups.used.length ? ' / 已用完 ' + groups.used.length + ' 个' : '') + - ' · 默认展示最早到期 ' + pkDetailLimitValue(detailLimit) + ' 条(' + - esc(PK_SORT_LABELS[pkSortMode] || '') + ')' + - '
' + - '' + - '' + - '' + - '' + rows + restSummary + usedSummary + '
包名 / 来源面额剩余已用发放到期
'; - }).join(''); -} - -if ($('pkDetail')) $('pkDetail').addEventListener('click', ev => { - const btn = ev.target.closest('button[data-pk-group]'); - if (!btn) return; - const body = btn.closest('tbody'); - if (!body) return; - const group = btn.dataset.pkGroup; - const expanded = btn.getAttribute('aria-expanded') === 'true'; - body.querySelectorAll('tr[data-pk-row="' + group + '"]').forEach(row => { row.hidden = expanded; }); - const count = btn.dataset.count || '0'; - const size = btn.dataset.size || '0'; - const remain = btn.dataset.remain || '0'; - btn.setAttribute('aria-expanded', String(!expanded)); - if (group === 'rest') { - btn.textContent = expanded - ? '其余未用完 ' + count + ' 个包(面额合计 ' + fmtTok(size) + ' · 剩余 ' + - fmtTok(remain) + '),展开' - : '收起其余未用完 ' + count + ' 个包'; - } else { - btn.textContent = expanded - ? '已用完 ' + count + ' 个包(面额合计 ' + fmtTok(size) + '),展开' - : '收起已用完 ' + count + ' 个包'; - } -}); - -/* ── 逐包明细排序模式 ─────────────────────────────────────────────── */ -/* 逐包明细的排序规则(选择持久化在 localStorage,跨会话记住): - end_asc 到期升序(默认)——快过期的包排最前,提醒优先消耗;无到期时间的 - 包(上游没下发 end_time)没有可比的日期,统一垫底,不掺进日期序里; - size_desc 面额降序——原来的展示口径,看「钱从哪来」。 - 行序统一由 pkDetailCompare 实现(明细折叠分组共用同一比较器,切换模式时 - 折叠组内行序同步跟随)。本块整体放在 renderPackages / renderExpiryDistribution - 之后:前端 harness 按区域切片求值([PK_ACCOUNT_COLORS, renderExpiryDistribution) - 与 [PK_DEFAULT_DETAIL_LIMIT, renderPackages)),顶层 localStorage/$ 语句落进 - 切片区会让无 DOM 桩的求值环境 ReferenceError——上游测试的切片边界不动。 */ -const LS_PK_SORT = 'pkSortMode'; -let pkSortMode = localStorage.getItem(LS_PK_SORT) || 'end_asc'; -const PK_SORT_LABELS = { end_asc: '按到期升序 · 近的在前', size_desc: '按面额降序' }; -// 排序切换时重排明细需要 detailLimit(上游折叠配置),loadPackages 拉到后缓存。 -let lastDetailLimit = PK_DEFAULT_DETAIL_LIMIT; - -// 排序规则控件:恢复上次选择并绑定切换。 -if ($('pkSort')) { - $('pkSort').value = pkSortMode; - if ($('pkSort').value !== pkSortMode) { // localStorage 里存了废弃值:回落默认 - pkSortMode = 'end_asc'; - localStorage.setItem(LS_PK_SORT, pkSortMode); // 不用 removeItem:harness 桩无此方法 - } - $('pkSort').onchange = () => { - pkSortMode = $('pkSort').value; - localStorage.setItem(LS_PK_SORT, pkSortMode); - if (lastPackages) renderPackages(lastPackages, lastDetailLimit); // 数据在内存,直接重排 - }; -} - -async function loadPackages() { - $('pkSummary').innerHTML = '
查询中…(逐账号向上游实时查询)
'; - $('pkDetail').innerHTML = ''; - $('pkExpiry').innerHTML = '
查询中…
'; - try { - const [d, c] = await Promise.all([ - api('packages'), - api('config').catch(() => null), - ]); - lastPackages = d; // 缓存供首页到期卡片与排序切换复用 - lastPackagesAt = Date.now(); - lastDetailLimit = pkDetailLimit(c && c.config); - renderPackages(d, lastDetailLimit); - } catch (e) { - $('pkSummary').innerHTML = '
读取失败:' + esc(e.message) + '
'; - $('pkExpiry').innerHTML = '
读取失败:' + esc(e.message) + '
'; - } -} - -/* ── 积分到期提醒(首页卡片)────────────────────────────────────────── */ -/* 积分不是永久的:签到/任务发的裂变包约一个月失效。只看「剩余积分 ÷ 日消耗」 - 会系统性偏乐观——用不完的部分到期直接蒸发。这里把「最近要过期的是哪批、 - 有多少、到期前每天要至少消耗多少」顶到首页,数据源与「积分构成」共用 - (lastPackages 缓存,EXP_FRESH_MS 内复用,不重复打上游)。 */ - -// expBatches 把某账号的包聚合成「到期日 → 该日作废积分」升序列表。 -// 只统计 remain>0 且有到期时间的包——没余额/长期包到期没有任何影响。 -function expBatches(packs) { - const byDay = new Map(); - for (const p of packs || []) { - const r = Number(p.remain || 0); - const t = (p.end_time || '').slice(0, 10); - if (r <= 0 || !t) continue; - byDay.set(t, (byDay.get(t) || 0) + r); - } - return [...byDay.entries()] - .map(([date, remain]) => ({ date, remain })) - .sort((a, b) => (a.date < b.date ? -1 : 1)); -} - -function expDaysLeft(dateStr, today) { - return Math.round((new Date(dateStr + 'T00:00:00') - today) / 86400000); -} - -function renderExpiry(d) { - const list = (d.accounts || []); - const today = new Date(); today.setHours(0, 0, 0, 0); - const rows = list.map(a => { - if (a.error) { - return '
' + - '' + esc(a.nickname || a.uid.slice(0, 8)) + '' + - '查询失败:' + esc(a.error) + '
'; - } - const bs = expBatches(a.packages).filter(b => expDaysLeft(b.date, today) >= 0); - if (!bs.length) { - return '
' + - '' + esc(a.nickname || a.uid.slice(0, 8)) + '' + - '7 天内无到期积分
'; - } - const first = bs[0]; - const days = expDaysLeft(first.date, today); - const daily = Math.ceil(first.remain / Math.max(1, days)); - const week = bs.filter(b => expDaysLeft(b.date, today) <= 7) - .reduce((s, b) => s + b.remain, 0); - // 危险度:≤3 天红(不抓紧就真没了)、≤7 天琥珀、更远绿。 - // 上游扣包是 FEFO(按失效时刻升序,实测两号口径一致):这些快过期批次正是 - // 被消耗得最快的,日均需耗给的是「哪怕单靠这个账号的自然流量也能对齐」的参照。 - const cls = days <= 3 ? 'var(--bad)' : days <= 7 ? 'var(--warn)' : 'var(--ok)'; - const dayWord = days === 0 ? '今天到期' : days === 1 ? '明天到期' : days + ' 天后到期'; - const more = bs.length > 4 ? ' 等 ' + bs.length + ' 批' : ''; - const rest = bs.slice(1, 4).map(b => - '随后 ' + esc(b.date.slice(5)) + ' · ' + fmtTok(b.remain)).join(' ') + more; - return '
' + - '' + esc(a.nickname || a.uid.slice(0, 8)) + '' + - '最近到期 ' + esc(first.date) + '(' + dayWord + - ')· 该批 ' + fmtTok(first.remain) + ' 积分 · 到期前日均需耗 ≥' + - fmtTok(daily) + '' + - (week > first.remain ? ' · 7 天内合计 ' + fmtTok(week) : '') + - (rest ? '
' + rest + '
' : '') + - '
'; - }).join(''); - $('expList').innerHTML = rows || '
没有账号
'; - // 数据新鲜度透明化:走缓存时标注年龄,免得把旧数据误当实时。 - const ageMin = lastPackages ? Math.floor((Date.now() - lastPackagesAt) / 60000) : 0; - $('expNote').textContent = (lastPackagesAt && ageMin > 0) - ? list.length + ' 个账号 · ' + ageMin + ' 分钟前的数据,可点「检查」刷新' - : list.length + ' 个账号 · 实时查询上游'; - $('expBox').hidden = false; -} - -async function loadExpiry(force) { - if (!$('expBox')) return; - if (expFetching) return; - const fresh = lastPackages && (Date.now() - lastPackagesAt) < EXP_FRESH_MS; - if (fresh && !force) { renderExpiry(lastPackages); return; } - expFetching = true; - $('expBox').hidden = false; - if (!$('expList').children.length) $('expList').innerHTML = '
查询中…(逐账号向上游实时查询)
'; - $('expNote').textContent = '查询中…'; - try { - const d = await api('packages'); - lastPackages = d; // 与「积分构成」视图共用同一份缓存 - lastPackagesAt = Date.now(); - renderExpiry(d); - } catch (e) { - $('expNote').textContent = '查询失败:' + esc(e.message); - } - expFetching = false; -} - -if ($('btnExp')) $('btnExp').onclick = () => loadExpiry(true); - -if ($('btnPk')) $('btnPk').onclick = loadPackages; +'use strict'; +/* ── 状态 ─────────────────────────────────────────────────────────── */ +const LS_KEY = 'wb2api.key', LS_THEME = 'wb2api.theme'; +/* 账号备注的本机键(模块级声明放顶部,避开 TDZ)。 */ +const LS_REMARKS = 'wb2api.remarks.v1'; +/* 下拉框记忆(issue #160)的单一键:日志范围、模型排序这类纯 UI 偏好存一份 JSON。 + 写不进去(隐私模式 / 配额满)就当没设过——偏好丢了不影响功能,不能因此抛异常。 */ +const LS_PREF = 'wb2api.pref.v1'; +function prefGet(k) { + try { return (JSON.parse(localStorage.getItem(LS_PREF)) || {})[k] || ''; } catch (e) { return ''; } +} +function prefSet(k, v) { + try { + const m = JSON.parse(localStorage.getItem(LS_PREF)) || {}; + if (v) m[k] = v; else delete m[k]; + localStorage.setItem(LS_PREF, JSON.stringify(m)); + } catch (e) { /* 偏好丢失可接受 */ } +} +let remarksCache = null; +let proxyData = null, proxyPage = 1, proxyLoading = false, proxyEditID = null, proxySettingsDirty = false; +let theme = localStorage.getItem(LS_THEME) || 'auto'; // auto | light | dark +let view = 'accounts'; +let overviewData = null, cfgLoaded = null, updateData = null, updateBusy = false; +let logPin = true, loginState = null, loginTimer = null, loginStartAt = 0; +let refTimer = null; +/* 视图级筛选状态(模块级声明放在文件顶部,避免顶层 go() 早于声明执行时踩 TDZ)。 */ +let mdFilter = { q: '', realm: '', cap: '', effort: '', promo: '', sort: prefGet('mdSort') || 'default' }; +/* 收纳行(「其余 N 个账号,展开」)的展开状态。必须存在 DOM 之外:账号池/任务中心视图 + 每 5s 轮询重建 tbody,只把状态放在 aria-expanded / hidden 里会被下一轮渲染收回 + (表现为点「展开」后什么都不点又自动收起)。键 = tbody id。 */ +const restOpen = Object.create(null); +let mdAll = [], mdProbes = {}, mdProbeOf = () => undefined; +let mdLocks = [], mdRecent = []; +let reqFilter = { q: '', outcome: '' }; +let reqEntries = []; +let usDim = 'account', usCreditDim = 'account', usSort = 'total'; +let usageData = null; +let reqRangeState = null; // 请求记录的时间范围(用量页的见 trangeState) + +const $ = id => document.getElementById(id); + +/* ── 主题 ─────────────────────────────────────────────────────────── */ +/* 两态翻转(浅/深),首次访问跟随系统偏好;点击总是切换可见外观,符合直觉。 */ +function effTheme() { + return theme === 'auto' ? (matchMedia('(prefers-color-scheme: light)').matches ? 'light' : 'dark') : theme; +} +function applyTheme() { + const eff = effTheme(); + document.documentElement.dataset.theme = eff; + $('icoTheme').innerHTML = eff === 'light' + ? '' + : ''; + $('btnTheme').title = eff === 'light' ? '切换到深色' : '切换到浅色'; +} +addEventListener('change', applyTheme); +$('btnTheme').onclick = () => { + theme = effTheme() === 'light' ? 'dark' : 'light'; + localStorage.setItem(LS_THEME, theme); + applyTheme(); +}; +applyTheme(); + +/* ── 手机抽屉导航(≤760px;桌面按钮隐藏、类名无副作用) ─────────────── */ +const navEl = document.querySelector('.nav'), navScrim = $('navScrim'), btnNav = $('btnNav'); +function navSet(open) { + if (!navEl || !navScrim) return; + navEl.classList.toggle('open', open); + navScrim.classList.toggle('on', open); + document.body.classList.toggle('nav-open', open); + if (btnNav) btnNav.setAttribute('aria-expanded', String(open)); +} +if (btnNav && navScrim) { + btnNav.onclick = () => navSet(!navEl.classList.contains('open')); + navScrim.onclick = () => navSet(false); +} +addEventListener('keydown', e => { if (e.key === 'Escape') navSet(false); }); + +/* ── 请求 ─────────────────────────────────────────────────────────── */ +async function api(path, opts = {}) { + const h = Object.assign({}, opts.headers || {}); + const k = localStorage.getItem(LS_KEY); + if (k) h['Authorization'] = 'Bearer ' + k; + if (opts.body) h['Content-Type'] = 'application/json'; + const r = await fetch('/panel/api/' + path, Object.assign({}, opts, { headers: h })); + // status 挂到错误上:调用方靠它区分「可重试的抖动」与「重试无意义的终态」 + // (登录轮询据此决定继续等 OAuth 还是提示重新发起)。 + if (r.status === 401) { openKey(); const e = new Error('密钥无效或未填写'); e.status = 401; throw e; } + const d = await r.json().catch(() => ({})); + if (!r.ok) { const e = new Error(d.error || ('HTTP ' + r.status)); e.status = r.status; throw e; } + return d; +} +function toast(msg, cls) { + const el = document.createElement('div'); + el.className = 'tst ' + (cls || ''); + el.textContent = msg; + $('toasts').appendChild(el); + setTimeout(() => el.remove(), 3600); +} +// esc 文本/属性双安全转义。不能只用 div.innerHTML(它转义 <>& 但不转义引号), +// 否则字符串拼进 HTML 属性(如 title="uid: ...")时引号可闭合属性并注入事件处理器。 +// 显式替换 5 个字符:& < > " '(& 必须最先,避免二次转义)。 +function esc(s) { + return String(s == null ? '' : s) + .replace(/&/g, '&') + .replace(//g, '>') + .replace(/"/g, '"') + .replace(/'/g, '''); +} + +/* setHTML:内容与上次相同时不碰 DOM(perf)。 + * + * 面板每 5 秒重建一次整张表(innerHTML = ...)。即使内容没变,也会: + * - 重新解析整段 HTML(构造大量临时节点), + * - 丢弃旧子树(整批 GC 压力), + * - 触发一次全表重排(LayoutCount / RecalcStyleCount 随之上涨)。 + * + * 实测(账号池视图,10 个账号):每 5 秒 DOM 节点数在 3278↔7088 之间震荡—— + * 一次轮询就把整表换掉。数据没变时这纯属白烧 CPU 与内存。 + * + * 做法:记住上次写入的 HTML 字符串,相同则跳过赋值(DOM 原样保留,滚动位置、 + * 选中态、事件绑定的 DOM 节点都不会丢)。注意:不能改成 diff/patch——那会引入 + * 「局部更新丢状态」的复杂度,而这里只要「完全相同就不动」即可覆盖绝大部分轮次。 + */ +let lastHTML = new WeakMap(); +function setHTML(el, html) { + if (!el) return; + if (lastHTML.get(el) === html) return; + lastHTML.set(el, html); + el.innerHTML = html; +} +function ago(iso) { + if (!iso || iso.startsWith('0001-')) return '—'; + const s = (Date.now() - new Date(iso)) / 1000; + if (s < 0) return '刚刚'; + if (s < 60) return Math.floor(s) + ' 秒前'; + if (s < 3600) return Math.floor(s / 60) + ' 分钟前'; + if (s < 86400) return Math.floor(s / 3600) + ' 小时前'; + return Math.floor(s / 86400) + ' 天前'; +} +function dur(sec) { + sec = Math.max(0, Math.round(sec)); + const h = Math.floor(sec / 3600), m = Math.floor(sec % 3600 / 60), s = sec % 60; + return h ? h + '时' + String(m).padStart(2, '0') + '分' : m ? m + '分' + String(s).padStart(2, '0') + '秒' : s + '秒'; +} +function parseAPITime(value) { + const text = String(value || ''); + if (!text || text.startsWith('0001-')) return 0; + const ms = Date.parse(text); + return Number.isFinite(ms) ? ms : 0; +} +function fmtLocalDateTime(ms) { + const d = new Date(ms); + const p = n => String(n).padStart(2, '0'); + return d.getFullYear() + '-' + p(d.getMonth() + 1) + '-' + p(d.getDate()) + ' ' + + p(d.getHours()) + ':' + p(d.getMinutes()); +} + +/* ── 时间范围控件(用量 / 请求记录共用)──────────────────────────────── + 预设项:今天 / 近 24 小时 / 近 3 天 / 近 7 天 / 近 30 天 / 全部历史 / 自定义。 + + 为什么区间一律由前端算好再发: + - 「今天」必须是**浏览器本地时区**的 00:00 起。服务端时区未必与浏览器一致 + (容器常挂 TZ=Asia/Shanghai,而浏览器可能在任何时区),让服务端算"今天" + 会在跨时区时切错日子。 + - 「自定义」本来就是用户挑的具体时刻,没有任何服务端推导空间。 + + 滚动预设(近 N 小时/天)则保留 hours 参数:服务端按整点对齐的滚动窗口与旧 + 行为逐位一致,前端自己减 N 小时会多算/少算一个边界桶。 */ +const TRANGE_PRESETS = [ + ['today', '今天'], + ['24', '近 24 小时'], + ['72', '近 3 天'], + ['168', '近 7 天'], + ['720', '近 30 天'], + ['0', '全部历史'], + ['custom', '自定义…'], +]; +const TRANGE_DEFAULT = '72'; +const trangeStates = new Map(); // hostId → { preset, from: Date|null, to: Date|null } + +// dtLocalValue / dtLocalParse 与 的取值格式互转 +// (YYYY-MM-DDTHH:mm,本地时区;ES 里"带时间的日期串"按本地解析,正是我们要的)。 +function dtLocalValue(d) { + const p = n => String(n).padStart(2, '0'); + return d.getFullYear() + '-' + p(d.getMonth() + 1) + '-' + p(d.getDate()) + 'T' + + p(d.getHours()) + ':' + p(d.getMinutes()); +} +function dtLocalParse(s) { + if (!s) return null; + const d = new Date(s); + return isNaN(d.getTime()) ? null : d; +} + +// trangeMidnight 今天 00:00(本地时区)。 +function trangeMidnight() { + const d = new Date(); + d.setHours(0, 0, 0, 0); + return d; +} + +function trangeState(id) { + if (!trangeStates.has(id)) { + // 「自定义」的初始值给一段有意义的默认:今天 00:00 → 现在。 + trangeStates.set(id, { preset: TRANGE_DEFAULT, from: trangeMidnight(), to: new Date() }); + } + return trangeStates.get(id); +} + +// trangeRender 画出控件骨架(幂等:重复调用会保留当前状态)。 +function trangeRender(id) { + const host = $(id); + if (!host) return; + const st = trangeState(id); + const custom = st.preset === 'custom'; + host.innerHTML = + '' + + '' + + '' + + '→' + + '' + + ''; + const preset = host.querySelector('.tr-preset'); + if (preset) preset.onchange = () => { + st.preset = preset.value; + // 从别的预设切到自定义时,把区间重置为"今天 00:00 → 现在", + // 免得用户上次留下的半年区间被无声沿用。 + if (st.preset === 'custom' && (!st.from || !st.to)) { st.from = trangeMidnight(); st.to = new Date(); } + trangeRender(id); + trangeEmit(id); + }; + const fromEl = host.querySelector('.tr-from'); + const toEl = host.querySelector('.tr-to'); + const readCustom = () => { + st.from = dtLocalParse(fromEl.value); + st.to = dtLocalParse(toEl.value); + // 起止颠倒就地标红(不静默纠正:用户可能正输到一半)。 + const bad = st.from && st.to && st.from > st.to; + fromEl.classList.toggle('tr-bad', !!bad); + toEl.classList.toggle('tr-bad', !!bad); + if (bad) return; + trangeEmit(id); + }; + if (fromEl) fromEl.onchange = readCustom; + if (toEl) toEl.onchange = readCustom; +} + +const trangeHandlers = new Map(); +// trangeBind 渲染控件并登记变化回调。**不**在绑定时触发回调:各视图的首次加载 +// 由 go() 统一驱动,这里再触发一次会让打开页面时打两遍接口。 +function trangeBind(id, onChange, preset) { + trangeHandlers.set(id, onChange); + if (preset) trangeState(id).preset = preset; + trangeRender(id); +} +function trangeEmit(id) { + const fn = trangeHandlers.get(id); + if (fn) fn(); +} + +// trangeQuery 把当前选择翻译成查询参数。 +// rolling=true → 滚动预设发 hours(服务端整点对齐),今天/自定义发 from/to +// rolling=false → 一律发 from/to(归档是线性日志,前端算区间更直观)。 +// 「全部历史」:**用量**必须显式发 hours=0 —— 服务端「不给参数」的默认是 72 小时, +// 空查询会让「全部历史」静默变成「近 3 天」(issue #121 的形态:全部历史 8903 次请求 +// 与近 3 天一模一样,而真全部历史是 24817 次)。归档接口不认 hours,保持空查询 +// (它的默认是「最近 N 条」,本身就是全量日志的最新一段)。 +function trangeQuery(id, rolling) { + const st = trangeState(id); + const q = new URLSearchParams(); + const sec = d => Math.floor(d.getTime() / 1000); + if (st.preset === 'custom') { + if (st.from) q.set('from', sec(st.from)); + if (st.to) q.set('to', sec(st.to)); + return q; + } + if (st.preset === 'today') { + q.set('from', sec(trangeMidnight())); + return q; + } + if (st.preset === '0') { + if (rolling) q.set('hours', '0'); + return q; + } + if (rolling) { q.set('hours', st.preset); return q; } + q.set('from', sec(new Date(Date.now() - Number(st.preset) * 3600 * 1000))); + return q; +} + +// trangeLabel 人读口径,用于「用量总览」右上角这类需要回显区间的位置。 +function trangeLabel(id) { + const st = trangeState(id); + const found = TRANGE_PRESETS.find(p => p[0] === st.preset); + if (st.preset !== 'custom') return found ? found[1] : ''; + if (!st.from && !st.to) return '自定义'; + const f = d => d ? (d.getMonth() + 1) + '-' + String(d.getDate()).padStart(2, '0') + ' ' + + String(d.getHours()).padStart(2, '0') + ':' + String(d.getMinutes()).padStart(2, '0') : '…'; + return f(st.from) + ' → ' + f(st.to); +} +function rateLimitMeta(row, now) { + const model = String(row && row.model || '未知模型'); + const kind = String(row && row.kind || 'rate_limit'); + const resetAt = parseAPITime(row && row.reset_at); // 上游文案时间(仅被 soft_rate_max 截断时才与 until 不同) + const until = parseAPITime(row && row.until); // 网关实际解锁时刻(黄框消失即它) + // 倒计时与「剩余」一律跟 until:跟上游文案走会出现「显示还剩 50 分钟却已经掉框」, + // 再发一次请求黄框又弹回来的错觉(issue #171-2)。模型与档位页的锁池表也是 until 口径。 + const deadline = until || resetAt; + const remaining = deadline > now ? Math.round((deadline - now) / 1000) : 0; + if (kind === 'model_unavailable') { + return { + model, + kind, + detail: remaining ? '预计 ' + dur(remaining) + ' 后重试' : '等待重新探测', + title: model + '\n模型当前不可用' + (deadline ? '\n最早重试:' + fmtLocalDateTime(deadline) : ''), + }; + } + let detail; + if (resetAt && until && resetAt > until) { + // 双口径:上游文案晚于网关封顶解锁时刻——两个都写出来,剩余跟网关口径。 + detail = '上游称 ' + fmtLocalDateTime(resetAt) + ' 恢复 · 网关 ' + fmtLocalDateTime(until) + + ' 起重试' + (remaining ? '(剩余 ' + dur(remaining) + ')' : ''); + } else if (resetAt) { + detail = '预计 ' + fmtLocalDateTime(resetAt) + ' 解封' + (remaining ? '(剩余 ' + dur(remaining) + ')' : ''); + } else if (until) { + detail = '预计 ' + fmtLocalDateTime(until) + ' 恢复' + (remaining ? '(剩余 ' + dur(remaining) + ')' : ''); + } else { + detail = '预计解封时间未知'; + } + const title = [model, resetAt ? '上游重置:' + fmtLocalDateTime(resetAt) : '上游重置:时间未知']; + if (until && (!resetAt || until !== resetAt)) { + title.push('网关最早重试:' + fmtLocalDateTime(until)); + } + return { model, kind, detail, title: title.join('\n') }; +} +// disabledKind 把禁用 reason 归成「类别 + 语气 + 建议动作」。 +// +// 为什么要分类而不是直接显示 reason:四种禁用成因的**处置方式完全不同** —— +// 上游封禁要申诉、登录失效要重登、手动禁用要人来判断、12153 也是重登。 +// 只甩一行原始文本,运维得先读懂才敢动手;分成标签后「该做什么」一眼可见。 +// 判据按**优先级**匹配:11140/封禁类先判(最严重且处置唯一),再判登录失效。 +function disabledKind(reason) { + const r = String(reason || '').toLowerCase(); + if (/11140|banned|restricted|request illegal/.test(r)) { + return { label: '上游封禁', tone: 'bad', action: '需在官方申诉,revive 无效' }; + } + if (/refresh.*失败|refresh 验证失败/.test(r)) { + return { label: '登录失效', tone: 'bad', action: '需重新登录' }; + } + if (/12153/.test(r)) { + return { label: '登录失效', tone: 'bad', action: '需重新登录' }; + } + if (/401/.test(r)) { + return { label: '鉴权失败', tone: 'warn', action: '确认后重登或恢复' }; + } + if (/manual|手动/.test(r)) { + return { label: '手动禁用', tone: 'warn', action: '随时可恢复' }; + } + return { label: '已禁用', tone: 'warn', action: '' }; +} + +// acctStateOf 按 uid 从 overview 快照里取账号状态(禁用/暂停)。 +// +// 为什么余额趋势要标:这张表每一行是一条**历史余额曲线**,它不会因为账号被封 +// 而消失——但读者不知道「这条线为什么从某天起不再更新」,会把「号被封了」误读成 +// 「这段时间没怎么用」。标出来才对得上。 +// bhColorOf 余额趋势统一取色:失效账号一律用灰线,且**不占色板序号**。 +// +// 两个要点: +// 1. 失效号用灰 —— 与表格里 bh-dead 行的去色一致,图上也不能让死号的颜色 +// 和活号一样鲜;它已经不再更新,艳丽的线会误导人以为「还在跑」。 +// 2. 灰线**不参与色板轮转** —— 否则某个健康号会因前面多了一个死号而换色, +// 同一账号在不同时间/不同域下颜色飘移,读者对不上。 + +// bhIsDead 该账号当前是否已失效(禁用)。暂停**不算** —— 暂停号照常保号、 +// 余额仍在更新,只是暂不接流量,图上应按活号正常着色。 +function bhIsDead(s) { + const a = acctStateOf(s && s.uid); + return !!(a && a.disabled); +} + +function bhColorOf(uid, colorIndex, isDead) { + if (isDead) return 'var(--ink-3)'; + return BH_COLORS[colorIndex % BH_COLORS.length]; +} +function acctStateOf(uid) { + const list = (overviewData && overviewData.accounts) || []; + return list.find(a => a && a.uid === uid) || null; +} + +// disabledAge 禁用时长(「刚禁”和「禁了一周」处置优先级差很远)。 +function disabledAge(at) { + if (!at) return ''; + const t = Date.parse(at); + if (!Number.isFinite(t)) return ''; + const sec = Math.max(0, (Date.now() - t) / 1000); + if (sec < 60) return '刚刚'; + if (sec < 3600) return Math.floor(sec / 60) + ' 分钟前'; + if (sec < 86400) return Math.floor(sec / 3600) + ' 小时前'; + return Math.floor(sec / 86400) + ' 天前'; +} + +function rateLimitRowsHtml(rows, now, realm) { + const list = Array.isArray(rows) ? rows.filter(row => row && row.model) : []; + if (!list.length) return ''; + // 降级路由表(overview 的 model_fallback):限流的模型若配了等价模型,标注 + // 「⤳ 已路由至 X」—— 否则用户看到「v4.1 限流」会以为服务断了,实际请求已被 + // 自动改道到等价模型继续服务。这条是用户实测反馈要求可见的。 + return '
' + list.map(row => { + const m = rateLimitMeta(row, now); + const alt = fallbackTargetFor(m.model, realm); + const route = alt ? '⤳ 已路由至 ' + esc(alt) + '' : ''; + const title = alt ? m.title + ';已自动改道到 ' + alt : m.title; + return '
' + esc(m.model) + '' + esc(m.detail) + '' + + route + '
'; + }).join('') + '
'; +} + +function formatTokenCount(tokens) { + if (tokens == null || tokens === '') return '—'; + const n = Number(tokens); + if (!Number.isFinite(n) || n < 0) return '—'; + if (n < 1000) return String(Math.round(n)); + const units = [['k', 1e3], ['m', 1e6], ['b', 1e9]]; + let unit = units[0]; + for (const candidate of units) { + if (n >= candidate[1]) unit = candidate; + } + let value = n / unit[1]; + let rounded = Number(value.toFixed(1)); + // 999999 → 1m,而不是 1000k;四舍五入后自动升级单位。 + const next = units[units.indexOf(unit) + 1]; + if (next && rounded >= 1000) { + unit = next; + value = n / unit[1]; + rounded = Number(value.toFixed(1)); + } + return rounded + unit[0]; +} + +function formatLatency(ms) { + if (ms == null || ms === '') return '—'; + const n = Number(ms); + if (!Number.isFinite(n) || n <= 0) return '—'; + return n < 1000 ? Math.round(n) + 'ms' : (n / 1000).toFixed(1).replace(/\.0$/, '') + 's'; +} +function formatRate(rate) { + if (rate == null || rate === '') return '—'; + const n = Number(rate); + if (!Number.isFinite(n) || n < 0) return '—'; + return n.toFixed(1) + 'tok/s'; +} + +/* ── 密钥门 ───────────────────────────────────────────────────────── */ +function openKey() { $('keyVeil').classList.add('on'); setTimeout(() => $('keyInput').focus(), 60); } +$('btnKey').onclick = async () => { + const v = $('keyInput').value.trim(); + if (!v) return; + localStorage.setItem(LS_KEY, v); + try { + await api('overview'); + $('keyErr').hidden = true; + $('keyVeil').classList.remove('on'); + start(); + } catch (e) { $('keyErr').hidden = false; } +}; +$('keyInput').addEventListener('keydown', e => { if (e.key === 'Enter') $('btnKey').click(); }); + +// 登出:api_key 是唯一凭据(服务端只做 VerifyBearer 比对,无会话无 cookie 可失效), +// 所以"登出"= 清掉本机保存的密钥并重载——重载把内存里的定时器与已渲染数据一并清空, +// 无密钥时 start() 的首次请求 401 会自动弹回密钥门(data-lock="1",不可绕过)。 +$('btnLogout').onclick = () => { + if (!confirm('登出将清空本机保存的 API 密钥,需要重新输入才能进入面板。确认登出?')) return; + localStorage.removeItem(LS_KEY); + location.reload(); +}; + +/* ── 路由 ─────────────────────────────────────────────────────────── */ +const TITLES = { accounts: '账号池', proxies: '代理池', usage: '用量', packages: '积分构成', balhist: '余额趋势', taskscenter: '任务中心', models: '模型与档位', extensions: '扩展模型', config: '配置', events: '请求事件日志', logs: '运行日志' }; +function go(v) { + navSet(false); + view = v; + document.querySelectorAll('.view').forEach(s => s.hidden = s.id !== 'view-' + v); + document.querySelectorAll('.nav a').forEach(a => a.classList.toggle('on', a.dataset.view === v)); + $('ttl').textContent = TITLES[v]; + if (v === 'models' && !$('mdBody').children.length) loadModels(); + if (v === 'extensions') loadExtensions(); + if (v === 'config') loadConfig(); + if (v === 'proxies') loadProxies(); + // 切到日志视图:本地窗口为空(首次)时全量拉一次;已有窗口则继续增量。 + // 注意**不要**在每次切视图时 resetLogWindow()——那会把增量游标清掉,下一轮 + // 又变成全量拉,白白丢掉增量带来的收益。 + if (v === 'events') loadEvents(); + if (v === 'logs') { if (!logRows.length) resetLogWindow(); loadLogs(); } + if (v === 'usage') loadUsage(); + if (v === 'packages') loadPackages(); + if (v === 'balhist') loadBalance(); + if (v === 'taskscenter') reattachQueueView(); +} +document.querySelectorAll('.nav a').forEach(a => a.onclick = e => { e.preventDefault(); go(a.dataset.view); history.replaceState(null, '', '#' + a.dataset.view); }); +/* 首次进入延到本轮脚本求值之后再 go()。 + 原因:go() 会同步触发视图的数据加载(loadUsage/loadLogs/loadPackages…),而这些 + 函数读到的模块级 let/const(usageRateWarmAt、PK_* 等)在文件后半段才初始化—— + 直接深链 #usage / #packages 打开页面时会踩 TDZ("Cannot access 'x' before + initialization"),表现为该页永远显示"读取失败",而点导航进去一切正常。 + 延迟 0ms 让整份脚本先求值完,是修这一类问题最省事也最不容易再犯的办法。 */ +setTimeout(() => { + const hash = (location.hash || '#accounts').slice(1); + go(hash in TITLES ? hash : 'accounts'); +}, 0); + +/* ── 账号池 ───────────────────────────────────────────────────────── */ +let accRealmFilter = 'all'; +let lastAccountsList = []; +/* 分组筛选(issue #159):'' = 全部分组。lastVisibleAccounts 是当前表格真正渲染的行, + 「组内批量」只对它生效——作用域与用户眼前看到的行一致,不会误伤被筛掉的账号。 */ +let accGroupFilter = ''; +let lastVisibleAccounts = []; + +/* syncGroupFilter 按当前账号列表重建分组下拉(组是自由标签,没有独立的组表可查)。 + 选中值不在新列表里就退回「全部分组」——否则筛到一个已清空的组会看到永远空表。 */ +function syncGroupFilter() { + const sel = $('accGroupFilter'); + if (!sel) return; + const groups = [...new Set(lastAccountsList.map(s => s.group).filter(Boolean))] + .sort((a, b) => a.localeCompare(b, 'zh')); + if (accGroupFilter && !groups.includes(accGroupFilter)) accGroupFilter = ''; + setHTML(sel, '' + groups.map(g => + '').join('')); + sel.value = accGroupFilter; +} + +function renderAccounts(list) { + lastAccountsList = Array.isArray(list) ? list : []; + if (document.activeElement?.matches?.('[data-proxy-uid]')) return; + const tb = $('accBody'); + const total = lastAccountsList.length; + const globalCnt = lastAccountsList.filter(s => s.realm === 'global').length; + const cnCnt = total - globalCnt; + + const elTabs = $('accRealmTabs'); + if (elTabs) { + const cAll = $('accCntAll'), cCn = $('accCntCn'), cGl = $('accCntGlobal'); + if (cAll) cAll.textContent = total; + if (cCn) cCn.textContent = cnCnt; + if (cGl) cGl.textContent = globalCnt; + elTabs.querySelectorAll('button[data-realm]').forEach(b => { + b.classList.toggle('on', b.dataset.realm === accRealmFilter); + }); + } + + let filtered = lastAccountsList; + if (accRealmFilter === 'cn') { + filtered = lastAccountsList.filter(s => s.realm !== 'global'); + } else if (accRealmFilter === 'global') { + filtered = lastAccountsList.filter(s => s.realm === 'global'); + } + syncGroupFilter(); + if (accGroupFilter) { + filtered = filtered.filter(s => (s.group || '') === accGroupFilter); + } + lastVisibleAccounts = filtered; + // 组内批量只在「筛到某一组」时才露出来:全部分组下这几个按钮等于第二个「全部签到」, + // 白占位还容易点错作用域。 + if ($('accGroupActions')) $('accGroupActions').hidden = !accGroupFilter; + + if (!filtered.length) { + if (!total) { + setHTML(tb, '
账号池是空的
点击右上角「添加账号」,用浏览器登录一个 WorkBuddy 账号
'); + } else if (accGroupFilter) { + setHTML(tb, '
分组「' + esc(accGroupFilter) + '」下没有账号
在「备注」里给账号填上分组后就会出现在这里
'); + } else if (accRealmFilter === 'cn') { + setHTML(tb, '
暂无国内版账号
当前账号池内均为国际版账号(共 ' + globalCnt + ' 个)
'); + } else if (accRealmFilter === 'global') { + setHTML(tb, '
暂无国际版账号
当前账号池内均为国内版账号(共 ' + cnCnt + ' 个)
'); + } + return; + } + // 有总额度(credits_total)→ 进度条按自身 剩余/总额 百分比;旧数据无总额 → 退回池内最高=100% + const maxCred = Math.max(1, ...filtered.map(s => s.credits || 0)); + // 「探活」是冻结态专属动作,占独立槽位;整表没有冻结账号时连那一列都不占, + // 否则中间会空出一条无意义的缝。判定式与行内 cool 同源(只看是否 > 0)。 + const nowF = Date.now(); + const anyFrozen = filtered.some(s => s.disabled || Math.max(s.cool_remaining_sec || 0, + (new Date(s.breaker_until || 0) - nowF) / 1000, (new Date(s.degrade_until || 0) - nowF) / 1000) > 0); + setHTML(tb, filtered.map(s => { + const bl = (new Date(s.breaker_until || 0) - Date.now()) / 1000; + const dg = (new Date(s.degrade_until || 0) - Date.now()) / 1000; + const cool = Math.max(s.cool_remaining_sec || 0, bl > 0 ? bl : 0, dg > 0 ? dg : 0); + let cls = '', tag; + if (s.disabled) { cls = 'off'; tag = '已禁用'; } + // 暂停选号:与禁用同属「不可选」,但照常保号(吸收上游 fd835df) + else if (s.paused) { cls = 'off'; tag = '已暂停选号'; } + else if (cool > 0) { + cls = 'cool'; + const kind = bl > Math.max(s.cool_remaining_sec || 0, dg > 0 ? dg : 0) ? '熔断' + : (dg > (s.cool_remaining_sec || 0) ? '连败降权' : (s.cool_kind === 'hard_credit' ? '积分冷却' : '限流冷却')); + tag = '' + kind + ' · ' + dur(cool) + ''; + } + else if (s.reserve_blocked) { cls = 'cool'; tag = '保留积分'; } + // 会话疑似失效(12153 连续计数已 >0、还没到禁用阈值):上游已判死、号还留在池里。 + // 此前这种中间态完全不可见,面板照样打「可用」(issue #215 复盘)。 + else if (s.session_dead_fails > 0) { cls = 'cool'; tag = '疑似登录失效 · 待重登'; } + else tag = '可用' + (s.in_flight ? '' : ''); + // 禁用原因分两行:类别+时长(谁来处置、多久了)/ 原始 reason(细节)。 + // 不分行的话「上游封禁 · 3 天前」和一段长 reason 挤在同一行,扫视时读不出重点。 + const dk = s.disabled ? disabledKind(s.reason) : null; + const dAge = s.disabled ? disabledAge(s.disabled_at) : ''; + const note = s.reason + ? '
' + + (dk ? '' + esc(dk.label) + '' : '') + + (dAge ? '' + esc(dAge) + '' : '') + + (dk && dk.action ? '' + esc(dk.action) + '' : '') + + '
' + esc(s.reason) + '
' + : ''; + const rateLimits = rateLimitRowsHtml(s.rate_limited_models, Date.now(), s.realm); + const short = s.uid.length > 16 ? s.uid.slice(0, 16) + '…' : s.uid; + // 企业版不限量:上游 limitNum == -1,网关以 credits_total=-1 透出(见 upstream + // enterpriseUnlimitedTotal)。此时剩余额度不参与展示,直接标「不限」。 + const unlimited = s.credits_total === -1; + const cred = unlimited ? '不限' + : (s.credits == null ? '—' : (s.credits_total > 0 ? s.credits + '/' + s.credits_total + '' : String(s.credits))); + const pct = unlimited ? 100 + : (s.credits_total > 0 + ? Math.min(100, Math.round((s.credits || 0) / s.credits_total * 100)) + : Math.round((s.credits || 0) / maxCred * 100)); + // 成本台账 tooltip(model_costs):每模型实测单价(≤0 = 实测免费),运维据此 + // 看「为什么总选它」——免费号垄断 / 单价排序一眼可见。 + let credTip; + if (unlimited) credTip = '企业版不限量(上游 limitNum=-1)'; + else if (s.credits_total > 0) { + credTip = (s.enterprise ? '企业版剩余额度 ' : '剩余 ') + + s.credits + ' / ' + (s.enterprise ? '分配 ' : '总额 ') + s.credits_total + '(' + pct + '%)'; + } else credTip = '积分(相对池内最高)'; + const costs = (s.model_costs || []).filter(c => c.model); + if (costs.length) { + credTip += '\n实测单价(credits/1K):\n' + costs.map(c => + ' ' + c.model + ':' + (c.cost_per_1k <= 0 ? '免费' : c.cost_per_1k) + + (c.win_tokens ? '(本窗口 ' + c.win_tokens + ' tok)' : '')).join('\n'); + } + const frozen = s.disabled || cool > 0; + // 无个人成长体系的账号(企业版 / 静态 API Key):签到与成长任务端点在上游对自己 + // 恒失败,按钮点了只会报错,故不渲染;「额度」按钮走企业口径端点照常可用。 + const personal = !(s.enterprise || s.api_key); + const tu = s.token_usage || {}; + const req = tu.request_count || 0; + const totalTok = formatTokenCount(tu.total_tokens); + const totalTokUnit = totalTok === '—' ? '' : 'tok'; + const latency = formatLatency(tu.last_latency_ms); + const rate = formatRate(tu.last_tokens_per_second); + const usageTitle = '最近一次:' + req + ' 次 / ' + totalTok + ' / 延迟 ' + latency + ' / ' + rate; + const rawWho = s.nickname || s.uid || ''; + const nameHtml = remarkName(s.uid, s.nickname ? esc(s.nickname) : '未命名'); + const tags = (s.realm === 'global' ? ' 国际版' : '') + + (s.enterprise ? ' 企业版' : '') + + (s.api_key ? ' API Key' : ''); + return '' + + '' + + '
' + nameHtml + '' + tags + '
' + esc(short) + '
' + accountProxyHTML(s.uid) + '' + + '' + tag + note + rateLimits + '' + + '
' + cred + '
' + + '' + (s.success_count || 0) + ' / ' + (s.err_total || 0) + '' + + '' + (s.in_flight || 0) + '' + + '' + + '' + req + '次' + + '' + totalTok + '' + totalTokUnit + '' + + '' + latency + '' + + '' + rate + '' + + '' + + '' + ago(s.last_success) + '' + + '
' + [ + // 无个人成长体系的账号(企业版 / 静态 API Key)不渲染「签到」「任务」:前者 + // 上游 400「企业账号不支持该操作」,后者 403 growth-only;只留「额度」,点它走 + // /balance,额度由 upstream 的企业口径端点(get-enterprise-user-usage)填充。 + // 八个动作按固定槽位输出,缺位留空 span —— CSS 用 grid 固定列宽,逐行对齐。 + // 「探活」单独占一槽(仅封禁态渲染):它与「解冻」是两个独立动作,若挤在同一 + // 槽里输出两个按钮,冻结行的列数就与其它行不同,整列又会错位。 + (personal ? + '' : ''), + '', + (personal ? + '' : ''), + (frozen ? '' + : (anyFrozen ? '' : null)), + (frozen ? '' + : (s.paused ? '' + : '')), + (s.disabled ? '' : ''), + '', + '', + ].filter(html => html !== null).map(html => html || '').join('') + + '
'; + }).join('')); +} + +// renderModelLocks 模型锁池:哪些模型不能用、锁了几个号、还要锁多久。后端已按 +// 「整池不可用 → 此刻没号 → 部分限流」排好序,这里只做展示(移植上游 PR #120)。 +const ML_STATE = { locked: ['bad', '全池锁定'], starved: ['warn', '此刻无号'], partial: ['ok', '部分限流'] }; +/* fallbackTargetFor 查该 (域, 模型) 配置的降级目标(未配置 → 空串)。 + 配置键既可能是裸名,也可能带 cn:/global: 前缀,查找顺序必须与网关侧 + lookupFallback 一致:带域前缀的键优先,再回退裸名——只查裸名会让按域 + 配置的键整表失效,限流的模型看不到「已路由至」。限流行(rateLimitRowsHtml) + 与锁池表(renderModelLocks)共用;函数声明提升,两处调用均可用。 */ +function fallbackTargetFor(model, realm) { + if (!model) return ''; + const bare = String(model).replace(/^[a-z]+:/, ''); + const t = (overviewData && overviewData.model_fallback) || {}; + return (realm ? t[realm + ':' + bare] : '') || t[model] || t[bare] || ''; +} +function renderModelLocks(rows) { + const tb = $('mlBody'); + const list = Array.isArray(rows) ? rows : []; + $('mlNote').textContent = list.length ? list.length + ' 个模型受限' : ''; + if (!list.length) { + setHTML(tb, '
当前没有模型级限流 —— 所有模型均可选
'); + return; + } + setHTML(tb, list.map(r => { + const [cls, label] = ML_STATE[r.state] || ['', r.state || '—']; + const unlock = r.unlock_at && !/^0001-/.test(r.unlock_at) ? fmtLocalDateTime(r.unlock_at) : '—'; + const fully = r.fully_unlock_at && !/^0001-/.test(r.fully_unlock_at) ? fmtLocalDateTime(r.fully_unlock_at) : '—'; + // 「锁了但请求照样能过」是这张表最容易误读的地方:配了降级路由表时,该模型 + // 在本域不可用,请求已被网关改道到等价模型继续服务。不标出来,会把 + // 「global flash 锁定」直接读成「flash 服务中断」。 + const alt = fallbackTargetFor(r.model, r.realm); + const route = alt ? '
⤳ 已路由至 ' + esc(alt) + '
' : ''; + return '' + + '' + esc(r.model) + '' + route + '' + + '' + (r.realm === 'global' ? '国际版' : '国内版') + '' + + '' + label + '' + + '' + (r.servable || 0) + ' / ' + (r.total || 0) + '' + + '' + (r.locked || 0) + '' + + '' + esc(unlock) + '' + + '' + esc(fully) + '' + + '' + esc(r.reason || '—') + '' + + ''; + }).join('')); +} + +function displayVersion(version) { + const value = String(version || 'dev').replace(/^v/, ''); + return value === 'dev' ? 'dev' : 'v' + value; +} + +function unknownVersionNote(update) { + const label = displayVersion(update.current_version) === 'dev' ? '开发构建 · 无法比较版本' : '当前版本无法比较'; + return label + (update.latest_version ? ' · 最新 Release v' + update.latest_version : ''); +} + +function renderUpdateStatus(update) { + if (!update) return; + updateData = update; + const unknown = update.current_known === false; + const local = displayVersion(update.current_version); + $('navSub').textContent = local; + $('navVer').textContent = local; + $('navUpdate').hidden = !update.update_available; + $('navUpdate').textContent = '有更新'; + $('navUpdate').title = update.update_available ? '发现 v' + update.latest_version + ',点击查看更新操作' : ''; + const note = $('updateNote'); + if (update.installing) { + note.textContent = '正在准备更新…'; + } else if (update.last_error) { + note.textContent = '更新失败:' + update.last_error; + } else if (unknown) { + note.textContent = unknownVersionNote(update); + } else if (update.update_available) { + note.textContent = '发现新版本 v' + update.latest_version + (update.can_install ? '' : ' · 请手动更新'); + } else if (update.latest_version) { + note.textContent = '已是最新版本 · v' + update.latest_version; + } else { + note.textContent = '尚未检查'; + } + $('btnUpdateInstall').hidden = !update.update_available || !update.can_install; + $('btnUpdateInstall').disabled = updateBusy || !!update.installing; + $('btnUpdateRelease').hidden = (!update.update_available && !unknown) || !!update.can_install || !update.release_url; + $('btnUpdateCheck').disabled = updateBusy || !!update.installing; + renderUpdateChannel(update); +} + +// renderUpdateChannel 展示「更新走哪条通道」与上次失败的归因(issue #198)。 +// +// 现场痛点:api.github.com 通、release-assets 被拦时,面板只显示一句原始超时文本, +// 用户既不知道自己有没有走代理,也不知道下一步该配什么。这里把通道名与类目直接 +// 摆出来,并把类目翻成一句人话建议。 +const UPDATE_CHANNEL_LABEL = { + 'direct': '直连(已关闭环境变量代理)', + 'direct(env)': '直连(跟随环境变量)', + 'proxy': '代理', + 'mirror': '镜像', + 'mirror+proxy': '镜像 + 代理', +}; +const UPDATE_ERROR_ADVICE = { + 'dns': '域名解析失败:检查容器 DNS(可用 dns_servers)与出站策略。', + 'connect': 'TCP 连不上:出站被拦或网络不可达;可配「更新代理」或「镜像前缀」绕行。', + 'tls': 'TLS 握手/证书失败:常见于中间设备劫持或系统 CA 过期;先试镜像。', + 'header-timeout': '等响应头超时:出站到 release-assets 很可能被拦(api.github.com 往往仍通);配代理或镜像即可。', + 'body-stall': '下载中途停滞:链路抖动或镜像限速;换镜像或配代理。', + 'checksum': '摘要/尺寸不符:下载内容被中间层改写;换回直连或换可信镜像(不要放宽校验)。', + 'http': '对方返回非 200:镜像不可用或前缀路径不对;检查镜像前缀。', + 'proxy-config': '代理地址不合法;只支持 http、https、socks5 三种协议。', + 'mirror-config': '镜像前缀不合法;需要 http 或 https 加主机名加斜杠的形式。', +}; +function renderUpdateChannel(update) { + const el = $('updateChannel'); + if (!el) return; + const bits = ['通道:' + (UPDATE_CHANNEL_LABEL[update.channel] || update.channel || '未知')]; + if (update.proxy_host) bits.push('代理 ' + update.proxy_host); + if (update.mirror) bits.push('镜像 ' + update.mirror); + el.textContent = bits.join(' · '); + const advice = UPDATE_ERROR_ADVICE[update.last_error_kind]; + if (advice) { + el.textContent += ' | 上次失败[' + update.last_error_kind + ']:' + advice; + el.style.color = 'var(--warn)'; + } else { + el.style.color = ''; + } +} + +// 测试连通性:分别探「版本元数据」与「资产下载」两条路,把结果逐行摆出来。 +// 检查更新只回答「有没有新版本」,通道坏的时候它给不出「坏在哪一段」。 +async function probeUpdateChannel() { + const button = $('btnUpdateProbe'); + const out = $('updateProbeOut'); + button.disabled = true; + button.textContent = '探测中…'; + out.hidden = false; + out.textContent = '正在探测…'; + try { + const r = await api('update/probe', { method: 'POST' }); + const rows = [r.meta, r.asset].filter(Boolean).map(p => { + const state = p.ok ? '通' : ('失败[' + (p.kind || 'unknown') + ']'); + const extra = p.ok ? ('HTTP ' + p.status) : (p.error || ''); + return p.target + ':' + state + ' · ' + p.elapsed_ms + 'ms · ' + extra; + }); + out.innerHTML = rows.map(t => '
' + esc(t) + '
').join(''); + const advice = UPDATE_ERROR_ADVICE[(r.meta && r.meta.kind) || (r.asset && r.asset.kind)]; + if (advice) out.innerHTML += '
' + esc(advice) + '
'; + if (r.update) renderUpdateStatus(r.update); + } catch (e) { + out.textContent = '探测失败:' + e.message; + } finally { + button.disabled = false; + button.textContent = '测试连通性'; + } +} + +async function checkForUpdates() { + if (updateBusy || updateData?.installing) return; + updateBusy = true; + const button = $('btnUpdateCheck'); + button.disabled = true; + button.textContent = '检查中…'; + try { + const update = await api('update/check', { method: 'POST' }); + renderUpdateStatus(update); + let message = '当前已是最新版本'; + if (update.current_known === false) message = unknownVersionNote(update); + else if (update.update_available) message = '发现新版本 v' + update.latest_version; + toast(message, update.update_available ? 'ok' : ''); + } catch (e) { + try { renderUpdateStatus(await api('update')); } catch (_) {} + toast('检查更新失败:' + e.message, 'err'); + } finally { + updateBusy = false; + if (updateData) renderUpdateStatus(updateData); + button.textContent = '检查更新'; + } +} + +async function installUpdate() { + if (updateBusy || !updateData || updateData.installing || !updateData.can_install || !updateData.update_available) return; + if (!confirm('将安装 v' + updateData.latest_version + ' 并重启服务,期间服务会短暂中断。请避开正在处理的请求,确认继续?')) return; + const button = $('btnUpdateInstall'); + updateBusy = true; + button.disabled = true; + button.textContent = '准备更新…'; + try { + const result = await api('update/install', { method: 'POST' }); + renderUpdateStatus(result.status); + toast('更新已准备,服务即将重启', 'ok'); + } catch (e) { + toast('更新失败:' + e.message, 'err'); + } finally { + updateBusy = false; + if (updateData) renderUpdateStatus(updateData); + button.textContent = '立即更新'; + } +} + +function openLatestRelease() { + if (updateData && updateData.release_url) open(updateData.release_url, '_blank', 'noopener'); +} + +if ($('btnUpdateCheck')) $('btnUpdateCheck').onclick = checkForUpdates; +if ($('btnUpdateProbe')) $('btnUpdateProbe').onclick = probeUpdateChannel; +if ($('btnUpdateInstall')) $('btnUpdateInstall').onclick = installUpdate; +if ($('btnUpdateRelease')) $('btnUpdateRelease').onclick = openLatestRelease; +if ($('navUpdate')) $('navUpdate').onclick = () => { + go('config'); + $('updateNote').scrollIntoView({ block: 'center', behavior: 'smooth' }); +}; + +// overviewSig 上一次渲染用的账号+锁池快照(JSON 文本)。轮询每 5 秒一次,内容没变时 +// 跳过表格重渲染:重建 innerHTML 会丢掉行内焦点与悬停,29 个号就是每 5 秒抖一次。 +let overviewSig = ''; + +async function loadOverview(quiet) { + try { + const d = await api('overview'); + overviewData = d; + if (d.proxy_pool) proxyData = d.proxy_pool; + // 应用服务端透出的自动刷新间隔(首轮 overview 之后即生效;后续不变则不重建表)。 + if (d.poll_interval_sec !== undefined && d.poll_interval_sec !== null) { + const sec = Number(d.poll_interval_sec); + if (Number.isFinite(sec)) { + const wantAuto = sec >= 0; + const wantMs = wantAuto ? (sec > 0 ? sec * 1000 : 5000) : pollIntervalMs; + if (wantAuto !== pollAutoRefresh || wantMs !== pollIntervalMs) { + pollAutoRefresh = wantAuto; + pollIntervalMs = wantMs; + startPolling(); + } + } + } + const previousUpdate = typeof updateData !== 'undefined' ? updateData : null; + $('sTotal').textContent = d.total; + $('sHealthy').textContent = d.healthy; + $('sCooling').textContent = d.cooling; + $('sDisabled').textContent = d.disabled; + // 暂停选号单列(issue #125):它只关选号、照常签到保活,与禁用是两种状态。 + if ($('sPaused')) $('sPaused').textContent = d.paused == null ? '-' : d.paused; + const remSum = (d.accounts || []).reduce((a, s) => a + (s.credits || 0), 0); + const totSum = (d.accounts || []).reduce((a, s) => a + (s.credits_total || 0), 0); + $('sCredits').textContent = totSum > 0 ? remSum + ' / ' + totSum : remSum; + $('sSticky').textContent = d.sticky_sessions; + if (typeof renderUpdateStatus === 'function') renderUpdateStatus(d.update || { current_version: d.version }); + if (d.update && d.update.update_available && + (!previousUpdate || !previousUpdate.update_available || previousUpdate.latest_version !== d.update.latest_version)) { + toast('发现新版本 v' + d.update.latest_version, 'ok'); + } + $('navRedis').textContent = d.redis_mode === 'upstash' ? 'Redis 镜像' : '本地内存'; + $('navState').textContent = d.healthy > 0 ? '服务正常' : (d.total ? '无可用账号' : '待添加账号'); + const p = $('navPulse'); + p.className = 'pulse' + (d.healthy > 0 ? '' : (d.total ? ' warn' : ' bad')); + $('accNote').textContent = d.in_flight_full ? d.in_flight_full + ' 个账号在途占满' : ''; + const up = Math.floor(d.uptime_sec); + $('subMeta').textContent = '运行 ' + (up >= 86400 ? Math.floor(up / 86400) + ' 天 ' : '') + Math.floor(up % 86400 / 3600) + ' 时 ' + Math.floor(up % 3600 / 60) + ' 分'; + // 只在载荷真变了才重建两张表(见 overviewSig 注释)。 + const sig = JSON.stringify([d.accounts || [], d.model_locks || []]); + if (sig !== overviewSig) { + overviewSig = sig; + renderAccounts(d.accounts || []); + renderModelLocks(d.model_locks); + } + // 到期提醒随首页统计一起刷新:只用响应里已有的最早到期快照,零上游请求。 + renderExpirySnapshot(d); + } catch (e) { + // 轮询(quiet)时也留痕:渲染异常被静默吞掉的表现就是「统计正常、表格空白」 + console.error('[panel] 首页刷新失败', e); + if (!quiet) toast(e.message, 'err'); + } +} + +$('accBody').addEventListener('click', async ev => { + const b = ev.target.closest('button[data-a]'); + if (!b) return; + const u = b.dataset.u, a = b.dataset.a; + // 行内「备注」只开本机编辑器,不打后端接口:提前返回,跳过下面的 disable 与 confirm。 + if (a === 'remark') { openRemarks(u); return; } + if (a === 'remove' && !confirm('移除账号将删除池状态与 auths/ 下的凭证文件,且不可恢复。确认移除?')) return; + if (a === 'disable' && !confirm('禁用后该账号不再参与选号(保号任务默认也跳过),需手动解冻才能恢复。若只是想临时让位、仍要保号,请改用「暂停选号」。确认禁用?')) return; + b.disabled = true; + try { + if (a === 'checkin') { + const r = await api('accounts/' + encodeURIComponent(u) + '/checkin', { method: 'POST' }); + const note = checkinResultNote(r); + toast(note.message, note.severity); + } else if (a === 'balance') { + const r = await api('accounts/' + encodeURIComponent(u) + '/balance', { method: 'POST' }); + toast('余额已更新:' + r.credits + (r.credits_total > 0 ? ' / ' + r.credits_total : ''), 'ok'); + } else if (a === 'probe_ban') { + // 只读探测:后端不改任何池状态,所以这里**不刷新** overview(没有变化)。 + // 结论用 toast 说清处置动作,而不是只报一句「仍被封」——运维要知道下一步做什么。 + const r = await api('accounts/' + encodeURIComponent(u) + '/probe_ban', { method: 'POST' }); + const map = { + lifted: ['已解封,可以点「解冻」恢复使用', 'ok'], + still_banned: ['仍被封禁,继续等待(勿反复 revive,可能加重风控)', 'warn'], + blocked: ['会话仍有效,但被上游风控拦截(可能仍是封禁)—— 继续观察', 'warn'], + session_dead: ['不是封禁问题 —— 登录态失效,需重新登录', 'warn'], + inconclusive: ['探测无明确结论(网络/限流等),稍后再试', 'warn'], + unknown: ['无法探测:上游客户端未配置', 'err'], + }; + const m = map[r.verdict] || [r.verdict + (r.detail ? ':' + r.detail : ''), 'warn']; + toast(m[0], m[1]); + return; // 探测不改变状态,跳过下面的 loadOverview + } else if (a === 'revive') { + await api('accounts/' + encodeURIComponent(u) + '/revive', { method: 'POST' }); + toast('已解冻', 'ok'); + } else if (a === 'disable') { + await api('accounts/' + encodeURIComponent(u) + '/disable', { method: 'POST' }); + toast('已禁用', 'ok'); + } else if (a === 'pause') { + await api('accounts/' + encodeURIComponent(u) + '/pause', { method: 'POST' }); + toast('已暂停选号(签到 / 保活照常)', 'ok'); + } else if (a === 'resume') { + await api('accounts/' + encodeURIComponent(u) + '/resume', { method: 'POST' }); + toast('已恢复选号', 'ok'); + } else if (a === 'tasks') { + openTasks(u); + } else if (a === 'remove') { + const r = await api('accounts/' + encodeURIComponent(u) + '/remove', { method: 'POST' }); + toast(r.file_error ? '已移除(凭证文件删除失败:' + r.file_error + ')' : '已移除', 'ok'); + } + } catch (e) { toast(e.message, 'err'); } + finally { + b.disabled = false; + if (a !== 'tasks') invalidatePackages(); + loadOverview(true); + } +}); + +$('btnCheckinAll').onclick = async () => { + try { await api('checkin_all', { method: 'POST' }); toast('全部签到已开始,结果见日志', 'ok'); } + catch (e) { toast(e.message, 'err'); } +}; +$('btnKeepaliveAll').onclick = async () => { + try { await api('keepalive_all', { method: 'POST' }); toast('全部保活已开始,结果见日志', 'ok'); } + catch (e) { toast(e.message, 'err'); } +}; +$('btnTravelAll').onclick = async () => { + try { await api('travel_all', { method: 'POST' }); toast('旅行巡检已开始(含领养链路),结果见日志', 'ok'); } + catch (e) { toast(e.message, 'err'); } +}; +$('btnActivityAll').onclick = async () => { + try { await api('activity_all', { method: 'POST' }); toast('活跃上报已开始,结果见日志', 'ok'); } + catch (e) { toast(e.message, 'err'); } +}; +if ($('accRealmTabs')) { + $('accRealmTabs').addEventListener('click', ev => { + const btn = ev.target.closest('button[data-realm]'); + if (!btn) return; + const r = btn.dataset.realm; + if (r === accRealmFilter) return; + accRealmFilter = r; + renderAccounts(lastAccountsList); + }); +} +if ($('accGroupFilter')) { + $('accGroupFilter').onchange = () => { + accGroupFilter = $('accGroupFilter').value; + renderAccounts(lastAccountsList); + }; +} +/* 组内批量(issue #159):作用域 = 当前表格里可见的行(lastVisibleAccounts), + 逐号打已有的单号接口——不新增批量端点,也不改调度器。签到跳过企业版/静态 Key + 与已禁用号:它们的签到端点注定 4xx,统计里不该算失败。 */ +const GROUP_ACT = { + checkin: { verb: '签到', ok: s => !s.enterprise && !s.api_key && !s.disabled }, + pause: { verb: '暂停选号', ok: s => !s.paused && !s.disabled }, + resume: { verb: '恢复选号', ok: s => s.paused }, +}; +if ($('accGroupActions')) { + $('accGroupActions').addEventListener('click', async ev => { + const b = ev.target.closest('button[data-gact]'); + if (!b) return; + const act = GROUP_ACT[b.dataset.gact]; + if (!act) return; + const targets = lastVisibleAccounts.filter(act.ok); + if (!targets.length) { toast('当前分组里没有需要「' + act.verb + '」的账号', 'warn'); return; } + // 恢复选号把号推回流量池、暂停选号把它撤出来,都影响在线请求,先确认再动手。 + if (b.dataset.gact !== 'checkin' && + !confirm('对分组「' + accGroupFilter + '」的 ' + targets.length + ' 个账号执行「' + act.verb + '」?')) return; + b.disabled = true; + let ok = 0, already = 0; + const bad = []; + for (const s of targets) { + const name = s.nickname || String(s.uid).slice(0, 8); + try { + const r = await api('accounts/' + encodeURIComponent(s.uid) + '/' + b.dataset.gact, { method: 'POST' }); + /* 签到端点对失败也回 200(错误在 body 里):只按 HTTP 成功计数,会把「今天早就 + 签过」和上游拒签一起算进「成功 N 个」——hub#875 那类误报的同一个根。 + 按 checkin_state 分开统计,already 单独报,不冒充新签到。 */ + if (b.dataset.gact === 'checkin') { + if (r && r.checkin_state === 'already') { already++; continue; } + if (r && r.ok === false) { bad.push(name + ':' + (r.checkin_message || '未完成')); continue; } + } + ok++; + } catch (e) { bad.push(name + ':' + e.message); } + } + b.disabled = false; + const tail = bad.length ? ',失败 ' + bad.length + ' 个(' + bad[0] + ')' : ''; + toast(b.dataset.gact === 'checkin' + ? '组内签到:新签到 ' + ok + ' 个' + (already ? ',今日已签 ' + already + ' 个' : '') + tail + : '组内' + act.verb + ':成功 ' + ok + ' 个' + tail, + bad.length ? 'warn' : 'ok'); + loadOverview(true); + }); +} + +/* ── 模型 ─────────────────────────────────────────────────────────── */ +/* 实测上限标注:scripts/probe_max_tokens.py --panel-out 写入探测结果, + /panel/api/model_probes 只读透传。探测键带域前缀(cn:glm-5.2),模型表 + 显示裸名,按「精确命中或 :后缀」关联。无数据时本列退回上游声称值。 */ +function fmtK(n) { n = Number(n || 0); return n >= 1000 ? Math.round(n / 1000) + 'K' : String(n); } +function probeDays(ts) { + if (!ts) return null; + const t = new Date(String(ts).replace(' ', 'T')); + const d = (Date.now() - t.getTime()) / 86400000; + return isNaN(d) ? null : Math.floor(d); +} +function outCell(m, pr) { + if (!pr) return '' + (m.max_output_tokens ? fmtK(m.max_output_tokens) : '—') + ''; + const tip = '声称 ' + (pr.claimed ? fmtK(pr.claimed) : '?') + ' · 实测 ' + (pr.measured ? fmtK(pr.measured) : '?') + + (pr.note ? ' · ' + pr.note : '') + (pr.tested_at ? ' · 探测于 ' + pr.tested_at : ''); + const days = probeDays(pr.tested_at); + const stale = days !== null && days > 30 ? ' · ' + days + ' 天前' : ''; + if (pr.verdict === 'clamped' && pr.measured) { + if (pr.claimed && pr.measured < pr.claimed) { + const x = pr.claimed / pr.measured; + const xs = (x >= 10 ? Math.round(x) : Math.round(x * 10) / 10) + '×'; + return '' + + fmtK(pr.measured) + ' ⚠
钳制 ' + xs + stale + '
'; + } + return '' + fmtK(pr.measured) + + (pr.claimed && pr.measured > pr.claimed ? ' ↑' : ' ✓') + ''; + } + if (pr.verdict === 'at_least' && pr.measured) + return '≥' + fmtK(pr.measured) + ''; + return '?
未测出' + stale + '
'; +} + +/* rateCell 倍率列:牌价 vs 生效价。上游 credits 是牌价(转正后基准倍率), + modelPromotions 给当前生效折扣(限时免费 factor=0 / 夜间五折 0.5 等)—— + WorkBuddy 客户端显示的正是生效价。有折扣:生效价大字 + 标签 + 划线牌价, + 悬停带时段说明;无 factor 只有标签(错峰类):牌价 + 标签。 + + 出图模型单独一套口径(2026-10-22 复测,见 /panel/api/models 的 credit_source): + 目录对出图模型已不报 credits(CN 混元条目只剩 id/name/tags),这一列基本只剩 + 「实测」一种来源: + - CN hunyuan-image-alpha:实扣每张固定 5.71,回执 output_image_coefficient=1, + 与 size/quality/n 全无关(1024/768/512 + n=2 恒等); + - global hy-image-3.5:实扣每张固定 0.27,回执恒 15000 output_image_tokens, + 但 low/medium/high 与 512/1024/1536 六档实测同价——token 数不代表单价, + 按 token 反推价格是错的,只能如实显示回执 credit。 */ +function rateCell(m) { + const tip = m.promo_note ? ' title="' + esc(m.promo_note) + '"' : ''; + if (m.promo_factor != null && m.promo_credits) { + const base = m.credits ? ' ' + esc(m.credits) + '' : ''; + const label = m.promo_label ? ' ' + esc(m.promo_label) + '' : ''; + return '' + esc(m.promo_credits) + '' + label + base + ''; + } + if (m.promo_label) { + return '' + (m.credits ? esc(m.credits) : '—') + + ' ' + esc(m.promo_label) + ''; + } + if (m.image_generation) return imageRateCell(m); + if (!m.credits && m.measured_credit) { + return '实测 ' + + esc(m.measured_credit) + '/张'; + } + return m.credits ? esc(m.credits) : '—'; +} + +/* imageRateCell 出图模型倍率格:牌价与实扣并列,档位取自 charge_variants。 + 数据来源:credits = 上游目录牌价;measured_credit = 账本均值(落盘); + charge_last / charge_variants = 上游回执 usage.credit(本次运行,按尺寸×画质分档)。 */ +function imageRateCell(m) { + const last = m.charge_last; + const per = last && last.credit != null ? last.credit : null; + const avg = m.measured_credit; + const tier = last ? [last.size, last.quality].filter(Boolean).join(' ') : ''; + const used = per != null ? per : (avg != null ? Number(avg) : null); + if (used == null) { + // 还没出过图:有牌价就显示牌价并说明「实扣未知」,没牌价就明说「未观测」。 + if (m.credits) { + return '' + + esc(m.credits) + ' 牌价'; + } + return '未观测'; + } + let tip; + if (m.credits) { + // 有牌价(CN 混元):说明牌价与实扣的关系,别让运维以为牌价就是账单。 + tip = '上游目录牌价 ' + m.credits + ';实扣取上游出图回执 usage.credit' + + (tier ? '(' + tier + ')' : '') + '。两者不一致时以实扣为准。'; + } else { + // 无牌价(global):按 token 计费,单张价随画质变——把 token 也报出来便于复核。 + tip = '上游目录不报倍率;此值为上游出图回执 usage.credit' + + (tier ? '(' + tier + ')' : '') + + (last && last.output_image_tokens ? ',输出图像 ' + last.output_image_tokens + ' token' : '') + + (last && last.output_image_coefficient ? ',回执倍率 ' + last.output_image_coefficient + 'x' : '') + + '。实测该模型按张固定计价,画质/尺寸不影响价格。'; + } + const shown = Number(used).toFixed(2); + const base = m.credits ? ' ' + esc(m.credits) + '' : ''; + const tierNote = tier ? '
' + esc(tier) + '
' : ''; + return '实扣 ' + + esc(shown) + '/张' + base + tierNote + ''; +} + +async function loadModels(force) { + const tb = $('mdBody'); + tb.innerHTML = '
正在向上游查询…
'; + try { + // 探测、模型锁与最近请求都是本地可选增强:任一失败不影响模型目录本身。 + // 可用性标签不额外发推理请求,只用模型锁和最近真实请求结果合成。 + // force=true(「重新获取」按钮):带 refresh=1 让后端清掉 global 目录 1h 缓存, + // 真正重新问一次上游,否则点多少次都是同一份缓存(issue #216 现象 3)。 + const [d, pr, st, rm] = await Promise.all([ + api('models' + (force ? '?refresh=1' : '')), + api('model_probes').catch(() => ({})), + api('status').catch(() => ({})), + api('request_metrics').catch(() => ({})), + ]); + mdAll = d.models || []; + mdProbes = pr.probes || {}; + mdLocks = Array.isArray(st.model_locks) ? st.model_locks : []; + mdRecent = Array.isArray(rm.recent) ? rm.recent : []; + if (!mdAll.length) { + tb.innerHTML = '
上游未返回模型
'; + $('mdCount').textContent = ''; + $('mdNote').textContent = '上游未返回模型'; + return; + } + // 探测键带域前缀(cn:glm-5.2),模型表显示裸名,按「精确命中或 :后缀」关联。 + const probeKeys = Object.keys(mdProbes); + mdProbeOf = id => mdProbes[id] || mdProbes[probeKeys.find(k => k.endsWith(':' + id))]; + const hit = mdAll.filter(m => mdProbeOf(m.id)).length; + // 目录来源:桌面端族是官方 picker 口径;union/enterprise 说明 v3 探测部分或全部失败, + // 拿到的是回落目录(数量偏少、倍率可能是旧值),必须在界面上说清楚。 + const srcNote = { 'v3-desktop': '', 'v3-union': ' · ⚠ 国际版目录来自回落(IDE+CLI 并集)', 'enterprise': ' · ⚠ 国际版目录已降级到企业端点(窄目录/旧倍率)' }[d.global_source] || ''; + // 分域取数失败告警(fetch_errors,2026-10-25):此前某域失败被后端静默吞掉—— + // global 探测失败(如 DNS 抖动 → 5min 负缓存)时页面只剩 CN 模型,无从知道原因。 + const errs = Array.isArray(d.fetch_errors) ? d.fetch_errors.filter(Boolean) : []; + const errNote = errs.length ? ' · ⚠ ' + errs.join(';') : ''; + $('mdNote').textContent = mdAll.length + ' 个模型 · 已刷新降级缓存' + (hit ? ' · ' + hit + ' 个有实测上限' : '') + srcNote + errNote; + renderModels(); + refreshEffortDowngradeNote(); // 模型目录到位后才知道哪些档位会降级 + } catch (e) { + mdAll = []; + tb.innerHTML = '
' + esc(e.message) + '
'; + $('mdCount').textContent = ''; + } +} + +/* ── 模型筛选(按条件查询)─────────────────────────────────────────── + 模型目录一次拉全(几十条),筛选与排序全部在前端完成:改条件零延迟,且不会 + 因为调一次筛选就打一次上游——/panel/api/models 是直连上游的实时查询,很贵。 + 条件之间是 AND;每个条件为空即不参与判定。 */ +// mdRateValue 当前生效的积分倍率数值:优先促销价(限时免费 = 0),无倍率记为 +// Infinity 排到最后(排序时"没有价格"不该冒充最便宜)。 +function mdRateValue(m) { + const raw = (m.promo_credits != null && m.promo_credits !== '') ? m.promo_credits : m.credits; + const n = parseFloat(String(raw == null ? '' : raw).replace(/[^\d.]/g, '')); + return Number.isFinite(n) ? n : Infinity; +} + +// mdSearchText 参与关键字搜索的字段(ID / 展示名 / 厂商 / 描述 / 标签)。 +function mdSearchText(m) { + return [m.id, m.name, m.vendor, m.description, (m.tags || []).join(' ')] + .filter(Boolean).join(' ').toLowerCase(); +} + +// mdMatch 单个模型是否满足全部筛选条件。 +function mdMatch(m, f) { + f = f || mdFilter; + if (f.q) { + const text = mdSearchText(m); + // 空格分词后逐个匹配:多关键词是 AND,便于"cn 视觉"这类组合查询。 + for (const kw of f.q.toLowerCase().split(/\s+/).filter(Boolean)) { + if (!text.includes(kw)) return false; + } + } + if (f.realm) { + const id = String(m.id || ''); + const realm = m.realm || (id.startsWith('cn:') ? 'cn' : id.startsWith('global:') ? 'global' : id.startsWith('free:') ? 'free' : m.channel === 'custom' ? 'custom' : ''); + if (realm !== f.realm) return false; + } + if (f.cap === 'tool' && !m.supports_tool_call) return false; + if (f.cap === 'vision' && !m.supports_images) return false; + if (f.cap === 'reasoning' && !m.supports_reasoning) return false; + if (f.cap === 'default' && !m.is_default) return false; + if (f.effort === 'off') { + if (!m.can_disable_thinking) return false; + } else if (f.effort && !(m.supported_efforts || []).includes(f.effort)) { + return false; + } + const factor = m.promo_factor == null ? null : Number(m.promo_factor); + if (f.promo === 'promo' && factor == null && !m.promo_label) return false; + if (f.promo === 'free' && !(factor === 0)) return false; + if (f.promo === 'discount' && !(factor != null && factor > 0)) return false; + return true; +} + +// mdSortList 按当前排序条件返回新数组(不改动入参,保持上游原始顺序可回溯)。 +function mdSortList(list, f) { + f = f || mdFilter; + const out = list.slice(); + const num = v => { const n = Number(v || 0); return Number.isFinite(n) ? n : 0; }; + if (f.sort === 'rate') out.sort((a, b) => mdRateValue(a) - mdRateValue(b)); + else if (f.sort === 'context') out.sort((a, b) => num(b.context_length) - num(a.context_length)); + else if (f.sort === 'output') out.sort((a, b) => num(b.max_output_tokens) - num(a.max_output_tokens)); + else if (f.sort === 'name') out.sort((a, b) => String(a.id || '').localeCompare(String(b.id || ''))); + return out; +} + +// mdAvailabilityOf 合成 Global 模型当前可用性:模型锁优先于最近请求结果。 +// 只返回有真实本地证据的状态;目录中存在但从未请求过的模型标为“待验证”, +// 避免把“上游列出了模型”误当成“当前账号有权限”。 +function mdAvailabilityOf(m, locks, recent) { + const id = String((m && m.id) || ''); + if (!id.startsWith('global:')) return null; + locks = Array.isArray(locks) ? locks : mdLocks; + recent = Array.isArray(recent) ? recent : mdRecent; + const bare = id.slice('global:'.length); + const lock = locks.find(r => r && r.realm === 'global' && r.model === bare); + if (lock) { + const reason = String(lock.reason || '').trim(); + const lower = reason.toLowerCase(); + if (lock.state === 'partial') { + return { key: 'partial', label: '部分可用', cls: 'warn', + tip: '仍有 ' + Number(lock.servable || 0) + ' 个 global 账号可服务;已锁 ' + Number(lock.locked || 0) + ' 个' + (reason ? ';' + reason : '') }; + } + if (lock.state === 'starved') { + return { key: 'starved', label: '账号暂不可用', cls: 'mute', + tip: '没有账号能服务该模型,但并非该模型自身被锁;请检查账号冷却/在途占用' }; + } + if (lower.startsWith('11158') || lower.includes('not allowed for user type')) { + return { key: 'denied', label: '无权限', cls: 'bad', + tip: '当前 global 账号类型不支持该模型' + (reason ? ';' + reason : '') }; + } + if (lower.startsWith('11102') || lower.includes('service info not found')) { + return { key: 'missing', label: '上游无此模型', cls: 'bad', + tip: '上游目录残留,实际请求返回模型不存在' + (reason ? ';' + reason : '') }; + } + return { key: 'limited', label: '限流/不可用', cls: 'warn', + tip: '模型级冷却中' + (reason ? ';' + reason : '') }; + } + // 同时匹配请求模型与降级后实际模型(model_eff):请求 A 实际用 B 成功时, + // B 的「可用」标注也要由这条真实流量合成(2026-10-25 链路补齐)。 + // model_eff 记的是出站线协议原值(通常是裸名),而这里的 id 带域前缀, + // 两种形态都要认——只比 id 会让 global 域的降级流量完全命中不了。 + const ev = recent.find(e => e && (e.model === id || e.model === bare || + e.model_eff === id || e.model_eff === bare)); + if (ev) { + const status = Number(ev.status || 0); + const when = ev.time ? new Date(ev.time).toLocaleString('zh-CN', { hour12: false }) : ''; + if (ev.outcome === 'success' || (status >= 200 && status < 300)) { + return { key: 'ok', label: '可用', cls: 'ok', + tip: '最近一次真实请求成功' + (when ? ' · ' + when : '') }; + } + if (status === 429) { + return { key: 'rate', label: '限流', cls: 'warn', + tip: '最近一次请求被限流' + (when ? ' · ' + when : '') }; + } + if (status >= 500) { + return { key: 'upstream', label: '上游错误', cls: 'bad', + tip: '最近一次请求上游错误 HTTP ' + status + (when ? ' · ' + when : '') }; + } + return { key: 'failed', label: '最近失败', cls: 'bad', + tip: '最近一次请求失败 HTTP ' + (status || '—') + (when ? ' · ' + when : '') }; + } + return { key: 'unknown', label: '待验证', cls: 'mute', + tip: '尚无模型锁或近期真实请求记录;目录存在不代表当前账号有权限' }; +} + +function mdAvailabilityTag(m) { + const av = mdAvailabilityOf(m); + if (!av) return ''; + return ' ' + esc(av.label) + ''; +} + +// mdRowHtml 单个模型行(纯渲染,便于独立测试)。 +// 上游模型繁忙度(/v2/chat/busy)文案:只标需要避让的三档,idle/normal 不打扰。 +const BUSY_WORDS = { busy: '繁忙', congested: '拥堵', unavailable: '不可用' }; + +function mdRowHtml(m, pr) { + const eff = (m.supported_efforts || []).slice(); + if (m.can_disable_thinking && eff.length && !eff.includes('off')) eff.push('off(可关)'); + // 出图模型没有思考档位(上游目录里它本就不带 reasoning 字段):显示 —,不写"不支持思考"。 + const effs = m.image_generation ? '—' + : eff.length ? eff.map(e => '' + esc(e) + '').join(' ') + : '' + (m.supports_reasoning ? (m.default_effort ? '固定档 · 默认 ' + esc(m.default_effort) : '固定档 · 默认档上游未报') : '不支持思考') + ''; + // 能力徽标:默认模型 / 工具调用 / 视觉 / 纯推理(上游目录全字段透出,缺失不显示) + const caps = []; + if (m.tier) caps.push('' + esc(m.tier) + ''); + if (m.image_generation) caps.push('出图'); + if (m.is_default) caps.push('默认'); + if (m.supports_tool_call) caps.push('工具'); + if (m.supports_images) caps.push('视觉'); + if (m.supports_reasoning && !m.can_disable_thinking) caps.push('思考常开'); + if (BUSY_WORDS[m.busy]) { + const bad = m.busy === 'congested' || m.busy === 'unavailable'; + caps.push('' + BUSY_WORDS[m.busy] + ''); + } + const capHtml = caps.length ? '
' + caps.join(' ') + '
' : ''; + const tip = m.description ? ' title="' + esc(m.description) + '"' : ''; + // 网关档位:选项原样取该模型「支持的思考档位」(可关思考的模型再补 off), + // 不合成"最高档(x)"之类的文案;默认选中支持的最高档(缺省 default_effort=max + // 的语义)。上游固定档的模型(没有 supported_efforts)也给一个单选项,表示网关 + // 只会跟随该档;出图模型与完全没有档位声明的模型仍渲染 —。 + const EFFORT_RANK = { off: 0, minimal: 1, low: 2, medium: 3, high: 4, xhigh: 5, max: 6 }; + const gwOpts = []; + for (const e of (m.supported_efforts || [])) { + const v = String(e).trim().toLowerCase(); + if (v && !gwOpts.includes(v)) gwOpts.push(v); + } + const fixedTier = !gwOpts.length && m.supports_reasoning && m.default_effort + ? String(m.default_effort).trim().toLowerCase() : ''; + if (fixedTier) gwOpts.push(fixedTier); + if (m.can_disable_thinking && gwOpts.length && !gwOpts.includes('off')) gwOpts.push('off'); + const gwTop = gwOpts.filter(t => t !== 'off') + .sort((a, b) => (EFFORT_RANK[b] || 0) - (EFFORT_RANK[a] || 0))[0] || ''; + const gwPicked = gwOpts.includes(m.gateway_effort) ? m.gateway_effort : gwTop; + let gw; + if (m.image_generation || !gwOpts.length) { + gw = '—'; + } else { + const gwFixed = !!fixedTier && !m.can_disable_thinking; + const gwDisabled = m.gateway_policy_enabled === false || gwFixed; + const gwTitle = m.gateway_policy_enabled === false + ? ' title="思考档位策略已关闭,网关不会注入档位;到「配置 → 思考档位」打开"' + : (gwFixed ? ' title="上游固定档,网关只需跟随,不可调"' : ''); + gw = ''; + } + // 下游可见:关掉 = 进 models.hidden(/v1/models 不列、点名调用直接拒绝), + // 保存即热生效;行整体降透明并把开关留在原列,方便再打开。 + const vis = ''; + const ch = m.channel || (String(m.id || '').startsWith('free:') ? 'free' : m.realm === 'custom' ? 'custom' : 'workbuddy'); + const chLabel = m.channel_label || (ch === 'free' ? '免费通道' : ch === 'custom' ? '自定义映射' : 'WorkBuddy'); + const chTag = '' + esc(chLabel) + ''; + return '
' + chTag + '' + esc(m.id) + '' + mdAvailabilityTag(m) + '
' + esc(m.name || '') + '
' + capHtml + '' + + '' + rateCell(m) + '' + gw + + '' + (m.default_effort && !m.image_generation ? '' + esc(m.default_effort) + '' : '—') + '' + + '' + effs + '' + + '' + (m.context_length ? Math.round(m.context_length / 1000) + 'K' : '—') + '' + + outCell(m, pr) + vis + ''; +} + +function renderModels() { + const tb = $('mdBody'); + const sorted = mdSortList(mdAll.filter(m => mdMatch(m))); + // 下游已隐藏的模型统一排到末尾(各自保持当前排序规则内的相对顺序);重新打开 + // 即回到排序规则给出的原位置——不额外记忆旧下标,避免两套顺序互相漂移。 + const list = sorted.filter(m => !m.hidden).concat(sorted.filter(m => m.hidden)); + if (!list.length) { + tb.innerHTML = '
没有符合当前筛选条件的模型
'; + } else { + tb.innerHTML = list.map(m => mdRowHtml(m, mdProbeOf(m.id))).join(''); + } + const filtered = list.length !== mdAll.length; + $('mdCount').textContent = !mdAll.length ? '' + : filtered ? '命中 ' + list.length + ' / ' + mdAll.length + ' 个模型' + : mdAll.length + ' 个模型'; + $('mdCount').className = filtered ? 'note src-off' : 'note'; +} + +// 行内「下游可见」开关:POST 写 models.hidden(保存即热生效),成功后本地更新 +// 并重排——隐藏行落到末尾,重新打开回到排序规则给出的原位置。失败回滚勾选态。 +// 行内「网关档位」下拉同表:POST 写 thinking.model_defaults 的精确键。 +$('mdBody').addEventListener('change', async ev => { + const sel = ev.target.closest('select[data-effort-id]'); + if (sel) return saveGatewayEffort(sel); + const cb = ev.target.closest('input[data-model-id]'); + if (!cb) return; + const id = cb.dataset.modelId, hidden = !cb.checked; + cb.disabled = true; + try { + await api('model_hidden', { method: 'POST', body: JSON.stringify({ id, hidden }) }); + const m = mdAll.find(x => x.id === id); + if (m) m.hidden = hidden; + renderModels(); + toast((hidden ? '已隐藏 ' : '已恢复 ') + id + (hidden ? '(下游不可见)' : '(下游可见)'), 'ok'); + } catch (e) { + cb.checked = !cb.checked; + toast('切换失败:' + e.message, 'err'); + } finally { cb.disabled = false; } +}); + +// saveGatewayEffort 行内「网关档位」:选项即模型支持的档位(含 off),选中即写 +// thinking.model_defaults 的「域:模型」精确键并热生效;失败直接重渲染回滚到 +// 服务端实际值(比手工还原选中的 option 可靠)。 +async function saveGatewayEffort(sel) { + const id = sel.dataset.effortId, effort = sel.value; + sel.disabled = true; + try { + await api('model_effort', { method: 'POST', body: JSON.stringify({ id, effort }) }); + const m = mdAll.find(x => x.id === id); + if (m) m.gateway_effort = effort; + toast('已设置 ' + id + ' 的网关档位 = ' + effort, 'ok'); + } catch (e) { + toast('设置失败:' + e.message, 'err'); + renderModels(); + } finally { sel.disabled = false; } +} + +function resetModelFilter() { + mdFilter = { q: '', realm: '', cap: '', effort: '', promo: '', sort: 'default' }; + $('mdQ').value = ''; $('mdRealm').value = ''; $('mdCap').value = ''; + $('mdEffort').value = ''; $('mdPromo').value = ''; $('mdSort').value = 'default'; + prefSet('mdSort', ''); + renderModels(); +} + +// 筛选控件:输入框防抖 120ms(长列表逐字符重排不必每键一次),下拉即时。 +let mdQTimer = null; +$('mdQ').oninput = () => { + clearTimeout(mdQTimer); + mdQTimer = setTimeout(() => { mdFilter.q = $('mdQ').value.trim(); renderModels(); }, 120); +}; +for (const [id, key] of [['mdRealm', 'realm'], ['mdCap', 'cap'], ['mdEffort', 'effort'], ['mdPromo', 'promo'], ['mdSort', 'sort']]) { + const el = $(id); + if (!el) continue; + // 排序方式记住上次选择(issue #160):其余筛选项是一次性查询,排序是长期偏好。 + if (key === 'sort' && mdFilter.sort) el.value = mdFilter.sort; + el.onchange = () => { + mdFilter[key] = el.value; + if (key === 'sort') prefSet('mdSort', el.value === 'default' ? '' : el.value); + renderModels(); + }; +} +$('mdReset').onclick = resetModelFilter; +$('btnModels').onclick = () => loadModels(true); + +/* ── 日志(频道:全部/任务/对话/系统) ─────────────────────────────── */ +let logCh = 'all'; +// 运行日志的增量拉取状态(perf):logRows 是本地窗口,logSeq 是下次增量的起点。 +// 常态每 5 秒只传新增行,不再每轮重拉 500 行(~90KB)并重建整块 DOM。 +// LOG_ROWS_MAX 与服务端环形缓冲同量级(500)——本地窗口不必更大。 +let logRows = []; +let logSeq = 0; +let logCursorAt = null; +const LOG_ROWS_MAX = 500; +// 增量游标最长有效期:超过则改全量拉(服务端环形缓冲只有 500 行,久了会淘汰 +// 中间旧行,增量就拿不到「完整的一段」)。 +const LOG_CURSOR_MAX_AGE_MS = 5 * 60 * 1000; +// resetLogWindow 丢弃本地窗口,下次改为全量拉(切视图/手动重载时用)。 +function resetLogWindow() { logRows = []; logSeq = 0; logCursorAt = null; } +$('logChips').addEventListener('click', ev => { + const b = ev.target.closest('button[data-ch]'); + if (!b) return; + logCh = b.dataset.ch; + document.querySelectorAll('#logChips .chip').forEach(c => c.classList.toggle('on', c === b)); + loadLogs(); +}); +// logLevel 日志行的颜色级别。先抹掉「空赋值」字段再判: +// `claim_error=""`(值为空 = 这一项没有错误)里带 error 字样,裸匹配会把成功的任务行 +// 整行标红;非空赋值(`claim_error="task not completed"`)仍然照常标红。 +function logLevel(text) { + const t = String(text == null ? '' : text).replace(/\b[a-z_]+=(?:""|'')/g, ''); + if (/error|失败|错误/.test(t)) return ' e'; + if (/warn|冷却|熔断/.test(t)) return ' w'; + return ''; +} + +async function loadLogs() { + const box = $('logBox'); + const atEnd = box.scrollTop + box.clientHeight >= box.scrollHeight - 24; + const limit = ($('reqLimit') && $('reqLimit').value) || 100; + // 时间范围由归档侧过滤(不是前端筛已拉取的条目):区间落在更早的时间段时, + // 「最近 N 条」里根本不会有那些记录,必须让服务端按时间取。 + const rq = trangeQuery('reqRange', false); + rq.set('limit', limit); + try { + // 归档是否开启要先知道,否则无法决定 request_metrics 要不要带 recent。 + // 先拉指标(recent=0,不带那 100 条事件),再用它决定请求记录表的数据源。 + const metrics = await api('request_metrics?recent=0').catch(() => ({})); + const archiveOn = !!(metrics && metrics.archive && metrics.archive.enabled); + // 运行日志:常态只传**新增行**(?since=),不再每 5 秒重拉 500 行。 + // logRows 是本地累积的窗口(上限 LOG_ROWS_MAX);首次加载/手动重载时全量拉 + // (since 置空),之后走增量。 + // + // 例外:切走很久再回来时,服务端环形缓冲(500 行)可能已经把中间的旧行 + // 淘汰掉了——增量只会拿到「还在环里」的那部分,中间缺一段。因此游标超过 + // LOG_CURSOR_MAX_AGE_MS 就退回全量拉(一次 90KB,换来不缺行)。 + if (logCursorAt && (Date.now() - logCursorAt.getTime()) > LOG_CURSOR_MAX_AGE_MS) { + resetLogWindow(); + } + const lq = logSeq ? '?since_seq=' + logSeq : ''; + const [d, requestRows, credit, errSum] = await Promise.all([ + api('logs' + lq), + api('request_logs?' + rq.toString()).catch(() => ({ entries: [] })), + api('credit_history?limit=' + creditLimitValue()).catch(() => null), + api('error_summary').catch(() => null), + ]); + // 归档开启时以归档为准——「区间内没有记录」是一个真实结果,不能回落成内存里 + // 的最近 100 条(那会把筛选条件之外、时间范围之外的请求显示出来)。 + // 只有归档关闭时才回落到内存指标,保证没有归档的部署仍能看到最近请求; + // 此时才需要 recent(第一次拉指标时已经知道归档关了,重新取一次带 recent 的)。 + // shortcut: 归档关闭时这是两次串行请求(默认 archive 开启,只有关掉才多一个 RTT), + // 要省就先让 overview 透出 archive.enabled、别为此单独打一次 request_metrics。 + const recent = archiveOn + ? (requestRows.entries || []) + : ((await api('request_metrics').catch(() => ({}))).recent || []); + renderRequestMetrics(metrics, recent); + // 增量合并到本地窗口(增量拉到的行 append;全量拉到的行 replace)。 + const incoming = d.entries || []; + if (logSeq) { + logRows = logRows.concat(incoming); + if (logRows.length > LOG_ROWS_MAX) logRows = logRows.slice(-LOG_ROWS_MAX); + } else { + logRows = incoming.slice(-LOG_ROWS_MAX); + } + // 下次增量的起点:**服务端给的单调节号 seq**,不是时间戳。 + // + // 时间戳在这里靠不住:入环 TS 是 time.Now(),同一时钟刻度内的多次写入完全相同 + // (Windows 实测 ~15.6ms 粒度,一次 Write 的多行、背靠背的 Write 都会撞)。 + // 按「最后一条的 ts」推进游标时,同一刻度里排在它后面(或就是它自己)的行 + // 永远满足「晚于 since」,于是每轮轮询都重复返回一次、游标再也不前进—— + // 面板「运行日志」底部那行反复刷出来。JS 的 Date 还只有毫秒,把原始串换成 + // Date 往返只会让重复更严重。 + // seq 是环内单调递增的(淘汰不回退),`seq > logSeq` 精确表达「还有哪些没给过」。 + for (const e of incoming) { + if (e && typeof e.seq === 'number' && e.seq > logSeq) logSeq = e.seq; + } + // logCursorAt 记的是「上次成功同步的时刻」,不是「上次出现新行的时刻」: + // 老化判断要回答的是「我离开多久没跟了」,与有没有新日志无关。空闲时也刷新, + // 否则静默期每 5 分钟就会误触发一次全量拉(90KB 白拉)。真正切走很久再回来时 + // 轮询本来就停了,这里的值会自然变旧,届时照旧回落全量。 + logCursorAt = new Date(); + const entries = logRows.filter(e => logCh === 'all' || e.ch === logCh); + setHTML(box, entries.length + ? entries.map(e => { + const lvl = logLevel(e.text); + const t = e.ts ? new Date(e.ts).toLocaleTimeString('zh-CN', { hour12: false }) : ''; + const ch = logCh === 'all' ? '' + ({ task: '任务', chat: '对话', sys: '系统' }[e.ch] || e.ch) + '' : ''; + return '' + ch + esc(t + ' ' + e.text) + ''; + }).join('') + : '暂无日志'); + if (logPin && atEnd) box.scrollTop = box.scrollHeight; + const counts = {}; + for (const e of logRows) counts[e.ch] = (counts[e.ch] || 0) + 1; + $('logNote').textContent = logCh === 'all' + ? '任务 ' + (counts.task || 0) + ' · 对话 ' + (counts.chat || 0) + ' · 系统 ' + (counts.sys || 0) + : (logCh === 'task' ? '任务' : logCh === 'chat' ? '对话' : '系统') + ' ' + entries.length + ' 行'; + renderCreditHistory(credit); + renderErrorSummary(errSum); + } catch (e) { /* 概览已提示 */ } +} + +/* 错误汇总(后端 /panel/api/error_summary 已聚合+排序):只渲染,不在这里再算。 */ +function renderErrorSummary(d) { + const rows = (d && d.rows) || []; + $('errBody').innerHTML = rows.length ? rows.map(r => + '' + + '' + esc(r.account || '—') + '' + + '' + esc(r.kind) + '' + + '' + esc(r.code || '—') + '' + + '' + esc(r.model || '—') + '' + + '' + r.count + '' + + '' + esc(r.last || '—') + '' + + '' + esc(r.until || '—') + '' + + '' + esc(r.sample || '') + '' + ).join('') : '窗口内没有 WARN/ERR'; + $('errNote').textContent = d + ? '扫描 ' + (d.scanned || 0) + ' 行 · ' + rows.length + ' 类 · 截至 ' + (d.updated_at || '—') + : '—'; +} + +function renderRequestMetrics(m, entries) { + m = m || {}; + const a = m.archive || {}; + $('reqStats').innerHTML = + usStat(fmtTok(m.completed), '已完成') + + usStat(m.success_rate == null ? '—' : Number(m.success_rate).toFixed(1) + '%', '完成成功率') + + usStat(m.http_success_rate == null ? '—' : Number(m.http_success_rate).toFixed(1) + '%', 'HTTP 成功率') + + usStat(fmtMs(m.avg_duration_ms), '平均耗时') + + usStat(String(m.in_flight || 0), '进行中') + + usStat(fmtTok(a.files), '归档文件'); + $('reqNote').textContent = a.enabled + ? 'JSONL 归档 ' + fmtBytes(a.bytes) + (a.dropped_writes ? ' · 丢弃 ' + a.dropped_writes + ' 条' : '') + + (a.last_error ? ' · 错误:' + a.last_error : '') + : '仅内存指标,JSONL 归档已关闭'; + + reqEntries = entries || []; + renderRequestTable(); +} + +/* ── 积分历史(每次真实查到余额与上次比对,变动即留痕)───────────────── + 纯格式化函数集中在此,便于前端测试按切片断言;变动列 +N / −N(U+2212, + 与请求记录一致),余额用千分位。 */ +function creditNum(n) { + return Number(n || 0).toLocaleString('zh-CN'); +} +function creditDeltaText(delta) { + const d = Number(delta || 0); + if (d > 0) return '+' + creditNum(d); + if (d < 0) return '−' + creditNum(-d); + return '0'; +} +function creditTimeText(e) { + if (!e || !e.time) return '—'; + const d = new Date(e.time); + // 正常链路 time 由 Go 的 time.Time 序列化,恒为 RFC3339;这里挡的是手工改文件/ + // 将来换格式等脏数据——toLocaleTimeString 遇到非法日期不抛异常,只会渲染出 + // "Invalid Date" 这种没意义的字样。 + return isNaN(d.getTime()) ? '—' : d.toLocaleTimeString('zh-CN', { hour12: false }); +} +function creditAccountText(e) { + e = e || {}; + return e.account ? String(e.account) : (e.uid || '—'); +} +function creditBalanceText(e) { + return creditNum(e && e.after); +} +function creditDescText(e) { + return '余额 ' + creditNum(e && e.before) + ' → ' + creditNum(e && e.after); +} +function creditEntryText(e) { + return creditTimeText(e) + ' | ' + creditAccountText(e) + ' | ' + creditDeltaText(e && e.delta) + + ' | ' + creditBalanceText(e) + ' | ' + creditDescText(e); +} +function creditHistoryNote(entries) { + entries = entries || []; + if (!entries.length) return '暂无积分变动记录'; + let net = 0; + for (const e of entries) net += Number(e && e.delta || 0); + return entries.length + ' 条 · 净 ' + (net > 0 ? '+' : net < 0 ? '−' : '') + creditNum(Math.abs(net)); +} +function renderCreditHistory(d) { + const body = $('creditBody'), note = $('creditNote'); + if (!body) return; + if (!d) { + if (note) note.textContent = '积分历史不可用'; + body.innerHTML = '积分历史不可用'; + return; + } + const entries = d.entries || []; + if (note) note.textContent = creditHistoryNote(entries); + setHTML(body, entries.length + ? entries.map(e => '' + + '' + esc(creditTimeText(e)) + '' + + '' + esc(creditAccountText(e)) + '' + + '' + esc(creditDeltaText(e && e.delta)) + '' + + '' + esc(creditBalanceText(e)) + '' + + '' + esc(creditDescText(e)) + '' + + '').join('') + : '暂无积分变动记录'); +} +function creditLimitValue() { + const el = $('creditLimit'); + const n = el ? Number(el.value) : 100; + return n === 300 || n === 1000 ? n : 100; +} +async function loadCreditHistory() { + let d = null; + try { d = await api('credit_history?limit=' + creditLimitValue()); } catch (e) { d = null; } + renderCreditHistory(d); +} + +/* reqMatch 请求记录筛选:q 对 IP/UA/模型/账号/请求 ID 做空格分词的 AND 包含匹配, + outcome 精确匹配。两者都在已拉取的条目上做(最多 1000 条),不发新请求。 */ +function reqMatch(e, f) { + f = f || reqFilter; + if (f.outcome && String(e && e.outcome || '') !== f.outcome) return false; + if (f.q) { + const text = [e && e.client_ip, e && e.user_agent, e && e.model, e && e.model_eff, e && e.account, e && e.request_id] + .filter(Boolean).join(' ').toLowerCase(); + for (const kw of f.q.toLowerCase().split(/\s+/).filter(Boolean)) { + if (!text.includes(kw)) return false; + } + } + return true; +} + +function reqOutcomeTag(e) { + const outcome = String(e && e.outcome || ''); + const label = { success: '成功', http_error: 'HTTP 错误', stream_error: '流错误', interrupted: '中断' }[outcome] || outcome || '—'; + const cls = outcome === 'success' ? 'ok' + : outcome === 'interrupted' ? 'warn' + : outcome ? 'bad' : 'mute'; + return '' + esc(String(e && e.status || '—') + ' ' + label) + ''; +} + +function reqTokenCell(e) { + const total = Number(e && e.total_tokens || 0) || + (Number(e && e.prompt_tokens || 0) + Number(e && e.completion_tokens || 0)); + return total ? fmtTok(total) : '—'; +} + +function reqCreditCell(e) { + if (!e || !e.credit_known) return '—'; + const v = Number(e.credit); + return Number.isFinite(v) ? trimFixed(v.toFixed(2)) : '—'; +} + +/* reqModelText 请求记录模型列:请求模型与降级后实际模型是两个不同模型(计价/能力 + 都不同,2026-10-25 实案),显示成 requested->effective;未降级保持单值旧格式。 */ +function reqModelText(e) { + const m = e && e.model; + const eff = e && e.model_eff; + if (!m) return '—'; + return eff && eff !== m ? m + '->' + eff : m; +} + +/* renderRequestTable 渲染请求记录表。来源列是这一版的重点:IP 用等宽字体方便扫, + UA 单行截断(完整值在 title 里,行本身用 requestLogText 作 tooltip)。 */ +function renderRequestTable() { + const list = reqEntries.filter(e => reqMatch(e)); + const tb = $('reqBody'); + if (!tb) return; + setHTML(tb, list.map(e => { + const when = e && e.time ? new Date(e.time).toLocaleTimeString('zh-CN', { hour12: false }) : '—'; + const ip = e && e.client_ip ? e.client_ip : ''; + const ua = e && e.user_agent ? e.user_agent : ''; + const rid = e && e.request_id ? e.request_id : ''; + return '' + + '' + esc(when) + '' + + '' + reqOutcomeTag(e) + '' + + '' + esc(reqModelText(e)) + '' + + '' + esc(e && e.account || '—') + '' + + '' + (ip ? '' + esc(ip) + '' : '—') + '' + + '' + (ua ? '' + esc(ua) + '' : '—') + '' + + '' + fmtMs(e && e.duration_ms) + '' + + '' + reqTokenCell(e) + '' + + '' + reqCreditCell(e) + '' + + '' + (rid ? '' + esc(rid) + '' : '—') + '' + + ''; + }).join('') || '' + + (reqEntries.length ? '没有符合当前筛选条件的请求记录' : '暂无请求记录') + ''); + + const filtered = list.length !== reqEntries.length; + // 归档里的旧条目没有来源字段(该功能上线前写入):这时提示开关/历史原因, + // 而不是让人以为筛选坏了。 + const hasSource = reqEntries.some(e => e && (e.client_ip || e.user_agent)); + $('reqCount').textContent = !reqEntries.length ? '' + : (filtered ? '命中 ' + list.length + ' / ' + reqEntries.length + ' 条' : reqEntries.length + ' 条') + + (hasSource ? '' : ' · 来源未记录'); + $('reqCount').className = (filtered || !hasSource) ? 'note src-off' : 'note'; +} + +/* 请求记录筛选控件。搜索框防抖 150ms:最多 1000 行重渲染,不必每键一次。 + 这段顶层绑定放在 requestLogText 之前,是为了让"纯函数切片"式前端测试 + (slice requestLogText → fmtBytes)只拿到无副作用的格式化函数。 */ +let reqQTimer = null; +if ($('reqQ')) $('reqQ').oninput = () => { + clearTimeout(reqQTimer); + reqQTimer = setTimeout(() => { reqFilter.q = $('reqQ').value.trim(); renderRequestTable(); }, 150); +}; +if ($('reqOutcome')) $('reqOutcome').onchange = () => { + reqFilter.outcome = $('reqOutcome').value; + renderRequestTable(); +}; +if ($('reqLimit')) $('reqLimit').onchange = loadLogs; +if ($('btnReqReload')) $('btnReqReload').onclick = () => { resetLogWindow(); loadLogs(); }; +// 时间范围:默认「全部历史」——请求记录页的历史行为就是"取最近 N 条", +// 加一个默认收窄的区间会让打开页面时看到的条数凭空变少。 +if ($('reqRange')) trangeBind('reqRange', loadLogs, '0'); +if ($('creditLimit')) $('creditLimit').onchange = loadCreditHistory; +if ($('btnCreditReload')) $('btnCreditReload').onclick = loadCreditHistory; + +function requestLogText(e) { + const when = e && e.time ? new Date(e.time).toLocaleTimeString('zh-CN', { hour12: false }) : '—'; + const outcomeLabel = { success: '成功', http_error: 'HTTP 错误', stream_error: '流错误', interrupted: '中断' }; + const token = Number(e && e.total_tokens || 0) || + (Number(e && e.prompt_tokens || 0) + Number(e && e.completion_tokens || 0)); + let credit = 'credit —'; + if (e && e.credit_known) { + const value = Number(e.credit); + if (Number.isFinite(value)) credit = String(Number(value.toFixed(2))) + ' credit'; + } + return [ + when, + String(e && e.status || '—') + ' ' + (outcomeLabel[e && e.outcome] || (e && e.outcome) || '—'), + e && e.model || '—', + (e && e.model_eff && e.model_eff !== e.model) ? '⤳ ' + e.model_eff : '', + e && e.account || '—', + e && e.client_ip || '—', + e && e.user_agent || '—', + fmtMs(e && e.duration_ms), + fmtTok(token) + ' tok', + credit, + cacheRateText(e && e.cache_hit_tokens, e && e.cache_miss_tokens) === '—' ? '' : '命中 ' + cacheRateText(e && e.cache_hit_tokens, e && e.cache_miss_tokens), + e && e.request_id || '—', + ].filter(Boolean).join(' | '); +} + +/* 缓存命中率纯文本(issue #92 同步):requestLogText 与积分表/kpi 卡共用。 + 自包含(不依赖 trimFixed):前端纯函数切片测试只截取本段。 */ +function cacheRateText(hit, miss) { + const h = Number(hit || 0), m = Number(miss || 0), total = h + m; + if (!total) return '—'; + return String(Math.round(h / total * 1000) / 10) + '%'; +} + +function fmtBytes(bytes) { + const n = Number(bytes || 0); + if (n < 1024) return n + ' B'; + if (n < 1024 * 1024) return (n / 1024).toFixed(1) + ' KB'; + return (n / 1024 / 1024).toFixed(1) + ' MB'; +} +/* 运行日志导出:落盘文件按区间打包成 ZIP。 + * 用 location.href 直接触发下载而不是 fetch+blob——落盘包可能几十 MB, + * blob 会把整包读进内存再复制一份;href 让浏览器原生流式落盘。 + * 失败(落盘未启用 / 区间无数据)时后端回 JSON 错误,浏览器会把它当文件下载, + * 所以先 HEAD 一次拿状态码,非 2xx 就读回错误文案弹出来。 */ +$('btnLogExport').onclick = async () => { + const days = $('logExportDays').value || '3'; + const url = '/panel/api/logs/export?days=' + encodeURIComponent(days); + try { + const resp = await fetch(url, {method: 'HEAD'}); + if (!resp.ok) { + // HEAD 不带 body,再 GET 一次拿文案(数据量很小:只有一个错误 JSON)。 + const detail = await fetch(url).then(r => r.text()).catch(() => ''); + let msg = 'HTTP ' + resp.status; + try { msg = JSON.parse(detail).error || msg; } catch (e) { } + alert('导出失败:' + msg); + return; + } + location.href = url; + } catch (e) { + alert('导出失败:' + e); + } +}; + +$('btnLogPin').onclick = () => { + logPin = !logPin; + $('btnLogPin').textContent = '自动滚动:' + (logPin ? '开' : '关'); +}; + +/* ── 配置 ─────────────────────────────────────────────────────────── */ +const CFG_MAP = { + listen: ['listen'], api_key: ['api_key'], + package_detail_limit: ['panel', 'package_detail_limit'], + update_auto_enabled: ['update', 'auto_enabled'], update_auto_time: ['update', 'auto_time'], + update_proxy: ['update', 'proxy'], update_mirror: ['update', 'mirror'], + update_proxy_from_env: ['update', 'proxy_from_env'], + poll_interval_sec: ['panel', 'poll_interval_sec'], + checkin_hours: ['schedule', 'checkin_hours'], checkin_enabled: ['schedule', 'checkin_enabled'], growth_hours: ['schedule', 'growth_hours'], growth_enabled: ['schedule', 'growth_enabled'], + travel_hours: ['schedule', 'travel_hours'], travel_enabled: ['schedule', 'travel_enabled'], + activity_hours: ['schedule', 'activity_hours'], activity_enabled: ['schedule', 'activity_enabled'], + web_activity_enabled: ['schedule', 'web_activity_enabled'], + growth_hours: ['schedule', 'growth_hours'], growth_enabled: ['schedule', 'growth_enabled'], + growth_concurrency: ['schedule', 'growth_concurrency'], + include_disabled_in_tasks: ['schedule', 'include_disabled_in_tasks'], + keepalive_hours: ['schedule', 'keepalive_hours'], keepalive_enabled: ['schedule', 'keepalive_enabled'], + keepalive_refresh_window: ['schedule', 'keepalive_refresh_window'], + balance_refresh_enabled: ['schedule', 'balance_refresh_enabled'], balance_refresh_minutes: ['schedule', 'balance_refresh_minutes'], + task_sweep_enabled: ['schedule', 'task_sweep_enabled'], task_sweep_minutes: ['schedule', 'task_sweep_minutes'], + account_spread_minutes: ['schedule', 'account_spread_minutes'], account_spread_min_gap_seconds: ['schedule', 'account_spread_min_gap_seconds'], + balance_refresh_jitter_permill: ['schedule', 'balance_refresh_jitter_permill'], task_sweep_jitter_permill: ['schedule', 'task_sweep_jitter_permill'], + makeup_cards_per_round: ['schedule', 'makeup_cards_per_round'], + max_in_flight: ['pool', 'max_in_flight'], max_in_flight_global: ['pool', 'max_in_flight_global'], + breaker_threshold: ['pool', 'breaker_threshold'], + degrade_threshold: ['pool', 'degrade_threshold'], degrade_cooldown: ['pool', 'degrade_cooldown'], + degrade_cooldown_max: ['pool', 'degrade_cooldown_max'], + cost_explore_interval: ['pool', 'cost_explore_interval'], + balance_window: ['pool', 'balance_window'], + credit_floor: ['pool', 'credit_floor'], credit_floor_max_rate: ['pool', 'credit_floor_max_rate'], + prefer_expiring: ['pool', 'prefer_expiring'], expiring_soon: ['pool', 'expiring_soon'], + soft_rate: ['cooldown', 'soft_rate'], soft_rate_max: ['cooldown', 'soft_rate_max'], + breaker_cooldown: ['pool', 'breaker_cooldown'], breaker_cooldown_max: ['pool', 'breaker_cooldown_max'], + idle_weight_per_hour: ['pool', 'idle_weight_per_hour'], idle_weight_max: ['pool', 'idle_weight_max'], + reserve_credits: ['pool', 'reserve_credits'], + ttl: ['session_sticky', 'ttl'], + timeout_seconds: ['upstream', 'timeout_seconds'], header_timeout_seconds: ['upstream', 'header_timeout_seconds'], + idle_timeout_seconds: ['upstream', 'idle_timeout_seconds'], user_agent: ['upstream', 'user_agent'], + prompt_mode: ['prompt', 'mode'], prompt_file: ['prompt', 'file'], + keep_recent_rounds: ['prompt', 'keep_recent_rounds'], + sanitize_blacklist_fingerprints: ['features', 'sanitize_blacklist_fingerprints'], + sanitize_brand_scope: ['features', 'sanitize_brand_scope'], + embeddings_enabled: ['features', 'embeddings_enabled'], + session_sticky_enabled: ['session_sticky', 'enabled'], + request_client_info: ['logging', 'request_client_info'], + request_archive_context: ['logging', 'request_archive_context'], + models_hidden: ['models', 'hidden'], + models_allowed: ['models', 'allowed'], + models_aliases: ['models', 'aliases'], + thinking_enabled: ['thinking', 'enabled'], + thinking_default_effort: ['thinking', 'default_effort'], + cn_chat_base: ['cn', 'chat_base'], cn_billing_base: ['cn', 'billing_base'], + global_chat_base: ['global', 'chat_base'], global_billing_base: ['global', 'billing_base'], +}; +/* 「覆盖型」文本字段:空串本身是有意义的取值(= 回落到内置默认),必须照发。 + * + * 其余文本字段保持「空 = 不下发」的既有语义——那是防误清空的保护,不是 bug: + * 表单里某个框没填,通常意味着"没改",把它当成"请清空"会静默抹掉配置。 + * + * 但覆盖型字段正好相反:清空 = 明确要求回到默认。漏发它们会让面板显示"已保存" + * 而值其实没变(吸收上游 10e17ef:user_agent 清空后 config.json 里仍是旧值)。 + * + * 刻意不含 api_key:清空它 = 关闭整个鉴权,误触代价是网关变成无鉴权公开服务。 + * 该字段(以及提示文案"留空 = 不鉴权"与现状不符的问题)单独处理。 + */ +const CLEARABLE_CFG = new Set(['user_agent', 'prompt_file', 'cn_chat_base', 'cn_billing_base', 'global_chat_base', 'global_billing_base']); + +function dig(obj, path) { return path.reduce((o, k) => (o == null ? undefined : o[k]), obj); } +function put(obj, path, val) { + let o = obj; + for (let i = 0; i < path.length - 1; i++) { if (typeof o[path[i]] !== 'object' || o[path[i]] === null) o[path[i]] = {}; o = o[path[i]]; } + o[path[path.length - 1]] = val; +} + +async function loadConfig() { + try { + const d = await api('config'); + cfgLoaded = d.config; + $('cfgPath').textContent = d.path || ''; + const f = $('cfgForm'); + const managed = d.environment_managed_fields || []; + for (const [name, path] of Object.entries(CFG_MAP)) { + const el = f.elements[name]; + if (!el) continue; + el.disabled = managed.includes(path.join('.')); + el.title = el.disabled ? '此项由启动环境变量设置,请在部署配置中修改。' : ''; + const v = dig(cfgLoaded, path); + if (el.type === 'checkbox') el.checked = !!v; + else if (Array.isArray(v)) el.value = v.join(', '); + // 按模型覆盖档位(对象):回显成「模型=档位」多行文本,与 textarea 输入同形。 + else if (v && typeof v === 'object') el.value = Object.entries(v).map(([k, x]) => k + '=' + x).join('\n'); + else el.value = v == null ? '' : v; + } + markDurationFields(); // 回填后重置校验态(清掉残留红框;现值来自后端必然合法) + // 思考档位策略是「三选一单选组」(客户端优先 / 网关优先·只档位 / 网关优先·档位+开关), + // 由两个既有配置键(client_priority + override_scope)推导,格式不变、手改配置仍生效。 + // 无 iterable NodeList 的 DOM 桩(故障注入/老测试)下静默跳过:只影响回显,不影响保存。 + const mode = thinkingModeOf(cfgLoaded.thinking); + try { + for (const r of f.querySelectorAll('input[name="thinking_mode"]')) r.checked = r.value === mode; + } catch (e) { /* DOM 桩没有 NodeList 迭代器 */ } + $('cfgKey').disabled = !!d.api_key_env_managed; + $('cfgKey').title = d.api_key_env_managed ? '访问密钥由启动环境变量设置,请在部署配置中修改。' : ''; + if (d.panel_key_env_managed) { + $('cfgKey').title = '面板登录密钥由 WB2A_PANEL_KEY 环境变量托管;这里修改的是下游 API 密钥,不影响面板登录。'; + } + $('cfgNote').textContent = managed.length ? '由启动环境管理:' + managed.join('、') : ''; + refreshEffortDowngradeNote(); // 回填后按当前值算一次降级提示 + } catch (e) { toast('读取配置失败:' + e.message, 'err'); } +} + +/* 默认网关档位不支持提示:选中档位若高于/低于某些模型的支持范围,网关会按 + 「≤ 目标档的最高支持档,没有更低的正档则取最低正档」降级(off 不参与降级)。 + 数据来自 /panel/api/models 的 gateway_effort_wanted vs gateway_effort—— + 后端用出站同一套 ResolveGatewayEffort 算的,提示与真实注入不会漂移。 + + 只在「改了默认档」时才需要重算,但模型目录是异步拉的(可能比配置晚到), + 所以两处都调:配置回填后、模型列表加载后。目录为空时静默隐藏(不编造)。 */ +function refreshEffortDowngradeNote() { + const el = $('effortDowngradeNote'); + if (!el) return; + const sel = $('cfgForm') && $('cfgForm').elements['thinking_default_effort']; + const want = sel ? String(sel.value || '').trim().toLowerCase() : ''; + const models = (typeof mdAll !== 'undefined' && Array.isArray(mdAll)) ? mdAll : []; + if (!want || !models.length) { el.textContent = ''; return; } + // 只统计「真正会降级」的模型:目标档与生效档不同,且生效档非空(空 = 不改写, + // 比如该模型根本没声明档位,不属于降级)。 + const downgraded = models.filter(m => { + const got = String(m.gateway_effort || '').trim().toLowerCase(); + const w = String(m.gateway_effort_wanted || '').trim().toLowerCase(); + return got && w === want && got !== want; + }); + if (!downgraded.length) { el.textContent = ''; return; } + // 按落点聚合,最多列前三个,其余归到「等 N 个」——几十个模型全列出来会把面板撑爆。 + const byTarget = {}; + for (const m of downgraded) { + const t = String(m.gateway_effort || '').toLowerCase(); + (byTarget[t] || (byTarget[t] = [])).push(m.id || ''); + } + const parts = Object.keys(byTarget).sort().map(t => byTarget[t].length + ' 个降到 ' + t); + el.textContent = '⚠ 当前有 ' + downgraded.length + ' 个模型不支持 ' + want + ':' + parts.join('、') + + '(逐个模型可在「模型与档位」页的「网关档位」列单独指定)'; +} +// thinkingModeOf 由 thinking.client_priority + override_scope 推导三选一的选中项。 +// 缺省(未写客户端优先)= 客户端优先,与 config 默认值一致。 +function thinkingModeOf(t) { + t = t || {}; + if (t.client_priority !== false) return 'client'; + return String(t.override_scope || '').toLowerCase() === 'all' ? 'all' : 'level'; +} + +function collectConfig() { + const f = $('cfgForm'), out = {}; + for (const [name, path] of Object.entries(CFG_MAP)) { + const el = f.elements[name]; + if (!el) continue; + let v; + if (el.type === 'checkbox') v = el.checked; + else if (el.type === 'number') { v = el.value.trim() === '' ? undefined : Number(el.value); } + else { + const raw = el.value.trim(); + // 逗号/空白分隔的列表字段:空 = 显式清空黑名单(空数组照发,否则删不掉条目)。 + // 白名单同款语义(issue #68):空串显式发空数组 = 关闭白名单。 + if (name === 'models_hidden' || name === 'models_allowed') v = raw.split(/[,,\s]+/).filter(Boolean); + // 模型映射(issue #30):"客户端名=真实名" 条目数组,同列表语义;空数组照发 = 清空。 + else if (name === 'models_aliases') v = raw.split(/[,,]+/).map(s => s.trim()).filter(Boolean); + // 覆盖型字段空串照发(见 CLEARABLE_CFG);其余空 = 不下发。 + else if (raw === '') v = CLEARABLE_CFG.has(name) ? '' : undefined; + else if (name.endsWith('_hours')) v = raw.split(/[,,\s]+/).filter(Boolean).map(Number); + else v = raw; + } + if (v !== undefined) put(out, path, v); + } + // 三选一单选组 → 两个既有键(与 CFG_MAP 互不覆盖:上面只回填了 thinking.enabled)。 + // 老测试桩没有 querySelector(只铺 elements),缺省按客户端优先回填。 + const modeEl = typeof f.querySelector === 'function' ? f.querySelector('input[name="thinking_mode"]:checked') : null; + const mode = modeEl ? modeEl.value : 'client'; + put(out, ['thinking', 'client_priority'], mode === 'client'); + put(out, ['thinking', 'override_scope'], mode === 'all' ? 'all' : 'level'); + return out; +} +/* Go 时长字段即时校验:空 = 沿用现值(collectConfig 跳过发送);非空必须是 + ParseDuration 语法(30m / 2h / 600s / 1h30m,可组合可带小数)。与后端 + config.go normalize() 的 time.ParseDuration 同口径,脏值在前端就地标红, + 不再等到保存被拒。 */ +const DURATION_RE = /^(\d+(\.\d+)?(ns|us|µs|ms|s|m|h))+$/; +const DURATION_FIELDS = ['soft_rate', 'soft_rate_max', 'breaker_cooldown', 'breaker_cooldown_max', + 'degrade_cooldown', 'degrade_cooldown_max', 'cost_explore_interval', 'balance_window', 'expiring_soon', 'ttl', + 'keepalive_refresh_window']; +const DURATION_TIP = '格式应为 Go 时长:30m / 2h / 600s / 1h30m'; +function durationBad(name) { + const el = $('cfgForm').elements[name]; + if (!el) return false; + const v = el.value.trim(); + return v !== '' && !DURATION_RE.test(v); +} +function markDurationFields() { + for (const name of DURATION_FIELDS) { + const el = $('cfgForm').elements[name]; + if (!el) continue; + const bad = durationBad(name); + el.classList.toggle('invalid', bad); + el.title = bad ? DURATION_TIP : ''; + } +} +$('cfgForm').addEventListener('input', ev => { + if (DURATION_FIELDS.includes(ev.target.name)) markDurationFields(); +}); +// 改「默认网关档位」时立刻重算降级提示:让操作员在保存前就看到「这一档有几个模型 +// 支持、几个会降级」,而不是保存后去事件日志里猜实际生效的档位。 +$('cfgForm').addEventListener('change', ev => { + if (ev.target.name === 'thinking_default_effort') refreshEffortDowngradeNote(); +}); +$('btnEye').onclick = () => { + const el = $('cfgKey'); + const show = el.type === 'password'; + el.type = show ? 'text' : 'password'; + $('btnEye').textContent = show ? '隐藏' : '显示'; +}; +$('btnCfgReload').onclick = loadConfig; +// cfgRealmFilter 配置页分域切换:all 显示全部;cn/global 仅显示该域专属字段 +// (data-realm 标记)。共享配置(无 data-realm)始终显示。保存时仍回传整份配置, +// 故切换仅控制可见性、不丢字段。域名 base 等各域独立配置由此分开关,与账号池 +// 已有的 accRealmTabs 同构。 +let cfgRealmFilter = 'all'; +function applyCfgRealmFilter() { + // tab 按钮自己也带 data-realm(记录它代表哪个域),必须跳过:否则同一段逻辑在 + // 选「国际版」时会把「全部」「国内版」两个按钮一起隐藏,tab 栏看起来就塌了。 + document.querySelectorAll('#cfgForm [data-realm]').forEach(el => { + if (el.closest('#cfgRealmTabs')) return; + const r = el.getAttribute('data-realm'); + el.style.display = (cfgRealmFilter === 'all' || cfgRealmFilter === r) ? '' : 'none'; + }); + const tabs = $('cfgRealmTabs'); + if (tabs) tabs.querySelectorAll('button[data-realm]').forEach(b => b.classList.toggle('on', b.dataset.realm === cfgRealmFilter)); +} +if ($('cfgRealmTabs')) { + $('cfgRealmTabs').addEventListener('click', ev => { + const btn = ev.target.closest('button[data-realm]'); + if (!btn) return; + cfgRealmFilter = btn.dataset.realm; + applyCfgRealmFilter(); + }); + applyCfgRealmFilter(); +} +$('cfgForm').onsubmit = async ev => { + ev.preventDefault(); + // 时长字段脏值拦截:标红 + toast 点名,不发保存请求(后端同样会拒,这里前置)。 + markDurationFields(); + const firstBad = DURATION_FIELDS.find(durationBad); + if (firstBad) { + const el = $('cfgForm').elements[firstBad]; + el.focus(); + toast('「' + (el.closest('.fld')?.querySelector('.lb')?.textContent || firstBad) + '」' + DURATION_TIP, 'err'); + return; + } + const btn = $('btnCfgSave'); + btn.disabled = true; btn.textContent = '保存中…'; + try { + const r = await api('config', { method: 'POST', body: JSON.stringify(collectConfig()) }); + const fields = r.restart_required || []; + const restartNote = fields.length ? '需重启生效:' + fields.join('、') : ''; + toast(fields.length ? '配置已保存,其中 ' + fields.length + ' 项需重启进程生效' : '配置已保存并立即生效', 'ok'); + // 密钥可能已改:本次会话沿用新值,避免下一次轮询被 401。 + // 由启动环境变量托管时不写入本地(避免把无效值当会话密钥)。 + const k = $('cfgKey').value.trim(); + if (k && !r.api_key_env_managed) localStorage.setItem(LS_KEY, k); + await loadConfig(); + $('cfgNote').textContent = [restartNote, (r.environment_managed_fields || []).length ? '由启动环境管理:' + r.environment_managed_fields.join('、') : ''].filter(Boolean).join(';'); + loadOverview(true); + } catch (e) { toast('保存失败:' + e.message, 'err'); } + finally { btn.disabled = false; btn.textContent = '保存配置'; } +}; + +/* ── 添加账号 ─────────────────────────────────────────────────────── */ +// 导入预览态的暂存:{files: File[], ready: bool, result?: 预览响应}。 +// 只活到确认导入或关闭弹窗为止;File 对象本身在浏览器里,再次 POST 时重发即可。 +let importPending = null; +function openAdd() { + $('addVeil').classList.add('on'); + // 重置到登录标签 + switchAddTab('login'); + $('addPick').hidden = false; + $('addLoad').hidden = true; $('addReady').hidden = true; + $('addDone').hidden = true; $('addErr').hidden = true; + $('importDone').hidden = true; $('importErr').hidden = true; + $('apiKeyDone').hidden = true; $('apiKeyErr').hidden = true; + $('btnCopyUrl').hidden = true; $('btnOpenUrl').hidden = true; + $('addQr').hidden = true; $('addQr').innerHTML = ''; // 上一次的 state 已作废,二维码不留 + $('btnStartLogin').hidden = false; $('btnStartLogin').disabled = false; + $('btnAddApiKey').hidden = true; + stopPoll(); +} +function switchAddTab(tab) { + document.querySelectorAll('#addTabs .tab').forEach(b => b.classList.toggle('on', b.dataset.tab === tab)); + $('addTabLogin').hidden = tab !== 'login'; + $('addTabImport').hidden = tab !== 'import'; + $('addTabApiKey').hidden = tab !== 'apikey'; + // 页脚按钮随标签切:登录页「获取授权链接」、API Key 页「添加 API Key」、 + // 导入页「确认导入」(仅预览通过后出现,见 renderImportPreview)。 + $('btnAddApiKey').hidden = tab !== 'apikey'; + $('btnStartLogin').hidden = tab !== 'login' || loginState != null; + $('btnImportCommit').hidden = !(tab === 'import' && importPending && importPending.ready); +} +document.querySelectorAll('#addTabs .tab').forEach(b => { + b.onclick = () => switchAddTab(b.dataset.tab); +}); +function startAddLogin() { + // 站点(官方域表 cn/intl/workbuddy):面板只传 site,realm 由后端按站点表决定, + // 避免前端自己维护一份域表。 + const site = (document.querySelector('input[name="addSite"]:checked') || {}).value || 'cn'; + $('btnStartLogin').disabled = true; + $('addLoad').hidden = false; $('addErr').hidden = true; + api('login/start', { method: 'POST', body: JSON.stringify({ site }) }).then(r => { + loginState = r.state; + loginStartAt = Date.now(); + $('addUrl').textContent = r.url; + // 手机/异地添加:链接转发常被 IM 预览抓取或截断 state,扫码这条路径不受影响。 + // 超出编码容量(workbuddy 站带 ww_device_nonce 时 157 字节)就只留链接。 + try { + const M = qrMatrix(r.url); + // 模块整数像素(4×):非整数的 viewBox 缩放会把模块边缘糊成半像素,手机更难扫。 + $('addQr').innerHTML = qrSVG(M, (M.length + 8) * 4); + $('addQr').hidden = false; + } catch (e) { + // shortcut: 编码器到 v6(134 字节)为止;装了 CODEBUDDY_LOGIN_DEVICE_NONCE 的 + // workbuddy 站链接 157 字节编不出来,再往上要补版本信息块,那时再升 v8。 + // 但降级必须说出来 —— 静默不显示二维码会被当成 bug 反复报。 + $('addQr').innerHTML = '链接过长,无法生成二维码,请用下方「复制链接」或「在浏览器打开」'; + $('addQr').hidden = false; + } + $('addPick').hidden = true; // 选域锁定(会话已按该域发起) + $('addLoad').hidden = true; $('addReady').hidden = false; + $('btnStartLogin').hidden = true; + $('btnCopyUrl').hidden = false; $('btnOpenUrl').hidden = false; + pollFails = 0; + loginTimer = setInterval(pollLogin, 3000); + }).catch(e => { + $('addLoad').hidden = true; + $('btnStartLogin').disabled = false; + $('addErr').hidden = false; + $('addErr').textContent = e.message; + }); +} +function stopPoll() { if (loginTimer) { clearInterval(loginTimer); loginTimer = null; } } +// pollFails 连续查询失败计数:网络抖动不该让用户以为「重新登录没用」。OAuth 可能已经在 +// 浏览器侧完成,只是这次没收到结果——停掉轮询账号就永远不入池。 +let pollFails = 0; +const POLL_MAX_FAILS = 20; +async function pollLogin() { + if (!loginState) return; + try { + const r = await api('login/poll?state=' + encodeURIComponent(loginState)); + pollFails = 0; + if (r.fatal) { + // 上游许可类终态(席位满 / 许可证过期 / 试用到期):重试无意义,直接把上游 + // 原话给用户(官方 SignLicenseError 行为)。 + stopPoll(); + $('addReady').hidden = true; + $('addErr').hidden = false; + $('addErr').textContent = r.message || '登录被上游拒绝'; + return; + } + if (r.done) { + stopPoll(); + $('addReady').hidden = true; + $('addDone').hidden = false; + const warn = r.balance_error ? ';但余额校验失败:' + r.balance_error + '(若持续 401,请在浏览器退出腾讯账号后重登)' : ''; + $('addDone').textContent = '已添加 ' + (r.nickname || r.uid) + (r.realm === 'global' ? '(国际版)' : '') + (r.credits >= 0 ? ' · 积分 ' + r.credits + (r.credits_total > 0 ? '/' + r.credits_total : '') : '') + ',账号已载入池中' + warn; + invalidatePackages(); // 凭据换新:缓存里的旧 401 行必须作废 + setTimeout(() => { closeAdd(); loadOverview(true); }, 1600); + } + // 浏览器侧一旦显示「登录失败」,这边只会一直 pending 到 15 分钟 TTL,用户盯着 + // 「等待中」不知道要不要重来。90s 后给一次可操作提示,别让他空等。 + if (!r.done && loginStartAt && Date.now() - loginStartAt > 90000 && $('addErr').hidden) { + $('addErr').hidden = false; + $('addErr').textContent = '仍在等待浏览器完成登录。若浏览器已显示「登录失败」,请关闭本窗口重新获取授权链接(链接 15 分钟内有效)。'; + } + } catch (e) { + if (e.status === 404 || e.status === 410) { + stopPoll(); + $('addReady').hidden = true; + $('addErr').hidden = false; + $('addErr').textContent = '登录会话已过期,请关闭后重新添加'; + return; + } + pollFails++; + if (pollFails >= POLL_MAX_FAILS) { + stopPoll(); + $('addReady').hidden = true; + $('addErr').hidden = false; + $('addErr').textContent = '连续 ' + POLL_MAX_FAILS + ' 次查询失败,已停止轮询:' + e.message + '(授权可能已完成,可关闭后重新添加)'; + return; + } + $('addErr').hidden = false; + $('addErr').textContent = '网络中断,自动重试中(' + pollFails + '/' + POLL_MAX_FAILS + '):' + e.message; + } +} +function closeAdd() { + stopPoll(); loginState = null; $('addVeil').classList.remove('on'); + // 导入预览态一并清掉:关掉弹窗再打开时不该还挂着上一次的文件和「确认导入」。 + importPending = null; + $('importPreview').hidden = true; + $('importPreview').innerHTML = ''; + $('btnImportCommit').hidden = true; + $('importDone').hidden = true; + $('importErr').hidden = true; + $('importFile').value = ''; +} +$('btnCloseAdd').onclick = closeAdd; +$('btnStartLogin').onclick = startAddLogin; + +$('btnAddApiKey').onclick = async () => { + const token = ($('apiKeyInput').value || '').trim(); + $('apiKeyDone').hidden = true; $('apiKeyErr').hidden = true; + if (!token) { $('apiKeyErr').hidden = false; $('apiKeyErr').textContent = '请填写 API Key'; return; } + const btn = $('btnAddApiKey'); + btn.disabled = true; + try { + const r = await api('accounts/add_apikey', { + method: 'POST', + body: JSON.stringify({ + access_token: token, + nickname: ($('apiKeyNickname').value || '').trim(), + uid: ($('apiKeyUid').value || '').trim(), + }), + }); + $('apiKeyDone').hidden = false; + $('apiKeyDone').textContent = '已添加 ' + (r.nickname || r.uid) + '(API Key 账号),账号已载入池中'; + $('apiKeyInput').value = ''; + setTimeout(() => { closeAdd(); loadOverview(true); }, 1600); + } catch (e) { + $('apiKeyErr').hidden = false; + $('apiKeyErr').textContent = '添加失败:' + e.message; + } finally { btn.disabled = false; } +}; +$('btnOpenUrl').onclick = () => open($('addUrl').textContent, '_blank'); +$('btnCopyUrl').onclick = () => navigator.clipboard.writeText($('addUrl').textContent) + .then(() => toast('链接已复制', 'ok'), () => toast('复制失败,请手动选择复制', 'err')); +$('importFile').onchange = async () => { + const files = Array.from($('importFile').files || []); + $('importDone').hidden = true; $('importErr').hidden = true; + importPending = null; + $('importPreview').hidden = true; + $('btnImportCommit').hidden = true; + if (!files.length) return; + // 导入是不可逆动作(覆盖已有凭据前还要过上游校验),所以分两步:选中文件后先 + // 发一次 dryRun 预览——服务端只做解析、必填、uid 合法性与批内去重,不落盘、 + // 不发上游请求;点「确认导入」才真正写入。 + // + // 多文件在服务端是整体事务:任一文件不是合法 JSON 或没有任何账号就整体 400, + // 不做「先把前面那部分导进去」。顺序即选择顺序(先选的优先)。 + importPending = { files, ready: false }; + const label = files.length > 1 ? files.length + ' 个文件' : files[0].name; + $('importPreview').hidden = false; + $('importPreview').innerHTML = '
正在校验 ' + esc(label) + '…
'; + try { + const d = await postImport(true); + importPending.result = d; + importPending.ready = true; + renderImportPreview(label, d); + $('btnImportCommit').hidden = false; + } catch (e) { + importPending = null; + $('importPreview').innerHTML = '
校验失败,未导入任何账号:' + esc(e.message) + '
'; + $('btnImportCommit').hidden = true; + } +}; +$('btnImportCommit').onclick = async () => { + if (!importPending || !importPending.ready) return; + const btn = $('btnImportCommit'); + btn.disabled = true; + const label = importPending.files.length > 1 ? importPending.files.length + ' 个文件' : importPending.files[0].name; + try { + const d = await postImport(false); + $('importPreview').hidden = true; + $('importDone').hidden = false; + $('importDone').textContent = '导入完成(' + label + '):新增 ' + (d.creates || 0) + + ' 个,覆盖 ' + (d.overwrites || 0) + ' 个' + + (d.skipped ? ',跳过 ' + d.skipped + ' 个' : ''); + if (d.errors && d.errors.length) console.warn('import errors:', d.errors); + importPending = null; + $('btnImportCommit').hidden = true; + invalidatePackages(); + loadOverview(true); + } catch (e) { + $('importErr').hidden = false; + $('importErr').textContent = '导入失败:' + e.message; + btn.disabled = false; + } + $('importFile').value = ''; +}; + +// 预览区:先给一句人话结论(新增/覆盖/跳过),再列具体条目问题。 +// 跳过项只列前 20 条——几百条的清单塞进弹窗只会把「结论」顶出视野。 +function renderImportPreview(label, d) { + const bits = ['新增 ' + (d.creates || 0) + ' 个', '覆盖 ' + (d.overwrites || 0) + ' 个']; + if (d.skipped) bits.push('跳过 ' + d.skipped + ' 个'); + let html = '
' + esc(label) + ' · 共 ' + (d.total || 0) + ' 条:' + bits.join(',') + '
'; + if (d.overwrites) { + html += '
覆盖项会先用 refresh 向上游求证新凭据可用,通过才写盘;不通过则保留原有凭据。
'; + } + const errs = d.errors || []; + if (errs.length) { + const shown = errs.slice(0, 20); + html += '
跳过明细' + + (errs.length > shown.length ? '(前 ' + shown.length + ' 条,共 ' + errs.length + ' 条)' : '') + + ':
' + + shown.map(e => '
' + esc(e) + '
').join('') + '
'; + } + if (!d.imported) { + html += '
没有可导入的账号。
'; + } + $('importPreview').innerHTML = html; +} + +// 导入请求:多文件按选择顺序塞进同一个 multipart,服务端逐份解码后合并。 +function postImport(dryRun) { + const fd = new FormData(); + for (const f of importPending.files) fd.append('file', f, f.name); + if (dryRun) fd.append('dryRun', 'true'); + const h = {}; + const k = localStorage.getItem(LS_KEY); + if (k) h['Authorization'] = 'Bearer ' + k; + return fetch('/panel/api/import/cockpit', { method: 'POST', body: fd, headers: h }) + .then(async r => { + const d = await r.json().catch(() => ({})); + if (!r.ok) throw new Error(d.error || ('HTTP ' + r.status)); + return d; + }); +} + +/* ── 顶部动作 ─────────────────────────────────────────────────────── */ +$('btnAdd').onclick = openAdd; +$('btnRefresh').onclick = async () => { + if (view === 'proxies') { await loadProxies(); return; } + const b = $('btnRefresh'); + b.disabled = true; b.title = '刷新中…'; + try { + await api('balance_all', { method: 'POST' }); + await loadOverview(true); + toast('余额已从上游刷新', 'ok'); + } catch (e) { toast('刷新失败:' + e.message, 'err'); await loadOverview(true); } + finally { b.disabled = false; b.title = '刷新'; } + if (view === 'logs') loadLogs(); +}; + +/* ── 轮询 ─────────────────────────────────────────────────────────── */ +// 页面隐藏时暂停轮询(perf):浏览器把标签页切到后台时,本页仍然每 5 秒打一轮 +// 接口 + 重建整张表——用户看不到,却照付网络、CPU 与内存代价。visibilitychange +// 事件在切后台/回前台时触发,这里据此停表与补一次刷新(回前台时数据是旧的, +// 立即补拉一次比空等一个周期更快)。 +// +// 代价:无人看时面板数据不更新。这与「自动刷新」的本意不冲突——自动刷新是给 +// 「盯着看」的人用的;真需要无人值守的数据,看服务端 /status 与排程日志。 +let pageHidden = document.visibilityState === 'hidden'; +// pollIntervalMs 自动刷新间隔:缺省 5000ms。服务端 /panel/api/overview 会透出 +// config 的 panel.poll_interval_sec(0 = 缺省,负数 = 关闭自动刷新)——首轮 +// overview 回来后据此重建定时器。账号多或只把面板当监控用时,调大间隔能显著 +// 降低浏览器与服务端负担。 +let pollIntervalMs = 5000; +let pollAutoRefresh = true; +document.addEventListener('visibilitychange', () => { + const nowHidden = document.visibilityState === 'hidden'; + if (nowHidden === pageHidden) return; + pageHidden = nowHidden; + if (pageHidden) { + if (refTimer) { clearInterval(refTimer); refTimer = null; } + return; + } + // 回前台:立刻补拉一次当前视图(不等下一个 tick)。 + refreshVisible(); + startPolling(); +}); + +function refreshVisible() { + if (pageHidden) return; // 后台不刷(见上) + if (view === 'accounts') { + loadOverview(true); + } + else if (view === 'logs') loadLogs(); + else if (view === 'proxies') loadProxies(true); + else if (view === 'taskscenter') reattachQueueView(); +} +// startPolling(重)建轮询定时器。间隔取 pollIntervalMs(服务端配置可调); +// pollAutoRefresh=false(配置为负)时不开表——只在用户手动操作时更新。 +function startPolling() { + if (refTimer) { clearInterval(refTimer); refTimer = null; } + if (pageHidden || !pollAutoRefresh) return; + refTimer = setInterval(refreshVisible, pollIntervalMs); +} +function start() { + loadOverview(true); + startPolling(); + checkAuthGate(); +} +async function checkAuthGate() { + try { await api('overview'); } + catch (e) { if (String(e.message).includes('密钥') || String(e.message).includes('api_key')) return; } +} +start(); + +/* ── 积分任务 ─────────────────────────────────────────────────────── */ +let taskUID = null, taskCapabilities = { accept: false, claim: false, automate: false }; +let taskJobTimer = null, taskJobPolling = null, taskJobID = null, taskJobGeneration = 0; +let taskJobsLoading = false; + +// 服务端状态与界面反馈共用的纯函数,避免把已提交/失败当成已完成。 +/* 签到四态文案(checkin_state 由后端按回执判定,见 upstream.CheckinState): + checked = 本次真签到、上游发了积分;already = 今天早就签过、一个积分都没发; + pending = 上游还在处理;failed = 上游拒签。 + 关键:already 和 checked 的事实不同。以前只凭 checkin_done 一律显示「签到已完成」 + (绿色),重复点按钮看起来像能无限刷积分——同类项目 hub#875 在生产 1288 条签到 + 记录里就踩了同一个坑(250 条幂等拒绝被报成「签到成功 (+100积分)」)。 + 积分数字只取上游这次真实带回的 checkin_credit,取不到就不显示,绝不硬编码。 */ +function checkinResultNote(r) { + if (r.skipped) return { message: r.skip_reason || '该账号不适用签到', severity: '' }; + const balance = r.credits != null ? ',当前积分 ' + r.credits + (r.credits_total > 0 ? '/' + r.credits_total : '') : ''; + const state = r.checkin_state || (r.checkin_done ? 'checked' : 'failed'); + if (state === 'skipped') return { message: r.checkin_message || r.skip_reason || '该账号不适用签到', severity: '' }; + if (state === 'already') return { message: '今天已签到,无需重复,上游不会再发积分' + balance, severity: '' }; + if (state === 'pending') return { message: '签到未完成:上游还在处理,稍后重试' + balance, severity: 'warn' }; + if (state !== 'checked') return { message: '签到未完成:' + (r.checkin_message || '请稍后重试') + balance, severity: 'err' }; + const gain = typeof r.checkin_credit === 'number' ? ',+' + r.checkin_credit + ' 积分' : ''; + if (r.balance_error) return { message: '签到成功' + gain + ';余额刷新失败:' + r.balance_error, severity: 'err' }; + return { message: '签到成功' + gain + balance, severity: 'ok' }; +} + +function taskOutcomeStatus(item) { + if (item.claim_error) return 'claim_pending'; + return item.status || (item.claimed ? 'done' : item.skipped ? 'skipped' : 'awaiting_progress'); +} + +function taskResultSummary(results) { + const counts = { done: 0, skipped: 0, error: 0, awaiting_progress: 0, claim_pending: 0, accepted: 0 }; + for (const item of results || []) { + const state = taskOutcomeStatus(item); + if (Object.prototype.hasOwnProperty.call(counts, state)) counts[state]++; + else counts.error++; + } + const parts = ['已完成 ' + counts.done + ' 项']; + if (counts.accepted) parts.push('报名已提交 ' + counts.accepted + ' 批'); + if (counts.awaiting_progress) parts.push('等待计分 ' + counts.awaiting_progress + ' 项'); + if (counts.claim_pending) parts.push('领奖待重试 ' + counts.claim_pending + ' 项'); + if (counts.skipped) parts.push('跳过 ' + counts.skipped + ' 项'); + if (counts.error) parts.push('失败 ' + counts.error + ' 项'); + return { message: parts.join(','), severity: counts.error || counts.claim_pending ? 'err' : counts.awaiting_progress || counts.skipped || !counts.done ? '' : 'ok' }; +} + +function taskRowPresentation(t, caps) { + const code = t.task_code || t.code || ''; + const cur = t.current ?? 0, tgt = t.target ?? 0; + const progress = t.progress_known === false ? '未提供' : tgt ? cur + ' / ' + tgt : cur > 0 ? String(cur) : '—'; + const rewards = []; + if (t.credit) rewards.push('+' + t.credit + ' 分'); + if (t.energy) rewards.push('+' + t.energy + ' 能'); + if (t.reward_buddy) rewards.push('Buddy'); + const reward = t.reward_known === false ? '未提供' : rewards.join(' ') || '—'; + const state = t.claimed ? '已领取' : t.claimable ? '可领取' : t.locked ? '未解锁' + : t.accept_status === 'accepted' ? '进行中' : t.status === 'completed' || t.status === 'complete' ? '已完成' + : t.status === 'available' ? '可在客户端完成' : '未接受'; + // first_buddy 特例(与后端一致):进度满≠可领,按钮仍走"一键完成"动作链。 + const action = !code || t.claimed || t.locked ? '' : t.claimable && caps.claim && code !== 'first_buddy' ? 'claim' + : caps.automate && AUTO_TASKS[code] ? 'auto' : t.accept_status !== 'accepted' && caps.accept ? 'accept' : ''; + return { code, progress, reward, state, action }; +} + +// 可自动完成的任务(与后端 autoActions 表一致):判据为行为事件、可经网关复现。 +// 其余任务需在官方客户端内交互,面板只展示指引(行 title 提示)。 +// 注意:任务 code 可能含点号,键一律加引号,否则会被解析成属性访问 + 数字字面量。 +const AUTO_TASKS = { + 'chat_5': '上报 5 条对话活跃事件(自动补足差额)', + 'first_buddy': '上报解锁 → 同意协议 → 领取第一只 Buddy', + 'RichMeow_Chat': '桌面指纹事件链上报(已验证可点亮)', + 'Buddy_App': '上报「进入 Buddy 应用」事件链(已验证可点亮)', + 'automation_1': '上报「定时任务创建」事件(已验证可点亮)', + 'Library_read': '上报「读资料库介绍」事件(已验证可点亮)', + 'template_5': '上报「使用模板创建任务」事件组 ×5(三账号实测点亮)', + 'playbook_prompt': '上报「灵感案例做同款发送 Prompt」事件组(三账号实测点亮)', + 'expert_5': '真实专家召唤+使用链 ×5(专家市场+真实 chat,三账号实测点亮)', + 'Expert_team_use_3': '真实专家团召唤+使用链 ×3(三账号实测点亮)', + 'Hp_Appearance': '设置主题 API + 皮肤生效事件(两账号实测点亮)', + 'Expert_lighthouse': '真实轻量云专家召唤+使用链(真实对话 requestId,两账号实测点亮)', + 'WorkBuddy_Valorant': '真实「无畏契约拼豆专家」召唤+使用链(真实对话 requestId,截止 11-15)', + 'expert_use_maidehao': '「中国电商运营专家」召唤+使用链(专家页搜索口径,截止 11-20,+50 分)', + 'expert_use_douyinyin': '「抖音策略师」召唤+使用链(专家页搜索口径,截止 11-20,+50 分)', + 'expert_use_shangjia_xuanchuan': '「商家宣传页与海报设计师」召唤+使用链(专家页搜索口径,截止 11-20,+50 分)', + 'expert_use_bowangwang': '「直播电商教练」召唤+使用链(专家页搜索口径,截止 11-20,+50 分)', + 'skill_1': '真实对话 + skill_info 技能加载事件(实测点亮)', + 'Sequential_Tasks_1': '小程序首对话(小程序口径):accept → mini 对话上报 → 领奖(+100c+5e)', + 'Sequential_Tasks_2': '小程序选专家对话(小程序口径):市场专家 id → accept → expert_actual_use 上报 → 领奖(+200c+5e)', + 'Sequential_Tasks_3': '小程序五次对话(小程序口径):accept → mini 对话上报 ×5(自动补差额)→ 领奖(+300c+5e)', + 'Sequential_Tasks_4': '小程序定时任务(预留,每日零点解锁一环):accept → 定时任务创建事件 → 领奖(判据待解锁验证)', + 'Sequential_Tasks_5': '小程序使用 GLM5.2(预留):accept → 带模型字段的 mini 对话上报 → 领奖(判据待解锁验证)', + 'Sequential_Tasks_6': '小程序十次对话(预留):accept → mini 对话上报 ×target(自动补差额)→ 领奖', + 'Sequential_Tasks_7': '体验灵感功能(预留,疑 PC 口径):accept → 灵感事件组(PC+mp 双形态)→ 领奖(判据待解锁验证)' +}; + +function openTasks(uid) { + taskJobGeneration++; + if (taskJobTimer) clearInterval(taskJobTimer); + taskJobTimer = null; + taskJobID = null; + taskUID = uid; + taskCapabilities = { accept: false, claim: false, automate: false }; + $('btnTaskAcceptAll').hidden = true; + $('btnTaskAutoAll').hidden = true; + $('taskNote').hidden = true; + $('taskJobView').hidden = true; + $('btnTaskAutoAll').disabled = false; + $('btnTaskAutoAll').textContent = '后台完成可自动任务'; + $('taskWho').textContent = uid.slice(0, 16); + $('taskVeil').classList.add('on'); + $('btnTaskReload').hidden = false; + loadTasks(); + loadAccountTaskJob(uid); +} +function closeTasks() { + taskJobGeneration++; + $('taskVeil').classList.remove('on'); taskUID = null; taskJobID = null; + if (taskJobTimer) clearInterval(taskJobTimer); + taskJobTimer = null; +} +$('btnCloseTask').onclick = closeTasks; +$('btnTaskReload').onclick = () => { loadTasks(); if (taskUID) loadAccountTaskJob(taskUID); }; + +// 全部接受:把该账号未接受的任务一次性报名(幂等,跳过已接受/已领取)。 +$('btnTaskAcceptAll').onclick = async () => { + if (!taskUID) return; + const btn = $('btnTaskAcceptAll'); + btn.disabled = true; btn.textContent = '接受中…'; + try { + const r = await api('accounts/' + encodeURIComponent(taskUID) + '/tasks/accept_all', { method: 'POST' }); + const n = r.accepted || 0; + if (r.failed && r.failed.length) { + toast(`已接受 ${n} 个,${r.failed.length} 个被上游拒绝(可重试)`, 'err'); + } else { + toast(n ? `已接受 ${n} 个任务` : (r.message || '所有任务均已接受'), 'ok'); + } + } catch (e) { toast(e.message, 'err'); } + finally { btn.disabled = false; btn.textContent = '全部接受'; loadTasks(); } +}; + +// 后台执行:请求仅启动任务,页面轮询进度;关闭弹窗不影响服务端执行。 +$('btnTaskAutoAll').onclick = async () => { + if (!taskUID || !taskCapabilities.automate) return; + const uid = taskUID; + const btn = $('btnTaskAutoAll'); + btn.disabled = true; btn.textContent = '启动中…'; + try { + const r = await api('accounts/' + encodeURIComponent(uid) + '/tasks/auto_all', { method: 'POST' }); + toast(r.started ? '后台任务已启动,关闭页面后仍会继续执行' : '该账号已有后台任务,已恢复进度显示', 'ok'); + if (taskUID === uid) { taskJobGeneration++; renderAccountTaskJob(r.job); startAccountTaskJobPolling(uid); } + if (view === 'taskscenter') loadTaskJobs(); + } catch (e) { + toast(e.message, 'err'); + if (taskUID === uid) { btn.disabled = false; btn.textContent = '后台完成可自动任务'; } + } +}; + +function taskJobPresentation(job) { + const active = ['pending', 'running'].includes(job.status); + const labels = { pending: '排队中', running: '执行中', finished: '已结束', interrupted: '已中断', error: '执行失败' }; + const trigger = { new_account: '新增账号', daily: '每日定时', manual: '手动启动', resume: '重启续跑' }[job.trigger] || job.trigger || ''; + const progress = '处理 ' + (job.completed || 0) + ' / ' + (job.total || 0) + ' 项'; + const summary = taskResultSummary(job.results || []); + const current = active && job.current_task ? '正在处理:' + job.current_task : ''; + return { active, trigger, progress, label: labels[job.status] || job.status, + message: [labels[job.status] || job.status, progress, current, job.error || job.message, summary.message].filter(Boolean).join(' · '), + severity: job.status === 'error' || job.status === 'interrupted' ? 'err' : summary.severity }; +} + +function taskJobRows(job) { + return (job.results || []).map(item => qrowHTML({ code: item.task_code || '', title: item.title, desc: item.desc, + status: taskOutcomeStatus(item), message: item.message || item.claim_error, + prog: item.progress_after || item.progress_before || '' })).join(''); +} + +function renderAccountTaskJob(job) { + $('taskJobView').hidden = !job; + if (!job) return; + taskJobID = job.id; + const info = taskJobPresentation(job); + $('taskJobState').className = 'state ' + info.severity; + $('taskJobState').textContent = info.message; + $('taskJobResults').innerHTML = taskJobRows(job) || '
等待后台任务开始处理
'; + $('btnTaskAutoAll').disabled = info.active; + $('btnTaskAutoAll').textContent = info.active ? '后台执行中…' : '后台完成可自动任务'; +} + +async function loadAccountTaskJob(uid) { + if (taskJobPolling === uid) return; + taskJobPolling = uid; + const generation = taskJobGeneration; + try { + const d = await api('accounts/' + encodeURIComponent(uid) + '/tasks/job'); + if (taskUID !== uid || taskJobGeneration !== generation) return; + const previous = taskJobID; + renderAccountTaskJob(d.job); + if (d.job && taskJobPresentation(d.job).active) startAccountTaskJobPolling(uid); + else { + if (taskJobTimer) clearInterval(taskJobTimer); + taskJobTimer = null; + if (previous && d.job && previous === d.job.id) loadTasks(); + } + } catch (e) { + if (taskUID === uid && taskJobGeneration === generation) { $('taskJobView').hidden = false; $('taskJobState').className = 'state err'; $('taskJobState').textContent = '后台进度查询失败:' + e.message; } + } finally { + if (taskJobPolling === uid) taskJobPolling = null; + if (taskUID && (taskUID !== uid || taskJobGeneration !== generation) && !taskJobTimer) loadAccountTaskJob(taskUID); + } +} + +function startAccountTaskJobPolling(uid) { + if (taskJobTimer) clearInterval(taskJobTimer); + taskJobTimer = setInterval(() => { if (taskUID === uid) loadAccountTaskJob(uid); }, 3000); +} + +/* 任务中心:一张卡、一个列表,来源两处——常驻的「后台自动任务」(tasks/jobs) 与 + 一次性的「待办扫描/队列」(tasks/scan_all、tasks/queue)。两者都是"某账号的任务 + 进展",行形态也一致(同走 qrowHTML),因此不各渲染一块,而是共用 renderQueue。 + taskCenterOwner 决定列表当前显示谁:queue=扫描结果或本页启动的队列(实时优先), + jobs=后台自动任务(默认;点「刷新进度」也回到它)。 */ +let taskCenterOwner = 'jobs'; +async function loadTaskJobs() { + // go() 顶层调用也会进入此函数,首次 await 前不读取后声明的状态。 + await Promise.resolve(); + if (taskJobsLoading) return; + taskJobsLoading = true; + try { + const d = await api('tasks/jobs'); + const jobs = d.jobs || []; + $('taskJobsNote').hidden = !!jobs.length && d.auto_enabled !== false; + $('taskJobsNote').textContent = d.auto_enabled === false ? '自动成长任务已关闭,可在账号任务中手动启动后台执行。' : '新增国区账号后自动执行,每日按成长任务排程继续推进;可在账号任务中手动启动。'; + if (taskCenterOwner !== 'jobs') return; // 队列/扫描结果正占着列表 + const groups = groupsFromJobs(jobs); + renderQueue(groups, null, jobs.length ? '后台任务还没有结果' : '还没有后台任务记录', + jobs.length ? '任务刚开始执行,结果出来后会显示在这里。' : '新增国区账号后自动执行;也可以在上面扫描待办并执行。'); + } catch (e) { + if (taskCenterOwner === 'jobs') renderQueue([], null, '后台任务查询失败', e.message); + } finally { taskJobsLoading = false; } +} +// 后台任务 → 与扫描/队列同形的分组(共用 qrowHTML 渲染) +function groupsFromJobs(jobs) { + return jobs.map(job => { + const info = taskJobPresentation(job); + return { + uid: job.uid, nick: job.nickname, + cnt: info.trigger + ' · ' + info.label + (info.progress ? ' · ' + info.progress : ''), + tip: info.message, // 明细挂 title(原「后台自动任务」卡的状态行) + rows: (job.results || []).map(item => ({ + kind: 'job', code: item.task_code || '', title: item.title, desc: item.desc, + status: taskOutcomeStatus(item), message: item.message || item.claim_error, + prog: item.progress_after || item.progress_before || '', + })), + }; + }).filter(g => g.rows.length); +} +$('btnTaskJobsReload').onclick = () => { taskCenterOwner = 'jobs'; loadTaskJobs(); }; + +async function loadTasks() { + if (!taskUID) return; + const uid = taskUID; + const st = $('taskState'), tb = $('taskTable'); + st.hidden = false; + st.className = 'state'; + st.innerHTML = '查询中'; + tb.hidden = true; + try { + const d = await api('accounts/' + encodeURIComponent(uid) + '/tasks'); + if (taskUID !== uid) return; + taskCapabilities = d.capabilities || { accept: d.realm !== 'global', claim: d.realm !== 'global', automate: d.realm !== 'global' }; + $('btnTaskAcceptAll').hidden = !taskCapabilities.accept; + $('btnTaskAutoAll').hidden = !taskCapabilities.automate; + $('taskNote').textContent = d.message || (d.realm === 'global' ? '国际区任务当前仅支持查询,请在官方客户端完成。' : ''); + $('taskNote').hidden = !$('taskNote').textContent; + const list = d.tasks || []; + if (!list.length) { + st.className = 'state'; + st.textContent = '该账号暂无任务'; + return; + } + // 有进度或可领取的排前面,已领取沉底——一眼看到"现在该做什么"。 + list.sort((a, b) => (a.claimed - b.claimed) || (b.claimable - a.claimable) || String(a.task_code).localeCompare(String(b.task_code))); + $('taskBody').innerHTML = list.map(t => { + // 进度/奖励/状态/动作统一走 taskRowPresentation(与后端任务结果口径一致) + const row = taskRowPresentation(t, taskCapabilities); + const badge = '' + esc(row.state) + ''; + const acted = row.action ? '' : ''; + // 操作指引(description/task_desc)挂 title 提示:如何完成交给用户看 + const tip = [t.title, t.task_desc || t.description, t.jump_url ? '跳转:' + t.jump_url : ''].filter(Boolean).join('\n'); + return '' + + '
' + esc(t.title || row.code) + '
' + esc(row.code) + (t.tag ? ' · ' + esc(t.tag) : '') + '
' + + '' + esc(row.progress) + '' + + '' + esc(row.reward) + '' + + '' + badge + '' + + '' + acted + ''; + }).join(''); + st.hidden = true; + tb.hidden = false; + } catch (e) { + if (taskUID !== uid) return; + taskCapabilities = { accept: false, claim: false, automate: false }; + $('btnTaskAcceptAll').hidden = true; + $('btnTaskAutoAll').hidden = true; + st.className = 'state err'; + st.textContent = e.message; + } +} + +$('taskBody').addEventListener('click', async ev => { + const b = ev.target.closest('button[data-t]'); + if (!b || !taskUID) return; + const kind = b.dataset.t, code = b.dataset.c; + if (!code || !(kind === 'auto' ? taskCapabilities.automate : taskCapabilities[kind])) return; + b.disabled = true; + try { + if (kind === 'auto') { + // 一键完成:后端执行动作 → 回读进度 → 汇报(耗时可到分钟级,含真实对话) + b.textContent = '执行中…'; + const r = await api('accounts/' + encodeURIComponent(taskUID) + '/tasks/auto', { + method: 'POST', body: JSON.stringify({ task_code: code }) + }); + const status = taskOutcomeStatus(r); + const severity = status === 'done' ? 'ok' : status === 'error' || status === 'claim_pending' ? 'err' : ''; + toast(r.message || taskResultSummary([r]).message, severity); + loadOverview(true); + } else { + const path = 'accounts/' + encodeURIComponent(taskUID) + '/tasks/' + (kind === 'claim' ? 'claim' : 'accept'); + const body = kind === 'claim' ? { task_code: code } : { task_codes: [code] }; + await api(path, { method: 'POST', body: JSON.stringify(body) }); + toast(kind === 'claim' ? '已领取奖励' : '已接受任务', 'ok'); + if (kind === 'claim') loadOverview(true); + } + } catch (e) { toast(e.message, 'err'); } + finally { loadTasks(); } +}); + +/* 成长任务队列。lastQueueSeq 记录本页启动过的队列代次:执行结束后的残留 items + (running=false 但 seq 停在旧值)不再回写视图——否则扫描结果 3 秒后被上一轮 + 队列状态覆盖。 */ +let queueTimer = null, lastQueueSeq = 0; +const GROWTH_TITLES = {}; // code → 展示名(扫描时从任务列表带出) +$('btnSchoolVouchers').onclick = loadSchoolVouchers; +$('btnVcClose').onclick = () => $('vcVeil').classList.remove('on'); +$('btnVcRefresh').onclick = loadSchoolVouchers; + +$('btnScanAll').onclick = async () => { + const b = $('btnScanAll'); + // 停掉队列轮询:显式扫描 = 切到待办视图。否则在途队列的下一 tick 会把扫描 + // 结果冲掉重渲染回队列视图(服务端执行不受影响,只是不再实时回写本视图)。 + if (queueTimer) { clearInterval(queueTimer); queueTimer = null; } + taskCenterOwner = 'queue'; + b.disabled = true; b.textContent = '扫描中…'; + try { + const d = await api('tasks/scan_all', { method: 'POST' }); + renderQueue(groupItems(d), null, '未发现可自动执行的待办', '当前扫描范围没有可自动执行的任务;跳过和扫描失败的账号会单独列出。'); + } catch (e) { toast(e.message, 'err'); } + finally { b.disabled = false; b.textContent = '扫描待办'; } +}; +$('btnRunQueue').onclick = async () => { + const conc = Number($('qcConc').value) || 1; + if (!confirm('扫描全部账号待办并排队执行(账号并发 ' + conc + ',账号内串行)。\n含真实对话的任务耗时较长,确认继续?')) return; + const b = $('btnRunQueue'); + taskCenterOwner = 'queue'; + b.disabled = true; b.textContent = '启动中…'; + try { + const r = await api('tasks/run_queue', { method: 'POST', body: JSON.stringify({ concurrency: conc }) }); + if (!r.started) { + if (r.scan_accounts) renderQueue(groupItems({ accounts: r.scan_accounts }), null, '未启动任务队列', r.message || '没有可自动执行的待办'); + toast(r.message || '没有可自动执行的待办', r.scan_error_count ? 'err' : ''); + return; + } + lastQueueSeq = r.seq || 0; + toast('队列已启动:' + r.total + ' 项(并发 ' + conc + ')', 'ok'); + startQueuePolling(); + } catch (e) { toast(e.message, 'err'); } + finally { b.disabled = false; b.textContent = '执行全部待办'; } +}; +// 扫描结果 → 分组条目(无执行状态) +function groupItems(d) { + const groups = []; + for (const a of (d.accounts || [])) { + const rows = []; + for (const t of (a.growth || [])) { + GROWTH_TITLES[t.task_code] = t.title || t.task_code; + rows.push({ kind: 'growth', code: t.task_code, prog: t.target ? t.current + '/' + t.target : '—', status: 'scan' }); + } + if (a.growth_error) rows.push({ kind: 'account', code: '', title: '扫描失败', status: 'error', message: a.growth_error }); + if (a.skipped) rows.push({ kind: 'account', code: '', title: '已跳过', status: 'skipped', message: a.skip_reason || '该账号不适用当前自动任务' }); + if (rows.length) groups.push({ uid: a.uid, nick: a.nickname, rows }); + } + return groups; +} +const ST_WORDS = { done: '完成', running: '执行中', error: '失败', skipped: '跳过', pending: '排队', scan: '待执行', awaiting_progress: '等待计分', claim_pending: '领奖待重试', accepted: '已接受' }; +function taskProgressLabel(value) { + const progress = String(value ?? '').trim(); + return /^\d+(?:\s*\/\s*\d+)?$/.test(progress) ? progress : '—'; +} +// 展示名:上游短中文名 > 扫描缓存 > 本仓中文说明 > 代号兜底。 +// 后台任务结果行只带 task_code/desc(实测 24 个码全无 title),不接 desc 就会 +// 一路退回代号,与左边那列代号同名。 +function qrowHTML(it) { + const title = it.title || GROWTH_TITLES[it.code] || it.desc || it.code; + const dotCls = it.status === 'scan' ? 'wait' : it.status === 'running' ? 'run' : it.status === 'error' ? 'err' : it.status === 'skipped' ? 'skip' : it.status === 'done' ? 'done' : 'wait'; + const stWord = it.status === 'scan' ? '待执行' : (ST_WORDS[it.status] || it.status); + const progress = taskProgressLabel(it.prog); + return '
' + + '' + esc(it.code) + '' + + '' + esc(title) + '' + + '' + esc(progress) + '' + + '' + stWord + '' + + '' + esc(it.message || '') + '' + + '
'; +} +/* 任务中心筛选:默认收起「已完成」与「该账号没有此任务」两类噪音行。 + 开关只影响渲染,不重新打上游;状态存本机,下次打开沿用。 */ +const LS_TC_HIDE_DONE = 'wb2api.tc.hideDone', LS_TC_HIDE_NA = 'wb2api.tc.hideNa'; +let tcHideDone = localStorage.getItem(LS_TC_HIDE_DONE) !== '0'; +let tcHideNa = localStorage.getItem(LS_TC_HIDE_NA) !== '0'; +let tcLastRender = null; // 最近一次 renderQueue 的原始入参,供切换开关时原地重绘 +const TC_NA_MESSAGE = '该账号没有此任务'; +function tcRowHidden(row) { + if (tcHideDone && row.status === 'done') return true; + if (tcHideNa && String(row.message || '').trim() === TC_NA_MESSAGE) return true; + return false; +} +function renderQueue(groups, progress, emptyTitle, emptyDesc) { + tcLastRender = { groups, progress, emptyTitle, emptyDesc }; + const rawRows = groups.reduce((n, g) => n + g.rows.length, 0); + groups = groups + .map(g => Object.assign({}, g, { rows: g.rows.filter(row => !tcRowHidden(row)) })) + .filter(g => g.rows.length); + const hiddenRows = rawRows - groups.reduce((n, g) => n + g.rows.length, 0); + const empty = $('tcEmpty'), list = $('qcList'); + if (!groups.length) { + empty.style.display = ''; + if (rawRows) { + empty.querySelector('.t').textContent = '当前筛选下没有任务'; + empty.querySelector('.d').textContent = '已隐藏 ' + rawRows + ' 行(已完成 / 该账号没有此任务),取消上方勾选即可查看。'; + } else { + if (emptyTitle) empty.querySelector('.t').textContent = emptyTitle; + if (emptyDesc) empty.querySelector('.d').textContent = emptyDesc; + } + list.innerHTML = ''; + $('qProg').hidden = true; $('tcSummary').textContent = ''; + return; + } + empty.style.display = 'none'; + let total = 0; + list.innerHTML = groups.map(g => { + total += g.rows.length; + const tasks = g.rows.filter(row => row.kind !== 'account' && row.kind !== 'job').length; + // cnt 给后台任务用("每日定时 · 执行中");扫描/队列按任务项数自己算 + const cnt = g.cnt ? g.cnt : (tasks ? tasks + ' 项任务' : '账号状态'); + return '
' + esc(g.nick || g.uid.slice(0, 12)) + '' + esc(cnt) + '' + + '
' + + g.rows.map(qrowHTML).join('') + '
'; + }).join(''); + const taskCount = groups.reduce((sum, group) => sum + group.rows.filter(row => row.kind !== 'account').length, 0); + $('tcSummary').textContent = taskCount + ' 项任务' + (total > taskCount ? ' · ' + (total - taskCount) + ' 条账号状态' : '') + + (hiddenRows ? ' · 已隐藏 ' + hiddenRows : ''); + updateProgress(progress); +} +function syncTcFilter(kind) { + if (kind === 'done') localStorage.setItem(LS_TC_HIDE_DONE, tcHideDone ? '1' : '0'); + if (kind === 'na') localStorage.setItem(LS_TC_HIDE_NA, tcHideNa ? '1' : '0'); + if (tcLastRender) renderQueue(tcLastRender.groups, tcLastRender.progress, tcLastRender.emptyTitle, tcLastRender.emptyDesc); +} +$('tcHideDone').checked = tcHideDone; +$('tcHideNa').checked = tcHideNa; +$('tcHideDone').onchange = ev => { tcHideDone = ev.target.checked; syncTcFilter('done'); }; +$('tcHideNa').onchange = ev => { tcHideNa = ev.target.checked; syncTcFilter('na'); }; +$('qcList').addEventListener('click', ev => { + const b = ev.target.closest('button[data-task-uid]'); + if (b) openTasks(b.dataset.taskUid); +}); +function updateProgress(q) { + if (!q || !q.items) { $('qProg').hidden = true; return; } + const total = q.items.length; + const done = q.items.filter(it => ['done', 'error', 'skipped', 'awaiting_progress', 'claim_pending'].includes(it.status)).length; + $('qProg').hidden = false; + $('qBarFill').style.width = (total ? Math.round(done / total * 100) : 0) + '%'; + $('qProgText').textContent = (q.running ? '执行中 ' : '已结束 ') + done + ' / ' + total; +} +// 队列状态 → 分组(执行时轮询) +function groupsFromQueue(items) { + const by = new Map(); + for (const it of items) { + if (!by.has(it.uid)) by.set(it.uid, { uid: it.uid, nick: it.nickname, rows: [] }); + by.get(it.uid).rows.push({ + kind: it.kind, code: it.code, title: it.title || '', + prog: '', + status: it.status, message: it.message, + }); + } + return Array.from(by.values()); +} +function startQueuePolling() { + if (queueTimer) clearInterval(queueTimer); + queueTimer = setInterval(async () => { + let q; + try { q = await api('tasks/queue'); } catch (e) { return; } + if (!q.started) return; + // 只渲染本页启动过的那轮队列(刷新页面后不再接管旧队列)。 + if (lastQueueSeq && q.seq !== lastQueueSeq) return; + if (q.running) { + renderQueue(groupsFromQueue(q.items || []), q); + return; + } + // 结束:终态只渲染这一次,随即停表。此后残留的 items(running=false)不再 + // 回写视图——曾把用户刚点开的「扫描待办」结果在下一个 tick 冲掉。 + renderQueue(groupsFromQueue(q.items || []), q); + clearInterval(queueTimer); queueTimer = null; + const summary = taskResultSummary(q.items || []); + toast('任务队列已结束:' + summary.message, summary.severity); + }, 3000); +} +// reattachQueueView 切回任务中心视图时恢复队列进度:仅当本页启动的队列仍在 +// 执行才重新开轮询(残留态/别页队列不接管——视图不被旧结果冲掉)。 +function reattachQueueView() { + // 扫描/队列结果占着列表时不抢视图(同 loadTaskJobs 里的归属闸门)。本函数也被 + // 5s 定时刷新调用,无条件改 owner + 渲染后台任务,会把用户刚查出来的扫描结果 + // 冲成空白(表现为「查完就自己消失」)。切回「后台任务」仍是显式动作:刷新进度 + // 按钮、或本页队列确实在跑时由下面的尾部接管。 + if (taskCenterOwner !== 'queue') { + taskCenterOwner = 'jobs'; + loadTaskJobs(); + } + // 全程异步:go() 在顶层(app.js ~143 行)被调用时,本文件下方 let/const + //(queueTimer/lastQueueSeq 等)尚未初始化——同步读取即 TDZ ReferenceError + // 使整个脚本中断。await 之后才碰它们(旧 pollQueueOnce 正是靠开头的 await + // 侥幸安全)。queueTimer 的"已在跑"判定也挪到 await 后,语义不变。 + (async () => { + try { + const q = await api('tasks/queue'); + if (queueTimer) return; // 轮询已在跑(跨视图不中断) + if (q.started && q.running && (!lastQueueSeq || q.seq === lastQueueSeq)) { taskCenterOwner = 'queue'; startQueuePolling(); } + } catch (e) { /* 静默 */ } + })(); +} + +/* ── 用量 ─────────────────────────────────────────────────────────── */ +/* 图表用原生 SVG 手绘:面板是 go:embed 单文件、无构建步骤,引入图表库 + 就得带上打包器,得不偿失。这里只需要堆叠柱状图,二十行足够。 */ + +function fmtTok(n) { + n = Number(n || 0); + if (n >= 1e9) return (n / 1e9).toFixed(2) + 'B'; + if (n >= 1e6) return (n / 1e6).toFixed(2) + 'M'; + if (n >= 1e3) return (n / 1e3).toFixed(1) + 'k'; + return String(n); +} +function fmtMs(ms) { + ms = Number(ms || 0); + if (!ms) return '—'; + if (ms >= 1000) return (ms / 1000).toFixed(2) + 's'; + return Math.round(ms) + 'ms'; +} +function fmtRate(r) { return r ? Number(r).toFixed(1) + ' tok/s' : '—'; } +function trimFixed(s) { + if (!String(s).includes('.')) return String(s); + return String(s).replace(/0+$/, '').replace(/\.$/, ''); +} +function fmtCredit(n) { + const v = Number(n || 0); + if (!Number.isFinite(v)) return '—'; + return trimFixed(v.toFixed(2)); +} +function fmtCreditRatio(v, samples, tokens) { + if (!samples || !tokens) return '—'; + const n = Number(v || 0); + if (!Number.isFinite(n)) return '—'; + return trimFixed(n.toFixed(4)) + ' / 1M'; +} +function fmtModelRate(rate) { + const s = String(rate || '').trim(); + return s ? 'x' + s : '—'; +} + +function usStat(v, k, cls) { + return '
' + esc(v) + + '
' + esc(k) + '
'; +} + +/* usKpi 用量页的指标卡。比账号池的 .stat 多两样:语义色轨(cls)与副标题(sub, + 放"占比 / 均速率"这类解释性数字);bar 是卡片内的构成条 HTML,只有需要时才传。 */ +function usKpi(v, k, cls, sub, bar) { + return '
' + + '
' + esc(k) + '
' + + '
' + esc(v) + '
' + + (bar || '') + + (sub ? '
' + esc(sub) + '
' : '') + + '
'; +} + +/* usMixBar prompt/completion 占比条。宽度按百分比而不是固定像素:表列宽随窗口变化, + 像素宽度在窄屏会溢出、宽屏又显得没信息。 */ +function usMixBar(prompt, completion, total) { + const t = Number(total || 0); + if (!t) return ''; + const pp = Math.max(0, Math.min(100, Number(prompt || 0) / t * 100)); + const pc = Math.max(0, Math.min(100, Number(completion || 0) / t * 100)); + return '' + + '' + + '' + + ''; +} + +/* usPct 占比文案(0 值不显示 "0.0%",直接 —,避免一行全是零)。 */ +function usPct(part, total) { + const t = Number(total || 0); + if (!t) return '—'; + return (Number(part || 0) / t * 100).toFixed(1) + '%'; +} + +/* usRow 生成一行。mid 是插在「名称」之后、请求数之前的额外单元格(如「域」列)。 + withPerf 控制延迟/速率两列;列开关显式传入,避免调用方改动后与表头错列。 */ +function usRow(name, sub, a, mid, withPerf, nameHtml) { + return '' + + '' + + '' + (nameHtml || esc(name)) + (sub ? '
' + esc(sub) + '
' : '') + '' + + (mid || '') + + '' + fmtTok(a.requests) + '' + + '' + (a.errors ? '' + fmtTok(a.errors) + '' : '—') + '' + + '' + fmtTok(a.prompt_tokens) + '' + + '' + fmtHit(a) + '' + + '' + fmtTok(a.completion_tokens) + '' + + '' + fmtTok(a.total_tokens) + + usMixBar(a.prompt_tokens, a.completion_tokens, a.total_tokens) + '' + + (withPerf + ? '' + fmtMs(a.avg_latency_ms) + '' + + '' + fmtRate(a.avg_tokens_per_second) + '' + : '') + + ''; +} + +/* ── 用量明细:三个维度共用一张表 + 页内切换 ────────────────────────── + 账号 / 模型 / 域三张表此前各自占一个 box,页面纵向拉得很长且表头结构几乎一样。 + 现在合成一个 box:表头由维度定义生成,行渲染复用 usRow,切换零请求。 */ +const US_DIMS = { + account: { key: 'by_account', title: '账号', withRealm: true, withPerf: true, span: 11 }, + model: { key: 'by_model', title: '模型', withRealm: false, withPerf: false, span: 8 }, + realm: { key: 'by_realm', title: 'realm', withRealm: false, withPerf: false, span: 8 }, +}; + +// usSortRows 按当前排序字段降序(默认合计 Token,最大者最相关)。 +function usSortRows(rows, sort) { + const out = rows.slice(); + const num = v => { const n = Number(v || 0); return Number.isFinite(n) ? n : 0; }; + const val = a => sort === 'requests' ? num(a.requests) + : sort === 'errors' ? num(a.errors) + : sort === 'latency' ? num(a.avg_latency_ms) + : num(a.total_tokens); + out.sort((a, b) => val(b) - val(a)); + return out; +} + +function usDimHead(dim) { + const m = US_DIMS[dim] || US_DIMS.account; + return '' + esc(m.title) + '' + + (m.withRealm ? '域' : '') + + '请求失败' + + 'Prompt缓存命中率Completion合计' + + (m.withPerf ? '均延迟均速率' : '') + + ''; +} + +/* usTabsHtml 维度切换按钮(带条数徽标)。整段 innerHTML 重写而不是逐个改 class: + 容器的 click 监听是委托式的,换掉子节点不会丢事件,代码也更短。 */ +function usTabsHtml(dims, active, counts) { + return dims.map(([k, label]) => { + const n = counts ? counts[k] : null; + return ''; + }).join(''); +} + +const US_DIM_TABS = [['account', '按账号'], ['model', '按模型'], ['realm', '按域']]; + +function renderUsageDim() { + const d = usageData || {}; + const m = US_DIMS[usDim] || US_DIMS.account; + const rows = usSortRows(d[m.key] || [], usSort); + $('usDimTabs').innerHTML = usTabsHtml(US_DIM_TABS, usDim, { + account: (d.by_account || []).length, + model: (d.by_model || []).length, + realm: (d.by_realm || []).length, + }); + $('usDimHead').innerHTML = usDimHead(usDim); + $('usDimBody').innerHTML = rows.map(x => { + const isAcct = usDim === 'account'; + const key = isAcct ? String(x.key || '').slice(0, 8) : x.key; + return usRow(key, + isAcct ? (x.extra || '') : '', + x, + isAcct ? '' + esc(x.realm || '') + '' : '', + m.withPerf, + isAcct ? remarkName(x.key, esc(key)) : ''); + }).join('') || '暂无数据'; + $('usDimNote').textContent = rows.length + ' 行 · 请求数含失败尝试'; +} + +/* 积分扣除:按账号 / 按模型两个维度共用一张表(同上,两个 box 合成一个)。 */ +function usCreditHead(dim) { + return dim === 'model' + ? '模型积分倍率' + + '请求扣除积分' + + '有效样本 Token积分 / 1M Token缓存命中率' + : '账号' + + '请求扣除积分' + + '有效样本 Token积分 / 1M Token缓存命中率'; +} + +function renderCreditDim() { + const d = usageData || {}; + $('usCreditHead').innerHTML = usCreditHead(usCreditDim); + const empty = '暂无积分扣除记录;升级前仅含 Token 的历史不会伪造积分。'; + if (usCreditDim === 'model') { + const models = d.credit_by_model || []; + $('usCreditBody').innerHTML = models.map(row => + '' + + '' + + '' + esc(row.key || '—') + '' + + '' + esc(fmtModelRate(row.rate)) + '' + + '' + fmtTok(row.requests) + '' + + '' + fmtCredit(row.credits) + '' + + '' + fmtTok(row.credit_tokens) + '' + + '' + fmtCreditRatio(row.credits_per_1m_tokens, row.credit_samples, row.credit_tokens) + '' + + '' + cacheRateCell(row.cache_hit_tokens, row.cache_miss_tokens) + '' + + '' + ).join('') || '' + empty + ''; + } else { + const accounts = d.credit_by_account || []; + $('usCreditBody').innerHTML = accounts.map(row => { + const uid = String(row.key || ''); + const account = row.nickname || uid.slice(0, 8) || '—'; + return '' + + '' + + '' + remarkName(uid, esc(account)) + '
' + esc(row.realm || '') + ' · ' + esc(uid.slice(0, 8)) + '
' + + '' + fmtTok(row.requests) + '' + + '' + fmtCredit(row.credits) + '' + + '' + fmtTok(row.credit_tokens) + '' + + '' + fmtCreditRatio(row.credits_per_1m_tokens, row.credit_samples, row.credit_tokens) + '' + + '' + cacheRateCell(row.cache_hit_tokens, row.cache_miss_tokens) + '' + + ''; + }).join('') || '' + empty + ''; + } + $('usCreditTabs').innerHTML = usTabsHtml([['account', '按账号'], ['model', '按模型']], usCreditDim, { + account: (d.credit_by_account || []).length, + model: (d.credit_by_model || []).length, + }); +} + +function renderUsage(d) { + usageData = d || {}; + const t = usageData.totals || {}; + const total = Number(t.total_tokens || 0); + const pt = Number(t.prompt_tokens || 0); + const ct = Number(t.completion_tokens || 0); + const reqs = Number(t.requests || 0); + const errs = Number(t.errors || 0); + const okRate = reqs ? (reqs - errs) / reqs * 100 : null; + // 构成条要的是合法 CSS 宽度,usPct 在无样本时返回 "—",不能直接拼进 style。 + const pctW = (part) => total ? Math.max(0, Math.min(100, Number(part || 0) / total * 100)).toFixed(2) + '%' : '0%'; + // 八张卡:请求数 / 总 token / 积分 / 平均缓存命中率 是四张主指标(同一行,均用强调色), + // completion 用成功色(与图表里的绿柱呼应), + // 失败/延迟只在有值时上语义色——全绿全黄的仪表盘等于没有重点。 + const chTok = Number(t.cache_hit_tokens || 0), cmTok = Number(t.cache_miss_tokens || 0); + const creditSamples = Number(t.credit_samples || 0); + $('usStats').innerHTML = + usKpi(fmtTok(reqs), '请求数', 'c-accent', + errs ? '其中失败 ' + errs + ' 次' : '全部成功') + + usKpi(fmtTok(total), '总 token', 'c-accent', + 'prompt ' + usPct(pt, total) + ' · completion ' + usPct(ct, total), + '
' + + '
') + + // 积分:按所选窗口累计上游 usage.credit(缺失该字段的历史不参与;样本数为 0 时 + // 明确写「无积分样本」而不是显示 0 —— 没观测到 ≠ 没消耗)。 + usKpi(creditSamples ? fmtCredit(t.credits) : '—', '总积分', 'c-accent', + creditSamples ? creditSamples + ' 条样本' : '无样本') + + usKpi(cacheRateText(chTok, cmTok), '平均缓存命中率', 'c-accent', + (chTok + cmTok) ? '命中 ' + fmtTok(chTok) + ' · 未命中 ' + fmtTok(cmTok) : '无缓存观测样本') + + usKpi(fmtTok(pt), 'prompt', 'c-soft', '占比 ' + usPct(pt, total)) + + usKpi(fmtTok(ct), 'completion', 'c-ok', '占比 ' + usPct(ct, total)) + + usKpi(String(errs), '失败尝试', errs ? 'c-warn' : 'c-mute', + okRate == null ? '—' : (errs ? '成功率 ' + okRate.toFixed(1) + '%' : '成功率 100%')) + + usKpi(fmtMs(t.avg_latency_ms), '平均延迟', 'c-soft', + t.avg_tokens_per_second ? '吐字 ' + fmtRate(t.avg_tokens_per_second) : '无速率样本'); + + // 卡片、明细表与时序图全部按所选窗口统计(切窗口数字随之变化); + // 「全部历史」含 90 天前折叠出的日桶。这里标注当前口径与数据起点。 + const winLabel = trangeLabel('usRange'); + // 服务端回显的实际区间优先(自定义区间下它就是权威口径);滚动窗口没有回显, + // 用控件自己的标签。 + const rangeEcho = usageData.window_from + ? String(usageData.window_from).replace('T', ' ').slice(0, 16) + + (usageData.window_to ? ' → ' + String(usageData.window_to).replace('T', ' ').slice(0, 16) : ' → 现在') + : ''; + const note = (rangeEcho || winLabel ? (rangeEcho || winLabel) + ' · ' : '') + + (usageData.buckets || 0) + ' 个分桶' + + (usageData.since ? ' · 数据自 ' + usageData.since.replace('T', ' ') : '') + + (usageData.file_bytes ? ' · 文件 ' + (usageData.file_bytes / 1024).toFixed(1) + ' KB' : ''); + $('usNote').textContent = note; + $('usNote').title = note; // 窄屏单行截断时靠悬停看全 + + // 积分扣除的四张卡片与说明。 + $('usCreditStats').innerHTML = + usKpi(fmtCredit(t.credits), '扣除积分', 'c-accent', '按上游 usage.credit 累计') + + usKpi(fmtTok(t.credit_tokens), '匹配 Token', 'c-mute', '与积分同时观测到的 Token') + + usKpi(fmtCreditRatio(t.credits_per_1m_tokens, t.credit_samples, t.credit_tokens), + '平均积分 / 1M Token', 'c-ok', '越低越划算') + + usKpi(String(t.credit_samples || 0), '有效积分样本', 'c-mute', '缺字段的历史不参与折算') + + usKpi(cacheRateText(t.cache_hit_tokens, t.cache_miss_tokens), '缓存命中率', 'c-mute', + '上游前缀缓存命中 / (命中+未命中);低命中意味着费用数倍放大'); + $('usCreditNote').textContent = + (usageData.credit_by_account || []).length + ' 个账号 · ' + + (usageData.credit_by_model || []).length + ' 个模型倍率分组 · 仅统计与积分同时观测到的 Token'; + + renderUsageDim(); + renderCreditDim(); + renderUsageChart(usageData.series || []); + renderUsageHours(usageData.series || []); +} + +// 维度切换 / 排序控件。 +if ($('usDimTabs')) $('usDimTabs').addEventListener('click', ev => { + const b = ev.target.closest('button[data-dim]'); + if (!b) return; + usDim = b.dataset.dim; + renderUsageDim(); +}); +if ($('usCreditTabs')) $('usCreditTabs').addEventListener('click', ev => { + const b = ev.target.closest('button[data-dim]'); + if (!b) return; + usCreditDim = b.dataset.dim; + renderCreditDim(); +}); +if ($('usSort')) $('usSort').onchange = () => { + usSort = $('usSort').value; + renderUsageDim(); +}; + +/* renderUsageChart 画堆叠柱状图。 + * + * x 轴是**真实时间轴**,不是按序号等距。这一点很重要:数据里存在 1 小时的 + * 间隔,也存在 6~8 小时的断档(没请求的时段不产生桶),等距排布会把 8 小时 + * 画得和 1 小时一样宽,让「什么时候用的」完全失真。 + * + * 另外不再用 preserveAspectRatio="none":那会把 viewBox 横向拉伸到容器宽度, + * 柱子和文字都变形。改为固定比例、按容器宽度自适应高度。 + * + * viewBox 取 1200×200(原 760×180):SVG 以 width:100% 渲染,高宽比决定实际 + * 高度——旧比例在 1500px 宽的主区里会撑到 ~355px,只有一两根柱子时整块几乎是 + * 空白。宽 viewBox 把同宽度下的高度压到 ~250px,与下方表格的视觉重量相当。 + * + * 时间轴用本地时间解析(后端返回的就是本地时区),day 点按当天 00:00 参与定位, + * 与 hour 点在同一个连续轴上——日桶本来就是他那天所有小时的聚合。 + */ + +/* renderUsageHours 填「积分与 token 按小时」表:直接消费 series 时序点(hour 点 + 一小时一行、day 点一行代表当天聚合),最新时段排在最上面。此前这张表只有静态 + 表头、没有任何渲染代码,用户永远看到一张空表。token/积分 = 合计 Token ÷ 该时段 + 实测扣除积分(兑换率),没有积分样本的时段留 —,不拿 0 顶替。 */ +function renderUsageHours(series) { + const body = $('usHourBody'); + if (!body) return; + const rows = []; + for (const p of (series || [])) { + if (parsePointTime(p) !== null) rows.push(p); + } + // 最新时段排最上面。后端 series 是「日桶升序 + 小时桶升序」两段拼接,简单 reverse + // 对混合窗口会错序,直接按时间戳降序排,与输入顺序解耦。 + rows.sort((a, b) => parsePointTime(b) - parsePointTime(a)); + body.innerHTML = rows.map(p => { + const tt = Number(p.total_tokens || 0); + const cr = Number(p.credits || 0); + return '' + + '' + + '' + esc(usHourLabel(p)) + '' + + '' + fmtTok(p.requests) + '' + + '' + fmtTok(p.prompt_tokens) + '' + + '' + fmtTok(p.completion_tokens) + '' + + '' + fmtTok(p.total_tokens) + '' + + '' + (cr ? fmtCredit(p.credits) : '—') + '' + + '' + (cr > 0 && tt > 0 ? fmtTok(tt / cr) : '—') + '' + + ''; + }).join('') || '暂无数据'; +} + +/* usHourLabel 时段列的完整标签:小时桶「MM-DD HH:00」(跨天窗口下只有 HH:00 分不清 + 是哪天),日桶「MM-DD」。t 的形态判别与 parsePointTime 同口径(长度 13 = 小时桶)。 */ +function usHourLabel(p) { + const s = p.t.length === 13 ? p.t + ':00:00' : p.t + 'T00:00:00'; + const d = new Date(s); + if (isNaN(d.getTime())) return p.t; + const day = (d.getMonth() + 1) + '-' + String(d.getDate()).padStart(2, '0'); + return p.scope === 'day' ? day : day + ' ' + String(d.getHours()).padStart(2, '0') + ':00'; +} + +/* parsePointTime 把后端的 t 解析成毫秒时间戳。 */ +function parsePointTime(p) { + // hour: "2026-09-16T13" day: "2026-09-16" + const s = p.t.length === 13 ? p.t + ':00:00' : p.t + 'T00:00:00'; + const d = new Date(s); + return isNaN(d.getTime()) ? null : d.getTime(); +} + +/* fmtTokTimeLabel 时间桶的短标签,与 x 轴刻度同一口径(日桶 MM-DD,小时桶 HH:00)。 */ +function fmtTokTimeLabel(p) { + const d = new Date(p.t); + return p.scope === 'day' + ? (d.getMonth() + 1) + '-' + String(d.getDate()).padStart(2, '0') + : String(d.getHours()).padStart(2, '0') + ':00'; +} + + +function renderUsageChart(series) { + const host = $('usChart'); + + // 丢掉时间解析不出来的点,而不是让 NaN 传染整张图。 + const pts = []; + for (const p of series) { + const t = parsePointTime(p); + if (t === null) continue; + const pt = Number(p.prompt_tokens || 0); + const ct = Number(p.completion_tokens || 0); + pts.push({ t, scope: p.scope, raw: p.t, pt, ct, tt: Number(p.total_tokens || 0) || (pt + ct), + ch: Number(p.cache_hit_tokens || 0), cm: Number(p.cache_miss_tokens || 0), + req: p.requests || 0 }); + } + if (!pts.length) { + host.innerHTML = '
暂无用量数据。发起一次对话后再刷新。
'; + $('usChartNote').textContent = '—'; + return; + } + + // 缓存命中率 = 命中/(命中+未命中)。没这两个字段的点(旧桶/上游没给)留 null, + // 曲线在那里断开,不拿 0 顶替——0% 和「没观测到」是两件事。 + let hasHit = false; + for (const p of pts) { + p.rate = (p.ch + p.cm) > 0 ? p.ch / (p.ch + p.cm) : null; + if (p.rate !== null) hasHit = true; + } + + const W = 1200, H = 200, PL = 58, PR = hasHit ? 34 : 14, PT = 18, PB = 30; + const iw = W - PL - PR, ih = H - PT - PB; + + const t0 = pts[0].t; + const t1 = pts[pts.length - 1].t; + const span = Math.max(1, t1 - t0); + + const max = Math.max(1, ...pts.map(p => p.tt)); + const peak = pts.reduce((a, b) => (b.tt > a.tt ? b : a), pts[0]); + const avg = pts.reduce((s, p) => s + p.tt, 0) / pts.length; + $('usChartNote').textContent = + pts.length + ' 个点 · 峰值 ' + fmtTok(peak.tt) + ' @ ' + fmtTokTimeLabel(peak) + + ' · 均值 ' + fmtTok(avg); + + // 柱宽取「最小真实间隔」的 70%,并夹在合理区间内——窗口拉到 30 天时柱子会 + // 变细,但不会细到看不见。 + let minGap = Infinity; + for (let i = 1; i < pts.length; i++) minGap = Math.min(minGap, pts[i].t - pts[i - 1].t); + if (!isFinite(minGap) || minGap <= 0) minGap = span; + const slot = iw * (minGap / span); + const bw = Math.max(2, Math.min(30, slot * 0.7)); + + // 首尾各让出半个柱宽:否则第一个点和最后一个点的柱子会各有一半跑到绘图区外 + // (末点柱子贴着卡片右边缘被切掉),刻度仍用同一个 xOf,标签与柱子始终对齐。 + const xOf = t => PL + bw / 2 + (t - t0) / span * Math.max(1, iw - bw); + const yOf = v => PT + ih - ih * (v / max); + + let out = ''; + + // 柱体渐变:顶部实、底部略透,堆叠时两段仍能一眼分清(纯色块并排会糊成一片)。 + // 注意 stop-color 必须走 style 而不是 presentation 属性——Blink/WebKit 不解析 + // 属性里的 var(),写成 stop-color="var(--accent)" 会整条渐变失效(柱子全透明)。 + out += '' + + '' + + '' + + '' + + '' + + '' + + '' + + ''; + + // y 轴网格 + 刻度 + for (let i = 0; i <= 4; i++) { + const y = PT + ih - (ih * i / 4); + out += ''; + out += '' + fmtTok(max * i / 4) + ''; + } + + // 均值参考线:一眼看出"这根是不是异常高",比只给刻度省心。 + // 标签放左侧:右侧常被峰值柱占用(峰值柱往往就是最后一根),贴左不会被压住。 + if (avg > 0 && avg < max) { + const y = yOf(avg); + out += ''; + out += '均值 ' + fmtTok(avg) + ''; + } + + // 柱子 + const yBase = PT + ih; + for (const p of pts) { + const x = xOf(p.t) - bw / 2; + const hTot = ih * (p.tt / max); + const hP = p.tt ? hTot * (p.pt / p.tt) : 0; + const hC = Math.max(p.tt && p.ct ? 1 : 0, hTot - hP); + // 圆角只给堆叠顶端(贴轴的底边保持方角,柱子才像"立"在基线上)。 + // 类名用 usbar 而不是 bar:账号池的积分条是 .bar{height:3px},而 SVG2 里 + // height 是 rect 的 CSS 几何属性,同名类会把每根柱子压成 3px 高(踩过)。 + // 每根柱子一个 , 作为它的**子元素**: + // - 只有作为元素的子节点才是那个元素的悬停提示;挂在 <svg> 根下时浏览器 + // 把它当整图的说明,于是**所有柱子都显示最后一条数据**(issue #128 的 + // 「细节数据好像所有柱状图都相同」)。 + // - 两个 rect(prompt/completion 堆叠)共用一个 <title>,悬停任一段都是同一份明细。 + out += '<g><title>' + esc(p.raw) + ' ' + fmtTok(p.pt) + ' prompt / ' + + fmtTok(p.ct) + ' completion / ' + p.req + ' 次'; + if (hP > 0) out += ' 0 ? '' : ' rx="1.5"') + '/>'; + if (hC > 0) out += ''; + out += ''; + } + + // 峰值标注:柱子够窄时文字压在柱顶,够宽时贴右侧避免和柱体重叠。 + { + const px = xOf(peak.t); + const py = yOf(peak.tt); + const anchor = px > W - PR - 90 ? 'end' : 'middle'; + out += '' + + '峰值 ' + fmtTok(peak.tt) + ''; + } + + // x 轴基线画在柱子之后,避免压在柱底 + out += ''; + + // x 轴刻度:按真实时间等距取 6 个位置,取该位置**最近的实际柱子**做标签, + // 所以标签永远落在有数据的点上,不会指到空档里。 + const TICKS = Math.min(6, pts.length); + const usedLabel = new Set(); + for (let k = 0; k < TICKS; k++) { + const target = t0 + span * (TICKS === 1 ? 0.5 : k / (TICKS - 1)); + let bi = 0, best = Infinity; + for (let i = 0; i < pts.length; i++) { + const d = Math.abs(pts[i].t - target); + if (d < best) { best = d; bi = i; } + } + if (usedLabel.has(bi)) continue; + usedLabel.add(bi); + const p = pts[bi]; + // 首尾标签靠边对齐,避免被裁掉 + const cx = xOf(p.t); + const anchor = cx < PL + 14 ? 'start' : (cx > W - PR - 14 ? 'end' : 'middle'); + out += '' + esc(fmtTokTimeLabel(p)) + ''; + } + + // 跨天时补一条日期分隔线,让「日界」在长窗口里可见 + let prevDay = null; + for (const p of pts) { + const d = new Date(p.t).getDate(); + if (prevDay !== null && d !== prevDay) { + const x = xOf(p.t).toFixed(1); + out += ''; + } + prevDay = d; + } + + // 命中率曲线:右轴 0-100%,断开处不连线(见上)。 + if (hasHit) { + for (const pct of [0, 50, 100]) { + const y = PT + ih - ih * (pct / 100); + out += '' + pct + '%'; + } + let seg = []; + const flush = () => { + if (seg.length > 1) out += ''; + seg = []; + }; + for (const p of pts) { + if (p.rate === null) { flush(); continue; } + const x = xOf(p.t).toFixed(1), y = (PT + ih - ih * p.rate).toFixed(1); + out += ''; + seg.push(x + ',' + y); + } + flush(); + } + + out += ''; + host.innerHTML = out; +} + +// fmtTokTip 图表 tooltip 的数值格式(与柱体标签同口径;前端测试以此为切片标记)。 +function fmtTokTip(v) { return fmtTok(v); } + +/* 缓存命中率 = 命中/(命中+未命中),颜色分级(issue #92 同步):≥90% 绿 / + 80–90% 黄 / <80% 红;样本不足灰(—)。title 带绝对量,供逐项核对。 */ +function fmtHit(a) { + const h = Number(a && a.cache_hit_tokens || 0), m = Number(a && a.cache_miss_tokens || 0); + return cacheRateCell(h, m); +} + +/* cacheRateCell 缓存命中率单元格(积分表等按 (hit, miss) 直传的调用点)。 */ +function cacheRateCell(hit, miss) { + const h = Number(hit || 0), m = Number(miss || 0), total = h + m; + if (!total) return '—'; + const pct = h / total * 100; + const color = pct >= 90 ? 'var(--ok)' : (pct >= 80 ? 'var(--warn)' : 'var(--bad)'); + const txt = trimFixed(pct.toFixed(1)) + '%'; + return '' + txt + ''; +} + +/* warmUsageModelRates 预热模型目录缓存(倍率来源)。旧桶缺倍率时后端只在 + 这次请求里能拿到当前倍率做展示回填;失败不阻塞用量统计,10 分钟后再试。 */ +let usageRateWarmAt = 0; +async function warmUsageModelRates() { + if (Date.now() - usageRateWarmAt < 10 * 60 * 1000) return; + try { + await api('models'); + } catch (e) { + // 倍率回填是可选增强;失败不阻塞用量统计,10 分钟后再试。 + } + usageRateWarmAt = Date.now(); +} + +async function loadUsage() { + const q = trangeQuery('usRange', true); + try { + await warmUsageModelRates(); + const d = await api('usage?' + q.toString()); + renderUsage(d); + } catch (e) { + // 失败时三块都要清干净:只改图表会留下上一次窗口的数字,看起来像"刷新成功"。 + usageData = null; + $('usChart').innerHTML = '
读取用量失败:' + esc(e.message) + '
'; + $('usChartNote').textContent = '—'; + $('usStats').innerHTML = ''; + $('usCreditStats').innerHTML = ''; + $('usNote').textContent = '—'; + $('usCreditNote').textContent = '—'; + $('usDimNote').textContent = '—'; + $('usDimHead').innerHTML = ''; + $('usCreditHead').innerHTML = ''; + $('usDimTabs').innerHTML = usTabsHtml(US_DIM_TABS, usDim, null); + $('usCreditTabs').innerHTML = usTabsHtml([['account', '按账号'], ['model', '按模型']], usCreditDim, null); + $('usDimBody').innerHTML = '读取用量失败'; + $('usCreditBody').innerHTML = '读取用量失败'; + $('usHourBody').innerHTML = '读取用量失败'; + } +} + +if ($('btnUsage')) $('btnUsage').onclick = loadUsage; +// 时间范围控件绑定:任何改动(预设切换 / 自定义起止)都重新拉一次用量。 +if ($('usRange')) trangeBind('usRange', loadUsage); + +/* ── 积分构成 ─────────────────────────────────────────────────────── */ +// 套餐标签(后端 pool.ClassifyPlan 判定,unknown 不显示):一眼看出该指望哪个号。 +const PLAN_LABELS = { free: '免费版', trial: '体验版', activity: '活动号', standard: '标准版' }; +/* 一个账号的余额是若干积分包之和。包按来源命名(「国内运营裂变包」「拉新权益包」 + 「个人体验版」…),面额从 6 到 1500 不等,且**按次发放**。所以两个任务完成度 + 完全一致的账号,余额可能差上千——差别只在包里。这里把逐包明细摊开,并给每个 + 包名一个稳定配色,跨账号对比时同色即同类。 */ + +const PK_COLORS = ['#4f8cff', '#25b08b', '#e8a33d', '#c96bd6', '#e2607a', + '#5aa9e6', '#8fbf3f', '#b58b5a', '#7d8fa8', '#d4785c']; +const PK_ACCOUNT_COLORS = ['#4f8cff', '#25b08b', '#e8a33d', '#c96bd6', + '#e2607a', '#20a4a4', '#8fbf3f', '#d4785c', + '#7c83db', '#c48a2f', '#b45f8c', '#5aa9e6']; + +function pkColor(i) { return PK_COLORS[i % PK_COLORS.length]; } + + +// pkAccountColorMap 按 UID 稳定分配颜色:排序后分配,账号刷新/重排不会换色。 +function pkAccountColorMap(list) { + const uids = (list || []) + .filter(a => a && !a.error && a.uid) + .map(a => String(a.uid)) + .sort(); + const colors = new Map(); + uids.forEach((uid, i) => colors.set(uid, PK_ACCOUNT_COLORS[i % PK_ACCOUNT_COLORS.length])); + return colors; +} + +/* pkBySource 把包按名称归并,得到「来源 → 面额/余额/个数」。这是对比的关键视图: + 两个号的差异一定体现在某几个来源的面额上。 */ +function pkBySource(packs) { + const m = new Map(); + for (const p of packs) { + // 分组键用 code + name,而不是只 name:上游给「首登赠送」和普通活动包用了 + // **同一个 PackageName 和同一个 PackageCode**,只按 name 会把两类混成一类, + // 那正是当初「两个号为何差 1500」看不出来的原因。这里至少把 code 带进键里, + // 并在卡片上显示最早的发放时间。 + const k = (p.package_code || '') + '|' + (p.name || '(未命名)'); + const e = m.get(k) || { + key: k, name: p.name || '(未命名)', code: p.package_code || '', + n: 0, remain: 0, size: 0, used: 0, minEnd: '', minCreated: '', + }; + e.n += 1; + e.remain += Number(p.remain || 0); + e.size += Number(p.size || 0); + e.used += Number(p.used || 0); + const t = (p.end_time || '').slice(0, 10); + if (t && (!e.minEnd || t < e.minEnd)) e.minEnd = t; + const c = (p.created_at || '').slice(0, 10); + if (c && (!e.minCreated || c < e.minCreated)) e.minCreated = c; + m.set(k, e); + } + return [...m.values()].sort((a, b) => b.size - a.size); +} + +const PK_DAY_MS = 24 * 3600 * 1000; + +const PK_DEFAULT_DETAIL_LIMIT = 5; + +function pkDetailLimitValue(raw) { + const n = Number(raw); + return Number.isFinite(n) && n > 0 ? Math.floor(n) : PK_DEFAULT_DETAIL_LIMIT; +} + +function pkDetailLimit(cfg) { + return pkDetailLimitValue(cfg && cfg.panel && cfg.panel.package_detail_limit); +} + +// pkExpiryMs 包到期毫秒时间戳:到期分布(#59)与明细排序(#61)共用这一份。 +function pkExpiryMs(p) { + const raw = Number(p && p.expires_at); + if (Number.isFinite(raw) && raw > 0) return raw; + const text = String((p && p.end_time) || '').trim(); + if (!text) return null; + let iso = text.includes('T') ? text : text.replace(' ', 'T'); + if (!/(?:Z|[+-]\d\d:\d\d)$/.test(iso)) iso += '+08:00'; + const parsed = Date.parse(iso); + return Number.isFinite(parsed) ? parsed : null; +} + +function pkCreditOpacity(days) { + if (days == null || !Number.isFinite(Number(days))) return 1; + return 0.25 + 0.75 * Math.max(0, Math.min(29, Number(days) - 1)) / 29; +} + +function pkExpiryText(expiresAt) { + if (!expiresAt) return '无到期时间'; + const diff = expiresAt - Date.now(); + if (diff <= 0) return '已到期'; + const minutes = Math.max(1, Math.ceil(diff / 60000)); + if (minutes < 60) return '剩余 ' + minutes + ' 分钟'; + const hours = Math.ceil(diff / 3600000); + if (hours < 24) return '剩余 ' + hours + ' 小时'; + return '剩余 ' + Math.ceil(diff / PK_DAY_MS) + ' 天'; +} + +function pkExpiryDateTime(expiresAt) { + if (!expiresAt) return '—'; + return new Date(expiresAt).toLocaleString('zh-CN', { + timeZone: 'Asia/Shanghai', hour12: false, + year: 'numeric', month: '2-digit', day: '2-digit', + hour: '2-digit', minute: '2-digit', second: '2-digit', + }); +} + +function pkAccountSegments(a, now) { + let balance = Math.max(0, Number(a.remain || 0)); + const out = []; + for (const p of a.packages || []) { + const remain = Number(p.remain || 0); + if (!Number.isFinite(remain) || remain <= 0 || balance <= 0) continue; + const amount = Math.min(balance, remain); + const expiresAt = pkExpiryMs(p); + out.push({ + amount, + expiresAt, + days: expiresAt == null ? null : Math.max(0, Math.ceil((expiresAt - now) / PK_DAY_MS)), + source: p.name || '积分', + uid: String(a.uid || ''), + accountName: a.nickname || String(a.uid || '').slice(0, 8) || '未命名账号', + }); + balance -= amount; + } + return out.sort((x, y) => { + if (x.expiresAt == null && y.expiresAt != null) return 1; + if (x.expiresAt != null && y.expiresAt == null) return -1; + return (x.expiresAt || 0) - (y.expiresAt || 0); + }); +} + +// summarizeCreditDays 对齐 WorkDaddy:按精确剩余天数逐行聚合,无有效到期时间的余额 +// 不进入图表,也不猜测到期日。账号内先按总余额约束逐包金额,避免上游重复记录膨胀。 +function summarizeCreditDays(list, now) { + const buckets = new Map(); + let unavailable = 0; + for (const a of list || []) { + if (a.error || !Number.isFinite(Number(a.remain))) { + unavailable++; + continue; + } + for (const segment of pkAccountSegments(a, now)) { + if (segment.days == null) continue; + let row = buckets.get(segment.days); + if (!row) { + row = { days: segment.days, credits: 0, segments: [] }; + buckets.set(segment.days, row); + } + row.credits += segment.amount; + row.segments.push(segment); + } + } + const rows = [...buckets.values()].sort((a, b) => a.days - b.days); + for (const row of rows) { + row.segments.sort((a, b) => + (a.expiresAt || Infinity) - (b.expiresAt || Infinity) || + a.accountName.localeCompare(b.accountName) || + a.source.localeCompare(b.source)); + } + return { rows, accountCount: (list || []).length, unavailable }; +} + +function renderExpiryDistribution(list, now) { + const summary = summarizeCreditDays(list, now); + const colors = pkAccountColorMap(list); + const rows = summary.rows.map(row => { + const total = row.credits || 1; + const nodes = row.segments.map(segment => { + const color = colors.get(segment.uid) || 'var(--accent)'; + const title = segment.source + '\n' + fmtTok(segment.amount) + ' 积分\n到期时间 ' + + pkExpiryDateTime(segment.expiresAt) + '(' + pkExpiryText(segment.expiresAt) + ')\n' + + segment.accountName; + return ''; + }).join(''); + return '
' + esc(row.days === 0 ? '已到期' : row.days + ' 天') + + '
' + nodes + '
' + esc(fmtTok(row.credits)) + + '
'; + }).join(''); + const foot = summary.accountCount + ' 个账号' + + (summary.unavailable ? ' · ' + summary.unavailable + ' 个未获取余额' : ''); + const legend = (list || []).filter(a => + a && !a.error && a.uid && pkAccountSegments(a, now).some(s => s.days != null) + ).map(a => '' + esc(a.nickname || String(a.uid).slice(0, 8)) + '').join(''); + const hdr = '
剩余天数各账号该批剩余剩余积分
'; + $('pkExpiry').innerHTML = (rows + ? hdr + '
' + rows + '
' + : '
暂无可汇总积分
') + + (legend ? '
' + legend + '
' : '') + + '
' + esc(foot) + '
'; +} + +// pkDetailGroups 只服务单账号逐包明细:正余额包先按到期时间挑选默认展示项, +// 其余正余额包与已用完包分别折叠;同一到期时间按面额降序。 +function pkDetailCompare(a, b) { + const sizeOf = p => { + const n = Number(p && p.size); + return Number.isFinite(n) ? n : 0; + }; + const ea = pkExpiryMs(a), eb = pkExpiryMs(b); + if (ea == null && eb != null) return 1; + if (ea != null && eb == null) return -1; + if (ea != null && eb != null && ea !== eb) return ea - eb; + return sizeOf(b) - sizeOf(a); +} + +function pkDetailGroups(packs, limit) { + const active = [], used = []; + let usedSize = 0, restSize = 0, restRemain = 0; + for (const p of packs || []) { + const remain = Number(p && p.remain); + if (remain > 0) { + active.push(p); + continue; + } + used.push(p); + const size = Number(p && p.size); + if (Number.isFinite(size)) usedSize += size; + } + active.sort(pkDetailCompare); + used.sort(pkDetailCompare); + const visible = active.slice(0, pkDetailLimitValue(limit)); + const rest = active.slice(visible.length); + for (const p of rest) { + const size = Number(p && p.size); + if (Number.isFinite(size)) restSize += size; + const remain = Number(p && p.remain); + if (Number.isFinite(remain)) restRemain += remain; + } + return { visible, rest, used, restSize, restRemain, usedSize }; +} + +function renderPackages(d, detailLimit) { + const list = (d.accounts || []); + const now = Date.now(); + renderExpiryDistribution(list, now); + if (!list.length) { + $('pkSummary').innerHTML = '
没有账号
'; + return; + } + + // 包名 → 稳定色号(跨账号一致,方便肉眼对齐) + const names = []; + for (const a of list) for (const s of pkBySource(a.packages || [])) { + if (!names.includes(s.key)) names.push(s.key); + } + names.sort((x, y) => { + const sz = n => Math.max(...list.map(a => { + const f = pkBySource(a.packages || []).find(s => s.key === n); + return f ? f.size : 0; + })); + return sz(y) - sz(x); + }); + const colorOf = n => pkColor(names.indexOf(n)); + // 键 → 展示名,供卡片与明细表共用(同一来源必然同色同名)。 + const labelOf = {}; + for (const a of list) for (const s of pkBySource(a.packages || [])) labelOf[s.key] = s; + + const maxRemain = Math.max(1, ...list.map(a => Number(a.remain || 0))); + + $('pkSummary').innerHTML = list.map(a => { + if (a.error) { + return '
' + + esc((a.nickname || a.uid.slice(0, 8))) + '' + + '' + esc(a.realm || '') + '
' + + '
查询失败:' + esc(a.error) + '
'; + } + const srcs = pkBySource(a.packages || []); + const total = Math.max(1, Number(a.size || 0)); + const bar = srcs.map(s => + '' + ).join(''); + const legend = srcs.map(s => + '' + + esc(s.name.replace(/^CodeBuddy/, '')) + ' x' + s.n + ' · ' + fmtTok(s.size) + + (s.minCreated ? ' · 首发 ' + esc(s.minCreated.slice(5)) : '') + '' + ).join(''); + return '
' + + '
' + esc(a.nickname || a.uid.slice(0, 8)) + '' + + '' + esc(a.realm || '') + '
' + + '
' + fmtTok(a.remain) + '
' + + '
共 ' + fmtTok(a.size) + ' · ' + (a.packages || []).length + + ' 个包 · 占最高 ' + (Number(a.remain || 0) / maxRemain * 100).toFixed(0) + '%' + + (PLAN_LABELS[a.plan] ? ' · ' + PLAN_LABELS[a.plan] : '') + '
' + + '
' + bar + '
' + + '
' + legend + '
' + + '
'; + }).join(''); + + $('pkNote').textContent = list.length + ' 个账号 · 实时查询上游'; + + // 逐包明细:每个账号一个表,包的**面额**列是重点 + $('pkDetail').innerHTML = list.map(a => { + if (a.error) return ''; + const groups = pkDetailGroups(a.packages || [], detailLimit); + const rowOf = (p, rowGroup) => { + const k = (p.package_code || '') + '|' + (p.name || '(未命名)'); + const sub = (p.sub_product_code || '').replace(/^sp_tcaca_codebuddyide_?/, '') || + (p.package_code || '').replace(/^TCACA_/, ''); + return '' + + '' + esc(p.name || '(未命名)') + + (sub ? '
' + esc(sub) + '
' : '') + '' + + '' + fmtTok(p.size) + '' + + '' + fmtTok(p.remain) + '' + + '' + fmtTok(p.used) + '' + + '' + esc((p.created_at || '').slice(0, 16).replace('T', ' ') || '—') + '' + + '' + esc((p.end_time || '').slice(0, 10) || '—') + '' + + ''; + }; + const groupSummary = (group, label, count, size, remain) => + ''; + const rows = groups.visible.map(p => rowOf(p, '')).join(''); + const restSummary = groups.rest.length + ? groupSummary('rest', '其余未用完 ' + groups.rest.length + ' 个包(面额合计 ' + + fmtTok(groups.restSize) + ' · 剩余 ' + fmtTok(groups.restRemain) + ')', + groups.rest.length, groups.restSize, groups.restRemain) + + groups.rest.map(p => rowOf(p, 'rest')).join('') + : ''; + const usedSummary = groups.used.length + ? groupSummary('used', '已用完 ' + groups.used.length + ' 个包(面额合计 ' + + fmtTok(groups.usedSize) + ')', groups.used.length, groups.usedSize, 0) + + groups.used.map(p => rowOf(p, 'used')).join('') + : ''; + return '

' + + esc(a.nickname || a.uid.slice(0, 8)) + ' · ' + esc(a.realm || '') + + '

余额 ' + fmtTok(a.remain) + + ' / 总额 ' + fmtTok(a.size) + ' · 可用 ' + (groups.visible.length + groups.rest.length) + ' 个包' + + (groups.used.length ? ' / 已用完 ' + groups.used.length + ' 个' : '') + + ' · 默认展示最早到期 ' + pkDetailLimitValue(detailLimit) + ' 条' + + '
' + + '' + + '' + + '' + + '' + rows + restSummary + usedSummary + '
包名 / 来源面额剩余已用发放到期
'; + }).join(''); +} + +if ($('pkDetail')) $('pkDetail').addEventListener('click', ev => { + const btn = ev.target.closest('button[data-pk-group]'); + if (!btn) return; + const body = btn.closest('tbody'); + if (!body) return; + const group = btn.dataset.pkGroup; + const expanded = btn.getAttribute('aria-expanded') === 'true'; + body.querySelectorAll('tr[data-pk-row="' + group + '"]').forEach(row => { row.hidden = expanded; }); + const count = btn.dataset.count || '0'; + const size = btn.dataset.size || '0'; + const remain = btn.dataset.remain || '0'; + btn.setAttribute('aria-expanded', String(!expanded)); + if (group === 'rest') { + btn.textContent = expanded + ? '其余未用完 ' + count + ' 个包(面额合计 ' + fmtTok(size) + ' · 剩余 ' + + fmtTok(remain) + '),展开' + : '收起其余未用完 ' + count + ' 个包'; + } else { + btn.textContent = expanded + ? '已用完 ' + count + ' 个包(面额合计 ' + fmtTok(size) + '),展开' + : '收起已用完 ' + count + ' 个包'; + } +}); + +/* 到期提醒快照(零上游请求):吃 /overview 里已有的 credits_expiry_buckets —— + 由签到与余额后台刷新按自然日聚合后写进 state.json,随首页统计一起到。 + 此前快照只有「最早一批」,同一天多个包会被少算,扣穿第一批后整行消失; + 现在批次由后端聚合(date/expires_at/remain),与「积分构成」的逐包按日汇总同口径。 + + 旧 state(升级后尚未跑过一轮余额刷新,或 Redis 快照来自旧版本)没有 buckets, + 退回 credits_earliest_expiry / credits_earliest_remaining 只显示最早一批,保证卡片 + 不空白;下一轮刷新后自动变成完整视图。 + + 剩余天数按自然日算(不再对精确时间戳 ceil——后者会把明天/今天多算一天, + 日均需耗随之偏小)。默认只展开最近到期的 3 个账号,其余收纳。 */ +// expCSTDate 把时间戳格式化成 UTC+8 的自然日(YYYY-MM-DD)。上游到期字段与后端 +// credits_expiry_buckets.date 都是 +08 口径,前端不能拿浏览器本地时区去截日期。 +function expCSTDate(value) { + const d = value instanceof Date ? value : new Date(value); + if (isNaN(d.getTime())) return ''; + const parts = new Intl.DateTimeFormat('en-US', { + timeZone: 'Asia/Shanghai', year: 'numeric', month: '2-digit', day: '2-digit', + }).formatToParts(d); + const part = t => (parts.find(x => x.type === t) || {}).value || ''; + return part('year') + '-' + part('month') + '-' + part('day'); +} + +function expBucketList(a) { + const raw = Array.isArray(a && a.credits_expiry_buckets) ? a.credits_expiry_buckets : []; + const out = []; + for (const b of raw) { + const date = String((b && b.date) || '').slice(0, 10); + const remain = Number((b && b.remain) || 0); + if (date && remain > 0) out.push({ date, remain, estimated: !!(b && b.estimated) }); + } + if (out.length) { + out.sort((x, y) => (x.date < y.date ? -1 : x.date > y.date ? 1 : 0)); + return out; + } + // 旧 state 兜底:只有最早一批。 + const ms = a && a.credits_earliest_expiry ? new Date(a.credits_earliest_expiry).getTime() : NaN; + const remain = Number((a && a.credits_earliest_remaining) || 0); + if (Number.isFinite(ms) && remain > 0) { + return [{ date: expCSTDate(ms), remain }]; + } + return []; +} + +// expDayDiff 按 UTC+8 自然日算剩余天数:今天=0、明天=1。不拿精确时间戳 ceil—— +// 那会把明天/今天多算一天,日均需耗随之偏小(旧快照的口径问题)。 +function expDayDiff(dateStr) { + const ms = Date.parse(dateStr + 'T00:00:00+08:00'); + const base = Date.parse(expCSTDate(Date.now()) + 'T00:00:00+08:00'); + if (!Number.isFinite(ms) || !Number.isFinite(base)) return null; + return Math.round((ms - base) / PK_DAY_MS); +} + +function renderExpirySnapshot(d) { + const rows = []; + for (const a of (d && d.accounts) || []) { + const bs = expBucketList(a).filter(b => { + const days = expDayDiff(b.date); + return days !== null && days >= 0; + }); + if (!bs.length) continue; // 无未来批次(长期包/已清空)不入表 + rows.push({ a, bs }); + } + // 按最早到期日升序;同一天按昵称/uid 兜底,保证多次刷新顺序稳定。 + rows.sort((x, y) => { + if (x.bs[0].date !== y.bs[0].date) return x.bs[0].date < y.bs[0].date ? -1 : 1; + const ax = String(x.a.nickname || x.a.uid || ''); + const ay = String(y.a.nickname || y.a.uid || ''); + return ax < ay ? -1 : ax > ay ? 1 : 0; + }); + const EXP_HEAD = 3; // 默认只展开最近到期的 3 个账号,其余收纳成一行 + /* 「最近到期」这一格分两层(用户反馈:旧版日期 / 随后 N 批 / 7 天内合计 三行 + 同字号同颜色,主次分不出来): + 第一行 = 日期(加大加粗)+「(明天到期)」+「7 天内合计 N」, + 第二行 = 后续批次索引,只给日期与剩余量,弱化到 --ink-3 / 12px。 + 该批积分与日均需耗本来就有独立列,这里不再重复一遍;紧急性依旧只由 + 「距到期」列着色,不额外加色点。 */ + const rowOf = ({ a, bs }, hidden) => { + const first = bs[0]; + const days = expDayDiff(first.date); + const daily = Math.ceil(first.remain / Math.max(1, days)); + const week = bs.filter(b => expDayDiff(b.date) <= 7).reduce((s, b) => s + b.remain, 0); + const color = days <= 3 ? 'var(--bad)' : days <= 7 ? 'var(--warn)' : 'var(--ok)'; + const when = days === 0 ? '今天到期' : days === 1 ? '明天到期' : days + ' 天后到期'; + const head = '
' + + '' + esc(first.date) + '' + + '(' + when + ')' + + (week > first.remain ? '7 天内合计 ' + fmtTok(week) + '' : '') + + (first.estimated ? '按计量周期推算' : '') + + '
'; + const rest = bs.slice(1, 4).map(b => '随后 ' + esc(b.date.slice(5)) + ' · ' + + fmtTok(b.remain) + '').join(''); + const more = bs.length > 4 ? '等 ' + bs.length + ' 批' : ''; + return '' + + '' + esc(a.nickname || String(a.uid || '').slice(0, 8)) + '' + + '' + head + + (rest ? '
' + rest + more + '
' : '') + '' + + '' + + (days === 0 ? '今天' : days === 1 ? '明天' : days + ' 天') + '' + + '' + fmtTok(first.remain) + '' + + '' + fmtTok(daily) + '' + + ''; + }; + // 跨账号合计(issue #102):同一份快照、同样只算有未来批次的号,按 UTC+8 自然日 + // 累加「该日到期」。cn/global 的积分不同源,混用时按域分开合计——混加一行没有意义。 + const expRealm = a => (a.realm === 'global' ? 'global' : 'cn'); + const splitRealm = new Set(rows.map(r => expRealm(r.a))).size > 1; + const dayMap = new Map(); + for (const { a, bs } of rows) { + for (const b of bs) { + const key = (splitRealm ? expRealm(a) + '|' : '') + b.date; + let t = dayMap.get(key); + if (!t) dayMap.set(key, t = { date: b.date, realm: expRealm(a), remain: 0, uids: new Set() }); + t.remain += b.remain; + t.uids.add(String(a.uid || '')); // 同一账号同日多批只算一个号 + } + } + const dayTotals = [...dayMap.values()].sort((x, y) => + (x.date < y.date ? -1 : x.date > y.date ? 1 : 0) || (x.realm < y.realm ? -1 : 1)); + if ($('expTotalNote')) { + $('expTotalNote').textContent = dayTotals.length ? dayTotals.length + ' 个到期日' : '暂无'; + } + $('expTotalBody').innerHTML = dayTotals.map(t => { + const days = expDayDiff(t.date); + return '' + esc(t.date) + + (splitRealm ? ' ' + (t.realm === 'global' ? '国际版' : '国内版') + '' : '') + + '' + + '' + + (days === 0 ? '今天' : days === 1 ? '明天' : days + ' 天') + '' + + '' + fmtTok(t.remain) + '' + + '' + t.uids.size + ''; + }).join(''); + // 收纳行沿用「积分构成」页的分组行样式(pk-group-summary / pk-group-toggle)。 + const rest = rows.slice(EXP_HEAD); + $('expBody').innerHTML = !rows.length ? '暂无未来到期批次' + : rows.slice(0, EXP_HEAD).map(r => rowOf(r, false)).join('') + + (rest.length ? '' + + '' + + rest.map(r => rowOf(r, true)).join('') : ''); + // 重建 tbody 后恢复用户上次的展开选择(否则下一轮 5s 轮询会把展开收回)。 + applyRestToggle($('expBody'), restOpen.expBody); + // 数据节奏透明化:界面 5 秒轮询,但卡片只随余额后台刷新更新(默认每 5 分钟)。 + const iv = Number(d && d.balance_refresh_sec) || 0; + const at = d && d.balance_refreshed_at ? new Date(d.balance_refreshed_at).getTime() : 0; + let cadence = '未开启后台刷新'; + if (iv > 0) { + cadence = '每 ' + (iv % 60 === 0 ? iv / 60 + ' 分钟' : iv + ' 秒') + '后台刷新'; + if (Number.isFinite(at) && at > 0) { + const min = Math.floor((Date.now() - at) / 60000); + cadence += ',' + (min < 1 ? '刚刚更新' : min + ' 分钟前更新'); + } + } + $('expNote').textContent = rows.length + ? rows.length + ' 个账号有未到期批次 · ' + cadence + ' · 明细见「积分构成」' + : '暂无未来到期批次'; +} + +// 按 restOpen 把指定 tbody 的收纳行落到「展开/收起」状态。渲染重建 innerHTML 后必须调用一次, +// 否则用户上一次的展开选择会丢(5s 轮询每次都会重建)。 +function applyRestToggle(body, expanded) { + if (!body) return; + const btn = body.querySelector('button[data-exp-rest]'); + if (!btn) return; + body.querySelectorAll('tr[data-exp-row="rest"]').forEach(row => { row.hidden = !expanded; }); + btn.setAttribute('aria-expanded', String(!!expanded)); + btn.textContent = (expanded ? '收起其余 ' : '其余 ') + btn.dataset.expRest + ' 个账号' + + (expanded ? '' : ',展开'); +} + +// 收纳行展开/收起(与「积分构成」页 pkDetail 同款:查 data 行 + aria-expanded + 改按钮文案)。 +// 监听挂在 tbody 上(渲染替换 innerHTML 不会丢);到期提醒用本函数。 +// 用户选择写进 restOpen,渲染函数重建 tbody 后调 applyRestToggle 恢复。 +function bindRestToggle(id) { + const body = $(id); + if (!body) return; + body.addEventListener('click', ev => { + const btn = ev.target.closest('button[data-exp-rest]'); + if (!btn) return; + const next = btn.getAttribute('aria-expanded') !== 'true'; + restOpen[id] = next; + applyRestToggle(body, next); + }); +} +bindRestToggle('expBody'); + +/* ── 精简 QR 编码器(券码 + 登录授权链接用)──────────────────────────── + 规格子集:byte 模式、ECC L、版本 1-6(v6 两块相等,需交织)、固定掩码 0。 + 完整性:规范允许任选掩码(解码器按格式信息位自行去掩码),固定掩码不影响 + 可扫描性;已用 python qrcode 库对多输入多版本做逐像素交叉验证 + (强制 byte 模式 + mask 0,5/5 全部 diff=0)。面板 CSP 只允许 self,外链 QR 服务不可用。 */ +// GF(256) 对数/指数表(本原多项式 0x11d) +const QR_EXP = new Array(512), QR_LOG = new Array(256); +(() => { + let x = 1; + for (let i = 0; i < 255; i++) { QR_EXP[i] = x; QR_LOG[x] = i; x <<= 1; if (x & 0x100) x ^= 0x11d; } + for (let i = 255; i < 512; i++) QR_EXP[i] = QR_EXP[i - 255]; +})(); +const gmul = (a, b) => (a && b) ? QR_EXP[QR_LOG[a] + QR_LOG[b]] : 0; + +// 各版本参数(下标 = 版本-1):[数据码字总数, 每块纠错码字数, 块数],ECC L。 +// v1-5 单块(免交织);v6 两块相等各 68 数据字。授权链接约 108 字节,v5 上限 106 +// 差两个字节,正好卡在版本边界上,所以必须补 v6。 +const QR_V = [[19, 7, 1], [34, 10, 1], [55, 15, 1], [80, 20, 1], [108, 26, 1], [136, 18, 2]]; +// 对齐图案中心坐标(v2+;与定位图案重叠的位置在放置时跳过) +const QR_ALIGN = [[], [6, 18], [6, 22], [6, 26], [6, 30], [6, 34]]; +const QR_MASK = (r, c) => (r + c) % 2 === 0; // 掩码模式 0 + +// 生成多项式(最高次系数在前,g[0] 恒为 1) +function qrGenPoly(deg) { + let g = [1]; + for (let i = 0; i < deg; i++) { + const a = QR_EXP[i], ng = new Array(g.length + 1).fill(0); + ng[0] = g[0]; + for (let j = 1; j < g.length; j++) ng[j] = g[j] ^ gmul(a, g[j - 1]); + ng[g.length] = gmul(a, g[g.length - 1]); + g = ng; + } + return g; +} + +// Reed-Solomon 求余(综合除法),返回 deg 个纠错码字 +function rsRem(data, deg) { + const g = qrGenPoly(deg); + const res = data.concat(new Array(deg).fill(0)); + for (let i = 0; i < data.length; i++) { + const f = res[i]; + if (f) for (let j = 0; j < g.length; j++) res[i + j] ^= gmul(g[j], f); + } + return res.slice(data.length); +} + +// 文本 → 码字流(byte 模式:0100 + 8 位计数 + 数据 + 终止符 + 0xEC/0x11 填充) +function qrDataCodewords(text, dataCap) { + const bytes = Array.from(new TextEncoder().encode(text)); + const bits = []; + const push = (val, n) => { for (let i = n - 1; i >= 0; i--) bits.push((val >> i) & 1); }; + push(4, 4); // byte 模式 + push(bytes.length, 8); // v1-9 计数 8 位 + for (const b of bytes) push(b, 8); + const cap = dataCap * 8; + push(0, Math.min(4, cap - bits.length)); // 终止符 + while (bits.length % 8) bits.push(0); + const out = []; + for (let i = 0; i < bits.length; i += 8) { + let v = 0; for (const b of bits.slice(i, i + 8)) v = (v << 1) | b; + out.push(v); + } + for (let p = 0; out.length < dataCap; p ^= 1) out.push(p ? 0x11 : 0xEC); + return out; +} + +// 主入口:text → 布尔矩阵(true=深色模块) +function qrMatrix(text) { + const bytes = Array.from(new TextEncoder().encode(text)); + // 版本选择:需求 ≈ 2 码字头 + 文本长度,取首个放得下的版本 + let ver = 0; + for (let v = 0; v < QR_V.length; v++) { if (bytes.length + 2 <= QR_V[v][0]) { ver = v + 1; break; } } + if (!ver) throw new Error('QR: text too long (>' + (QR_V[QR_V.length - 1][0] - 2) + ' bytes)'); + const [dataCap, ecCap, nblk] = QR_V[ver - 1]; + const n = 17 + 4 * ver; + + const M = Array.from({ length: n }, () => new Array(n).fill(false)); + const F = Array.from({ length: n }, () => new Array(n).fill(false)); // 功能模块占位 + + const setF = (r, c, v) => { M[r][c] = v; F[r][c] = true; }; + // 定位图案 + 分隔带 + const finder = (r0, c0) => { + for (let r = -1; r <= 7; r++) for (let c = -1; c <= 7; c++) { + const rr = r0 + r, cc = c0 + c; + if (rr < 0 || cc < 0 || rr >= n || cc >= n) continue; + const dark = r >= 0 && r <= 6 && c >= 0 && c <= 6 && (r === 0 || r === 6 || c === 0 || c === 6 || (r >= 2 && r <= 4 && c >= 2 && c <= 4)); + setF(rr, cc, dark); + } + }; + finder(0, 0); finder(0, n - 7); finder(n - 7, 0); + // 校正图形(仅贯穿两定位图案之间:8..n-9,不得覆盖定位图案本体) + for (let r = 8; r <= n - 9; r++) setF(r, 6, r % 2 === 0); + for (let c = 8; c <= n - 9; c++) setF(6, c, c % 2 === 0); + // 对齐图案(v2+,跳过与定位重叠处) + const align = QR_ALIGN[ver - 1] || []; + for (const ar of align) for (const ac of align) { + if (F[ar][ac]) continue; + for (let r = -2; r <= 2; r++) for (let c = -2; c <= 2; c++) + setF(ar + r, ac + c, Math.max(Math.abs(r), Math.abs(c)) !== 1); + } + // 暗模块 + 格式信息(ECC L=01,掩码 0)——BCH(15,5) + 0x5412 异或。 + // 位序遵循规范(与 python qrcode 逐位对齐验证):bit i 从 LSB 起数, + // 副本一走左上角 L 形、副本二走右下 L 形。 + let fmt = (1 << 3) | 0; // L<<3 | mask + let rem = fmt << 10; + for (let i = 14; i >= 10; i--) if ((rem >> i) & 1) rem ^= 0x537 << (i - 10); + fmt = ((fmt << 10) | rem) ^ 0x5412; // 15 位 + const fb = i => (fmt >> i) & 1; + // 副本一(左上):位 0..5 → (i,8);6 → (7,8);7 → (8,8) + for (let i = 0; i <= 5; i++) setF(i, 8, !!fb(i)); + setF(7, 8, !!fb(6)); setF(8, 8, !!fb(7)); + // 副本一续 + 副本二(右下):位 8..14 → (n-15+i, 8);位 0..7 → (8, n-1-i);8 → (8,7);9..14 → (8,14-i) + for (let i = 8; i <= 14; i++) setF(n - 15 + i, 8, !!fb(i)); + for (let i = 0; i <= 7; i++) setF(8, n - 1 - i, !!fb(i)); + setF(8, 7, !!fb(8)); + for (let i = 9; i <= 14; i++) setF(8, 14 - i, !!fb(i)); + // 暗模块(恒为深色,位于副本一垂直段末端) + setF(n - 8, 8, true); + + // 数据码字 + 纠错码字 → 位流 + const dcw = qrDataCodewords(text, dataCap); + // 分块独立算纠错,再按规范交织:先逐列取数据字,再逐列取纠错字(单块时即原顺序) + const per = dataCap / nblk; + const blk = Array.from({ length: nblk }, (_, i) => dcw.slice(i * per, (i + 1) * per)); + const ecs = blk.map(b => rsRem(b, ecCap)); + const cw = []; + for (let i = 0; i < per; i++) for (const b of blk) cw.push(b[i]); + for (let i = 0; i < ecCap; i++) for (const e of ecs) cw.push(e[i]); + const bits = []; + for (const b of cw) for (let i = 7; i >= 0; i--) bits.push((b >> i) & 1); + + // 蛇形放置(成对列,从右向左,跳过第 6 列),写数据时直接异或掩码 + let bi = 0, up = true; + for (let x = n - 1; x > 0; x -= 2) { + if (x === 6) x--; + for (let i = 0; i < n; i++) { + const r = up ? n - 1 - i : i; + for (const c of [x, x - 1]) { + if (F[r][c]) continue; + const bit = bi < bits.length ? bits[bi++] : 0; + M[r][c] = bit ? !QR_MASK(r, c) : QR_MASK(r, c); + } + } + up = !up; + } + return M; +} + +// 矩阵 → SVG(quiet zone 4 模块) +function qrSVG(M, px) { + const n = M.length, q = 4, total = n + q * 2; + let s = ''; + for (let r = 0; r < n; r++) for (let c = 0; c < n; c++) + if (M[r][c]) s += ''; + return s + ''; +} + +/* ── 开学季券码查询(弹窗,仿活动页 #/prizes?tab=vouchers)──────────── */ +/* copyText:clipboard API 只在 secure context(https/localhost)可用, + 远程 http 面板会拿不到 navigator.clipboard → 降级 execCommand。 */ +function copyText(text) { + if (navigator.clipboard && window.isSecureContext) return navigator.clipboard.writeText(text); + return new Promise((resolve, reject) => { + const ta = document.createElement('textarea'); + ta.value = text; + ta.style.cssText = 'position:fixed;opacity:0'; + document.body.appendChild(ta); + ta.select(); + try { document.execCommand('copy') ? resolve() : reject(new Error('copy failed')); } + catch (e) { reject(e); } + finally { ta.remove(); } + }); +} + +function vcCard(v) { + const expired = v.valid_to && new Date(v.valid_to) < new Date(); + return '
' + + '
' + esc(v.prize_name || v.sku_code || '券') + '' + + (expired ? '已过期' : '可使用') + '
' + + '
' + + (v.valid_to ? '有效期至 ' + esc(v.valid_to) : '长期有效') + + (v.granted_at ? ' · ' + esc(v.granted_at.slice(0, 10)) + ' 抽中' : '') + + '
' + + '
' + + '
券码' + esc(v.code || '-') + '' + + '' + + (v.code ? '' : '') + + '' + + '
' + + '
'; +} + +async function loadSchoolVouchers() { + const body = $('vcBody'); + $('vcVeil').classList.add('on'); + body.innerHTML = '
查询中
'; + $('vcNote').textContent = ''; + try { + const d = await api('school/vouchers'); + const arr = d.accounts || []; + const ok = arr.filter(a => !a.error); + const total = ok.reduce((n, a) => n + (a.vouchers || []).length, 0); + body.innerHTML = ok.filter(a => (a.vouchers || []).length).map(a => + '
' + esc(a.nickname || a.uid) + '' + + '' + a.vouchers.length + ' 张
' + + a.vouchers.map(vcCard).join('') + ).join('') || '
🎟️
还没有抽到券
'; + $('vcNote').textContent = total ? total + ' 张券 · ' + ok.filter(a => !(a.vouchers || []).length).length + ' 个账号未抽中' : ''; + const errs = arr.filter(a => a.error); + if (errs.length) { + body.insertAdjacentHTML('beforeend', '
查询失败:' + + errs.map(a => esc(a.nickname || a.uid.slice(0, 8)) + '(' + esc(a.error) + ')').join('、') + '
'); + } + body.querySelectorAll('button[data-copy]').forEach(b => b.onclick = async () => { + try { await copyText(b.dataset.copy); toast('券码已复制', 'ok'); } + catch (e) { toast('复制失败,请手动选择券码', 'err'); } + }); + // 二维码:券码本体编码为 QR(到店出示扫描),点击切换显示/隐藏 + body.querySelectorAll('button[data-qr]').forEach(b => b.onclick = () => { + const card = b.closest('.vc'); + const old = card.querySelector('.vc-qr'); + if (old) { old.remove(); return; } + const box = document.createElement('div'); + box.className = 'vc-qr'; + try { box.innerHTML = qrSVG(qrMatrix(b.dataset.qr), 148); } + catch (e) { box.innerHTML = '二维码生成失败:' + esc(e.message) + ''; } + card.appendChild(box); + }); + } catch (e) { + body.innerHTML = '
' + esc(e.message) + '
'; + } +} + +// 按需拉取(移植上游 8391a05):packages 是**逐账号实时查上游**,切进本视图就打一次, +// 账号一多既慢又压上游。有缓存先直接渲染(标注数据年龄),只有首次进入或显式刷新生效。 +let lastPackages = null, lastPackagesAt = 0, lastPkLimit = 0; + +// invalidatePackages 账号/凭据/余额变更后作废积分构成与到期明细缓存。 +// 缓存没有 TTL,不加这一处会把旧 401 行一直顶到用户手点刷新——重新登录后 +// 「点检查还是 401」的观感就是这么来的。 +function invalidatePackages() { lastPackages = null; lastPackagesAt = 0; } + +async function loadPackages(force) { + if (!force && lastPackages) { + renderPackages(lastPackages, lastPkLimit); + const ageMin = Math.floor((Date.now() - lastPackagesAt) / 60000); + if (ageMin > 0) $('pkNote').textContent = lastPackages.accounts.length + ' 个账号 · ' + ageMin + ' 分钟前的数据,点「刷新」更新'; + return; + } + $('pkSummary').innerHTML = '
查询中…(逐账号向上游实时查询)
'; + $('pkDetail').innerHTML = ''; + $('pkExpiry').innerHTML = '
查询中…
'; + try { + const [d, c] = await Promise.all([ + api('packages'), + api('config').catch(() => null), + ]); + lastPackages = d; + lastPackagesAt = Date.now(); + lastPkLimit = pkDetailLimit(c && c.config); + renderPackages(d, lastPkLimit); + } catch (e) { + $('pkSummary').innerHTML = '
读取失败:' + esc(e.message) + '
'; + $('pkExpiry').innerHTML = '
读取失败:' + esc(e.message) + '
'; + } +} + +// 「刷新」始终实时查:必须显式 force —— 直接 `onclick = loadPackages` 会把事件对象当真值传进去,恒等于强刷。 +if ($('btnPk')) $('btnPk').onclick = () => loadPackages(true); + +/* ══ 账号备注(只写本机 localStorage;账号池 / 用量两个视图共用同一份映射)══════ + 键取 uid 前 8 位——与 renderUsageDim 账号维度的 key 和积分扣除表的 uid 前缀同源, + 三个表格因此都能直接 join。展示层只替换文本并挂 .rm-ghost 虚体,账号标识本身 + 仍由服务端下发,不写回后端;备注是纯展示层信息,不参与选号 / 计费 / 鉴权。 */ +function remarksAll() { + if (remarksCache) return remarksCache; + try { remarksCache = JSON.parse(localStorage.getItem(LS_REMARKS)) || {}; } + catch (e) { remarksCache = {}; } + return remarksCache; +} +function remarkKey(uid) { return String(uid == null ? '' : uid).slice(0, 8); } +function remarkOf(uid) { + const k = remarkKey(uid); + return k ? String(remarksAll()[k] || '') : ''; +} +/* nameHtml 必须是已转义的 HTML;有备注时返回「备注 + 原标识(浅色虚体)」 */ +function remarkName(uid, nameHtml) { + const r = remarkOf(uid); + return r ? esc(r) + '' + nameHtml + '' : nameHtml; +} +// 返回是否真的落盘:localStorage 在隐私模式/配额满时会抛,吞掉就等于「界面说保存了、 +// 刷新后全没了」。调用方必须把 false 报出去。 +function storeRemarks(map) { + remarksCache = map; + try { localStorage.setItem(LS_REMARKS, JSON.stringify(map)); return true; } catch (e) { return false; } +} + +/* 编辑器的行来自 overview 缓存(账号池加载过就有),另外补上「已有备注但当前列表里 + 没有」的键,避免账号被移除后备注看起来凭空消失。 */ +function remarkFormRows() { + // key = uid 前 8 位(备注映射的键);uid 保留全值,分组要打真接口按完整 uid 走; + // inPool=false 的行是「账号已不在池里、但本机还留着备注」的孤儿,只能改备注。 + const rows = ((overviewData && overviewData.accounts) || []) + .map(s => ({ key: remarkKey(s.uid), uid: s.uid, who: s.nickname || remarkKey(s.uid), group: s.group || '', inPool: true })) + .filter(r => r.key); + for (const k of Object.keys(remarksAll())) { + if (!rows.some(r => r.key === k)) rows.push({ key: k, uid: '', who: k, group: '', inPool: false }); + } + return rows; +} + +/* 分组编辑的原始值(保存时只提交真正改动过的行,避免「保存备注」顺手把几十个账号 + 的分组各打一次接口)。 */ +let remarkGroupOrig = {}; +/* onlyUID 非空时只渲染该账号一行(账号池行内「备注」按钮走这条),避免为改一个号 + 在几十行里翻找。 */ +function renderRemarkBody(onlyUID) { + const box = $('remarkBody'); + if (!box) return; + let rows = remarkFormRows(); + if (onlyUID) { + const k = remarkKey(onlyUID); + rows = rows.filter(r => r.key === k); + } + remarkGroupOrig = {}; + rows.forEach(r => { if (r.inPool) remarkGroupOrig[r.uid] = r.group; }); + box.innerHTML = rows.length + ? rows.map(r => '
' + esc(r.who) + '' + + '' + + (r.inPool + ? '' + : '') + + '
').join('') + : '
暂无账号:先在「账号池」加载一次账号列表。
'; +} +function openRemarks(onlyUID) { + renderRemarkBody(typeof onlyUID === 'string' ? onlyUID : ''); + if ($('remarkVeil')) $('remarkVeil').classList.add('on'); +} +function closeRemarks() { if ($('remarkVeil')) $('remarkVeil').classList.remove('on'); } +async function saveRemarkForm() { + // 在现有映射上合并:单账号编辑器里只有一行,整体替换会把其它号的备注全清掉。 + const map = Object.assign({}, remarksAll()); + document.querySelectorAll('#remarkBody input[data-uid]').forEach(inp => { + const k = inp.getAttribute('data-uid'), v = inp.value.trim(); + if (v) map[k] = v; + else delete map[k]; + }); + const saved = storeRemarks(map); + // 分组是服务端字段:只提交真正改动过的行,其余账号不发请求。 + const changed = []; + document.querySelectorAll('#remarkBody input[data-guid]').forEach(inp => { + const uid = inp.getAttribute('data-guid'), v = inp.value.trim(); + if ((remarkGroupOrig[uid] || '') !== v) changed.push([uid, v]); + }); + closeRemarks(); + let ok = 0; + const bad = []; + for (const [uid, group] of changed) { + try { await api('accounts/' + encodeURIComponent(uid) + '/group', { method: 'POST', body: JSON.stringify({ group }) }); ok++; } + catch (e) { bad.push(uid.slice(0, 8) + ':' + e.message); } + } + if (view === 'accounts') loadOverview(true); + else if (view === 'usage' && usageData) renderUsage(usageData); + if (changed.length) { + const head = bad.length + ? '分组已更新 ' + ok + ' 个,失败 ' + bad.length + ' 个(' + bad[0] + ')' + : '分组已更新 ' + ok + ' 个'; + toast(head + (saved ? '' : ';备注未能写入浏览器存储(隐私模式或空间已满),刷新后会丢失'), bad.length || !saved ? 'err' : 'ok'); + } else { + toast(saved ? '备注已保存(仅本机浏览器)' : '备注未能写入浏览器存储(隐私模式或空间已满),刷新后会丢失', saved ? '' : 'err'); + } +} +if ($('btnRemarks')) $('btnRemarks').onclick = () => openRemarks(''); +if ($('btnRemarkClose')) $('btnRemarkClose').onclick = closeRemarks; +if ($('btnRemarkClear')) $('btnRemarkClear').onclick = () => { + if (!storeRemarks({})) toast('清空未能写入浏览器存储,刷新后备注会回来', 'err'); + renderRemarkBody(); +}; +if ($('btnRemarkSave')) $('btnRemarkSave').onclick = saveRemarkForm; + +/* 账号身份色板(8 槽)。槽位 0 = var(--accent)(**主题主色**,浅色主题下 + 自动跟随;刻意保留,因为它承载的是"第一条线=当前主题强调色"的既有语义, + 不是与状态语义撞车),槽位 1~7 走 CSS 变量 --bh-1..--bh-7,两套主题各一份。 + + ── 各槽色相与选它的理由(色相为实测值) ────────────────────────── + 槽0 227° var(--accent) 主题主色,非新增取舍 + 槽1 58° 黄 语义色的 38°(warn) 与 154°(ok) 之间唯一能放的点 + 槽2 96° 黄绿 离三语义色都远(≥46°),最"安全"的槽位 + 槽3 135° 绿 在 warn/ok 之间的另一侧,与 58° 相距 77° + 槽4 191° 青 冷色区,与 accent(227°) 相距 36° + 槽5 247° 蓝紫 与 accent 相距 19°,靠明度/饱和度区分(见下) + 槽6 295° 品红 远离所有语义色(≥66°) + 槽7 343° 玫红 与 bad(2.6°) 相距 20°,靠低饱和暖粉区分 + 相邻间距:77/40/42/42/42/42/40 度(槽1→槽7 内部链),最小 40°。 + + ── 为何避开语义色 ──────────────────────────────────────────────── + 绿/红/黄已被状态语义占用(--ok 可用 / --bad 失败 / --warn 限流告警)。 + 账号身份色若与它们同色相,同一颜色就有两个互斥含义("某账号" vs "状态"), + 读者必然误读 —— 这是 §十一"一个视觉通道只承载一种含义"的直接推论。 + 故 1~7 槽都把色相放在距 warn/ok/bad 至少 20° 的位置(浅色主题下 + warn 37°、ok 155°、bad 3°,均已核验)。 + + ⚠️ 这里有一个**已实测的取舍**,勿轻改:要求「8 色 + 相邻相差距 ≥40° + + 同时避开 全部 4 个语义色(含 accent) ±20°」三者**数学上不可同时成立** —— + 4 个禁区共占 160°,而 8 槽相邻 ≥40° 需要 320° 的弧,160+320 > 360。 + 穷举求解证实:若同时避开 accent,最大可实现的相邻最小间距只有 38.5°。 + 因此本色板选择:**槽位 0 复用 accent(不视为撞车)**,1~7 槽避开 warn/ok/bad + 且相邻间距 ≥40°。槽 5(247°) 与 accent 相距仅 19° 是这一取舍的唯一代价 —— + 它靠**明显不同的明度/饱和度**(accent 是高饱和靛蓝、槽5 是亮紫)来区分, + 这是 20° 色相判据之外的第二条判据,符合任务"或明度/饱和度明显不同"的允许。 + + ── 两套主题(硬编码 hex 必须两套,见 index.html) ──────────────── + 对比度实测(深底 #14171f / 浅底 #ffffff,WCAG 对比度): + 槽1 13.3/4.6 槽2 14.1/4.5 槽3 13.5/4.5 槽4 11.8/4.5 + 槽5 6.4/11.8 槽6 7.1/5.9 槽7 6.7/6.4 槽0(var(--accent)) 4.9/5.4 + 全部达到非文本对比度 3:1 的要求,且多数 ≥4.5:1。 */ +const BH_COLORS = [ + 'var(--accent)', 'var(--bh-1)', 'var(--bh-2)', 'var(--bh-3)', + 'var(--bh-4)', 'var(--bh-5)', 'var(--bh-6)', 'var(--bh-7)', +]; +/* 域元数据:cn = 国内(CodeBuddy),global = 国际(WorkBuddy)。 + 两域的积分不同源、不可互换(连上游 base 与模型目录都不同), + 因此**跨域求和语义不成立** —— 余额趋势与模型页都必须分域展示, + 不做"国内 + 国际"的全局总计。 */ +const BH_REALMS = [ + { key: 'cn', label: '国内' }, + { key: 'global', label: '国际' }, +]; +/* bhRealm 当前选中的域。null = 尚未初始化(首次加载时按数据自动选一个非空域)。 */ +let bhRealm = null; +/* realmOf 归一化账号域:空/未知归入 'other'(不静默丢弃,让它可见)。 */ +function realmOf(s) { + const r = (s && s.realm) || ''; + return r === 'cn' || r === 'global' ? r : 'other'; +} +/* pickRealm 选择默认域:优先记住的选择,其次第一个有数据的已知域。 */ +function pickRealm(rows) { + const have = {}; + rows.forEach(s => { have[realmOf(s)] = true; }); + const remembered = (function () { + try { return localStorage.getItem('bhRealm'); } catch (e) { return null; } + })(); + if (remembered && have[remembered]) return remembered; + const first = BH_REALMS.find(r => have[r.key]); + if (first) return first.key; + return have.other ? 'other' : (BH_REALMS[0] && BH_REALMS[0].key) || 'cn'; +} +/* filterRealm 取当前域的账号行。 */ +function filterRealm(rows, realm) { + return rows.filter(s => realmOf(s) === realm); +} +/* renderBalanceChart 画多账号余额折线。 + x 轴按**真实时间比例**排布(30 分钟等间隔),而非数据序号等距—— + 因为"什么时候到账/掉分"本身就是这张图要回答的问题。 */ +function renderBalanceChart(series) { + const host = $('bhChart'); + const rows = (series || []).filter(s => (s.points || []).length >= 1); + if (!rows.length) { + host.innerHTML = '
暂无余额采样。服务每 30 分钟自动记录一点,' + + '余额刷新后即出现(也可点上方「刷新」立即采样一次)。
'; + return; + } + let t0 = Infinity, t1 = -Infinity, lo = Infinity, hi = -Infinity; + rows.forEach(s => s.points.forEach(p => { + const t = Number(p.t) * 1000; + if (t < t0) t0 = t; + if (t > t1) t1 = t; + const c = Number(p.c); + if (c < lo) lo = c; + if (c > hi) hi = c; + })); + if (t1 <= t0) t1 = t0 + 1; // 单点:给最小跨度,避免除零 + if (hi <= lo) hi = lo + 1; // 水平线:撑开一点,否则贴边 + // y 轴下界(20260918 用户反馈"丑"的真实根因)。 + // + // 现象:坐标轴 1854~7499,但两条线都在 2400 以上 —— 底部一大片空白。 + // 根因:`lo = Math.max(0, lo - pad)` 把下界夹到 0。夹 0 本身是对的 + // (§十:余额非负,不能画负刻度),但代价是最低值离 0 很远时底部全空。 + // + // 关键区分(我一开始诊断错了):所谓"中间空档"实测只有 440/7833 = 5.6%, + // 不是问题;真正的浪费是 0 ~ 最低值 这段(30.6%)。 + // + // 修法:下界取 max(0, 最低值-留白),仅当最低值本身贴近 0(< 轴高 15%)时 + // 才贴 0(那时更符合"余额从 0 起"的直觉)。 + // 不违反 §十:下界仍是真实值域下沿,轴标签是真余额,不产出不可能的刻度。 + const pad = (hi - lo) * 0.12; + const rawLo = Math.max(0, lo - pad); + const dataLo = lo; + hi += pad; + const AXIS_ZERO_SNAP = 0.15; + lo = (dataLo <= (hi - rawLo) * AXIS_ZERO_SNAP) ? 0 : rawLo; + + // 坐标系 1:1:W 取容器实际宽度,文字/线宽不再被 CSS 缩放(见 measureWidth 注释)。 + const W = measureWidth(host), H = 200, PL = 52, PR = 12, PT = 12, PB = 26; + const iw = W - PL - PR, ih = H - PT - PB; + const X = t => PL + iw * ((t - t0) / (t1 - t0)); + // Y 映射:单段线性(不压缩空档 —— 实测空档仅 5.6%,压缩反而放大它)。 + const Y = c => PT + ih - ih * ((c - lo) / (hi - lo)); + let out = ''; + for (let i = 0; i <= 4; i++) { // y 轴 4 档刻度 + const v = lo + (hi - lo) * i / 4; + const y = Y(v); + out += ''; + out += '' + + fmtNum(Math.round(v)) + ''; + } + out += ''; + + // 轴不从 0 起时**必须显式标注**(§十一:口径不标注会被误读)。 + // 不标的话,读者会把"两线贴得很近/很远"按 0 基线理解,从而**高估相对差距**。 + // 这里画一个标准的"截断轴"符号(轴左下两道斜杠)+ 文字说明。 + if (lo > 0) { + const yb = PT + ih; + out += ''; + out += '轴不从 0 起'; + } + + const spanDays = (t1 - t0) / 86400000; // x 轴标签:首/中/末三点 + const fmtT = t => { + const d = new Date(t); + const mm = String(d.getMonth() + 1).padStart(2, '0'); + const dd = String(d.getDate()).padStart(2, '0'); + if (spanDays <= 2) return mm + '-' + dd + ' ' + String(d.getHours()).padStart(2, '0') + ':00'; + return mm + '-' + dd; + }; + // x 轴刻度:与下方「每日变化」图**用同一套刻度密度**(都按天数 / 10 取整)。 + // 为什么必须一致(设计心理学 · 格式塔相似律):两张图上下排列、共享同一个时间窗, + // 读者想回答「10-15 那根大绿柱对应上图的哪一段」时靠的是纵向对齐刻度; + // 旧实现上图固定 3 点、下图按天算 8 点,两张图刻度错位,无法对照。 + const tickCount = Math.max(2, Math.min(10, Math.ceil(spanDays / 3) + 1)); + for (let i = 0; i < tickCount; i++) { + const t = t0 + (t1 - t0) * (tickCount === 1 ? 0 : i / (tickCount - 1)); + out += '' + esc(fmtT(t)) + ''; + } + + // 色板序号只按**健康系列**推进:失效号用灰线但不占号,避免健康号换色。 + let liveIdx = 0; + rows.forEach((s, si) => { + const dead = bhIsDead(s); + const color = bhColorOf(s.uid, dead ? 0 : liveIdx++, dead); + const pts = s.points.map(p => ({ x: X(Number(p.t) * 1000), y: Y(Number(p.c)), c: Number(p.c), t: Number(p.t) * 1000, g: p.d })); + // 平滑 (monotone,不过冲 —— 见 smoothPath 注释)+ 统一线宽/线帽。 + // 线宽按**本图系列数**取档,两处折线共用同一函数,风格不会各走各的。 + out += ''; + // 点标记:**只标"显著变化"**,不是每个点都画圈。 + // + // 为何改(20260918 用户反馈"丑"):原先 delta !== 0 就画圈,151 个采样点 + // × 2 账号 ≈ 300 个绿/红圆点。折线本身已表达趋势,圆点是**重复编码**; + // 而鲜艳小圆点是人眼**前注意加工**最易捕捉的特征 —— 结果注意力被 300 个点 + // 抓走,反而看不见"线"(想看的趋势)。且相邻点间距 ~7px、圆点直径 6px, + // 已经糊成一条花带,退化为噪音。 + // + // 阈值取该账号**自身跨度**的 3%(而非固定值):水位 4000 的号与 400 的号, + // "显著"的绝对量不同,用相对值才等价可比。跨度极小时保底 1,避免永不标记。 + const span = Math.max(1, hi - lo); + const markMin = Math.max(1, span * 0.03); + // 点数自适应:点数 > POINT_MARK_MAX 时不再逐点画实心小圆(见其注释), + // 显著变化点仍然标记 —— 两者是不同用途:前者是"采样点",后者是"事件"。 + const markAll = shouldMarkPoints(pts.length); + pts.forEach((p, i) => { + const prev = i > 0 ? pts[i - 1] : null; + const delta = prev ? p.c - prev.c : 0; + const sig = prev && Math.abs(delta) >= markMin; + const up = delta > 0; + const when = new Date(p.t).toLocaleString('zh-CN', { hour12: false }); + const head = (s.name || s.uid.slice(0, 8)) + ' ' + when + (p.g ? '(日粒度)' : ''); + const tip = head + '\n余额 ' + fmtNum(p.c) + + (prev ? '\n较上一点 ' + (delta > 0 ? '+' : '') + fmtNum(delta) : ''); + if (sig) { + // 显著变化:涨=绿、跌=红(唯一允许"借用"语义色的地方 —— 因为它 + // 表达的**就是**涨跌语义,不是账号身份)。 + out += '' + esc(tip) + ''; + } else if (markAll) { + out += drawPointMarker(p.x, p.y, true, color, tip); + } else { + // 点太密:不画圆点,但**保留透明热区**,悬停仍可查任意点。 + // 减少的是视觉噪音,不是信息量 —— 这是"降噪"与"减信息"的关键区别。 + out += drawPointMarker(p.x, p.y, false, color, tip); + } + }); + const last = pts[pts.length - 1]; // 末点加大命中圈,便于悬停 + out += '' + + '' + esc(s.name || s.uid.slice(0, 8)) + ' 当前 ' + fmtNum(last.c) + ''; + }); + out += ''; + host.innerHTML = out; + + const lg = $('bhLegend'); + // 账号名加 truncate 包装:超长名(如「汪羽杰(工作相关内容不要发v)」)会挤压卡头, + // 按 12em 截断 + 省略号,完整名放 title 悬浮可见(识别优先、完整信息可及)。 + if (lg) lg.innerHTML = rows.map((s, i) => { + const nm = s.name || s.uid.slice(0, 8); + return '' + + '' + esc(nm) + ''; + }).join(' '); +} +/* renderDailyBars 画「每日变化」分组柱状图:x = 日期,每账号一根。 + 与余额折线的区别:折线看"水位随时间",这里看"每天的净变化量"(涨跌方向 + 幅度)。 + 不完整日(今日 / 服务中途启用那天)用低透明度 + 虚线描边标出 —— 否则 + 「今天只涨了一点」会被误读成「今天赚得少」,其实是当天还没采完。 */ +function renderDailyBars(series) { + const host = $('bhDaily'); + if (!host) return; + // 收集所有日期(并集,升序) + const daySet = new Set(); + series.forEach(s => (s.daily || []).forEach(d => daySet.add(d.day))); + const days = [...daySet].sort(); + if (!days.length) { + host.innerHTML = '
暂无按日数据(需跨过零点后才出现第一天)。
'; + const lg = $('bhDailyLegend'); + if (lg) lg.innerHTML = ''; + return; + } + // 每个账号每天的变化值,以及是否有任一不完整 + const map = new Map(); // uid -> {day: {change, full}} + const fullMap = new Map(); + series.forEach(s => { + const m = {}; + (s.daily || []).forEach(d => { m[d.day] = d.change; if (!d.full) fullMap.set(s.uid + '|' + d.day, true); }); + map.set(s.uid, m); + }); + // y 轴范围:正负分开,零轴居中 + let hi = 0, lo = 0; + series.forEach(s => (s.daily || []).forEach(d => { + if (d.change > hi) hi = d.change; + if (d.change < lo) lo = d.change; + })); + // ⭐ 离群点裁剪(20261021):纵轴用 P95 分位而非极值,超出者单独标记。 + // 为什么:一次 +4414 的到账(如新手礼包)会把轴拉到 ±4414,其余日常 ±500 + // 的波动被压成 2px 短线 —— 韦伯-费希纳定律:人读的是**比例**,轴被离群值 + // 撑开后,真正想看的「今天比昨天多赚多少」在视觉上消失,80% 的像素在 + // 表达「接近零」(数据墨水比极低)。 + // 做法:把 |change| 排序取 P95 作为轴范围,超出者画成贴顶的三角标记 + + // title 标注真实值 —— 既保留离群点的存在感,又让主体数据可读。 + const absVals = []; + series.forEach(sr => (sr.daily || []).forEach(d => { + if (!d || typeof d.change !== 'number') return; + if (!days.includes(d.day)) return; + absVals.push(Math.abs(d.change)); + })); + if (absVals.length >= 8) { + absVals.sort((a, b) => a - b); + const p95 = absVals[Math.floor(absVals.length * 0.95)]; + // 只用 P95 收窄「明显比主体大一个量级」的离群点;不无条件裁剪, + // 否则数据本身就在高位时会被误裁。判据:极值 > P95 的 3 倍才启用。 + const curMax = Math.max(Math.abs(hi), Math.abs(lo)); + if (p95 > 0 && curMax > p95 * 3) { + hi = Math.min(hi, p95 * 1.12); + lo = Math.max(lo, -p95 * 1.12); + } + } + + // 上下独立缩放 + 各留 12% 余量(不再强制对称)。 + // 为什么:强制对称(hi=lo=-span)在"几乎只涨"的数据上会把下半区留成 + // 5 倍空白(实测 +1998/-393 → 轴 ±1998),视觉上又空又怪,且正柱贴顶。 + // 独立缩放让柱高比例真实反映数值比例。 + // 边界断言(§十:不得产出物理上不可能的值):日变化可正可负,故只在 + // 该侧确有数据时才外扩;两侧都无数据时兜底 ±1 避免除零。 + if (hi > 0) hi *= 1.12; + if (lo < 0) lo *= 1.12; + // 单侧有数据时,给另一侧留一点呼吸空间,否则零轴贴边、柱子像被裁掉。 + if (hi > 0 && lo === 0) lo = -Math.max(1, hi * 0.15); + if (lo < 0 && hi === 0) hi = Math.max(1, -lo * 0.15); + if (hi === 0 && lo === 0) { hi = 1; lo = -1; } + + // 坐标系 1:1(同余额折线,见 measureWidth 注释)。 + const W = measureWidth(host), H = 180, PL = 56, PR = 12, PT = 14, PB = 34; + const iw = W - PL - PR, ih = H - PT - PB; + const Y = v => PT + ih - ih * ((v - lo) / (hi - lo)); + const zeroY = Y(0); + + const nAcc = Math.max(1, series.length); + const groupW = iw / days.length; + const bw = Math.max(2, Math.min(14, (groupW - 8 - Math.max(0, nAcc - 1)) / nAcc)); + + let out = ''; + // 网格(4 档)+ 零轴加粗 + for (let i = 0; i <= 4; i++) { + const v = lo + (hi - lo) * i / 4; + const y = Y(v); + const isZero = Math.abs(v) < Math.max(hi, -lo) / 8; + out += ''; + out += '' + + (v > 0 ? '+' : '') + fmtNum(Math.round(v)) + ''; + } + // 色板序号只按健康系列推进,与折线同一口径(见 bhColorOf 注释)—— + // 否则同一账号在两张图上颜色不同。 + const barColor = new Map(); + let barLive = 0; + series.forEach(s => { + const dead = bhIsDead(s); + barColor.set(s.uid, bhColorOf(s.uid, dead ? 0 : barLive++, dead)); + }); + // 每日一组柱 + days.forEach((day, di) => { + const gx = PL + di * groupW; + series.forEach((s, si) => { + const v = (map.get(s.uid) || {})[day]; + if (v === undefined) return; + const color = barColor.get(s.uid) || 'var(--ink-3)'; + // 组内柱之间留 1px 缝:无缝隙时相邻两柱会被知觉成一个整体 + // (格式塔共边界效应),看不出"两根独立的柱"。 + const gap = nAcc > 1 ? 1 : 0; + const x = gx + (groupW - (bw * nAcc + gap * (nAcc - 1))) / 2 + si * (bw + gap); + const y0 = Math.min(zeroY, Y(v)), h = Math.max(1, Math.abs(Y(v) - zeroY)); + const incomplete = fullMap.get(s.uid + '|' + day); + // 零值画一条中性底痕(与 buka 规范一致:0 值也要可见) + if (v === 0) { + out += ''; + } else { + // 离群点(超出裁剪后的轴范围):柱子贴边 + 顶部三角标记, + // 让读者一眼看出「这根比轴还高」,而不是误以为它只有这么高。 + const clippedHi = v > hi, clippedLo = v < lo; + out += ''; + if (clippedHi || clippedLo) { + const ty = clippedHi ? PT : PT + ih; + out += '' + + '超出纵轴范围(已裁剪),实际 ' + (v > 0 ? '+' : '') + fmtNum(v) + ''; + } + } + out += '' + esc(s.name || s.uid.slice(0, 8)) + ' ' + esc(day) + '\n' + + (v > 0 ? '+' : '') + fmtNum(v) + (incomplete ? '\n⚠️ 该日采样不完整(当天未结束或中途启用)' : '') + ''; + }); + // x 轴日期标签(稀疏) + // 与上方「积分水位」图同一口径(天数 / 3 + 1,夹在 2~10 之间),保证可纵向对照。 + const every = Math.max(1, Math.ceil(days.length / Math.max(2, Math.min(10, Math.ceil(days.length / 3) + 1)))); + if (di % every === 0) { + out += '' + esc(day.slice(5)) + ''; + } + }); + out += ''; + host.innerHTML = out; + + // 图例:柱色表示**涨跌**(绿=净增、红=净减),不表示账号——账号由组内 + // 左→右的位置区分(与下方表格行序一致)。故这里只说明颜色语义, + // 再按位置列出账号顺序,避免"颜色=账号"的错误暗示。 + const lg = $('bhDailyLegend'); + if (lg) lg.innerHTML = + '净增' + + '净减' + + '' + + '组内左→右:' + + series.map((s, i) => (i + 1) + '. ' + esc(s.name || s.uid.slice(0, 8))).join(' ') + + ''; +} +/* 取某账号的「今日/昨日」变化(用于表格列)。 */ +function dayChangeOf(s, which) { + const d = s.daily || []; + if (!d.length) return null; + if (which === 'today') return d[d.length - 1]; + return d.length >= 2 ? d[d.length - 2] : null; +} +function fmtChange(v, full) { + if (v === null || v === undefined) return '—'; + const txt = (v > 0 ? '+' : '') + fmtNum(v); + const color = v > 0 ? 'var(--ok)' : v < 0 ? 'var(--bad)' : 'inherit'; + // 不完整日用虚线底 + 提示,避免与完整日直接比较 + return '' + txt + ''; +} +/* monthFlowOf 取某账号**当月**的消耗/到账合计,以及这份合计是否覆盖了整月。 + 返回 { consumed, gained, covered, firstDay, today }: + - consumed/gained:本月已发生部分的下界估计(口径同 Daily,相邻采样差值累加); + - covered=false 表示 s.daily 里没有当月 1 号及更早的点 → 窗口没覆盖整月, + 此时数值只是「窗口内那几天」的和,必须淡化并标注,否则会被当成整月值; + - firstDay 是当月最早有数据的那天,用于标题说明到底从哪天算起。 + + 为什么不做「全年」:balance 折叠成日粒度后每账号每天只剩 1 个点,虽然 + 折叠时已把当日流量写在点上(Point.Consumed/Gained),但 30 天窗口以外的 + 日仍受 dayKeep 约束,且 balance_history 的 days 被钳在 30(panel.go)。 + 超出窗口的月份这里拿不到数据,故只算本月、且显式标注覆盖范围。 */ +function monthFlowOf(s, now) { + const d = s.daily || []; + const today = new Date(now || Date.now()); + const ym = today.getFullYear() + '-' + String(today.getMonth() + 1).padStart(2, '0'); + const firstOfMonth = ym + '-01'; + let consumed = 0, gained = 0, n = 0, firstDay = null; + d.forEach(x => { + if (!x || typeof x.day !== 'string' || x.day.slice(0, 7) !== ym) return; + if (typeof x.consumed === 'number') consumed += x.consumed; + if (typeof x.gained === 'number') gained += x.gained; + n++; + if (!firstDay || x.day < firstDay) firstDay = x.day; + }); + return { + consumed: consumed, + gained: gained, + covered: !!firstDay && firstDay <= firstOfMonth, + firstDay: firstDay, + days: n, + }; +} +/* fmtFlow 渲染「消耗/到账」这类恒非负的流量值。 + 与 fmtChange 的区别:这些量不表示方向(消耗恒 >=0),故不用涨跌色, + 用中性色 + 弱化不完整日。0 显示为 "–"(无变化比 "0" 更易扫读)。 */ +/* fmtFlow 渲染「消耗/到账」单个数值(今日或本月的一行)。 + 「无数据」与「零」必须用**不同符号**(§十一 口径标注)。 + + 事故:原先零值用 en-dash「–」(U+2013)、无数据用 em-dash「—」(U+2014) —— + 两者都是一条横线,12px 下仅差 6px 宽,扫视时无法区分(用户看到「今日消耗 –」 + 以为是"没数据",实际是当天消耗 0)。故:零值显式写 0(灰化),无数据才「—」。 + dim=true 表示该数口径受限(不完整日 / 本月未覆盖整月),淡化 + title 说明。 */ +function fmtFlow(v, dim, dimTitle) { + if (v === null || v === undefined) return '—'; + const n = Number(v); + if (!n) { + return '0'; + } + return '' + + fmtNum(n) + ''; +} +/* fmtFlowCell 把「今日 / 本月」两行合成一个单元格(方案 A:不增列)。 + 上行 = 今日(完整度口径同「今日」列),下行 = 本月。 + 本月行有两种受限情形,都必须标注而不是静默给数字: + - 窗口未覆盖整月(monthFlowOf().covered === false)→ 淡化 + 说明起算日; + - bhWindow 选了「近 24 小时」→ 本月合计几乎等于今日,等于没意义,直接说明。 */ +function fmtFlowCell(today, month, key, winDays) { + const t = fmtFlow(today && today[key], !!today && !today.full, + '该日采样不完整(当天未结束或中途启用),消耗/到账均为下界估计'); + let m; + if (!month || !month.days) { + m = fmtFlow(null); // 本月无任何采样 + } else if (Number(winDays) < 28) { + // 窗口短于 28 天时「本月」必然不含全月,数字虽真但会误导 —— 只标下标不显示值。 + m = '—'; + } else if (!month.covered) { + m = fmtFlow(month[key], true, + '窗口只覆盖本月 ' + String(month.firstDay || '').slice(5) + ' 起,本月值为该区间之和(下界)'); + } else { + m = fmtFlow(month[key], false); + } + return '' + + '' + t + '' + + '' + m + ''; +} +function bhCard(k, v, tone) { + return '
' + esc(k) + '' + esc(v) + '
'; +} +/* renderRealmSeg 画域切换分段控件。只列出**有数据的域**(避免点了空白页), + 并在按钮上标明账号数,让"这个域有几个号"一眼可见。 */ +function renderRealmSeg(all) { + const seg = $('bhRealmSeg'); + if (!seg) return; + const count = {}; + all.forEach(s => { const r = realmOf(s); count[r] = (count[r] || 0) + 1; }); + const items = BH_REALMS.filter(r => count[r.key]).concat( + count.other ? [{ key: 'other', label: '其他' }] : []); + if (!items.length) { seg.innerHTML = ''; return; } + seg.innerHTML = items.map(r => + '').join(''); + Array.prototype.forEach.call(seg.querySelectorAll('button'), function (b) { + b.onclick = function () { + bhRealm = b.getAttribute('data-realm'); + try { localStorage.setItem('bhRealm', bhRealm); } catch (e) { /* 隐私模式:忽略 */ } + loadBalance(); + }; + }); +} +/* renderBalanceFoot 画「按账号」表的合计行(**域内小计**)。 + 口径纪律(§十:不得产出语义错误的数): + - 当前 / 净变化 / 今日 / 昨日 / 采样点 —— 可加,给出合计; + - 最低 / 最高 —— **不可加**!各账号的低谷/高峰不在同一时刻, + Σ最低 没有任何物理含义(会得出一个从未存在过的水位),故填 "—"。 + 不做跨域总计:cn 与 global 的积分不同源、不可互换(见 BH_REALMS)。 */ +function renderBalanceFoot(rows, now, winDays) { + const host = $('bhAccFoot'); + if (!host) return; + if (!rows.length) { host.innerHTML = ''; return; } + // 合计行的本月口径与明细行必须**同源**(同一个 now、同一个窗口), + // 否则行与合计会在"覆盖了几天"上打架。 + const footNow = now, footDays = winDays; + let cur = 0, chg = 0, pts = 0; + let todaySum = 0, todayHas = false, ydaySum = 0, ydayHas = false; + let consSum = 0, consHas = false, gainSum = 0, gainHas = false; + // 本月合计:逐账号求和(同域绝对量可加),覆盖范围按「是否所有账号都覆盖整月」 + // 取严 —— 只要有一个账号的本月不全,合计就不全,不能当成整月值展示。 + let mcSum = 0, mgSum = 0, mHas = false, mCovered = true, mFirstDay = null; + rows.forEach(s => { + cur += Number(s.current || 0); + chg += Number(s.change || 0); + pts += (s.points || []).length; + const t = dayChangeOf(s, 'today'), y = dayChangeOf(s, 'yesterday'); + if (t && typeof t.change === 'number') { todaySum += t.change; todayHas = true; } + if (y && typeof y.change === 'number') { ydaySum += y.change; ydayHas = true; } + // 消耗/到账可跨账号相加(都是同域的绝对量),但**同为下界估计** + if (t && typeof t.consumed === 'number') { consSum += t.consumed; consHas = true; } + if (t && typeof t.gained === 'number') { gainSum += t.gained; gainHas = true; } + const mo = monthFlowOf(s, footNow); + if (mo.days) { + mHas = true; + mcSum += mo.consumed; + mgSum += mo.gained; + if (!mo.covered) mCovered = false; + if (mo.firstDay && (!mFirstDay || mo.firstDay < mFirstDay)) mFirstDay = mo.firstDay; + } + }); + const num = (v, has) => has + ? '' + + (v > 0 ? '+' : '') + fmtNum(v) + '' + : '—'; + // 可用账号数:该域内**当前真正能干活**的账号(未禁用且未暂停)。 + // 为什么放在合计行:「合计余额」是历史水位之和,可能包含已死号的残留 —— + // 只看余额会高估可用资源,必须并排给出「这些钱有几个号在扛」。 + let usable = 0; + rows.forEach(s => { + const a = acctStateOf(s.uid); + if (!a) { usable += 1; return; } // 无状态记录:按可用计(不无端扣减) + if (!a.disabled && !a.paused) usable += 1; + }); + host.innerHTML = '' + + '' + + '合计(' + esc(realmLabel(bhRealm)) + ')' + + '可用 ' + usable + '/' + rows.length + '' + + '' + + '' + fmtNum(cur) + '' + + // 最低/最高不求和——见函数头注释 + '—' + + '—' + + '' + + (chg > 0 ? '+' : '') + fmtNum(chg) + '' + + num(todaySum, todayHas) + num(ydaySum, ydayHas) + + fmtFlowCell({ consumed: consSum, gained: gainSum, full: true }, { consumed: mcSum, gained: mgSum, days: mHas ? 1 : 0, covered: mCovered, firstDay: mFirstDay }, 'consumed', footDays) + + fmtFlowCell({ consumed: consSum, gained: gainSum, full: true }, { consumed: mcSum, gained: mgSum, days: mHas ? 1 : 0, covered: mCovered, firstDay: mFirstDay }, 'gained', footDays) + + '' + fmtNum(pts) + '' + + ''; +} +async function loadBalance() { + const host = $('bhChart'); + const days = Number(($('bhWindow') || {}).value || 30); + try { + const d = await api('balance_history?days=' + days); + const all = d.series || []; + // 首次进入(或记忆的域已无数据)时确定默认域;之后保持用户的显式选择。 + if (bhRealm === null || !all.some(s => realmOf(s) === bhRealm)) { + bhRealm = pickRealm(all); + } + renderRealmSeg(all); + // 失效账号(禁用)**不参与统计**,但保留记录单独列出。 + // + // 为什么分开:禁用号的余额是历史残留(人已不能干活),混进「当前合计 / 净变化 / + // 消耗到账」会把死钱算成活钱,运维据此判断容量必然高估。但历史曲线本身有诊断 + // 价值(能看出「哪天开始不更新」),所以不是删掉,而是移出统计区单独陈列。 + // 暂停号不受影响:它照常保号、余额仍会更新,只是暂不接流量。 + const inRealm = filterRealm(all, bhRealm); + const isDead = s => { const a = acctStateOf(s.uid); return !!(a && a.disabled); }; + const rows = inRealm.filter(s => !isDead(s)); + const deadRows = inRealm.filter(isDead); + renderBalanceChart(inRealm); // 折线画全部:失效号用灰线保留历史轨迹(表格才做统计剔除) + renderDailyBars(inRealm); // 同上:柱子也画全,灰线/灰柱表示已失效 + // 分域小计:同域内可加(语义成立);**不做跨域总计**——cn 与 global 的 + // 积分不同源、不可互换,相加得出的数没有意义(见 BH_REALMS 注释)。 + let total = 0, delta = 0; + rows.forEach(s => { total += Number(s.current || 0); delta += Number(s.change || 0); }); + // 可用账号数:未禁用且未暂停(口径与合计行一致,两处必须同源)。 + let usableCount = 0; + rows.forEach(s => { + const a = acctStateOf(s.uid); + if (!a || (!a.disabled && !a.paused)) usableCount += 1; + }); + const st = $('bhStats'); + if (st) st.innerHTML = + bhCard('账号', String(rows.length)) + + // 可用数单列:合计余额可能包含已死号的残留,必须并排看「几个号在扛这些分」。 + bhCard('可用', String(usableCount) + '/' + String(rows.length), usableCount < rows.length ? 'bad' : '') + + bhCard('当前合计', fmtNum(total)) + + bhCard('窗口净变化', (delta > 0 ? '+' : '') + fmtNum(delta), delta > 0 ? 'ok' : delta < 0 ? 'bad' : '') + + bhCard('采样点数', fmtNum(rows.reduce((a, s) => a + (s.points || []).length, 0))); + const tb = $('bhAccBody'); + const renderRow = (s, i, dead) => + '' + + (() => { + const a = acctStateOf(s.uid); + // 账号已禁用/暂停:名字后加小标签。曲线仍展示(历史数据有意义), + // 但要让读者知道「之后不再更新」的原因,否则会把断更误读成没在用。 + const mark = !a ? '' + : a.disabled ? '' + esc(disabledKind(a.reason).label) + '' + : a.paused ? '暂停选号' + : ''; + const nm = s.name || s.uid.slice(0, 8); + const tip = a && a.reason ? nm + ' · ' + a.reason : nm; + return '' + esc(nm) + mark + ''; + })() + + '' + fmtNum(s.current) + '' + + '' + fmtNum(s.min) + '' + + '' + fmtNum(s.max) + '' + + '' + + (s.change > 0 ? '+' : '') + fmtNum(s.change) + '' + + (function () { + const t = dayChangeOf(s, 'today'), y = dayChangeOf(s, 'yesterday'); + // 本月口径:与窗口脱钩判定覆盖范围(见 monthFlowOf 注释) + const mo = monthFlowOf(s, d.now); + return '' + fmtChange(t && t.change, t && t.full) + '' + + '' + fmtChange(y && y.change, y && y.full) + '' + + // 消耗/到账:上行今日、下行本月(方案 A,不增列) + fmtFlowCell(t, mo, 'consumed', days) + + fmtFlowCell(t, mo, 'gained', days); + })() + + '' + (s.points || []).length + ''; + + const deadHtml = deadRows.length + ? '已失效 ' + deadRows.length + ' 个(不计入上方统计,仅保留历史记录)' + + deadRows.map((s, i) => renderRow(s, rows.length + i, true)).join('') + : ''; + const liveHtml = rows.map((s, i) => renderRow(s, i, false)).join(''); + if (tb) tb.innerHTML = (rows.length + deadRows.length) ? (liveHtml + deadHtml) + : '
该域暂无采样
' + + '切到其他域,或等待下一次余额刷新
'; + renderBalanceFoot(rows, d.now, days); + const note = $('bhNote'); + if (note) note.textContent = '更新于 ' + new Date(d.now).toLocaleTimeString('zh-CN', { hour12: false }); + } catch (e) { + if (host) host.innerHTML = '
读取余额趋势失败:' + esc(e.message) + '
'; + } +} +/* 窗口选择与「刷新」自己没有事件:切换视图才会重跑 loadBalance, + 改了窗口或点刷新都没反应,控件形同摆设(issue #186)。 */ +if ($('bhWindow')) $('bhWindow').onchange = loadBalance; +if ($('btnBalHist')) $('btnBalHist').onclick = loadBalance; + +/* ── 图表与域标签工具(迁移遗漏,20261021 补齐)── */ +const CHART_FALLBACK_W = 760; + +/* measureWidth 量容器内容宽(去掉 padding)。 + 为什么用 clientWidth-padding 而不用 getBoundingClientRect: + 后者包含 border、且受 CSS transform 影响,算出来的坐标系 + 会与 CSS 布局尺寸不一致(一个被 transform 缩放的容器会让图表 + 再次被非等比拉伸)。 */ +function measureWidth(el) { + if (!el) return CHART_FALLBACK_W; + const cs = getComputedStyle(el); + const pl = parseFloat(cs.paddingLeft) || 0; + const pr = parseFloat(cs.paddingRight) || 0; + const w = el.clientWidth - pl - pr; + return w > 40 ? Math.round(w) : CHART_FALLBACK_W; +} + +/* ── 折线共用的三个渲染规则(两处折线图必须一致,故抽成共享函数) ────── + 为什么抽出来:余额趋势图与账号×模型图是**同类图形**(都是"真实时间 x + 轴 + 值 y 轴的多序列折线")。同一类图形若各写一套线宽/平滑/点标记, + 两处必然逐渐漂移,用户看到的是"同一个面板里两种线风格" —— 这正是 + 本次要修的问题本身。故把三者收敛为共享实现,两处只负责传数据。 */ + +/* lineWidthFor 按**系列数**给线宽:系列多时略细、少时略粗。 + 为什么与系列数挂钩:线宽是"信息密度"的补偿手段。1~3 条线时线细会显得 + 单薄、且单条线的视觉权重不足以承载注意力;>6 条时线越细越不糊 —— + 60px 高的绘图区里 8 条 2.0px 线会互相吃掉、趋势读不出来。 + 这与既有的"点标记按点数自适应"是同一思路:**图形密度决定笔触粗细**。 + 分档取整(2.0/1.8/1.5)而非连续函数,是为了让同一系列数在任何容器宽度 + 下都得到同一线宽,避免"窗口一拉线宽就变"的抖动感。 */ +function lineWidthFor(n) { + if (n > 6) return 1.5; + if (n >= 4) return 1.8; + return 2.0; +} + +/* smoothPath 用 **Monotone 三次插值(Fritsch–Carlson)** 生成平滑 的 + d 属性。入参 pts = [{x, y}, ...](已投影到屏幕坐标,x 单调递增)。 + + ⚠️ 为什么**必须**是 monotone,不能用 Catmull-Rom / 普通三次样条: + 后两者只保证**经过**控制点与一阶连续,**不保证不过冲**。在"余额/用量" + 这类统计图上,过冲会在两个真实点之间画出**数据里不存在的波峰或负值** —— + 例如余额从 4000→4100 的两点之间被样条拱到 4150,用户据此判断"当时冲到 + 过 4150",而成因只是曲线形状。这是**虚构数据**,比"线条不好看"严重得多。 + Fritsch–Carlson 的做法是:先按三点斜率算切线,再把切线限制在相邻割线 + 斜率的 3 倍以内(即保证插值函数在每个子区间内单调),于是平滑段 + **始终夹在两端真实值之间**,不会产生局部极值。 + + 边界:点数 <2 退回直线(无插值意义);点数 ==2 直接给一条线段 + (两点之间任何"平滑"都是凭空造的弧度)。 */ +function smoothPath(pts) { + if (!pts || pts.length < 2) return ''; + if (pts.length === 2) { + return 'M' + pts[0].x.toFixed(1) + ' ' + pts[0].y.toFixed(1) + + 'L' + pts[1].x.toFixed(1) + ' ' + pts[1].y.toFixed(1); + } + const n = pts.length; + // 1) 相邻割线斜率 d[i] = (y[i+1]-y[i]) / (x[i+1]-x[i]) + const dx = [], dy = [], d = []; + for (let i = 0; i < n - 1; i++) { + dx[i] = pts[i + 1].x - pts[i].x; + dy[i] = pts[i + 1].y - pts[i].y; + d[i] = dx[i] === 0 ? 0 : dy[i] / dx[i]; + } + // 2) 各点切线 m[i]:端点用单侧割线,内部点用相邻割线的加权平均 + // (Fritsch–Carlson 的标准初始化;下一步再对 m 作单调性约束)。 + const m = new Array(n); + m[0] = d[0]; + m[n - 1] = d[n - 2]; + for (let i = 1; i < n - 1; i++) { + if (d[i - 1] * d[i] <= 0) { + m[i] = 0; // 极值点/拐点:切线必须为 0,否则必然过冲 + } else { + m[i] = (d[i - 1] + d[i]) / 2; + } + } + // 3) 单调性约束(本算法的关键):把每点切线夹到相邻割线的 3 倍以内。 + // 这一步才是"单调保持"的来源;只做第 2 步仍会过冲。 + for (let i = 0; i < n - 1; i++) { + if (d[i] === 0) { // 水平段:两端切线都归零,段内恒为常数 + m[i] = 0; + m[i + 1] = 0; + continue; + } + const a = m[i] / d[i], b = m[i + 1] / d[i]; + const s = a * a + b * b; + if (s > 9) { // 限制在半径 3 的圆内(Fritsch–Carlson 判据) + const t = 3 / Math.sqrt(s); + m[i] = t * a * d[i]; + m[i + 1] = t * b * d[i]; + } + } + // 4) 转成三次贝塞尔:控制点 = 端点沿切线外推 1/3 段长(与 Hermite 等价) + let out = 'M' + pts[0].x.toFixed(1) + ' ' + pts[0].y.toFixed(1); + for (let i = 0; i < n - 1; i++) { + const c1x = pts[i].x + dx[i] / 3, c1y = pts[i].y + m[i] * dx[i] / 3; + const c2x = pts[i + 1].x - dx[i] / 3, c2y = pts[i + 1].y - m[i + 1] * dx[i] / 3; + out += 'C' + c1x.toFixed(1) + ' ' + c1y.toFixed(1) + ' ' + + c2x.toFixed(1) + ' ' + c2y.toFixed(1) + ' ' + + pts[i + 1].x.toFixed(1) + ' ' + pts[i + 1].y.toFixed(1); + } + return out; +} + +/* POINT_MARK_MAX 点标记(实心小圆)的**点数上限**:超过即不画圆点。 + 为什么:60 个点 × 每点一个 r=2.2 实心圆,在 ~7px 点距下糊成花带—— + 圆点是前注意加工最易捕捉的特征,注意力被它抓走反而看不到"线"(趋势)。 + 阈值 30 的经验来源:绘图区宽约 900px 时,30 点在 30px 间距下圆点互不 + 粘连,仍能起"采样点"的作用;再多就退化为噪音。 + ⚠️ 不画圆点 ≠ 少给信息:hover 仍靠透明大热区(见 POINT_HIT_R)逐点可查, + 且"显著变化"的点在两个图上都仍然保留标记(降噪 ≠ 减信息)。 */ +const POINT_MARK_MAX = 30; +/* POINT_HIT_R 无圆点时使用的**透明热区半径**:圆点不画了,但命中判定不能 + 跟着消失,否则 tooltip 只能靠线宽命中、悬停极难触发(线宽仅 1.5~2px)。 + 取 6px ≈ 手指/光标可稳定停留的范围,且相邻热区不重叠(点距通常 >12px)。 */ +const POINT_HIT_R = 6; + +/* shouldMarkPoints 是否画实心圆点(点数自适应)。 + 为什么做成函数而不是各处内联比较:这条规则是**两个折线图共有的产品决策**, + 分散写会漂移;且集中一处后"阈值"只有一个真源,调整时不会漏改一处。 */ +function shouldMarkPoints(n) { + return n <= POINT_MARK_MAX; +} + +/* drawPointMarker 画一个数据点的标记 + hover 文案。 + marked=true → 实心小圆(能被看见);false → 透明大热区(不可见但可悬停)。 + 两个折线图共用,保证"看不见的点同样查得到值"这一行为在两处一致。 */ +function drawPointMarker(x, y, marked, color, title) { + const r = marked ? 2.6 : 0; + const t = esc(title); + if (marked) { + return '' + t + ''; + } + return '' + t + ''; +} + + +/* realmOf 归一化账号域:空/未知归入 'other'(不静默丢弃,让它可见)。 */ + +function realmLabel(key) { + const r = BH_REALMS.find(x => x.key === key); + return r ? r.label : '其他'; +} + +/* ── 数值格式化(迁移遗漏)── */ +function fmtNum(v) { + const n = Number(v) || 0; + return n.toLocaleString('zh-CN'); +} +/* fmtTokens 人类可读 token 量(额度评估的数量级都是"亿")。 */ +function fmtTokens(n) { + n = Number(n) || 0; + if (n >= 1e8) return (n / 1e8).toFixed(2) + ' 亿'; + if (n >= 1e4) return (n / 1e4).toFixed(1) + ' 万'; + return String(n); +} + + +/* ── 请求事件日志 (Keeper 风格大屏) ────────────────────────────────── */ +let rawEventsData = []; +// eventRows 当前筛选后的行序(与表格 data-ev 下标一致):展开上下文时按它取事件。 +let eventRows = []; + +async function loadEvents() { + const tb = $('eventTableBody'); + const limit = ($('eventFilterLimit') && $('eventFilterLimit').value) || 100; + try { + const res = await api('request_logs?limit=' + limit); + rawEventsData = res.entries || []; + populateEventFilterOptions(rawEventsData); + renderEventTable(); + } catch (err) { + // 不能把失败渲染成「共 0 条事件」——归档没开和查询出错是两回事,用户得知道是哪种。 + rawEventsData = []; + if ($('eventBadge')) $('eventBadge').textContent = '读取失败'; + if (tb) setHTML(tb, '' + + (err.status === 501 ? '请求归档未开启,事件日志不可用' : '读取失败: ' + esc(err.message || String(err))) + ''); + } +} + +function populateEventFilterOptions(list) { + const modelSel = $('eventFilterModel'); + const acctSel = $('eventFilterAccount'); + if (!modelSel || !acctSel) return; + const currModel = modelSel.value; + const currAcct = acctSel.value; + + const models = new Set(); + const accts = new Set(); + list.forEach(e => { + if (e.model) models.add(e.model); + if (e.account) accts.add(e.account); + }); + + let mOpt = ''; + models.forEach(m => mOpt += ''); + setHTML(modelSel, mOpt); + + let aOpt = ''; + accts.forEach(a => aOpt += ''); + setHTML(acctSel, aOpt); +} + +function renderEventTable() { + const tb = $('eventTableBody'); + if (!tb) return; + const modelFilter = ($('eventFilterModel') && $('eventFilterModel').value) || ''; + const acctFilter = ($('eventFilterAccount') && $('eventFilterAccount').value) || ''; + const statusFilter = ($('eventFilterStatus') && $('eventFilterStatus').value) || ''; + + let filtered = rawEventsData.filter(e => { + if (modelFilter && e.model !== modelFilter) return false; + if (acctFilter && e.account !== acctFilter) return false; + if (statusFilter === 'success' && !(e.ok || (e.status >= 200 && e.status < 300))) return false; + if (statusFilter === '429' && e.status !== 429) return false; + if (statusFilter === 'error' && (e.ok || (e.status >= 200 && e.status < 300))) return false; + return true; + }); + + if ($('eventBadge')) $('eventBadge').textContent = '共 ' + filtered.length + ' 条事件'; + + if (!filtered.length) { + setHTML(tb, '没有符合筛选条件的请求事件'); + return; + } + + eventRows = filtered; + const html = filtered.map((e, i) => { + const d = new Date(e.time); + const tStr = isNaN(d) ? '-' : (String(d.getHours()).padStart(2, '0') + ':' + String(d.getMinutes()).padStart(2, '0') + ':' + String(d.getSeconds()).padStart(2, '0')); + const dStr = isNaN(d) ? '' : (d.getFullYear() + '/' + (d.getMonth() + 1) + '/' + d.getDate()); + + const acctRaw = e.account || '-'; + const acctClean = acctRaw.replace(/\([^)]*\)/, ''); + const mName = e.model || '-'; + const effort = e.reasoning_effort || ''; + // 旧归档行没有这个键(不知道客户端发了什么);新行恒有(空串 = 确认没发)。 + const hasEffortReq = 'reasoning_effort_requested' in e; + const effortReq = e.reasoning_effort_requested || ''; + + let resTag = '成功'; + if (e.status === 429) { + resTag = '429 限流'; + } else if (e.status && (e.status < 200 || e.status >= 300)) { + resTag = '' + e.status + ' 错误'; + } + + const reqProto = (e.mode === 'stream' || (e.path && e.path.includes('responses'))) ? 'SSE' : 'POST'; + const reqPath = (e.path || '/chat').replace(/^\/v1/, ''); + + const durSec = ((e.duration_ms || 0) / 1000).toFixed(1) + 's'; + const ttfbSec = e.ttfb_ms ? '首字延迟 ' + ((e.ttfb_ms) / 1000).toFixed(1) + 's' : '-'; + + let tpsStr = '-'; + if (e.completion_tokens > 0) { + const genMs = Math.max(100, (e.duration_ms || 0) - (e.ttfb_ms || 0)); + tpsStr = ((e.completion_tokens / genMs) * 1000).toFixed(1) + ' t/s'; + } + + const totTok = formatEventNum(e.total_tokens || 0); + const pTok = formatEventNum(e.prompt_tokens || 0); + const cTok = formatEventNum(e.completion_tokens || 0); + const thinkTok = e.reasoning_tokens > 0 ? ('🧠 ' + formatEventNum(e.reasoning_tokens) + '') : ''; + + const cHit = e.cache_hit_tokens || 0; + const cMiss = e.cache_miss_tokens || 0; + const cTot = cHit + cMiss; + const cRate = cTot > 0 ? ((cHit / cTot) * 100).toFixed(2) + '%' : '-'; + + const exec = e.executor_type || deriveEventExecutor(e.user_agent); + const ip = e.client_ip || '-'; + const ua = e.user_agent || '-'; + + return '' + + '
' + esc(tStr) + '
' + esc(dStr) + '
' + + '
' + esc(acctClean) + '
' + + '
' + esc(mName) + '
' + + '' + eventEffortPill(effort, effortReq, hasEffortReq) + '' + + '' + resTag + '' + + '' + esc(reqProto) + '
' + esc(reqPath) + '
' + + '
' + esc(durSec) + '
' + esc(ttfbSec) + '
' + + '
' + esc(tpsStr) + '
' + + '
' + esc(totTok) + '
↑ ' + esc(pTok) + '
↓ ' + esc(cTok) + ' ' + thinkTok + '
' + + '
' + esc(cRate) + '
命中 ' + esc(formatEventNum(cHit)) + '
未命中 ' + esc(formatEventNum(cMiss)) + '
' + + '' + esc(exec) + '' + + '' + esc(ip) + '' + + '
' + esc(ua) + '
' + + ''; + }).join(''); + + setHTML(tb, html); +} + +// eventEffortPill 事件页「推理强度」列:「客户端要的」→「网关实际发出去的」两段显示。 +// 网关会在客户端没带档位时补模型默认档(thinking 默认档)、按策略改写或就近降级; +// 只显示生效值时整列都是 max,看不出这一档是谁定的(与聊天行日志的 +// effort=max->high / effort=- ->max 同一口径)。 +// - 一致:max;不一致(改写/降级):high→max;客户端没发(网关补默认档):-→max;都没有:- +// - hasReq=false 是升级前的老归档行(没有这个键),按旧口径只显示生效值,不臆测。 +function eventEffortPill(eff, req, hasReq) { + if (!hasReq) return '' + esc(eff || '-') + ''; + if (!eff && !req) return '-'; + if (!req) return '-→' + esc(eff) + ''; + if (!eff) return '' + esc(req) + ''; + if (req === eff) return '' + esc(eff) + ''; + return '' + esc(req) + '→' + esc(eff) + ''; +} + +// renderEventContext 把一次请求的会话上下文渲染成「角色 + 原文」块。 +// 只认 archiveContext 写出的三种键(system / messages / prompt);content 是数组的 +// 多模态块原样 JSON 展示——拆开反而丢掉结构。 +function renderEventContext(ctx) { + if (!ctx) return '
本次请求没有记录上下文(在「配置 → 日志」打开「记录请求上下文」后新产生的请求才有)
'; + const textOf = c => typeof c === 'string' ? c : (c == null ? '' : JSON.stringify(c, null, 2)); + const block = (role, text) => '
' + esc(role) + '
' + esc(text) + '
'; + const parts = []; + if (ctx.system != null) parts.push(block('system', textOf(ctx.system))); + if (ctx.prompt != null) parts.push(block('prompt', textOf(ctx.prompt))); + (ctx.messages || []).forEach(m => parts.push(block((m && m.role) || '?', textOf(m && m.content)))); + return '
' + parts.join('') + '
'; +} + +// 事件行点击打开上下文弹窗。挂 tbody 一次,重渲染后照样有效。 +if ($('eventTableBody')) $('eventTableBody').onclick = ev => { + const tr = ev.target.closest('tr[data-ev]'); + if (!tr) return; + const e = eventRows[Number(tr.dataset.ev)] || {}; + // 标题带上请求身份:弹窗遮住表格后,否则看不出打开的是哪一条。 + $('evCtxHint').textContent = [e.time ? fmtLocalDateTime(e.time) : '', e.path, e.model].filter(Boolean).join(' · '); + setHTML($('evCtxBody'), renderEventContext(e.context)); + $('evCtxVeil').classList.add('on'); +}; +if ($('btnEvCtxClose')) $('btnEvCtxClose').onclick = () => $('evCtxVeil').classList.remove('on'); +// 点遮罩关闭(与其它弹窗一致:只在点在 veil 自身时关,点内容不关)。 +if ($('evCtxVeil')) $('evCtxVeil').onclick = ev => { if (ev.target === $('evCtxVeil')) $('evCtxVeil').classList.remove('on'); }; + +function formatEventNum(n) { + if (!n || n < 0) return '0'; + if (n >= 1000000) return (n / 1000000).toFixed(2) + 'M'; + if (n >= 1000) return (n / 1000).toFixed(2) + 'K'; + return String(n); +} + +function deriveEventExecutor(ua) { + if (!ua) return 'WorkBuddyExecutor'; + const l = ua.toLowerCase(); + if (l.includes('antigravity')) return 'AntigravityExecutor'; + if (l.includes('codex')) return 'CodexExecutor'; + if (l.includes('claude')) return 'ClaudeCodeExecutor'; + if (l.includes('cursor')) return 'CursorExecutor'; + if (l.includes('continue')) return 'ContinueExecutor'; + if (l.includes('openai') || l.includes('python')) return 'OpenAIClient'; + return 'WorkBuddyExecutor'; +} + +// 筛选下拉记住上次选择(issue #160):日志范围和状态是长期偏好,模型/来源是一次性 +// 查询——后者每次都会按当前归档重建选项,记住反而容易指向已不存在的事件。 +if ($('eventFilterStatus')) { + const saved = prefGet('eventStatus'); + if (saved) $('eventFilterStatus').value = saved; +} +if ($('eventFilterLimit')) { + const saved = prefGet('eventLimit'); + if (saved) $('eventFilterLimit').value = saved; +} +if ($('eventFilterModel')) $('eventFilterModel').onchange = renderEventTable; +if ($('eventFilterAccount')) $('eventFilterAccount').onchange = renderEventTable; +if ($('eventFilterStatus')) $('eventFilterStatus').onchange = () => { + prefSet('eventStatus', $('eventFilterStatus').value); + renderEventTable(); +}; +if ($('eventFilterLimit')) $('eventFilterLimit').onchange = () => { + prefSet('eventLimit', $('eventFilterLimit').value); + loadEvents(); +}; +// 清空归档(issue #160):删的是磁盘上的事件文件,不可恢复,二次确认后再打。 +if ($('btnEventClearLogs')) $('btnEventClearLogs').onclick = async () => { + if (!confirm('清空归档会删掉归档目录里的全部请求事件文件(不可恢复,导出过的 JSON 不受影响)。确认清空?')) return; + const b = $('btnEventClearLogs'); + b.disabled = true; + try { + const r = await api('request_logs/clear', { method: 'POST' }); + toast('已清空归档:删除 ' + (r.files || 0) + ' 个文件(' + fmtBytes(r.bytes || 0) + ')', 'ok'); + await loadEvents(); + } catch (e) { + toast('清空失败:' + e.message, 'err'); + } finally { b.disabled = false; } +}; +if ($('btnEventClearFilters')) $('btnEventClearFilters').onclick = () => { + if ($('eventFilterModel')) $('eventFilterModel').value = ''; + if ($('eventFilterAccount')) $('eventFilterAccount').value = ''; + if ($('eventFilterStatus')) $('eventFilterStatus').value = ''; + // 记住的状态也是「筛选条件」的一部分(issue #160 引入的偏好):只清下拉不清偏好, + // 下次打开页面 / reload 时会把「错误」重新选回去,用户以为清除筛选没生效。 + // 模型 / 来源两项本来就不落盘(每次按归档重建选项),无需处理。 + prefSet('eventStatus', ''); + renderEventTable(); +}; +if ($('btnEventRefresh')) $('btnEventRefresh').onclick = loadEvents; +if ($('btnEventExport')) $('btnEventExport').onclick = () => { + const blob = new Blob([JSON.stringify(rawEventsData, null, 2)], { type: 'application/json' }); + const url = URL.createObjectURL(blob); + const a = document.createElement('a'); + a.href = url; + a.download = 'request-events-' + new Date().toISOString().slice(0, 10) + '.json'; + a.click(); + URL.revokeObjectURL(url); +}; + +const PROXY_STATES = { pending: ['warn', '待检测'], healthy: ['ok', '可用'], unhealthy: ['bad', '自动禁用'], disabled: ['bad', '手动禁用'] }; +function accountProxyHTML(uid) { + if (!proxyData) return ''; + const binding = proxyData.bindings?.[uid] || { mode: 'random' }; + const selected = binding.mode === 'fixed' ? (proxyData.proxies || []).find(p => p.id === binding.proxy_id) : null; + return ''; +} + +function populateProxySelect(select) { + if (!proxyData) return; + const current = select.value; + select.innerHTML = '' + + (proxyData.proxies || []).map(p => '').join(''); + select.value = current; +} +$('accBody').addEventListener('focusin', ev => { + if (ev.target.matches('[data-proxy-uid]')) populateProxySelect(ev.target); +}); +$('accBody').addEventListener('change', async ev => { + const select = ev.target; + if (!select.matches('[data-proxy-uid]')) return; + const uid = select.dataset.proxyUid, value = select.value; + const hadFocus = document.activeElement === select; + select.disabled = true; + try { + const body = value === 'random' || value === 'direct' ? { mode: value } : { mode: 'fixed', proxy_id: value }; + await api('accounts/' + encodeURIComponent(uid) + '/proxy', { method: 'PUT', body: JSON.stringify(body) }); + toast('账号代理已保存', 'ok'); + } catch (e) { toast('保存失败:' + e.message, 'err'); } + finally { + select.disabled = false; + const restoreFocus = hadFocus && (document.activeElement === select || document.activeElement === document.body); + if (restoreFocus) select.blur(); + await loadOverview(true); + if (restoreFocus) { + [...$('accBody').querySelectorAll('[data-proxy-uid]')].find(el => el.dataset.proxyUid === uid)?.focus(); + } + } +}); + +function proxyIcon(name) { + const paths = { + check: '', + edit: '', + remove: '', + }; + return ''; +} +function renderProxies() { + if (!proxyData) return; + const list = proxyData.proxies || [], pages = Math.max(1, Math.ceil(list.length / 25)); + proxyPage = Math.max(1, Math.min(proxyPage, pages)); + const healthy = list.filter(p => p.status === 'healthy').length; + $('proxySummary').textContent = list.length + ' 个代理 · ' + healthy + ' 个可用'; + $('proxyPage').textContent = proxyPage + ' / ' + pages; + $('proxyPrev').disabled = proxyPage === 1; + $('proxyNext').disabled = proxyPage === pages; + $('proxyCheckAll').disabled = !list.length; + setHTML($('proxyBody'), list.length ? list.slice((proxyPage - 1) * 25, proxyPage * 25).map(p => { + const [tone, text] = PROXY_STATES[p.status] || ['warn', p.status]; + const action = (type, label, disabled = false) => ''; + const exitNote = p.exit && p.exit.ip + ? '
出口 ' + esc(p.exit.ip) + ' · ' + esc([p.exit.country, ({residential:'住宅',datacenter:'机房'})[p.exit.ip_type] || ''].filter(Boolean).join(' ')) + (p.exit.isp ? ' · ' + esc(p.exit.isp) : '') + '
' + : ''; + return '' + esc(p.name) + '
' + esc(p.protocol.toUpperCase()) + '
' + + '' + esc(p.url) + (p.password_set ? '
已设置密码
' : '') + exitNote + '' + + '' + (p.checking ? '检测中' : esc(text)) + '' + + '' + (p.checked_at && !p.checked_at.startsWith('0001-') ? p.latency_ms + ' ms' : '—') + '' + + '' + (p.checked_at && !p.checked_at.startsWith('0001-') ? esc(fmtLocalDateTime(p.checked_at)) : '—') + '' + + '' + esc(p.last_error || '—') + '' + p.bound_count + '' + + '' + + '
' + action('check', '检测', p.checking) + action('edit', '编辑') + action('remove', p.bound_count ? '先解除账号绑定' : '删除', p.bound_count > 0) + '
'; + }).join('') : '
代理池为空
'); + // realm 级默认出口(issue #39 P3):选项集与账号行下拉同源。 + const realmOpts = '' + + list.map(p => '').join(''); + for (const [id, realm] of [['proxyRealmCn', 'cn'], ['proxyRealmGlobal', 'global']]) { + const sel = $(id); + if (!sel) continue; + const b = (proxyData.realms || {})[realm] || { mode: 'random' }; + const want = b.mode === 'fixed' ? b.proxy_id : b.mode; + sel.innerHTML = realmOpts; + sel.value = want; + if (sel.value !== want) sel.value = 'random'; // 绑的代理已删 → 显示「默认随机」 + } + if (!proxySettingsDirty) { + const s = proxyData.health; + $('proxyHealthURL').value = s.url; + $('proxyInterval').value = s.interval_seconds; + $('proxyTimeout').value = s.timeout_seconds; + $('proxyFailures').value = s.failure_threshold; + $('proxySuccesses').value = s.success_threshold; + } +} +async function loadProxies(quiet = false) { + if (proxyLoading) return; + proxyLoading = true; + try { + proxyData = await api('proxies'); + renderProxies(); + } catch (e) { + $('proxySummary').textContent = '读取失败:' + e.message; + if (!quiet) toast(e.message, 'err'); + } finally { proxyLoading = false; } +} +$('proxyAdd').onclick = () => { + $('proxyImportPanel').open = true; + $('proxyLines').focus(); +}; +$('proxyPrev').onclick = () => { proxyPage--; renderProxies(); }; +$('proxyNext').onclick = () => { proxyPage++; renderProxies(); }; +$('proxyImport').onclick = async () => { + const button = $('proxyImport'), lines = $('proxyLines').value; + if (!lines.trim()) { $('proxyLines').focus(); return; } + button.disabled = true; + try { + const data = await api('proxies', { method: 'POST', body: JSON.stringify({ lines }) }); + const rows = data.results || []; + $('proxyImportResults').textContent = '添加 ' + rows.filter(r => r.status === 'added').length + ' 个 · 重复 ' + rows.filter(r => r.status === 'duplicate').length + ' 个 · 无效 ' + rows.filter(r => r.status === 'invalid').length + ' 个' + + rows.filter(r => r.status === 'invalid').map(r => '\n第 ' + r.line + ' 行:' + r.error).join(''); + const inputLines = lines.split('\n'); + $('proxyLines').value = rows.filter(r => r.status === 'invalid').map(r => inputLines[r.line - 1]).join('\n'); + await loadProxies(); + } catch (e) { toast('添加失败:' + e.message, 'err'); } + finally { button.disabled = false; } +}; +$('proxyCheckAll').onclick = async () => { + const button = $('proxyCheckAll'); + button.disabled = true; + try { await api('proxies/check', { method: 'POST' }); toast('检测已排队', 'ok'); await loadProxies(); } + catch (e) { toast(e.message, 'err'); } + finally { button.disabled = false; } +}; +$('proxyBody').addEventListener('click', async ev => { + const button = ev.target.closest('button[data-proxy-action]'); + if (!button) return; + const { id, proxyAction: action } = button.dataset; + const item = proxyData?.proxies.find(p => p.id === id); + if (!item) return; + if (action === 'edit') { + proxyEditID = id; + $('proxyName').value = item.name; + $('proxyURL').value = item.url; + $('proxyPassword').value = ''; + $('proxyEditor').hidden = false; + $('proxyName').focus(); + return; + } + button.disabled = true; + try { + await api('proxies/' + encodeURIComponent(id) + (action === 'check' ? '/check' : ''), { method: action === 'check' ? 'POST' : 'DELETE' }); + if (action === 'remove' && proxyEditID === id) { proxyEditID = null; $('proxyEditor').hidden = true; } + toast(action === 'check' ? '检测已排队' : '代理已删除', 'ok'); + await loadProxies(); + } catch (e) { toast(e.message, 'err'); } + finally { button.disabled = false; } +}); +$('proxyBody').addEventListener('change', async ev => { + const input = ev.target; + if (!input.matches('[data-proxy-toggle]')) return; + input.disabled = true; + try { + await api('proxies/' + encodeURIComponent(input.dataset.proxyToggle), { method: 'PATCH', body: JSON.stringify({ enabled: input.checked }) }); + await loadProxies(); + } catch (e) { input.checked = !input.checked; toast(e.message, 'err'); } + finally { input.disabled = false; } +}); +$('proxyCancel').onclick = () => { + const id = proxyEditID; + proxyEditID = null; + $('proxyEditor').hidden = true; + $('proxyPassword').value = ''; + const origin = [...$('proxyBody').querySelectorAll('[data-proxy-action="edit"]')].find(el => el.dataset.id === id); + (origin || $('proxyAdd')).focus(); +}; +$('proxySave').onclick = async () => { + if (!proxyEditID) return; + const button = $('proxySave'); + button.disabled = true; + try { + await api('proxies/' + encodeURIComponent(proxyEditID), { method: 'PATCH', body: JSON.stringify({ + name: $('proxyName').value, url: $('proxyURL').value, password: $('proxyPassword').value, + }) }); + await loadProxies(); + $('proxyCancel').click(); + toast('代理已保存', 'ok'); + } catch (e) { toast(e.message, 'err'); } + finally { button.disabled = false; } +}; +$('proxyHealthFields').addEventListener('input', () => { proxySettingsDirty = true; }); +$('proxyHealthSave').onclick = async () => { + const button = $('proxyHealthSave'); + button.disabled = true; + try { + await api('proxies/health', { method: 'PUT', body: JSON.stringify({ + url: $('proxyHealthURL').value, interval_seconds: Number($('proxyInterval').value), timeout_seconds: Number($('proxyTimeout').value), + failure_threshold: Number($('proxyFailures').value), success_threshold: Number($('proxySuccesses').value), + }) }); + proxySettingsDirty = false; + toast('测活设置已保存', 'ok'); + await loadProxies(); + } catch (e) { toast(e.message, 'err'); } + finally { button.disabled = false; } +}; + +// realm 级默认出口(issue #39 P3):账号绑定优先于它,两者都没有才是随机池 / 直连。 +for (const [id, realm] of [['proxyRealmCn', 'cn'], ['proxyRealmGlobal', 'global']]) { + if (!$(id)) continue; + $(id).onchange = async ev => { + const v = ev.target.value; + const body = v === 'random' || v === 'direct' ? { mode: v } : { mode: 'fixed', proxy_id: v }; + try { + await api('proxies/realm/' + realm, { method: 'PUT', body: JSON.stringify(body) }); + toast((realm === 'cn' ? '国内版' : '国际版') + '默认出口已保存', 'ok'); + } catch (e) { toast('保存失败:' + e.message, 'err'); } + await loadProxies(true); + }; +} + +/* ── 扩展模型(免费渠道 / 自定义映射 / 访问密钥) ───────────────────── */ +let extData = null; +let extEditKeyID = ''; +let extEditKeyEnabled = true; +let extTargetsCache = null; + +const EXT_TYPE_DEFAULTS = { + opencode: { base: 'https://opencode.ai', models: '/inference/v1/models', chat: '/inference/openai/v1/chat/completions', filter: 'free-suffix', label: 'OpenCode Zen' }, + kilo: { base: 'https://ai-gateway.kilo.ai/api/v1', models: '/models', chat: '/chat/completions', filter: 'is-free', label: 'Kilo' }, + openai: { base: '', models: '/models', chat: '/chat/completions', filter: 'all', label: '' }, +}; + +function extTypeLabel(t) { + return t === 'opencode' ? 'OpenCode Zen' : t === 'kilo' ? 'Kilo' : 'OpenAI 兼容'; +} + +function extFilterLabel(f) { + return f === 'free-suffix' ? 'ID 含 free 段' : f === 'is-free' ? 'isFree=true' : '全部模型'; +} + +function splitLines(value) { + return String(value || '').split(/[\n,,;;]+/).map(s => s.trim()).filter(Boolean); +} + +function linesOf(list) { + return (Array.isArray(list) ? list : []).join('\n'); +} + +async function loadExtensions() { + try { + extData = await api('extensions'); + renderExtensions(); + loadExtTargets(); + } catch (e) { + if (e.status !== 401) toast('读取扩展配置失败:' + e.message, 'err'); + } +} + +function renderExtensions() { + if (!extData) return; + const f = extData.free || {}; + const providers = Array.isArray(f.providers) ? f.providers : []; + $('extFreeEnabled').checked = !!f.enabled; + $('extFreeNote').textContent = extData.path ? ('配置文件:' + extData.path) : ''; + + $('extProviders').innerHTML = providers.length ? providers.map(p => { + const models = Array.isArray(p.models) ? p.models : []; + return '
' + + '
' + esc(p.label || p.name) + '' + esc(p.name) + '' + + '' + + '
' + + '' + + '
' + + '' + + '' + + '
' + + '
' + + '' + + '' + + '
' + + '
' + + '' + + '' + + '
' + + '
' + + '' + models.length + ' 个模型' + (p.updated_at ? ' · ' + esc(new Date(p.updated_at).toLocaleString()) : '') + '
' + + '
'; + }).join('') : '
还没有渠道。点「添加渠道」接入一个免登录公共端点。
'; + + const rows = []; + for (const p of providers) { + for (const m of (Array.isArray(p.models) ? p.models : [])) { + rows.push('' + esc(p.label || p.name) + '' + + '' + esc('free:' + p.name + '/' + m.id) + '' + + '' + esc(m.name || '') + '' + + ''); + } + } + $('extModelsCount').textContent = rows.length ? rows.length + ' 个模型' : '尚未刷新'; + setHTML($('extModelsBody'), rows.length ? rows.join('') : + '
还没有模型清单。先添加渠道,再点「刷新模型清单」。
'); + + renderExtCustom(); + renderExtKeys(); +} + +function renderExtCustom() { + const customs = Array.isArray(extData.custom_models) ? extData.custom_models : []; + $('extCustomNote').textContent = customs.length ? customs.length + ' 条映射' : ''; + const modeLabel = m => m === 'prepend' ? 'user 前缀' : m === 'replace' ? '替换 system' : '追加 system'; + setHTML($('extCustomBody'), customs.length ? customs.map(m => + '' + esc(m.name) + '' + esc(m.target) + '' + + '' + esc(modeLabel(m.mode)) + '' + + '' + esc((m.prompt || '').slice(0, 140)) + ((m.prompt || '').length > 140 ? '…' : '') + '' + + '' + (m.enabled ? '启用' : '停用') + '' + + '
' + + ' ' + + '' + + '
').join('') : + '
还没有自定义模型映射
'); +} + +function renderExtKeys() { + const keys = Array.isArray(extData.access_keys) ? extData.access_keys : []; + $('extKeyNote').textContent = extData.panel_key_env_managed ? '面板密钥由 WB2A_PANEL_KEY 环境变量托管' : ''; + const limitHtml = k => { + const allow = Array.isArray(k.allow_models) ? k.allow_models : []; + const deny = Array.isArray(k.deny_models) ? k.deny_models : []; + if (!allow.length && !deny.length) return '全部模型'; + const parts = []; + if (allow.length) parts.push('白名单 ' + allow.length + ' 条'); + if (deny.length) parts.push('黑名单 ' + deny.length + ' 条'); + const tip = [allow.length ? '允许:' + allow.join(', ') : '', deny.length ? '拒绝:' + deny.join(', ') : ''].filter(Boolean).join('\n'); + return '' + esc(parts.join(' / ')) + ''; + }; + setHTML($('extKeyBody'), keys.length ? keys.map(k => + '' + esc(k.name || '') + '
' + esc(k.note || '') + '
' + + '' + esc(k.key) + '' + + '' + limitHtml(k) + '' + + '' + esc(k.created_at ? new Date(k.created_at).toLocaleString() : '—') + '' + + '' + esc(k.last_used_at ? new Date(k.last_used_at).toLocaleString() : '—') + '' + + '' + (k.enabled ? '启用' : '停用') + '' + + '
' + + ' ' + + ' ' + + ' ' + + '' + + '
').join('') : + '
还没有访问密钥
'); +} + +async function loadExtTargets() { + if (extTargetsCache) { fillExtTargets(); return; } + try { + const d = await api('models'); + extTargetsCache = Array.isArray(d.models) ? d.models : []; + } catch (e) { + extTargetsCache = []; + } + fillExtTargets(); +} + +function fillExtTargets() { + const set = new Set(); + for (const m of (extTargetsCache || [])) if (m.id) set.add(m.id); + for (const p of ((extData && extData.free && extData.free.providers) || [])) { + for (const m of (p.models || [])) set.add('free:' + p.name + '/' + m.id); + } + for (const m of ((extData && extData.custom_models) || [])) if (m.name) set.add(m.name); + const list = $('extTargetList'); + if (list) setHTML(list, [...set].sort().map(id => '').join('')); +} + +/* 渠道卡片保存 */ +function collectProviders() { + const prev = (extData && extData.free && extData.free.providers) || []; + return [...document.querySelectorAll('#extProviders .ext-provider')].map(card => { + const name = card.dataset.extProvider; + const old = prev.find(p => p.name === name) || { name }; + const val = sel => { const el = card.querySelector(sel); return el ? el.value.trim() : ''; }; + const checked = sel => { const el = card.querySelector(sel); return !!(el && el.checked); }; + return Object.assign({}, old, { + name, + label: old.label || old.name, + type: val('[data-ext-p-type]') || old.type || 'openai', + enabled: checked('[data-ext-p-enabled]'), + base_url: val('[data-ext-p-base]'), + models_path: val('[data-ext-p-models]'), + chat_path: val('[data-ext-p-chat]'), + free_filter: val('[data-ext-p-filter]'), + auth_header: val('[data-ext-p-authh]'), + auth_value: val('[data-ext-p-authv]'), + }); + }); +} + +async function saveFreeSettings() { + const btn = $('extFreeSave'); + btn.disabled = true; + try { + extData = await api('extensions/free', { method: 'POST', body: JSON.stringify({ + enabled: $('extFreeEnabled').checked, + providers: collectProviders(), + }) }); + renderExtensions(); + toast('渠道设置已保存', 'ok'); + } catch (e) { toast('保存失败:' + e.message, 'err'); } + finally { btn.disabled = false; } +} +$('extFreeSave').onclick = saveFreeSettings; + +$('extProviderAddToggle').onclick = () => { + const box = $('extProviderAdd'); + box.hidden = !box.hidden; + if (!box.hidden) applyProviderDefaults(); +}; + +function applyProviderDefaults() { + const d = EXT_TYPE_DEFAULTS[$('extPType').value] || EXT_TYPE_DEFAULTS.openai; + if (!$('extPBase').value) $('extPBase').value = d.base; + $('extPModelsPath').value = d.models; + $('extPChatPath').value = d.chat; + $('extPFilter').value = d.filter; + if (!$('extPLabel').value) $('extPLabel').value = d.label; +} +$('extPType').onchange = applyProviderDefaults; + +$('extPCancel').onclick = () => { + $('extProviderAdd').hidden = true; + ['extPName', 'extPLabel', 'extPBase', 'extPModelsPath', 'extPChatPath', 'extPAuthHeader', 'extPAuthValue', 'extPHeaders'].forEach(id => { $(id).value = ''; }); +}; + +$('extPAdd').onclick = async () => { + const name = $('extPName').value.trim().toLowerCase().replace(/[^a-z0-9_-]+/g, '-').replace(/^-+|-+$/g, ''); + if (!name) { toast('渠道名不能为空', 'err'); return; } + let headers = {}; + const rawHeaders = $('extPHeaders').value.trim(); + if (rawHeaders) { + try { headers = JSON.parse(rawHeaders); } catch (e) { toast('额外请求头不是合法 JSON', 'err'); return; } + } + const provider = { + name, label: $('extPLabel').value.trim() || name, type: $('extPType').value, enabled: true, + base_url: $('extPBase').value.trim(), models_path: $('extPModelsPath').value.trim(), + chat_path: $('extPChatPath').value.trim(), free_filter: $('extPFilter').value, + auth_header: $('extPAuthHeader').value.trim(), auth_value: $('extPAuthValue').value.trim(), headers, + }; + try { + extData = await api('extensions/free', { method: 'POST', body: JSON.stringify({ providers: [provider] }) }); + renderExtensions(); + $('extPCancel').click(); + toast('渠道已添加,正在刷新模型清单…', 'ok'); + await refreshFreeProvider(name); + } catch (e) { toast('添加失败:' + e.message, 'err'); } +}; + +async function refreshFreeProvider(provider) { + try { + const r = await api('extensions/free/refresh', { method: 'POST', body: JSON.stringify({ provider }) }); + extData = r.view || extData; + renderExtensions(); + toast((provider + ' 已刷新:' + r.count + ' 个模型'), 'ok'); + } catch (e) { toast(provider + ' 刷新失败:' + e.message, 'err'); } +} + +$('extProviders').addEventListener('click', async ev => { + const btn = ev.target.closest ? ev.target.closest('button') : null; + if (!btn) return; + if (btn.dataset.extPRefresh !== undefined) { + btn.disabled = true; + try { await refreshFreeProvider(btn.dataset.extPRefresh); } finally { btn.disabled = false; } + return; + } + if (btn.dataset.extPDel !== undefined) { + const name = btn.dataset.extPDel; + if (!confirm('删除渠道「' + name + '」及其模型清单?')) return; + try { + extData = await api('extensions/free/provider/delete', { method: 'POST', body: JSON.stringify({ name }) }); + renderExtensions(); + toast('渠道已删除', 'ok'); + } catch (e) { toast('删除失败:' + e.message, 'err'); } + } +}); + +$('extModelsBody').addEventListener('change', async ev => { + const cb = ev.target; + if (!cb || !cb.dataset || !cb.dataset.extFreeProvider) return; + try { + extData = await api('extensions/free/model', { method: 'POST', body: JSON.stringify({ + provider: cb.dataset.extFreeProvider, id: cb.dataset.extFreeId, enabled: cb.checked, + }) }); + renderExtensions(); + } catch (e) { + toast('保存失败:' + e.message, 'err'); + cb.checked = !cb.checked; + } +}); + +/* 自定义映射 */ +function resetCustomForm() { + ['extCName', 'extCTarget', 'extCDesc', 'extCTemp', 'extCMax', 'extCPrompt'].forEach(id => { $(id).value = ''; }); + $('extCMode').value = 'append'; + $('extCEnabled').checked = true; +} +$('extCReset').onclick = resetCustomForm; + +$('extCSave').onclick = async () => { + const name = $('extCName').value.trim(); + const target = $('extCTarget').value.trim(); + if (!name || !target) { toast('模型名与目标模型都必须填写', 'err'); return; } + const tempRaw = $('extCTemp').value.trim(); + const maxRaw = $('extCMax').value.trim(); + const btn = $('extCSave'); + btn.disabled = true; + try { + extData = await api('extensions/custom', { method: 'POST', body: JSON.stringify({ + name, target, prompt: $('extCPrompt').value, mode: $('extCMode').value, + description: $('extCDesc').value.trim(), + temperature: tempRaw === '' ? null : Number(tempRaw), + max_tokens: maxRaw === '' ? null : Number(maxRaw), + enabled: $('extCEnabled').checked, + }) }); + renderExtensions(); + resetCustomForm(); + toast('自定义模型已保存', 'ok'); + } catch (e) { toast('保存失败:' + e.message, 'err'); } + finally { btn.disabled = false; } +}; + +$('extCustomBody').addEventListener('click', async ev => { + const button = ev.target.closest ? ev.target.closest('button') : null; + if (!button) return; + if (button.dataset.extCustomEdit !== undefined) { + const name = button.dataset.extCustomEdit; + const m = (extData.custom_models || []).find(x => x.name === name); + if (!m) return; + $('extCName').value = m.name; + $('extCTarget').value = m.target; + $('extCPrompt').value = m.prompt || ''; + $('extCMode').value = m.mode || 'append'; + $('extCDesc').value = m.description || ''; + $('extCTemp').value = m.temperature == null ? '' : m.temperature; + $('extCMax').value = m.max_tokens == null ? '' : m.max_tokens; + $('extCEnabled').checked = !!m.enabled; + window.scrollTo({ top: 0, behavior: 'smooth' }); + return; + } + if (button.dataset.extCustomDel !== undefined) { + const name = button.dataset.extCustomDel; + if (!confirm('删除自定义模型「' + name + '」?')) return; + try { + extData = await api('extensions/custom/delete', { method: 'POST', body: JSON.stringify({ name }) }); + renderExtensions(); + toast('已删除', 'ok'); + } catch (e) { toast('删除失败:' + e.message, 'err'); } + } +}); + +/* 访问密钥 */ +function resetKeyForm() { + extEditKeyID = ''; + extEditKeyEnabled = true; + ['extKeyName', 'extKeyNoteInput', 'extKeyAllow', 'extKeyDeny'].forEach(id => { $(id).value = ''; }); + $('extKeyCreate').textContent = '生成访问密钥'; +} +$('extKeyReset').onclick = resetKeyForm; + +$('extKeyCreate').onclick = async () => { + const btn = $('extKeyCreate'); + btn.disabled = true; + const payload = { + name: $('extKeyName').value.trim(), + note: $('extKeyNoteInput').value.trim(), + allow_models: splitLines($('extKeyAllow').value), + deny_models: splitLines($('extKeyDeny').value), + enabled: extEditKeyID ? extEditKeyEnabled : true, + }; + try { + if (extEditKeyID) { + payload.id = extEditKeyID; + extData = await api('extensions/keys/update', { method: 'POST', body: JSON.stringify(payload) }); + renderExtensions(); + resetKeyForm(); + toast('访问密钥已更新', 'ok'); + } else { + const r = await api('extensions/keys', { method: 'POST', body: JSON.stringify(payload) }); + extData = r.view || extData; + const box = $('extKeyCreated'); + box.hidden = false; + box.innerHTML = '新密钥(只在这里完整显示,请立即复制):
' + esc(r.key) + ''; + renderExtensions(); + resetKeyForm(); + toast('访问密钥已生成', 'ok'); + } + } catch (e) { toast('保存失败:' + e.message, 'err'); } + finally { btn.disabled = false; } +}; + +$('extKeyBody').addEventListener('click', async ev => { + const button = ev.target.closest ? ev.target.closest('button') : null; + if (!button) return; + if (button.dataset.extKeyCopy !== undefined) { + try { + await navigator.clipboard.writeText(button.dataset.extKeyCopy); + toast('已复制到剪贴板', 'ok'); + } catch (e) { toast('复制失败,请手动选中密钥复制', 'err'); } + return; + } + if (button.dataset.extKeyEdit !== undefined) { + const k = (extData.access_keys || []).find(x => x.id === button.dataset.extKeyEdit); + if (!k) return; + extEditKeyID = k.id; + extEditKeyEnabled = !!k.enabled; + $('extKeyName').value = k.name || ''; + $('extKeyNoteInput').value = k.note || ''; + $('extKeyAllow').value = linesOf(k.allow_models); + $('extKeyDeny').value = linesOf(k.deny_models); + $('extKeyCreate').textContent = '保存修改'; + window.scrollTo({ top: 0, behavior: 'smooth' }); + return; + } + if (button.dataset.extKeyToggle !== undefined) { + try { + extData = await api('extensions/keys/toggle', { method: 'POST', body: JSON.stringify({ + id: button.dataset.extKeyToggle, enabled: button.dataset.extKeyEnabled !== '1', + }) }); + renderExtensions(); + } catch (e) { toast('操作失败:' + e.message, 'err'); } + return; + } + if (button.dataset.extKeyDel !== undefined) { + if (!confirm('删除这个访问密钥?使用它的客户端会立刻 401。')) return; + try { + extData = await api('extensions/keys/delete', { method: 'POST', body: JSON.stringify({ id: button.dataset.extKeyDel }) }); + renderExtensions(); + toast('已删除', 'ok'); + } catch (e) { toast('删除失败:' + e.message, 'err'); } + } +}); diff --git a/internal/panel/autotask.go b/internal/panel/autotask.go index bfcd984f4265e8fa501d7c24fa370367feba37bf..99e0411fb770851dde2b7eadeb3b024715e8d009 100644 --- a/internal/panel/autotask.go +++ b/internal/panel/autotask.go @@ -1,1265 +1,1631 @@ -// autotask.go 面板「一键完成」任务的动作实现。 -// -// 设计依据:上游 scripts/task_*.py 实测结论 + 2026-09-12 桌面指纹协议逆向 -// (data/desktop-task-protocol.md)—— -// - first_buddy(+300 分):report(前置解锁)→ agreement → buddy/first -// - chat_5(+100 分):累计 5 条 chat_request_send 上报 -// - Model_chat_GLM5.2(+100 分):accept → 用 glm-5.2 真实对话一次 → 上报(模型字段对齐) -// - RichMeow_Chat:桌面指纹(workbuddy-desktop)完整对话事件链,纯 API 可点亮(三账号实测) -// - Buddy_App / Buddy_App_QQ:buddyapp 五连事件,纯 API 可点亮(两账号实测) -// - automation_1:automated_task_create_suc 事件,纯 API 可点亮(两账号实测) -// - Library_read:web 域 web_element_click(library_doc_intro_click)(三账号实测) -// - template_5 / playbook_prompt / create_canvas:asar 逆向出的判据事件 -// (template_used / playbook_prompt_send / wbx_design_canvas_*),纯 API 可点亮(三账号实测) -// - expert_5 / Expert_team_use_3:真实专家列表 + 召唤链 + 真实 chat(服务端 requestId) -// - expert_actual_use(三账号实测) -// - Hp_Appearance:appearance/set + appearance_skin_apply 事件(两账号实测) -// -// 仍未破解:skill_1(疑似要求真实 Skill 工具调用)。 -// 不做:Expert_lighthouse(需真实连接器授权)、Expert_Philanthropy(真实捐款)。 -// -// 所有动作幂等:已 claimed/已达标的任务直接跳过,不重复消耗上游配额。 -package panel - -import ( - "context" - "encoding/json" - "fmt" - "io" - "log" - "math/rand/v2" - "net/http" - "strings" - "time" - - "github.com/linguo2625469/workbuddy2api-panel/internal/auth" - "github.com/linguo2625469/workbuddy2api-panel/internal/logfmt" - "github.com/linguo2625469/workbuddy2api-panel/internal/upstream" -) - -// autoAction 一个可自动化的任务动作。 -type autoAction struct { - TaskCode string // 目标任务 code - Desc string // 展示用说明 - Attempt bool // true = 尝试型(上游未证实可脚本化,跑了可能不点亮) - run func(p *Panel, a *auth.Auth) (string, error) -} - -// autoActions 已实现的任务动作表(顺序即执行顺序:先解锁依赖项)。 -// first_buddy 依赖活跃上报解锁,故 chat_5/first_buddy 的执行都自带 report 步骤。 -var autoActions = []autoAction{ - { - TaskCode: "chat_5", - Desc: "上报 5 条对话活跃事件(自动补足差额)", - run: runChat5, - }, - { - TaskCode: "first_buddy", - Desc: "上报解锁 → 同意协议 → 领取第一只 Buddy(+300 分)", - run: runFirstBuddy, - }, - { - TaskCode: "Model_chat_GLM5.2", - Desc: "接受任务 → glm-5.2 真实对话一次 → 对齐模型上报", - run: runModelChat, - }, - { - TaskCode: "RichMeow_Chat", - Desc: "桌面指纹事件链上报(已验证:纯 API 可点亮,三账号实测)", - run: runRichMeow, - }, - { - TaskCode: "Buddy_App", - Desc: "上报「进入 Buddy 应用」事件链(已验证:纯 API 可点亮)", - run: runBuddyApp, - }, - { - TaskCode: "Buddy_App_QQ", - Desc: "上报「进入企鹅教师助手」事件链(已验证:纯 API 可点亮)", - run: runBuddyApp, - }, - { - TaskCode: "automation_1", - Desc: "上报「定时任务创建」事件(已验证:纯 API 可点亮)", - run: runAutomationCreate, - }, - { - TaskCode: "Library_read", - Desc: "上报「读资料库介绍」事件(已验证:纯 API 可点亮)", - run: runLibraryRead, - }, - { - TaskCode: "template_5", - Desc: "上报「使用模板创建任务」事件组 ×5(已验证:三账号点亮)", - run: runTemplateUse, - }, - { - TaskCode: "playbook_prompt", - Desc: "上报「灵感案例做同款发送 Prompt」事件组(已验证:三账号点亮)", - run: runPlaybookPrompt, - }, - { - TaskCode: "create_canvas", - Desc: "上报「设计创意画布创建」事件组(已验证:三账号点亮,+300 分)", - run: runCreateCanvas, - }, - { - TaskCode: "expert_5", - Desc: "真实专家召唤+使用链 ×5(专家市场列表+真实 chat,已验证:三账号点亮)", - run: runExpertUse, - }, - { - TaskCode: "Expert_team_use_3", - Desc: "真实专家团召唤+使用链 ×3(已验证:三账号点亮)", - run: runExpertTeamUse, - }, - { - TaskCode: "Hp_Appearance", - Desc: "设置主题 API + 皮肤生效事件(已验证:两账号点亮)", - run: runAppearance, - }, - { - TaskCode: "skill_1", - Desc: "真实对话 + skill_info 技能加载事件(已验证:人杰2 点亮)", - run: runSkillFresh, - }, - { - TaskCode: "Expert_lighthouse", - Desc: "真实轻量云专家召唤+使用链(chat 链带 has_expert,已验证:两账号点亮)", - run: runExpertLighthouse, - }, - { - TaskCode: "black_cat", - Desc: "夜猫子:23:00–08:00 窗口内 glm-5.2 对话补足(窗口外提示稍后再试)", - Attempt: true, - run: runBlackCat, - }, - { - TaskCode: "school_season", - Desc: "校园日(小程序口径):accept → mini 对话+activityId 上报 → 领奖(+100c+5e)", - run: runSchoolSeason, - }, - { - TaskCode: "Sequential_Tasks_1", - Desc: "小程序首对话(小程序口径):accept → mini 对话上报 → 领奖(+100c+5e)", - run: runSequentialChat, - }, - { - TaskCode: "Sequential_Tasks_2", - Desc: "小程序选专家对话(小程序口径):市场专家 id → accept → expert_actual_use 上报 → 领奖(+200c+5e)", - run: runMiniExpert, - }, - { - TaskCode: "Sequential_Tasks_3", - Desc: "小程序五次对话(小程序口径):accept → mini 对话上报 ×5(自动补差额)→ 领奖(+300c+5e)", - run: runSequentialChat5, - }, - { - TaskCode: "Sequential_Tasks_4", - Desc: "小程序定时任务(预留,每日零点解锁一环):accept → 定时任务创建事件(PC 同源)→ 领奖(判据待解锁验证)", - run: runSequentialAutomation, - }, - { - TaskCode: "Sequential_Tasks_5", - Desc: "小程序使用 GLM5.2(预留):accept → 带模型字段的 mini 对话上报 → 领奖(判据待解锁验证)", - run: runSequentialModelChat, - }, - { - TaskCode: "Sequential_Tasks_6", - Desc: "小程序十次对话(预留):accept → mini 对话上报 ×target(自动补差额)→ 领奖", - run: runSequentialChat10, - }, - { - TaskCode: "Sequential_Tasks_7", - Desc: "体验灵感功能(预留,疑 PC 口径 +500c+5e):accept → 灵感事件组(PC+mp 双形态)→ 领奖(判据待解锁验证)", - run: runSequentialPlaybook, - }, -} - -// autoActionFor 查任务对应的动作;无则返回 nil(不可自动化)。 -func autoActionFor(code string) *autoAction { - for i := range autoActions { - if autoActions[i].TaskCode == strings.TrimSpace(code) { - return &autoActions[i] - } - } - return nil -} - -// autoActionIndex 任务在 autoActions 中的顺序(队列执行按依赖序排;未知返回大值)。 -func autoActionIndex(code string) int { - for i := range autoActions { - if autoActions[i].TaskCode == code { - return i - } - } - return 1 << 20 -} - -// mpTaskCodes 小程序口径专属下发的成长任务:默认(无 mp 头)列表不出现, -// accept/claim 均要求 X-Client-Platform: miniprogram。新任务出现时在此登记。 -var mpTaskCodes = map[string]bool{ - "school_season": true, // 校园日(mini chat + activityId) - "Sequential_Tasks_1": true, // 小程序首对话(mini chat,无 activityId) - "Sequential_Tasks_2": true, // 小程序选中专家并完成有效对话(mp 指纹 expert_actual_use) - "Sequential_Tasks_3": true, // 小程序完成 5 次对话(与 Tasks_1 同形状,target=5 逐条累加) - // Tasks_4..7 存在性已实测(accept 返回 prerequisite not met 链式依赖;Tasks_8 not - // found 封顶)。链条每日零点解锁一环(task locked until 次日),判据为 issue #42 - // 描述 + mpsrc 事件形状预置,解锁后逐个实测校正。 - "Sequential_Tasks_4": true, - "Sequential_Tasks_5": true, - "Sequential_Tasks_6": true, - "Sequential_Tasks_7": true, -} - -// isMPTaskCode 报告任务是否小程序口径专属(决定回读/接受/领奖走 mp 变体)。 -func isMPTaskCode(code string) bool { return mpTaskCodes[code] } - -// taskByCode 拉取任务列表并定位单个任务;未找到返回 nil(不视为错误)。 -// 双口径:mp 专属任务在默认列表查不到,自动回落 mp 列表(仅对已登记的 mp 码, -// 未知码不多打一次上游)。 -func (p *Panel) taskByCode(a *auth.Auth, code string) (*upstream.Task, error) { - tasks, err := p.cfg.Upstream.ListTasks(a) - if err != nil { - return nil, err - } - for i := range tasks { - if tasks[i].TaskCode == code { - return &tasks[i], nil - } - } - if isMPTaskCode(code) { - return p.taskByCodeMP(a, code) - } - return nil, nil -} - -// claimPollAttempts / claimPollGap 达标回读的有界轮询参数。 -// 背景:上游计分是**异步**的——行为事件上报后进度要数秒才刷新(实测 Model_chat -// 对话完成后立即回读仍是 0/1,约 5-8 秒后才变 1/1)。一次性回读会误判"未达标", -// 从而跳过自动领奖。这里最多轮询 N 次、每次间隔 gap,总预算约 12 秒。 -var ( - claimPollAttempts = 4 - claimPollGap = 3 * time.Second -) - -// taskByCodeWaiting 回读任务,若未达标则在有界预算内轮询等待(上游异步计分)。 -// 已达标(claimable)立即返回;预算耗尽返回最后一次结果(可能仍未达标)。 -func (p *Panel) taskByCodeWaiting(a *auth.Auth, code string) (*upstream.Task, error) { - t, err := p.taskByCode(a, code) - if err != nil || t == nil { - return t, err - } - if t.Claimable || t.Claimed { - return t, nil - } - for i := 1; i < claimPollAttempts; i++ { - time.Sleep(claimPollGap) - t2, err2 := p.taskByCode(a, code) - if err2 != nil { - return t, nil // 轮询期间的查询失败不覆盖已拿到的结果 - } - if t2 != nil { - t = t2 - if t.Claimable || t.Claimed { - return t, nil - } - } - } - return t, nil -} - -// taskByCodeMP 以小程序口径拉取任务列表并定位单个任务;未找到返回 nil。 -// 小程序限定任务(school_season / Sequential_Tasks_1)在默认口径列表不出现。 -func (p *Panel) taskByCodeMP(a *auth.Auth, code string) (*upstream.Task, error) { - tasks, err := p.cfg.Upstream.ListTasksMP(a) - if err != nil { - return nil, err - } - for i := range tasks { - if tasks[i].TaskCode == code { - return &tasks[i], nil - } - } - return nil, nil -} - -// acceptWithVerifyMP accept 并回读验证登记生效:上游存在 200+OK 但 accept 未真正 -// 登记的形态(此时上报事件全部不归账,任务永远点不亮,上游 task_runner c793ae3 -// 实测)——判定以回读 accept_status 为准,未生效重试一次。 -func (p *Panel) acceptWithVerifyMP(a *auth.Auth, code string) bool { - for attempt := 1; attempt <= 2; attempt++ { - if err := p.cfg.Upstream.AcceptTasksMP(a, []string{code}); err != nil { - log.Printf("autotask %s %s: accept 尝试%d: %v", logfmt.Label(a.UID, a.Nickname), code, attempt, err) - continue - } - time.Sleep(mpActionGap) - t, err := p.taskByCodeMP(a, code) - if err == nil && t != nil && t.AcceptStatus != "not_accepted" && t.AcceptStatus != "" { - return true - } - log.Printf("autotask %s %s: accept 尝试%d 未登记生效(回读=%q)", logfmt.Label(a.UID, a.Nickname), code, attempt, acceptStatusOr(t)) - } - return false -} - -// acceptStatusOr 安全读取任务 accept_status(nil 任务返回 "?")。 -func acceptStatusOr(t *upstream.Task) string { - if t == nil { - return "?" - } - if t.AcceptStatus == "" { - return "?" - } - return t.AcceptStatus -} - -// mpActionGap mp 任务写动作间隔(accept/上报/领奖之间,防频控)。 -var mpActionGap = 2 * time.Second - -// mpChatEventGap mp 对话事件(chat_request_send)的真人节奏间隔。上游对 -// Sequential_Tasks_3「5 次有效对话」有反作弊校验:数秒级连发的事件会先被计入 -// 进度(回读 5/5、accept_status 甚至短暂转 completed),随后被判定无效整体回滚 -// (进度回落、claim 返回 400 "task not completed")——2026-09-26 实测 2s 连发 -// 4 条全灭,45s 间隔逐条上报全存活且 claim +300c+5e 成功。每条上报前 -// sleep gap + 0~10s 抖动;首条也等(上一轮残留进度被回滚后立即重报同样无效)。 -var mpChatEventGap = 45 * time.Second - -// runMPMiniChatTask growth 域小程序限定任务通用闭环: -// mp 查询 → accept(带登记回读验证)→ mini chat 事件上报(withActivityId 决定 -// 是否带开学季 activityId:school_season 必带,Sequential_Tasks_1 不带——服务端按 -// source=mini_program 指纹关联)→ 回读 → 达标即领奖。 -func (p *Panel) runMPMiniChatTask(a *auth.Auth, code string, withActivityId bool) (string, error) { - t, err := p.taskByCodeMP(a, code) - if err != nil { - return "", err - } - if t == nil { - return "mp 口径未下发该任务(活动可能已结束)", nil - } - if t.Claimed { - return "已领取", nil - } - if t.AcceptStatus == "not_accepted" || t.AcceptStatus == "" { - if !p.acceptWithVerifyMP(a, code) { - return "accept 未登记生效(上游 200+OK 但未落账形态),待下次重试", nil - } - // accept 前的任务进度为 null(target 下发 0),兜底 target=1 会少报—— - // Tasks_6 首轮实测:accept 后真实 target=10,只补 1 条就误判达标去领奖 - // (claim 400 task not completed)。接受后回读一次拿真实 target/current。 - if t2, err := p.taskByCodeMP(a, code); err == nil && t2 != nil { - t = t2 - } - } - // 已达标(含 completed 未领):直接领奖。 - target := t.Target - if target <= 0 { - target = 1 - } - if t.Current >= target || t.AcceptStatus == "completed" { - credit, energy, err := p.cfg.Upstream.ClaimRewardMP(a, code) - if err != nil { - return "", err - } - return fmt.Sprintf("已领取奖励(+%dc +%de)", credit, energy), nil - } - // 判据上报:按差额补 mini chat 事件。每条前 sleep mpChatEventGap+抖动—— - // 连发会被上游反作弊判无效(见 mpChatEventGap 注释),宁可慢不可白报。 - need := target - t.Current - for i := int64(0); i < need; i++ { - time.Sleep(mpChatEventGap + time.Duration(rand.Int64N(int64(10*time.Second)))) - conv := fmt.Sprintf("wb2api-mp-%d-%d", time.Now().UnixMilli(), i) - var ev map[string]any - if withActivityId { - ev = upstream.SchoolSeasonChatEvent(conv) - } else { - ev = upstream.SchoolChatTimesEvents(conv) - } - if err := p.cfg.Upstream.ReportMPEvent(a, ev); err != nil { - return fmt.Sprintf("完成 %d/%d 次上报后中断: %v", i, need, err), nil - } - } - // 回读(异步计分,有界轮询复用 claimPoll 预算的紧凑版:两轮各隔 3s)。 - for i := 0; i < 2; i++ { - time.Sleep(claimPollGap) - t2, err2 := p.taskByCodeMP(a, code) - if err2 != nil || t2 == nil { - continue - } - t = t2 - if t.Claimable || t.Claimed || t.Current >= target { - break - } - } - if t.Claimed { - return "本轮已入账(claimed)", nil - } - if t.Current < target { - return fmt.Sprintf("已上报 %d 次但进度未达 %d/%d(异步计分未归账,下次重试)", need, t.Current, target), nil - } - credit, energy, err := p.cfg.Upstream.ClaimRewardMP(a, code) - if err != nil { - return "", err - } - return fmt.Sprintf("任务点亮并领取奖励(+%dc +%de)", credit, energy), nil -} - -// runSchoolSeason 完成 school_season「校园日」(growth 域小程序限定)。 -// 判据 = mini chat_request_send + activityId=school_open_day_2026(无 activityId -// 不点亮,与 school 域开学季同活动关联;上游 task_runner e2e 实测 +100c+5e)。 -func runSchoolSeason(p *Panel, a *auth.Auth) (string, error) { - return p.runMPMiniChatTask(a, "school_season", true) -} - -// runSequentialChat 完成 Sequential_Tasks_1「小程序内完成 1 次有效对话」。 -// 判据 = mini chat_request_send(无 activityId,服务端按 source=mini_program -// 指纹关联;上游 task_runner 实测 +100c+5e)。 -func runSequentialChat(p *Panel, a *auth.Auth) (string, error) { - return p.runMPMiniChatTask(a, "Sequential_Tasks_1", false) -} - -// runSequentialChat5 完成 Sequential_Tasks_3「在小程序内完成 5 次有效对话」。 -// 判据与 Sequential_Tasks_1 同形状(mini 指纹 chat_request_send,无 activityId), -// 仅 target=5——服务端按上报条数累加进度,但**要求真人节奏**:连发事件先计数 -// 后被反作弊回滚(claim 400 "task not completed"),由 mpChatEventGap 间隔保证 -// (2026-09-26 实测:45s 间隔补满 5/5 → claim +300c+5e 成功,领后 accept_status -// =claimed 稳定不回滚)。 -func runSequentialChat5(p *Panel, a *auth.Auth) (string, error) { - return p.runMPMiniChatTask(a, "Sequential_Tasks_3", false) -} - -// runSequentialChat10 完成 Sequential_Tasks_6「在小程序内完成 10 次有效对话」(预留)。 -// 判据假定与 Tasks_1/3 同形状(mini chat_request_send),target 由任务自带(回读), -// runMPMiniChatTask 按差额补报——issue #42 称 target=10,以解锁后实际下发为准。 -// 真人节奏间隔同样适用(mpChatEventGap):9 条 × ~50s ≈ 8 分钟/账号,夜间队列可接受。 -func runSequentialChat10(p *Panel, a *auth.Auth) (string, error) { - return p.runMPMiniChatTask(a, "Sequential_Tasks_6", false) -} - -// runSequentialEventTask Sequential 链预留任务通用骨架:mp 查询 → accept(带验证) -// → 判据事件上报(primary;未点亮且 fallback 非空时补一轮)→ 回读 → 达标领奖。 -// 每日零点解锁一环:locked 期间 accept 不落账,返回等下次调度(无需人工干预)。 -func (p *Panel) runSequentialEventTask(a *auth.Auth, code string, primary, fallback func() error) (string, error) { - t, err := p.taskByCodeMP(a, code) - if err != nil { - return "", err - } - if t == nil { - return "mp 口径未下发该任务(前置任务未完成或活动未开始)", nil - } - if t.Claimed { - return "已领取", nil - } - target := t.Target - if target <= 0 { - target = 1 - } - if t.Current >= target || t.AcceptStatus == "completed" { - credit, energy, err := p.cfg.Upstream.ClaimRewardMP(a, code) - if err != nil { - return "", err - } - return fmt.Sprintf("已领取奖励(+%dc +%de)", credit, energy), nil - } - if t.AcceptStatus == "not_accepted" || t.AcceptStatus == "" { - if !p.acceptWithVerifyMP(a, code) { - return "accept 未登记生效(任务可能处于每日锁定窗口,等解锁后自动重试)", nil - } - } - if err := primary(); err != nil { - return fmt.Sprintf("判据上报失败: %v", err), nil - } - // 回读(两轮各隔 3s);未点亮且有 fallback 时补报一轮再读。 - for round := 0; round < 2; round++ { - time.Sleep(claimPollGap) - t2, err2 := p.taskByCodeMP(a, code) - if err2 != nil || t2 == nil { - continue - } - t = t2 - if t.Claimable || t.Claimed || t.Current >= target { - break - } - if round == 0 && fallback != nil { - if err := fallback(); err != nil { - return fmt.Sprintf("备选判据上报失败: %v", err), nil - } - } - } - if t.Claimed { - return "本轮已入账(claimed)", nil - } - if t.Current < target { - return "已上报但进度未点亮(判据形态待解锁后校正,下次重试)", nil - } - credit, energy, err := p.cfg.Upstream.ClaimRewardMP(a, code) - if err != nil { - return "", err - } - return fmt.Sprintf("任务点亮并领取奖励(+%dc +%de)", credit, energy), nil -} - -// runSequentialAutomation 完成 Sequential_Tasks_4「创建定时任务」(预留)。 -// mp 源码无 automation 事件发射点 → 判据疑为 PC 口径:复用 automation_1 同源 -// 事件(DesktopAutomationCreateEvent,PC 任务三账号实测点亮)。 -func runSequentialAutomation(p *Panel, a *auth.Auth) (string, error) { - return p.runSequentialEventTask(a, "Sequential_Tasks_4", - func() error { - return p.cfg.Upstream.ReportDesktopEvent(a, upstream.DesktopAutomationCreateEvent("wb2api 自动化")) - }, nil) -} - -// runSequentialModelChat 完成 Sequential_Tasks_5「使用 GLM5.2」(预留)。 -// primary:mp 对话事件带 requestModelId/requestModelName=glm-5.2(mpsrc main 32904 -// 发射点实测形状);fallback:PC 域模型活跃上报(Model_chat_GLM5.2 同源)。 -func runSequentialModelChat(p *Panel, a *auth.Auth) (string, error) { - return p.runSequentialEventTask(a, "Sequential_Tasks_5", - func() error { - conv := fmt.Sprintf("wb2api-mp-glm-%d", time.Now().UnixMilli()) - return p.cfg.Upstream.ReportMPEvent(a, upstream.MiniChatModelEvent(conv, "glm-5.2", "GLM-5.2")) - }, - func() error { - return p.cfg.Upstream.ReportChatActivityModel(a, fmt.Sprintf("wb2api-mp-glm-%d", time.Now().UnixMilli()), "", "glm-5.2", "GLM-5.2") - }) -} - -// runSequentialPlaybook 完成 Sequential_Tasks_7「体验灵感功能」(预留,疑 PC 口径)。 -// primary:PC 灵感事件组(DesktopPlaybookPromptSequence,playbook_prompt 三账号 -// 实测点亮);fallback:mp 指纹灵感事件组(MiniPlaybookEvents,mpsrc 形状)。 -func runSequentialPlaybook(p *Panel, a *auth.Auth) (string, error) { - ms := time.Now().UnixMilli() - return p.runSequentialEventTask(a, "Sequential_Tasks_7", - func() error { - conv := fmt.Sprintf("wb2api-pb-%d", ms) - req := fmt.Sprintf("wb2api-pb-req-%d", ms) - return p.cfg.Upstream.ReportDesktopEvent(a, - upstream.DesktopPlaybookPromptSequence(conv, req, "pm-gtm-launch-plan", "新产品上市 GTM 发布计划一页纸")...) - }, - func() error { - return p.cfg.Upstream.ReportMPEvent(a, upstream.MiniPlaybookEvents("pm-gtm-launch-plan", "新产品上市 GTM 发布计划一页纸")...) - }) -} - -// runMiniExpert 完成 Sequential_Tasks_2「在小程序内选中专家并完成有效对话」。 -// 判据 = mp 指纹 expert_actual_use(**不带** activityId/conversationId、 -// extVersion=2.2.8、type=send_message——小程序源码实测形状,与 school 域 expert -// 事件两套口径勿混;上游 task_runner 实测上报即 completed,claim +200c+5e)。 -// 专家 id 必须是市场真实 ex_ id(空 id 服务端不入账)→ **accept 之前**先解析市场 -// 列表:拉不到就整任务不动作,避免留下「已登记未上报」的半程态(上游 9a26ae7 -// 的 ids 前置判定同款)。复用既有 MarketExpertList(expert_5 任务同源,实测可用)。 -func runMiniExpert(p *Panel, a *auth.Auth) (string, error) { - const code = "Sequential_Tasks_2" - t, err := p.taskByCodeMP(a, code) - if err != nil { - return "", err - } - if t == nil { - return "mp 口径未下发该任务(活动可能已结束)", nil - } - if t.Claimed { - return "已领取", nil - } - target := t.Target - if target <= 0 { - target = 1 // 未 accept 的 mp 任务 progress 为 null,target 兜底(上游实测) - } - // 已达标(含 completed 未领):直接领奖。 - if t.Current >= target || t.AcceptStatus == "completed" { - credit, energy, err := p.cfg.Upstream.ClaimRewardMP(a, code) - if err != nil { - return "", err - } - return fmt.Sprintf("已领取奖励(+%dc +%de)", credit, energy), nil - } - // 判据载体前置(accept 之前):市场真实专家 id。 - experts, merr := p.cfg.Upstream.MarketExpertList(a, "") - if merr != nil || len(experts) == 0 { - return fmt.Sprintf("专家市场不可用(%v),跳过以防半程态", merr), nil - } - e := experts[0] - name := e.DisplayNameZH - if name == "" { - name = e.ProfessionZH - } - if t.AcceptStatus == "not_accepted" || t.AcceptStatus == "" { - if !p.acceptWithVerifyMP(a, code) { - return "accept 未登记生效(上游 200+OK 但未落账形态),待下次重试", nil - } - } - ev := upstream.MiniExpertUseEvent(e.ExpertID, name, e.ExpertType) - if err := p.cfg.Upstream.ReportMPEvent(a, ev); err != nil { - return fmt.Sprintf("上报 expert_actual_use 失败: %v", err), nil - } - // 回读(异步计分,两轮各隔 3s——与 runMPMiniChatTask 同预算)。 - for i := 0; i < 2; i++ { - time.Sleep(claimPollGap) - t2, err2 := p.taskByCodeMP(a, code) - if err2 != nil || t2 == nil { - continue - } - t = t2 - if t.Claimable || t.Claimed || t.Current >= target { - break - } - } - if t.Claimed { - return "本轮已入账(claimed)", nil - } - if t.Current < target { - return "已上报但进度未归账(异步计分,下次重试)", nil - } - credit, energy, err := p.cfg.Upstream.ClaimRewardMP(a, code) - if err != nil { - return "", err - } - return fmt.Sprintf("任务点亮并领取奖励(+%dc +%de)", credit, energy), nil -} - -// accountTaskAuto 一键完成单个任务:执行对应动作 → 回读进度 → 汇报结果。 -func (p *Panel) accountTaskAuto(w http.ResponseWriter, r *http.Request) { - uid := r.PathValue("uid") - a := p.accountByUID(w, uid) - if a == nil { - return - } - var body struct { - TaskCode string `json:"task_code"` - } - if err := json.NewDecoder(r.Body).Decode(&body); err != nil || body.TaskCode == "" { - writeErr(w, http.StatusBadRequest, "task_code required") - return - } - act := autoActionFor(body.TaskCode) - if act == nil { - writeErr(w, http.StatusNotImplemented, - "该任务需要客户端内交互(无对应接口),无法自动完成;请按任务说明在官方客户端操作") - return - } - // per-account 互斥:同账号的任务动作正在跑(单任务或全量)时直接 409, - // 不并发重跑(动作幂等但 expert/skill 系含真实对话,重跑浪费配额)。 - if !p.tryLockAccount(uid) { - writeErr(w, http.StatusConflict, "该账号有任务动作正在执行中,请等本轮结束后再试") - return - } - defer p.unlockAccount(uid) - // 前置读取:已完成的任务直接跳过(幂等,不浪费上游调用)。 - // taskByCode 已双口径(mp 专属码自动回落 mp 列表)。 - before, err := p.taskByCode(a, act.TaskCode) - if err != nil { - writeErr(w, http.StatusBadGateway, "list tasks: "+err.Error()) - return - } - if before == nil { - writeErr(w, http.StatusNotFound, "该账号没有此任务") - return - } - isMP := isMPTaskCode(act.TaskCode) - if before.Claimed { - writeJSON(w, http.StatusOK, map[string]any{"ok": true, "skipped": true, "message": "该任务已领取过奖励"}) - return - } - msg, err := act.run(p, a) - if err != nil { - writeErr(w, http.StatusBadGateway, "执行失败: "+err.Error()) - return - } - // 回读验证:上报 200 ≠ 计分(上游可能静默丢弃 + 计分异步), - // 用有界轮询等异步计时落定,再决定是否自动领奖(mp 任务同口径回读)。 - var after *upstream.Task - var aerr error - if isMP { - after, aerr = p.taskByCodeMP(a, act.TaskCode) - } else { - after, aerr = p.taskByCodeWaiting(a, act.TaskCode) - } - progressBefore, progressAfter := taskProgressText(before), "" - claimable := false - if aerr == nil && after != nil { - progressAfter = taskProgressText(after) - claimable = after.Claimable - } - resp := map[string]any{ - "ok": true, - "message": msg, - "progress_before": progressBefore, - "progress_after": progressAfter, - "claimable": claimable, - "attempt": act.Attempt, - "verify_supported": true, - } - // 达标即自动领奖(Web 端 claim):把"完成→领奖"收敛成一步,无需用户再点一次。 - if claimable { - var credit, energy int64 - var cerr error - if isMP { - credit, energy, cerr = p.cfg.Upstream.ClaimRewardMP(a, act.TaskCode) - } else { - credit, energy, cerr = p.cfg.Upstream.ClaimReward(a, act.TaskCode) - } - if cerr == nil { - resp["claimed"] = true - resp["credit"] = credit - resp["energy"] = energy - if credit > 0 || energy > 0 { - resp["message"] = msg + fmt.Sprintf(";已自动领奖 +%d 分 +%d 能", credit, energy) - } else { - resp["message"] = msg + ";奖励此前已领取" - } - } else { - resp["claim_error"] = cerr.Error() - resp["message"] = msg + ";达标但领奖失败,可在任务列表手动点「领取」重试" - } - } - log.Printf("panel: 任务动作 uid=%s code=%s progress %s -> %s claimable=%v claimed=%v", - uid, act.TaskCode, progressBefore, progressAfter, claimable, resp["claimed"]) - writeJSON(w, http.StatusOK, resp) -} - -// taskProgressText 任务进度的可读表示(回读对比用)。 -func taskProgressText(t *upstream.Task) string { - if t == nil { - return "?" - } - if t.Target > 0 { - return fmt.Sprintf("%d/%d", t.Current, t.Target) - } - if t.Claimed { - return "claimed" - } - return t.AcceptStatus -} - -// truncateStr 截断错误文本(避免把上游长响应原样透给前端)。 -func truncateStr(s string, n int) string { - if len(s) <= n { - return s - } - return s[:n] + "…" -} - -// --------------------------------------------------------------------------- -// 各任务动作实现 -// --------------------------------------------------------------------------- - -// reportGap 连续上报之间的间隔(对齐上游脚本实测的 1.05s 口径,避免风控)。 -var reportGap = 1050 * time.Millisecond - -// runChat5 补足 chat_5 的进度:按差额上报 chat_request_send。 -func runChat5(p *Panel, a *auth.Auth) (string, error) { - t, err := p.taskByCode(a, "chat_5") - if err != nil { - return "", err - } - if t == nil { - return "", fmt.Errorf("任务不存在") - } - target := t.Target - if target <= 0 { - target = 5 - } - need := target - t.Current - if need <= 0 { - return "进度已达标,无需上报", nil - } - for i := int64(0); i < need; i++ { - cid := fmt.Sprintf("wb2api-chat5-%d-%d", time.Now().UnixMilli(), i) - if err := p.cfg.Upstream.ReportChatActivity(a, cid, ""); err != nil { - return fmt.Sprintf("上报第 %d/%d 条失败: %v", i+1, need, err), nil - } - if i < need-1 { - time.Sleep(reportGap) - } - } - return fmt.Sprintf("已补报 %d 条对话事件", need), nil -} - -// runFirstBuddy 领养:report(解锁前置)→ agreement → first。 -func runFirstBuddy(p *Panel, a *auth.Auth) (string, error) { - if err := p.cfg.Upstream.ReportChatActivity(a, fmt.Sprintf("wb2api-adopt-%d", time.Now().UnixMilli()), ""); err != nil { - return "", fmt.Errorf("前置上报: %w", err) - } - time.Sleep(reportGap) // 给上游事件处理留时间(脚本实测口径) - if err := p.cfg.Upstream.BuddyAgreement(a); err != nil { - return "", fmt.Errorf("同意协议: %w", err) - } - if err := p.cfg.Upstream.BuddyFirst(a); err != nil { - if upstream.IsBuddyTaskIncomplete(err) { - return "前置已上报,但领养门槛未过(上游要求当日活跃),请稍后重试", nil - } - return "", fmt.Errorf("领取 Buddy: %w", err) - } - return "已领取 Buddy(+300 分 +8 能量)", nil -} - -// runModelChat 完成 Model_chat_GLM5.2:accept → 真实对话 → 对齐模型上报。 -func runModelChat(p *Panel, a *auth.Auth) (string, error) { - const code, modelID, modelName = "Model_chat_GLM5.2", "glm-5.2", "GLM-5.2" - // 1. accept(报名;失败不阻塞——行为事件才是判据) - if err := p.cfg.Upstream.AcceptTasks(a, []string{code}); err != nil { - log.Printf("panel: accept %s: %v(继续走行为链路)", code, err) - } - time.Sleep(reportGap) - // 2. 真实对话一次(判据的最直接证据) - body, _ := json.Marshal(map[string]any{ - "model": modelID, - "messages": []map[string]any{ - {"role": "user", "content": "hi,请回复一句话"}, - }, - "stream": true, - }) - rc, status, respBody, err := p.cfg.Upstream.ChatStream(a, body, "", upstream.ChatMeta{}) - if err != nil { - return "", fmt.Errorf("对话请求: %w", err) - } - if status >= 400 { - rc.Close() - return "", fmt.Errorf("对话失败 http=%d: %s", status, truncateStr(string(respBody), 160)) - } - // 读干 SSE(网关对上游强制 flow:不读完会残留连接) - _, _ = io.Copy(io.Discard, io.LimitReader(rc, 1<<20)) - rc.Close() - time.Sleep(reportGap) - // 3. 对齐模型的上报(触发进度) - if err := p.cfg.Upstream.ReportChatActivityModel(a, fmt.Sprintf("wb2api-glm52-%d", time.Now().UnixMilli()), "", modelID, modelName); err != nil { - return "对话已完成,但进度上报失败:" + err.Error(), nil - } - return "已完成 glm-5.2 对话并上报", nil -} - -// runRichMeow 完成 RichMeow_Chat(桌面端对话1次)。 -// 2026-09-12 三账号实测验证:以桌面指纹(extName=workbuddy-desktop)向 -// copilot.tencent.com/v2/report 上报完整对话事件链(agent_task_created → -// chat_message_response isSuccessful=true 等 6 事件),纯 API 即可点亮并领奖 -// (紫川/人杰2 两账号无桌面客户端登录状态下 3 秒内 0/1 → 1/1)。 -// Hp_Appearance 的纯 API set 不计分(需客户端在主题下活跃),区别对待。 -func runRichMeow(p *Panel, a *auth.Auth) (string, error) { - ms := time.Now().UnixMilli() - conv := fmt.Sprintf("wb2api-rm-%d", ms) - req := fmt.Sprintf("wb2api-rm-req-%d", ms) - msg := fmt.Sprintf("req-%d-user", ms) - events := upstream.DesktopChatSequence(conv, req, msg, "fast-model", "fast-model") - if err := p.cfg.Upstream.ReportDesktopEvent(a, events...); err != nil { - return "", err - } - return "已按桌面端指纹上报完整对话事件链(agent_task_created→chat_response)", nil -} - -// runBuddyApp 完成 Buddy_App / Buddy_App_QQ(进入 Buddy 应用)。 -// 2026-09-12 两账号实测:buddyapp 五连事件(discover→show→enter→auth_confirm→ -// bind_skip)以 workbuddy-desktop 指纹上报即点亮,服务端不校验真实授权。 -// 用企鹅教师助手(Buddy_App_QQ 判据应用)作载体,同一组事件同时满足 -// Buddy_App「进入任一应用」——两个表项共用本 run,幂等由任务状态跳过兜底。 -func runBuddyApp(p *Panel, a *auth.Auth) (string, error) { - events := upstream.DesktopBuddyAppSequence("cb_y5Dy46tPQGGWtueMxXbe", "企鹅教师助手") - if err := p.cfg.Upstream.ReportDesktopEvent(a, events...); err != nil { - return "", err - } - return "已上报 buddyapp 进入五连事件(同时覆盖 Buddy_App 与 Buddy_App_QQ)", nil -} - -// runAutomationCreate 完成 automation_1(设置自动化任务)。 -// 2026-09-12 两账号实测:automated_task_create_suc 事件纯 API 上报即点亮, -// 无需真实创建定时任务。 -func runAutomationCreate(p *Panel, a *auth.Auth) (string, error) { - if err := p.cfg.Upstream.ReportDesktopEvent(a, - upstream.DesktopAutomationCreateEvent("wb2api 自动化")); err != nil { - return "", err - } - return "已上报定时任务创建事件", nil -} - -// runLibraryRead 完成 Library_read(体验资料库)。 -// 2026-09-12 三账号实测:web 域 /v2/report 上报 web_element_click -// (elementId=library_doc_intro_click) 即点亮(space 的 open/WS/inlong 都不是判据)。 -func runLibraryRead(p *Panel, a *auth.Auth) (string, error) { - const docURL = "https://www.workbuddy.cn/space/d/o0KWYeynteVv06UnAZqIFm" - if err := p.cfg.Upstream.ReportWebEvent(a, "web_element_click", docURL, - "library_doc_intro_click", "WorkBuddy资料库介绍"); err != nil { - return "", err - } - return "已上报资料库介绍阅读事件", nil -} - -// runBlackCat 完成 black_cat(夜猫子,夜间 23:00–08:00 计数)。 -// 判据 = 夜间窗口内 glm-5.2 真实对话 + chat 事件上报(WorkBuddy-Daily 实测口径)。 -// 窗口外不做(提示等排程);网关 blackcat_hours(默认 23 点)排程会自动补足。 -func runBlackCat(p *Panel, a *auth.Auth) (string, error) { - if !upstream.InNightWindow(time.Now()) { - return "当前不在 23:00–08:00 计数窗口,行为不计分;网关会在每日 23 点自动补足", nil - } - need, err := p.cfg.Upstream.BlackcatNeed(a) - if err != nil { - return "", err - } - if need <= 0 { - return "进度已达标,无需补足", nil - } - ok, err := p.cfg.Upstream.RunNightChats(a, int(need)) - if err != nil { - return fmt.Sprintf("完成 %d/%d 次后中断: %v", ok, need, err), nil - } - return fmt.Sprintf("已完成 %d 次夜间对话并上报", ok), nil -} - -// runSkillFresh 完成 skill_1(尝鲜热门技能)。 -// 2026-09-12 判据(紫川手动完成抓包 row 209):`skill_info` 事件(桌面指纹)—— -// {id:<技能名>, skillId, skillVersion, toolStatus:"success", fileCount, -// source:"workbuddy-desktop"} JOIN 真实会话(conversationId/requestId=服务端 -// id)。此前的 skill_request_send/skill_installed/skill_action 全是错误方向。 -// 人杰2 实测 0/1 → 1/1 点亮。 -func runSkillFresh(p *Panel, a *auth.Auth) (string, error) { - conv, req, err := p.cfg.Upstream.DesktopChatWithExpert(a, "") - if err != nil { - return "", fmt.Errorf("真实对话: %w", err) - } - msgID := "msg-" + req[len(req)-8:] - events := upstream.DesktopChatSequence(conv, req, msgID, "fast-model", "fast-model") - for _, ev := range events { - if ev["eventCode"] == "chat_message_response" { - ev["finishReason"] = "tool_calls" // 模型发起工具调用(技能加载)语义 - } - } - events = append(events, upstream.DesktopEvent{ - "eventCode": "skill_info", - "id": "润泽小馆·日报撰写", - "skillId": "skill_2097350077599879168", - "skillVersion": "1.0.0", - "toolStatus": "success", - "fileCount": 56, - "source": "workbuddy-desktop", - "conversationId": conv, "requestId": req, "messageId": msgID, - "requestModelId": "fast-model", "requestModelName": "fast-model", - "traceId": req, - }) - if err := p.cfg.Upstream.ReportDesktopEvent(a, events...); err != nil { - return "", fmt.Errorf("skill_info 事件: %w", err) - } - return "已上报真实对话 + skill_info 技能加载事件", nil -} - -// runExpertLighthouse 完成 Expert_lighthouse(体验「腾讯轻量云」专家)。 -// 2026-09-12 判据(真实样本 Sunny row 868):与 expert_5 同构,但两处差异—— -// chat 链的 agent_task_created 需带 has_expert:true + expert_id(我们默认 false), -// expert_actual_use 的 mode 为 "LOCAL"(非 craft)。id 固定为轻量云专家 -// ex_2cvvUZQhDyeJ;requestId 必须是真实 chat 的服务端 id。紫川/人杰2 实测点亮。 -func runExpertLighthouse(p *Panel, a *auth.Auth) (string, error) { - const lhID = "ex_2cvvUZQhDyeJ" - lh := upstream.MarketExpert{ - ExpertID: lhID, ExpertType: "agent", - DisplayNameZH: "腾讯轻量云专家", ProfessionZH: "腾讯轻量云专家", Version: "1.0.2", - } - // 市场列表若命中真实条目则用其信息(version 等以服务端为准)。 - if experts, err := p.cfg.Upstream.MarketExpertList(a, "agent"); err == nil { - for _, e := range experts { - if e.ExpertID == lhID { - lh = e - break - } - } - } - if err := p.cfg.Upstream.ReportDesktopEvent(a, upstream.DesktopExpertSummonSequence(lh)...); err != nil { - return "", fmt.Errorf("召唤链: %w", err) - } - conv, req, err := p.cfg.Upstream.DesktopChatWithExpert(a, lhID) - if err != nil { - return "", fmt.Errorf("真实对话: %w", err) - } - events := upstream.DesktopChatSequence(conv, req, "msg-"+req[len(req)-8:], "fast-model", "fast-model") - for _, ev := range events { - if ev["eventCode"] == "agent_task_created" { - ev["has_expert"] = true - ev["expert_id"] = lh.ExpertID - ev["expert_name"] = lh.DisplayNameZH - ev["expert_industry_id"] = "" - } - } - events = append(events, upstream.DesktopExpertActualUseLocal(lh, conv, req)) - // 对齐真实样本细节:轻量云专家 actual_use 的 type 为空、cost=0。 - events[len(events)-1]["type"] = "" - events[len(events)-1]["cost"] = 0 - if err := p.cfg.Upstream.ReportDesktopEvent(a, events...); err != nil { - return "", fmt.Errorf("使用事件: %w", err) - } - return "已上报轻量云专家召唤+使用链(真实对话 requestId)", nil -} - -// runAppearance 完成 Hp_Appearance(换主题)。 -// 2026-09-12 紫川/人杰2 实测(desktopverify12):判据是 appearance_skin_apply -// 事件 {action:"apply",source:"settings_close",id:,...}(客户端在 -// 主题生效状态下离开设置页时上报)——早期"纯 API set 不计分"的结论不准确, -// 真相是当时只调了 appearance/set 没发事件。组合:set API 留痕 + 事件上报。 -func runAppearance(p *Panel, a *auth.Auth) (string, error) { - const themeKey = "theme-tkmw7j" // 和平精英激战金秋(Hp_Appearance 判据主题) - if err := p.cfg.Upstream.SetAppearanceTheme(a, themeKey); err != nil { - return "", fmt.Errorf("设置主题: %w", err) - } - time.Sleep(2 * time.Second) - if err := p.cfg.Upstream.ReportDesktopEvent(a, upstream.DesktopEvent{ - "eventCode": "appearance_skin_apply", "action": "apply", "source": "settings_close", - "id": themeKey, "vipLevel": 0, "series": "", "type": "unknown", - }); err != nil { - return "", err - } - return "已设置主题并上报皮肤生效事件", nil -} - -// runTemplateUse 完成 template_5(使用 5 个模板创建任务)。 -// 2026-09-12 三账号实测:agent_task_created_with_template + template_used 事件组 -// (JOIN chat 链)一次上报 5 组即 5/5 点亮。template_id 服务端不校验真实性。 -func runTemplateUse(p *Panel, a *auth.Auth) (string, error) { - templates := [][2]string{{"1", "深度研究"}, {"2", "周报生成"}, {"3", "竞品分析"}, {"4", "活动策划"}, {"5", "代码评审"}} - for i, tp := range templates { - ms := time.Now().UnixMilli() - conv := fmt.Sprintf("wb2api-tpl-%d-%d", ms, i) - req := fmt.Sprintf("wb2api-tpl-req-%d-%d", ms, i) - events := upstream.DesktopTemplateUseSequence(conv, req, tp[0], tp[1]) - if err := p.cfg.Upstream.ReportDesktopEvent(a, events...); err != nil { - return fmt.Sprintf("第 %d 组模板事件上报失败: %v", i+1, err), nil - } - time.Sleep(300 * time.Millisecond) - } - return "已上报 template_used ×5", nil -} - -// runPlaybookPrompt 完成 playbook_prompt(灵感案例 Dialog 中发送 Prompt)。 -// 判据是 playbook_prompt_send(Dialog 发送)而非卡片曝光/点击——asar 逆向确认。 -func runPlaybookPrompt(p *Panel, a *auth.Auth) (string, error) { - ms := time.Now().UnixMilli() - conv := fmt.Sprintf("wb2api-pb-%d", ms) - req := fmt.Sprintf("wb2api-pb-req-%d", ms) - events := upstream.DesktopPlaybookPromptSequence(conv, req, "pm-gtm-launch-plan", "新产品上市 GTM 发布计划一页纸") - if err := p.cfg.Upstream.ReportDesktopEvent(a, events...); err != nil { - return "", err - } - return "已上报 playbook_cta_click + playbook_prompt_send", nil -} - -// runCreateCanvas 完成 create_canvas(设计创意模式创建画布,+300 分)。 -// 判据是 wbx_design_canvas_task_create/open(Ardot create_design 工具完成遥测)。 -func runCreateCanvas(p *Panel, a *auth.Auth) (string, error) { - ms := time.Now().UnixMilli() - conv := fmt.Sprintf("wb2api-canvas-%d", ms) - req := fmt.Sprintf("wb2api-canvas-req-%d", ms) - events := upstream.DesktopDesignCanvasSequence(conv, req) - if err := p.cfg.Upstream.ReportDesktopEvent(a, events...); err != nil { - return "", err - } - return "已上报 wbx_design_canvas_task_create/open", nil -} - -// expertSummonGap 专家召唤链的间隔(真实使用节奏,v11 实测 8s 成功率 100%)。 -const expertSummonGap = 6 * time.Second - -// runExpertUse 完成 expert_5(使用 5 个平台专家)。 -// 2026-09-12 三账号实测公式:真实专家列表(id 必须真实存在)→ 召唤链 -// (summon_click/summoned)→ 真实 chat 拿服务端 requestId → expert_actual_use。 -// 自造专家 id 或自造 requestId 均不计数。 -func runExpertUse(p *Panel, a *auth.Auth) (string, error) { - return runExpertBatch(p, a, "agent", 5) -} - -// runExpertTeamUse 完成 Expert_team_use_3(使用 3 个专家团,expertType=team)。 -func runExpertTeamUse(p *Panel, a *auth.Auth) (string, error) { - return runExpertBatch(p, a, "team", 3) -} - -// runExpertBatch 专家召唤+使用的公共实现。失败逐个继续,返回汇总信息。 -func runExpertBatch(p *Panel, a *auth.Auth, expertType string, count int) (string, error) { - experts, err := p.cfg.Upstream.MarketExpertList(a, expertType) - if err != nil { - return "", fmt.Errorf("拉取专家列表: %w", err) - } - if len(experts) == 0 { - return "", fmt.Errorf("专家市场列表为空") - } - ok, fail := 0, 0 - for i, e := range experts { - if ok >= count { - break - } - // 召唤链(web_element_click + summon_click + summoned)。 - summonEvents := upstream.DesktopExpertSummonSequence(e) - if err := p.cfg.Upstream.ReportDesktopEvent(a, summonEvents...); err != nil { - fail++ - continue - } - // 真实 chat(带 X-Expert-Id)→ 服务端 requestId。 - conv, req, cerr := p.cfg.Upstream.DesktopChatWithExpert(a, e.ExpertID) - if cerr != nil { - fail++ - continue - } - // 使用事件(JOIN 服务端 requestId)+ chat 链。 - events := append(upstream.DesktopChatSequence(conv, req, "msg-"+req[len(req)-8:], "fast-model", "fast-model"), - upstream.DesktopExpertActualUseEvent(e, conv, req)) - if err := p.cfg.Upstream.ReportDesktopEvent(a, events...); err != nil { - fail++ - continue - } - ok++ - if i < len(experts)-1 { - time.Sleep(expertSummonGap) - } - } - _ = fail - return fmt.Sprintf("已对 %d 位真实专家完成召唤+使用链(类型 %s)", ok, expertType), nil -} - -// --------------------------------------------------------------------------- -// 全量自动完成 -// --------------------------------------------------------------------------- - -// runAutoAll 对单账号依次执行所有可自动化任务,返回逐项结果。 -// 供「一键完成全部可自动任务」使用;单项失败不影响后续项。 -// -// 流程:先把所有未接受的任务批量 accept(规范状态机;上游脚本建议"先 accept"), -// 再逐项执行行为链路。accept 不是进度产生的必要条件,但让后续状态流转规范。 -func (p *Panel) runAutoAll(a *auth.Auth) []map[string]any { - var out []map[string]any - - // 阶段 0:批量接受尚未接受的任务(失败不阻塞——行为事件才是进度唯一判据)。 - if tasks, err := p.cfg.Upstream.ListTasks(a); err == nil { - var codes []string - for _, t := range tasks { - if !t.Claimed && !t.Locked && t.AcceptStatus != "accepted" && t.AcceptStatus != "completed" { - codes = append(codes, t.TaskCode) - } - } - if len(codes) > 0 { - if err := p.cfg.Upstream.AcceptTasks(a, codes); err != nil { - out = append(out, map[string]any{ - "task_code": "(批量接受)", "status": "error", - "message": "接受任务失败(不阻塞后续): " + err.Error(), - }) - } else { - out = append(out, map[string]any{ - "task_code": "(批量接受)", "status": "done", - "message": fmt.Sprintf("已接受 %d 个任务", len(codes)), - }) - time.Sleep(reportGap) - } - } - } - - // 阶段 0b:小程序口径任务单独接受(默认列表不含 mp 码;失败不阻塞)。 - if mpTasks, err := p.cfg.Upstream.ListTasksMP(a); err == nil { - var mpCodes []string - for _, t := range mpTasks { - if !t.Claimed && !t.Locked && t.AcceptStatus != "accepted" && t.AcceptStatus != "completed" { - mpCodes = append(mpCodes, t.TaskCode) - } - } - if len(mpCodes) > 0 { - if err := p.cfg.Upstream.AcceptTasksMP(a, mpCodes); err != nil { - out = append(out, map[string]any{ - "task_code": "(批量接受-mp)", "status": "error", - "message": "接受小程序任务失败(不阻塞后续): " + err.Error(), - }) - } else { - out = append(out, map[string]any{ - "task_code": "(批量接受-mp)", "status": "done", - "message": fmt.Sprintf("已接受 %d 个小程序任务", len(mpCodes)), - }) - time.Sleep(reportGap) - } - } - } - - for _, act := range autoActions { - item := map[string]any{"task_code": act.TaskCode, "desc": act.Desc} - before, err := p.taskByCode(a, act.TaskCode) - if err != nil { - item["status"] = "error" - item["message"] = "查询失败: " + err.Error() - out = append(out, item) - continue - } - if before == nil { - item["status"] = "skipped" - item["message"] = "该账号无此任务" - out = append(out, item) - continue - } - if before.Claimed || before.Current >= before.Target && before.Target > 0 { - item["status"] = "skipped" - item["message"] = "已完成(" + taskProgressText(before) + ")" - out = append(out, item) - continue - } - msg, err := act.run(p, a) - if err != nil { - item["status"] = "error" - item["message"] = err.Error() - out = append(out, item) - continue - } - var after *upstream.Task - if isMPTaskCode(act.TaskCode) { - after, _ = p.taskByCodeMP(a, act.TaskCode) - } else { - after, _ = p.taskByCodeWaiting(a, act.TaskCode) - } - item["status"] = "done" - item["message"] = msg - item["progress_after"] = taskProgressText(after) - // 进度达标即自动领奖(mp 任务走 chat 域 mp 口径,其余 Web 端接口)。 - // 领奖失败不掩盖主流程结果:status 仍为 done,附加 claim_error 供前端提示。 - if after != nil && after.Claimable { - item["claimable"] = true - var credit, energy int64 - var cerr error - if isMPTaskCode(act.TaskCode) { - credit, energy, cerr = p.cfg.Upstream.ClaimRewardMP(a, act.TaskCode) - } else { - credit, energy, cerr = p.cfg.Upstream.ClaimReward(a, act.TaskCode) - } - if cerr == nil { - item["claimed"] = true - item["credit"] = credit - item["energy"] = energy - if credit > 0 || energy > 0 { - item["message"] = msg + fmt.Sprintf(";已自动领奖 +%d 分 +%d 能", credit, energy) - } else { - item["message"] = msg + ";奖励此前已领取" - } - } else { - item["claim_error"] = cerr.Error() - item["message"] = msg + ";达标但领奖失败(可在列表手动重试)" - } - } - out = append(out, item) - time.Sleep(reportGap) // 项间节流 - } - return out -} - -// accountTaskAutoAll 一键完成该账号全部可自动任务。 -func (p *Panel) accountTaskAutoAll(w http.ResponseWriter, r *http.Request) { - uid := r.PathValue("uid") - a := p.accountByUID(w, uid) - if a == nil { - return - } - // per-account 互斥(与单任务动作共用一把锁):重复点击 409。 - if !p.tryLockAccount(uid) { - writeErr(w, http.StatusConflict, "该账号有任务动作正在执行中,请等本轮结束后再试") - return - } - // 用 context 兜底超时(多项任务串联 + 每项含真实对话,可能耗时较长)。 - ctx, cancel := context.WithTimeout(r.Context(), 5*time.Minute) - defer cancel() - done := make(chan []map[string]any, 1) - go func() { - defer p.unlockAccount(uid) // 流水线真正结束(而非 HTTP 超时返回)才放锁 - done <- p.runAutoAll(a) - }() - select { - case results := <-done: - log.Printf("panel: 一键完成可自动任务 uid=%s 共 %d 项", uid, len(results)) - writeJSON(w, http.StatusOK, map[string]any{"ok": true, "results": results}) - case <-ctx.Done(): - // HTTP 侧超时返回,但后台流水线仍在跑——锁在流水线 goroutine 内释放, - // 期间重复点击会被 409 挡住,不会出现两轮并发。 - writeErr(w, http.StatusGatewayTimeout, "执行超时(任务仍在后台继续)") - } -} +// autotask.go 面板「一键完成」任务的动作实现。 +// +// 设计依据:上游 scripts/task_*.py 实测结论 + 2026-09-12 桌面指纹协议逆向 +// (data/desktop-task-protocol.md)—— +// - first_buddy(+300 分):report(前置解锁)→ agreement → buddy/first +// - chat_5(+100 分):累计 5 条 chat_request_send 上报 +// - RichMeow_Chat:桌面指纹(workbuddy-desktop)完整对话事件链,纯 API 可点亮(三账号实测) +// - Buddy_App:buddyapp 五连事件,纯 API 可点亮(两账号实测) +// - automation_1:automated_task_create_suc 事件,纯 API 可点亮(两账号实测) +// - Library_read:web 域 web_element_click(library_doc_intro_click)(三账号实测) +// - template_5 / playbook_prompt:asar 逆向出的判据事件 +// (template_used / playbook_prompt_send),纯 API 可点亮(三账号实测) +// - expert_5 / Expert_team_use_3:真实专家列表 + 召唤链 + 真实 chat(服务端 requestId) +// - expert_actual_use(三账号实测) +// - expert_use_* 系列(中国电商运营专家 / 抖音策略师 / 商家宣传页与海报设计师 / 直播电商教练): +// 判据同 Expert_lighthouse,专家 id 取自任务 jump_url +// - Hp_Appearance:appearance/set + appearance_skin_apply 事件(两账号实测) +// +// 仍未破解:skill_1(疑似要求真实 Skill 工具调用)。 +// 不做:Expert_lighthouse(需真实连接器授权)、Expert_Philanthropy(真实捐款)。 +// 已下架(上游列表里没有,动作代码一并删除):Model_chat_GLM5.2 / Buddy_App_QQ / +// create_canvas / black_cat。 +// +// 已领取任务不重复执行,已达标未领奖的任务只领奖,不重复消耗对话配额。 +package panel + +import ( + "context" + "encoding/json" + "errors" + "fmt" + "log" + "math/rand/v2" + "net/http" + "strings" + "time" + + "github.com/misakano7545/workbuddy2api-panel/internal/auth" + "github.com/misakano7545/workbuddy2api-panel/internal/logfmt" + "github.com/misakano7545/workbuddy2api-panel/internal/session" + "github.com/misakano7545/workbuddy2api-panel/internal/upstream" +) + +// autoAction 一个可自动化的任务动作。 +type autoAction struct { + TaskCode string // 目标任务 code + Desc string // 展示用说明 + Attempt bool // true = 尝试型(上游未证实可脚本化,跑了可能不点亮) + // ClaimOnly 只领奖不做动作(issue #174):白名单外的任务达标后没人领,积分就永久卡住。 + // 执行器看到 progress 已达标直接 claim;未达标则跳过("没有可执行的自动动作"), + // 不消耗对话配额、不发任何上游动作请求。 + ClaimOnly bool + run func(p *Panel, a *auth.Auth) (string, error) +} + +const globalTaskWriteMessage = "国际区任务暂仅支持查询,请在官方客户端操作" + +// autoTaskOutcome 是统一任务执行器的结果。Status 是任务状态机的唯一完成判据: +// done 只表示服务端已确认领取或领奖请求已成功;未入账、领奖失败、读错均保留各自状态。 +type autoTaskOutcome struct { + Status string + Message string + ProgressBefore string + ProgressAfter string + Claimable bool + Claimed bool + Credit int64 + Energy int64 + ClaimError string + Attempt bool + ActionRun bool +} + +// autoActions 已实现的任务动作表(顺序即执行顺序:先解锁依赖项)。 +// first_buddy 依赖活跃上报解锁,故 chat_5/first_buddy 的执行都自带 report 步骤。 +var autoActions = []autoAction{ + { + TaskCode: "chat_5", + Desc: "上报 5 条对话活跃事件(自动补足差额)", + run: runChat5, + }, + { + TaskCode: "first_buddy", + Desc: "上报解锁 → 同意协议 → 领取第一只 Buddy(+300 分)", + run: runFirstBuddy, + }, + { + TaskCode: "RichMeow_Chat", + Desc: "桌面指纹事件链上报(已验证:纯 API 可点亮,三账号实测)", + run: runRichMeow, + }, + { + TaskCode: "Buddy_App", + Desc: "上报「进入 Buddy 应用」事件链(已验证:纯 API 可点亮)", + run: runBuddyApp, + }, + { + TaskCode: "automation_1", + Desc: "上报「定时任务创建」事件(已验证:纯 API 可点亮)", + run: runAutomationCreate, + }, + { + TaskCode: "Library_read", + Desc: "上报「读资料库介绍」事件(已验证:纯 API 可点亮)", + run: runLibraryRead, + }, + { + TaskCode: "template_5", + Desc: "上报「使用模板创建任务」事件组 ×5(已验证:三账号点亮)", + run: runTemplateUse, + }, + { + TaskCode: "playbook_prompt", + Desc: "上报「灵感案例做同款发送 Prompt」事件组(已验证:三账号点亮)", + run: runPlaybookPrompt, + }, + { + TaskCode: "expert_5", + Desc: "真实专家召唤+使用链 ×5(专家市场列表+真实 chat,已验证:三账号点亮)", + run: runExpertUse, + }, + { + TaskCode: "Expert_team_use_3", + Desc: "真实专家团召唤+使用链 ×3(已验证:三账号点亮)", + run: runExpertTeamUse, + }, + { + TaskCode: "Hp_Appearance", + Desc: "设置主题 API + 皮肤生效事件(已验证:两账号点亮)", + run: runAppearance, + }, + { + TaskCode: "skill_1", + Desc: "真实对话 + skill_info 技能加载事件(已验证:人杰2 点亮)", + run: runSkillFresh, + }, + { + TaskCode: "Expert_lighthouse", + Desc: "真实轻量云专家召唤+使用链(chat 链带 has_expert,已验证:两账号点亮)", + run: runExpertLighthouse, + }, + { + TaskCode: "WorkBuddy_Valorant", + Desc: "无畏契约拼豆专家召唤+使用链(判据同 Expert_lighthouse;活动截止 2026-11-15)", + run: runValorantExpert, + }, + { + TaskCode: "expert_use_maidehao", + Desc: "中国电商运营专家召唤+使用链(专家页搜索口径;活动截止 2026-11-20,+50c+5e)", + run: runExpertExperienceFor("expert_use_maidehao"), + }, + { + TaskCode: "expert_use_douyinyin", + Desc: "抖音策略师召唤+使用链(专家页搜索口径;活动截止 2026-11-20,+50c+5e)", + run: runExpertExperienceFor("expert_use_douyinyin"), + }, + { + TaskCode: "expert_use_shangjia_xuanchuan", + Desc: "商家宣传页与海报设计师召唤+使用链(专家页搜索口径;活动截止 2026-11-20,+50c+5e)", + run: runExpertExperienceFor("expert_use_shangjia_xuanchuan"), + }, + { + TaskCode: "expert_use_bowangwang", + Desc: "直播电商教练召唤+使用链(专家页搜索口径;活动截止 2026-11-20,+50c+5e)", + run: runExpertExperienceFor("expert_use_bowangwang"), + }, + { + TaskCode: "Sequential_Tasks_1", + Desc: "小程序首对话(小程序口径):accept → mini 对话上报 → 领奖(+100c+5e)", + run: runSequentialChat, + }, + { + TaskCode: "Sequential_Tasks_2", + Desc: "小程序选专家对话(小程序口径):市场专家 id → accept → expert_actual_use 上报 → 领奖(+200c+5e)", + run: runMiniExpert, + }, + { + TaskCode: "Sequential_Tasks_3", + Desc: "小程序五次对话(小程序口径):accept → mini 对话上报 ×5(自动补差额)→ 领奖(+300c+5e)", + run: runSequentialChat5, + }, + { + TaskCode: "Sequential_Tasks_4", + Desc: "小程序定时任务(预留,每日零点解锁一环):accept → 定时任务创建事件(PC 同源)→ 领奖(判据待解锁验证)", + run: runSequentialAutomation, + }, + { + TaskCode: "Sequential_Tasks_5", + Desc: "小程序使用 GLM5.2(预留):accept → 带模型字段的 mini 对话上报 → 领奖(判据待解锁验证)", + run: runSequentialModelChat, + }, + { + TaskCode: "Sequential_Tasks_6", + Desc: "小程序十次对话(预留):accept → mini 对话上报 ×target(自动补差额)→ 领奖", + run: runSequentialChat10, + }, + { + TaskCode: "Sequential_Tasks_7", + Desc: "体验灵感功能(预留,疑 PC 口径 +500c+5e):accept → 灵感事件组(PC+mp 双形态)→ 领奖(判据待解锁验证)", + run: runSequentialPlaybook, + }, +} + +// autoActionFor 查任务对应的动作;无则返回 nil(不可自动化)。 +func autoActionFor(code string) *autoAction { + for i := range autoActions { + if autoActions[i].TaskCode == strings.TrimSpace(code) { + return &autoActions[i] + } + } + return nil +} + +// autoActionIndex 任务在 autoActions 中的顺序(队列执行按依赖序排;未知返回大值)。 +// claimOnlyAction 为「已达标但无自动化动作」的任务合成只领奖动作(issue #174)。 +// run == nil:不执行任何动作,执行器只在 progress 已达标时 claim。 +func claimOnlyAction(code string) *autoAction { + return &autoAction{TaskCode: code, Desc: "补领:已达标未领奖(无自动动作)", ClaimOnly: true} +} + +// queuedActionFor 队列执行用的动作解析:白名单有动作就用白的;否则合成只领奖动作。 +// +// 为什么不在入队前过滤:白名单外任务的「达标」判定要等扫描拿到 progress 才知道, +// 而入队与执行共享同一份扫描结果(scanAccountGrowth → it.Growth)。合成动作后, +// 未达标的任务在执行器里按「没有可执行的自动动作」跳过,等价于旧的入队过滤, +// 但达标未领的那部分被捞回来了。 +func queuedActionFor(code string) *autoAction { + if a := autoActionFor(code); a != nil { + return a + } + return claimOnlyAction(code) +} + +func autoActionIndex(code string) int { + for i := range autoActions { + if autoActions[i].TaskCode == code { + return i + } + } + return 1 << 20 +} + +// mpTaskCodes 小程序口径专属下发的成长任务:默认(无 mp 头)列表不出现, +// accept/claim 均要求 X-Client-Platform: miniprogram。新任务出现时在此登记。 +var mpTaskCodes = map[string]bool{ + "Sequential_Tasks_1": true, // 小程序首对话(mini chat,无 activityId) + "Sequential_Tasks_2": true, // 小程序选中专家并完成有效对话(mp 指纹 expert_actual_use) + "Sequential_Tasks_3": true, // 小程序完成 5 次对话(与 Tasks_1 同形状,target=5 逐条累加) + // Tasks_4..7 存在性已实测(accept 返回 prerequisite not met 链式依赖;Tasks_8 not + // found 封顶)。链条每日零点解锁一环(task locked until 次日),判据为 issue #42 + // 描述 + mpsrc 事件形状预置,解锁后逐个实测校正。 + "Sequential_Tasks_4": true, + "Sequential_Tasks_5": true, + "Sequential_Tasks_6": true, + "Sequential_Tasks_7": true, +} + +// isMPTaskCode 报告任务是否小程序口径专属(决定回读/接受/领奖走 mp 变体)。 +func isMPTaskCode(code string) bool { return mpTaskCodes[code] } + +// 上游软限流(429 soft_rate)重试预算:growth 域频控是分钟级窗口,而一轮全量任务 +// 要连打几十次 ListTasks/accept/claim——撞上一次就把整条链断在「查询任务失败」, +// 用户只看到失败,实际等一会儿就能过去(任务动作都是幂等读/写)。 +// softRateRetries 是首次之外的重试次数;单次等待取上游 Retry-After(封顶 +// softRateGapMax,防一个头把后台作业拖住),没给就按 softRateGap 线性递增。 +var ( + softRateRetries = 2 + softRateGap = 15 * time.Second + softRateGapMax = 60 * time.Second +) + +// isSoftRateErr 是否上游软限流(429)。只对这一类重试——其它错误等不来。 +func isSoftRateErr(err error) bool { + var ue *upstream.Error + return errors.As(err, &ue) && ue.Kind == upstream.ErrSoftRate +} + +// softRateWait 本次重试前应等待的时长:上游 Retry-After 优先,缺省按次数递增并封顶。 +func softRateWait(err error, attempt int) time.Duration { + d := time.Duration(attempt) * softRateGap + var ue *upstream.Error + if errors.As(err, &ue) && ue.RetryAfter > d { + d = ue.RetryAfter + } + if d > softRateGapMax { + d = softRateGapMax + } + return d +} + +// softRateGate 该账号距限流窗口结束还剩多久(0 = 未限流,过期自动清)。 +func (p *Panel) softRateGate(uid string) time.Duration { + p.softRateMu.Lock() + defer p.softRateMu.Unlock() + until, ok := p.softRateUntil[uid] + if !ok { + return 0 + } + d := time.Until(until) + if d <= 0 { + delete(p.softRateUntil, uid) + return 0 + } + return d +} + +func (p *Panel) noteSoftRate(uid string, d time.Duration) { + p.softRateMu.Lock() + defer p.softRateMu.Unlock() + if p.softRateUntil == nil { + p.softRateUntil = make(map[string]time.Time) + } + p.softRateUntil[uid] = time.Now().Add(d) +} + +// listTasksSoftRate 拉任务列表,软限流时按窗口等待重试(mp 走小程序口径)。 +// 冷却窗口内不重试直接快失败:此时上游还没放开,再打只会把窗口续得更长。 +func (p *Panel) listTasksSoftRate(a *auth.Auth, mp bool) ([]upstream.Task, error) { + if d := p.softRateGate(a.UID); d > 0 { + return nil, fmt.Errorf("上游限流(429),约 %s 后恢复,请稍后重跑该任务", d.Round(time.Second)) + } + for attempt := 0; ; attempt++ { + var tasks []upstream.Task + var err error + if mp { + tasks, err = p.cfg.Upstream.ListTasksMP(a) + } else { + tasks, err = p.cfg.Upstream.ListTasks(a) + } + if err == nil { + return tasks, nil + } + if !isSoftRateErr(err) { + return nil, err + } + if attempt >= softRateRetries { + p.noteSoftRate(a.UID, softRateGapMax) + return nil, fmt.Errorf("上游限流(429),已重试 %d 次仍未恢复,约 %s 后再试:%w", + softRateRetries, softRateGapMax.Round(time.Second), err) + } + d := softRateWait(err, attempt+1) + log.Printf("autotask %s: 上游软限流,等 %s 后重试(第 %d/%d 次)", + logfmt.Label(a.UID, a.Nickname), d.Round(time.Second), attempt+1, softRateRetries) + time.Sleep(d) + } +} + +// taskByCode 拉取任务列表并定位单个任务;未找到返回 nil(不视为错误)。 +// 双口径:mp 专属任务在默认列表查不到,自动回落 mp 列表(仅对已登记的 mp 码, +// 未知码不多打一次上游)。 +func (p *Panel) taskByCode(a *auth.Auth, code string) (*upstream.Task, error) { + tasks, err := p.listTasksSoftRate(a, false) + if err != nil { + return nil, err + } + for i := range tasks { + if tasks[i].TaskCode == code { + return &tasks[i], nil + } + } + if isMPTaskCode(code) { + return p.taskByCodeMP(a, code) + } + return nil, nil +} + +// claimPollAttempts / claimPollGap 达标回读的有界轮询参数。 +// 背景:上游计分是**异步**的——行为事件上报后进度要数秒才刷新(实测 Model_chat +// 对话完成后立即回读仍是 0/1,约 5-8 秒后才变 1/1)。一次性回读会误判"未达标", +// 从而跳过自动领奖。这里最多轮询 N 次、每次间隔 gap,总预算约 12 秒。 +var ( + claimPollAttempts = 4 + claimPollGap = 3 * time.Second +) + +// taskByCodeWaiting 回读任务,若未达标则在有界预算内轮询等待(上游异步计分)。 +// 已达标(claimable)立即返回;预算耗尽返回最后一次结果(可能仍未达标)。 +func (p *Panel) taskByCodeWaiting(a *auth.Auth, code string) (*upstream.Task, error) { + t, err := p.taskByCode(a, code) + if err != nil || t == nil { + return t, err + } + if t.Claimable || t.Claimed { + return t, nil + } + for i := 1; i < claimPollAttempts; i++ { + time.Sleep(claimPollGap) + t2, err2 := p.taskByCode(a, code) + if err2 != nil { + return t, err2 // 回读失败不能把旧进度当作本轮已确认结果 + } + if t2 != nil { + t = t2 + if t.Claimable || t.Claimed { + return t, nil + } + } + } + return t, nil +} + +// taskByCodeMP 以小程序口径拉取任务列表并定位单个任务;未找到返回 nil。 +// 小程序限定任务(Sequential_Tasks_*)在默认口径列表不出现。 +func (p *Panel) taskByCodeMP(a *auth.Auth, code string) (*upstream.Task, error) { + tasks, err := p.listTasksSoftRate(a, true) + if err != nil { + return nil, err + } + for i := range tasks { + if tasks[i].TaskCode == code { + return &tasks[i], nil + } + } + return nil, nil +} + +// acceptWithVerifyMP accept 并回读验证登记生效:上游存在 200+OK 但 accept 未真正 +// 登记的形态(此时上报事件全部不归账,任务永远点不亮,上游 task_runner c793ae3 +// 实测)——判定以回读 accept_status 为准,未生效重试一次。 +func (p *Panel) acceptWithVerifyMP(a *auth.Auth, code string) bool { + for attempt := 1; attempt <= 2; attempt++ { + if err := p.cfg.Upstream.AcceptTasksMP(a, []string{code}); err != nil { + log.Printf("autotask %s %s: accept 尝试%d: %v", logfmt.Label(a.UID, a.Nickname), code, attempt, err) + continue + } + time.Sleep(mpActionGap) + t, err := p.taskByCodeMP(a, code) + if err == nil && t != nil && t.AcceptStatus != "not_accepted" && t.AcceptStatus != "" { + return true + } + log.Printf("autotask %s %s: accept 尝试%d 未登记生效(回读=%q)", logfmt.Label(a.UID, a.Nickname), code, attempt, acceptStatusOr(t)) + } + return false +} + +// acceptStatusOr 安全读取任务 accept_status(nil 任务返回 "?")。 +func acceptStatusOr(t *upstream.Task) string { + if t == nil { + return "?" + } + if t.AcceptStatus == "" { + return "?" + } + return t.AcceptStatus +} + +// mpActionGap mp 任务写动作间隔(accept/上报/领奖之间,防频控)。 +var mpActionGap = 2 * time.Second + +// mpChatEventGap mp 对话事件(chat_request_send)的真人节奏间隔。上游对 +// Sequential_Tasks_3「5 次有效对话」有反作弊校验:数秒级连发的事件会先被计入 +// 进度(回读 5/5、accept_status 甚至短暂转 completed),随后被判定无效整体回滚 +// (进度回落、claim 返回 400 "task not completed")——2026-09-26 实测 2s 连发 +// 4 条全灭,45s 间隔逐条上报全存活且 claim +300c+5e 成功。每条上报前 +// sleep gap + 0~10s 抖动;首条也等(上一轮残留进度被回滚后立即重报同样无效)。 +var mpChatEventGap = 45 * time.Second + +// mpChatTarget 未 accept 的小程序任务 progress 为空,上报的 target 是 0。 +// 上游 task_runner 用任务表兜底;否则 Sequential_Tasks_3 只会上报 1 次就去领。 +func mpChatTarget(code string, reported int64) int64 { + if reported > 0 { + return reported + } + switch code { + case "Sequential_Tasks_3": + return 5 + case "Sequential_Tasks_6": + return 10 + default: + return 1 + } +} + +// runMPMiniChatTask growth 域小程序限定任务通用闭环: +// mp 查询 → accept(带登记回读验证)→ mini chat 事件上报 → 回读 → 达标即领奖。 +func (p *Panel) runMPMiniChatTask(a *auth.Auth, code string) (string, error) { + t, err := p.taskByCodeMP(a, code) + if err != nil { + return "", err + } + if t == nil { + return "mp 口径未下发该任务(活动可能已结束)", nil + } + if t.Claimed { + return "已领取", nil + } + if t.AcceptStatus == "not_accepted" || t.AcceptStatus == "" { + if !p.acceptWithVerifyMP(a, code) { + return "", fmt.Errorf("accept 未登记生效,上游未确认任务已接受") + } + // accept 前的任务进度为 null(target 下发 0),兜底 target=1 会少报—— + // Tasks_6 首轮实测:accept 后真实 target=10,只补 1 条就误判达标去领奖 + // (claim 400 task not completed)。接受后回读一次拿真实 target/current。 + if t2, err := p.taskByCodeMP(a, code); err == nil && t2 != nil { + t = t2 + } + } + // 已达标(含 completed 未领):直接领奖。 + target := mpChatTarget(code, t.Target) + if t.Current >= target || t.AcceptStatus == "completed" { + credit, energy, err := p.cfg.Upstream.ClaimRewardMP(a, code) + if err != nil { + return "", err + } + return fmt.Sprintf("已领取奖励(+%dc +%de)", credit, energy), nil + } + // 判据上报:按差额补 mini chat 事件。每条前 sleep mpChatEventGap+抖动—— + // 连发会被上游反作弊判无效(见 mpChatEventGap 注释),宁可慢不可白报。 + need := target - t.Current + for i := int64(0); i < need; i++ { + time.Sleep(mpChatEventGap + time.Duration(rand.Int64N(int64(10*time.Second)))) + conv := session.NewConversationID() + if err := p.cfg.Upstream.ReportMPEvent(a, upstream.MiniChatSendEvent(conv)); err != nil { + return "", fmt.Errorf("完成 %d/%d 次上报后中断: %w", i, need, err) + } + } + // 回读(异步计分,有界轮询复用 claimPoll 预算的紧凑版:两轮各隔 3s)。 + for i := 0; i < 2; i++ { + time.Sleep(claimPollGap) + t2, err2 := p.taskByCodeMP(a, code) + if err2 != nil || t2 == nil { + continue + } + t = t2 + if t.Claimable || t.Claimed || t.Current >= target { + break + } + } + if t.Claimed { + return "本轮已入账(claimed)", nil + } + if t.Current < target { + return fmt.Sprintf("已上报 %d 次但进度未达 %d/%d(异步计分未归账,下次重试)", need, t.Current, target), nil + } + credit, energy, err := p.cfg.Upstream.ClaimRewardMP(a, code) + if err != nil { + return "", err + } + return fmt.Sprintf("任务点亮并领取奖励(+%dc +%de)", credit, energy), nil +} + +// runSequentialChat 完成 Sequential_Tasks_1「小程序内完成 1 次有效对话」。 +// 判据 = mini chat_request_send(无 activityId,服务端按 source=mini_program +// 指纹关联;上游 task_runner 实测 +100c+5e)。 +func runSequentialChat(p *Panel, a *auth.Auth) (string, error) { + return p.runMPMiniChatTask(a, "Sequential_Tasks_1") +} + +// runSequentialChat5 完成 Sequential_Tasks_3「在小程序内完成 5 次有效对话」。 +// 判据与 Sequential_Tasks_1 同形状(mini 指纹 chat_request_send,无 activityId), +// 仅 target=5——服务端按上报条数累加进度,但**要求真人节奏**:连发事件先计数 +// 后被反作弊回滚(claim 400 "task not completed"),由 mpChatEventGap 间隔保证 +// (2026-09-26 实测:45s 间隔补满 5/5 → claim +300c+5e 成功,领后 accept_status +// =claimed 稳定不回滚)。 +func runSequentialChat5(p *Panel, a *auth.Auth) (string, error) { + return p.runMPMiniChatTask(a, "Sequential_Tasks_3") +} + +// runSequentialChat10 完成 Sequential_Tasks_6「在小程序内完成 10 次有效对话」(预留)。 +// 判据假定与 Tasks_1/3 同形状(mini chat_request_send),target 由任务自带(回读), +// runMPMiniChatTask 按差额补报——issue #42 称 target=10,以解锁后实际下发为准。 +// 真人节奏间隔同样适用(mpChatEventGap):9 条 × ~50s ≈ 8 分钟/账号,夜间队列可接受。 +func runSequentialChat10(p *Panel, a *auth.Auth) (string, error) { + return p.runMPMiniChatTask(a, "Sequential_Tasks_6") +} + +// runSequentialEventTask Sequential 链预留任务通用骨架:mp 查询 → accept(带验证) +// → 判据事件上报(primary;未点亮且 fallback 非空时补一轮)→ 回读 → 达标领奖。 +// 每日零点解锁一环:locked 期间 accept 不落账,返回等下次调度(无需人工干预)。 +func (p *Panel) runSequentialEventTask(a *auth.Auth, code string, primary, fallback func() error) (string, error) { + t, err := p.taskByCodeMP(a, code) + if err != nil { + return "", err + } + if t == nil { + return "mp 口径未下发该任务(前置任务未完成或活动未开始)", nil + } + if t.Claimed { + return "已领取", nil + } + target := t.Target + if target <= 0 { + target = 1 + } + if t.Current >= target || t.AcceptStatus == "completed" { + credit, energy, err := p.cfg.Upstream.ClaimRewardMP(a, code) + if err != nil { + return "", err + } + return fmt.Sprintf("已领取奖励(+%dc +%de)", credit, energy), nil + } + if t.AcceptStatus == "not_accepted" || t.AcceptStatus == "" { + if !p.acceptWithVerifyMP(a, code) { + return "", fmt.Errorf("accept 未登记生效,任务可能处于每日锁定窗口") + } + } + if err := primary(); err != nil { + return "", fmt.Errorf("判据上报失败: %w", err) + } + // 回读(两轮各隔 3s);未点亮且有 fallback 时补报一轮再读。 + for round := 0; round < 2; round++ { + time.Sleep(claimPollGap) + t2, err2 := p.taskByCodeMP(a, code) + if err2 != nil || t2 == nil { + continue + } + t = t2 + if t.Claimable || t.Claimed || t.Current >= target { + break + } + if round == 0 && fallback != nil { + if err := fallback(); err != nil { + return "", fmt.Errorf("备选判据上报失败: %w", err) + } + } + } + if t.Claimed { + return "本轮已入账(claimed)", nil + } + if t.Current < target { + return "已上报但进度未点亮(判据形态待解锁后校正,下次重试)", nil + } + credit, energy, err := p.cfg.Upstream.ClaimRewardMP(a, code) + if err != nil { + return "", err + } + return fmt.Sprintf("任务点亮并领取奖励(+%dc +%de)", credit, energy), nil +} + +// runSequentialAutomation 完成 Sequential_Tasks_4「创建定时任务」(预留)。 +// mp 源码无 automation 事件发射点 → 判据疑为 PC 口径:复用 automation_1 同源 +// 事件(DesktopAutomationCreateEvent,PC 任务三账号实测点亮)。 +func runSequentialAutomation(p *Panel, a *auth.Auth) (string, error) { + return p.runSequentialEventTask(a, "Sequential_Tasks_4", + func() error { + return p.cfg.Upstream.ReportDesktopEvent(a, upstream.DesktopAutomationCreateEvent("自动化")) + }, nil) +} + +// runSequentialModelChat 完成 Sequential_Tasks_5「使用 GLM5.2」(预留)。 +// primary:mp 对话事件带 requestModelId/requestModelName=glm-5.2(mpsrc main 32904 +// 发射点实测形状);fallback:PC 域模型活跃上报(Model_chat_GLM5.2 同源)。 +func runSequentialModelChat(p *Panel, a *auth.Auth) (string, error) { + return p.runSequentialEventTask(a, "Sequential_Tasks_5", + func() error { + conv := session.NewConversationID() + return p.cfg.Upstream.ReportMPEvent(a, upstream.MiniChatModelEvent(conv, "glm-5.2", "GLM-5.2")) + }, + func() error { + return p.cfg.Upstream.ReportChatActivityModel(a, session.NewConversationID(), "", "glm-5.2", "GLM-5.2") + }) +} + +// runSequentialPlaybook 完成 Sequential_Tasks_7「体验灵感功能」(预留,疑 PC 口径)。 +// primary:PC 灵感事件组(DesktopPlaybookPromptSequence,playbook_prompt 三账号 +// 实测点亮);fallback:mp 指纹灵感事件组(MiniPlaybookEvents,mpsrc 形状)。 +func runSequentialPlaybook(p *Panel, a *auth.Auth) (string, error) { + return p.runSequentialEventTask(a, "Sequential_Tasks_7", + func() error { + conv := session.NewConversationID() + req := session.NewMessageID() + return p.cfg.Upstream.ReportDesktopEvent(a, + upstream.DesktopPlaybookPromptSequence(conv, req, "pm-gtm-launch-plan", "新产品上市 GTM 发布计划一页纸")...) + }, + func() error { + return p.cfg.Upstream.ReportMPEvent(a, upstream.MiniPlaybookEvents("pm-gtm-launch-plan", "新产品上市 GTM 发布计划一页纸")...) + }) +} + +// runMiniExpert 完成 Sequential_Tasks_2「在小程序内选中专家并完成有效对话」。 +// 判据 = mp 指纹 expert_actual_use(**不带** activityId/conversationId、 +// extVersion=2.2.8、type=send_message——小程序源码实测形状; +// 上游 task_runner 实测上报即 completed,claim +200c+5e)。 +// 专家 id 必须是市场真实 ex_ id(空 id 服务端不入账)→ **accept 之前**先解析市场 +// 列表:拉不到就整任务不动作,避免留下「已登记未上报」的半程态(上游 9a26ae7 +// 的 ids 前置判定同款)。复用既有 MarketExpertList(expert_5 任务同源,实测可用)。 +func runMiniExpert(p *Panel, a *auth.Auth) (string, error) { + const code = "Sequential_Tasks_2" + t, err := p.taskByCodeMP(a, code) + if err != nil { + return "", err + } + if t == nil { + return "mp 口径未下发该任务(活动可能已结束)", nil + } + if t.Claimed { + return "已领取", nil + } + target := t.Target + if target <= 0 { + target = 1 // 未 accept 的 mp 任务 progress 为 null,target 兜底(上游实测) + } + // 已达标(含 completed 未领):直接领奖。 + if t.Current >= target || t.AcceptStatus == "completed" { + credit, energy, err := p.cfg.Upstream.ClaimRewardMP(a, code) + if err != nil { + return "", err + } + return fmt.Sprintf("已领取奖励(+%dc +%de)", credit, energy), nil + } + // 判据载体前置(accept 之前):市场真实专家 id。 + experts, merr := p.cfg.Upstream.MarketExpertList(a, "") + if merr != nil { + return "", fmt.Errorf("专家市场不可用,跳过以防半程态: %w", merr) + } + if len(experts) == 0 { + return "", fmt.Errorf("专家市场列表为空,跳过以防半程态") + } + e := experts[0] + name := e.DisplayNameZH + if name == "" { + name = e.ProfessionZH + } + if t.AcceptStatus == "not_accepted" || t.AcceptStatus == "" { + if !p.acceptWithVerifyMP(a, code) { + return "", fmt.Errorf("accept 未登记生效,上游未确认任务已接受") + } + } + ev := upstream.MiniExpertUseEvent(e.ExpertID, name, e.ExpertType) + if err := p.cfg.Upstream.ReportMPEvent(a, ev); err != nil { + return "", fmt.Errorf("上报 expert_actual_use 失败: %w", err) + } + // 回读(异步计分,两轮各隔 3s——与 runMPMiniChatTask 同预算)。 + for i := 0; i < 2; i++ { + time.Sleep(claimPollGap) + t2, err2 := p.taskByCodeMP(a, code) + if err2 != nil || t2 == nil { + continue + } + t = t2 + if t.Claimable || t.Claimed || t.Current >= target { + break + } + } + if t.Claimed { + return "本轮已入账(claimed)", nil + } + if t.Current < target { + return "已上报但进度未归账(异步计分,下次重试)", nil + } + credit, energy, err := p.cfg.Upstream.ClaimRewardMP(a, code) + if err != nil { + return "", err + } + return fmt.Sprintf("任务点亮并领取奖励(+%dc +%de)", credit, energy), nil +} + +// accountTaskAuto 一键完成单个任务:执行对应动作 → 回读进度 → 汇报结果。 +func (p *Panel) accountTaskAuto(w http.ResponseWriter, r *http.Request) { + uid := r.PathValue("uid") + a := p.accountByUID(w, uid) + if a == nil { + return + } + if a.IsGlobal() { + writeErr(w, http.StatusNotImplemented, globalTaskWriteMessage) + return + } + // 无个人成长体系的账号直接拒绝:企业版成长端点上游 403(「growth system is only + // available for personal users」);静态 API Key 账号(ck_/pt_)根本没有个人 + // 账号身份。两者执行任何成长任务都是零收益白跑。 + if !a.SupportsPersonalGrowth() { + writeErr(w, http.StatusUnprocessableEntity, + "该账号无个人成长体系(企业版或静态 API Key);请改用个人账号") + return + } + var body struct { + TaskCode string `json:"task_code"` + } + if err := json.NewDecoder(r.Body).Decode(&body); err != nil || body.TaskCode == "" { + writeErr(w, http.StatusBadRequest, "task_code required") + return + } + act := autoActionFor(body.TaskCode) + if act == nil { + writeErr(w, http.StatusNotImplemented, + "该任务需要客户端内交互(无对应接口),无法自动完成;请按任务说明在官方客户端操作") + return + } + // per-account 互斥:同账号的任务动作正在跑(单任务或全量)时直接 409, + // 不并发重跑(动作幂等但 expert/skill 系含真实对话,重跑浪费配额)。 + if !p.tryLockAccount(uid) { + writeErr(w, http.StatusConflict, "该账号有任务动作正在执行中,请等本轮结束后再试") + return + } + defer p.unlockAccount(uid) + outcome := p.executeAutoTask(a, act) + log.Printf("panel: 任务动作 uid=%s code=%s status=%s progress %s -> %s claimed=%v", + uid, act.TaskCode, outcome.Status, outcome.ProgressBefore, outcome.ProgressAfter, outcome.Claimed) + writeJSON(w, http.StatusOK, outcome.resultMap(act)) +} + +// taskProgressText 任务进度的可读表示(回读对比用)。 +func taskProgressText(t *upstream.Task) string { + if t == nil { + return "?" + } + if t.Target > 0 { + return fmt.Sprintf("%d/%d", t.Current, t.Target) + } + if t.Claimed { + return "claimed" + } + return t.AcceptStatus +} + +func (o autoTaskOutcome) resultMap(act *autoAction) map[string]any { + result := map[string]any{ + "ok": o.Status != "error", + "status": o.Status, + "message": o.Message, + "progress_before": o.ProgressBefore, + "progress_after": o.ProgressAfter, + "claimable": o.Claimable, + "claimed": o.Claimed, + "attempt": o.Attempt, + "verify_supported": true, + } + if act != nil { + result["task_code"] = act.TaskCode + result["desc"] = act.Desc + } + if o.Credit != 0 || o.Energy != 0 { + result["credit"] = o.Credit + result["energy"] = o.Energy + } + if o.ClaimError != "" { + result["claim_error"] = o.ClaimError + } + return result +} + +func taskProgressReached(t *upstream.Task) bool { + return t != nil && (t.Target > 0 && t.Current >= t.Target || + t.AcceptStatus == "completed" || strings.EqualFold(t.Status, "complete")) +} + +// executeAutoTask 统一执行任务:只在服务端确认进度达标后领奖,只有服务端确认已领 +// 或领奖接口成功才返回 done。已达标未领取时先领奖,避免重复执行真实对话动作。 +func (p *Panel) executeAutoTask(a *auth.Auth, act *autoAction) (out autoTaskOutcome) { + taskCode := "?" + uid := "?" + if act != nil { + taskCode = act.TaskCode + } + if a != nil { + uid = a.UID + } + defer func() { + log.Printf("panel: task auto uid=%s code=%s status=%s progress=%s->%s claimed=%v claim_error=%q", + uid, taskCode, out.Status, truncateStr(out.ProgressBefore, 64), + truncateStr(out.ProgressAfter, 64), out.Claimed, truncateStr(out.ClaimError, 180)) + }() + if a == nil { + return autoTaskOutcome{Status: "error", Message: "账号凭证不可用"} + } + if a.IsGlobal() { + return autoTaskOutcome{Status: "error", Message: globalTaskWriteMessage} + } + if !a.SupportsPersonalGrowth() { + return autoTaskOutcome{Status: "skipped", Message: noPersonalTaskMessage} + } + if act == nil { + return autoTaskOutcome{Status: "skipped", Message: "未配置该任务的自动动作"} + } + out = autoTaskOutcome{Attempt: act.Attempt} + before, err := p.taskByCode(a, act.TaskCode) + if err != nil { + out.Status = "error" + out.Message = "查询任务失败: " + err.Error() + return out + } + if before == nil { + out.Status = "skipped" + out.Message = "该账号没有此任务" + return out + } + out.ProgressBefore = taskProgressText(before) + if before.Locked { + out.Status = "skipped" + out.Message = "任务尚未解锁" + return out + } + if before.Claimed { + out.Status = "done" + out.Claimed = true + out.Message = "该任务已领取过奖励" + out.ProgressAfter = taskProgressText(before) + return out + } + if taskProgressReached(before) && act.TaskCode != "first_buddy" { + return p.claimAutoTask(a, act, "任务已达标", before, before) + } + // ponytail: first_buddy 是例外——进度满只说明对话做过,奖励在 agreement + + // buddy/first 动作链里。按进度直接去领会永远领不到,所以进度满仍走领养。 + if act.run == nil { + out.Status = "skipped" + out.Message = "该任务没有可执行的自动动作" + return out + } + message, err := act.run(p, a) + // 软限流(429)时动作根本没被执行,等窗口过去重发一次;任务动作幂等,重发不加重。 + if err != nil && isSoftRateErr(err) { + d := softRateWait(err, 1) + log.Printf("autotask %s: 动作 %s 撞上游软限流,等 %s 后重试一次", + logfmt.Label(a.UID, a.Nickname), act.TaskCode, d.Round(time.Second)) + time.Sleep(d) + message, err = act.run(p, a) + } + out.ActionRun = true + if err != nil { + out.Status = "error" + out.Message = "执行失败: " + err.Error() + return out + } + after, err := p.taskByCodeWaiting(a, act.TaskCode) + if err != nil { + out.Status = "error" + out.Message = message + ";回读进度失败: " + err.Error() + if after != nil { + out.ProgressAfter = taskProgressText(after) + out.Claimable = taskProgressReached(after) + } + return out + } + if after == nil { + out.Status = "awaiting_progress" + out.Message = message + ";回读时未找到该任务,暂不能确认完成" + return out + } + out.ProgressAfter = taskProgressText(after) + out.Claimable = taskProgressReached(after) + if after.Claimed { + out.Status = "done" + out.Claimed = true + out.Message = message + ";服务端已确认领取" + return out + } + if !out.Claimable { + out.Status = "awaiting_progress" + out.Message = message + ";服务端进度尚未达标,等待入账后再确认" + return out + } + return p.claimAutoTask(a, act, message, before, after) +} + +func (p *Panel) claimAutoTask(a *auth.Auth, act *autoAction, message string, before, after *upstream.Task) autoTaskOutcome { + out := autoTaskOutcome{ + Status: "done", + Message: message, + ProgressBefore: taskProgressText(before), + ProgressAfter: taskProgressText(after), + Claimable: true, + Attempt: act.Attempt, + } + var credit, energy int64 + var err error + if isMPTaskCode(act.TaskCode) { + credit, energy, err = p.cfg.Upstream.ClaimRewardMP(a, act.TaskCode) + } else { + credit, energy, err = p.cfg.Upstream.ClaimReward(a, act.TaskCode) + } + if err != nil { + out.Status = "claim_pending" + out.ClaimError = err.Error() + out.Message = message + ";任务已达标,但领奖失败: " + err.Error() + return out + } + out.Claimed = true + out.Credit, out.Energy = credit, energy + if credit > 0 || energy > 0 { + out.Message = message + fmt.Sprintf(";已自动领奖 +%d 分 +%d 能", credit, energy) + } else { + out.Message = message + ";领奖接口已确认(奖励此前可能已领取)" + } + return out +} + +// truncateStr 截断错误文本(避免把上游长响应原样透给前端)。 +func truncateStr(s string, n int) string { + if len(s) <= n { + return s + } + return s[:n] + "…" +} + +// --------------------------------------------------------------------------- +// 各任务动作实现 +// --------------------------------------------------------------------------- + +// reportGap 连续上报之间的间隔(对齐上游脚本实测的 1.05s 口径,避免风控)。 +var reportGap = 1050 * time.Millisecond + +// runChat5 补足 chat_5 的进度:按差额上报 chat_request_send。 +func runChat5(p *Panel, a *auth.Auth) (string, error) { + t, err := p.taskByCode(a, "chat_5") + if err != nil { + return "", err + } + if t == nil { + return "", fmt.Errorf("任务不存在") + } + target := t.Target + if target <= 0 { + target = 5 + } + need := target - t.Current + if need <= 0 { + return "进度已达标,无需上报", nil + } + for i := int64(0); i < need; i++ { + cid := session.NewConversationID() + if err := p.cfg.Upstream.ReportChatActivity(a, cid, ""); err != nil { + return "", fmt.Errorf("上报第 %d/%d 条失败: %w", i+1, need, err) + } + if i < need-1 { + time.Sleep(reportGap) + } + } + return fmt.Sprintf("已补报 %d 条对话事件", need), nil +} + +// runFirstBuddy 领养:report(解锁前置)→ agreement → first。 +func runFirstBuddy(p *Panel, a *auth.Auth) (string, error) { + if err := p.cfg.Upstream.ReportChatActivity(a, session.NewConversationID(), ""); err != nil { + return "", fmt.Errorf("前置上报: %w", err) + } + time.Sleep(reportGap) // 给上游事件处理留时间(脚本实测口径) + if err := p.cfg.Upstream.BuddyAgreement(a); err != nil { + return "", fmt.Errorf("同意协议: %w", err) + } + if err := p.cfg.Upstream.BuddyFirst(a); err != nil { + if upstream.IsBuddyTaskIncomplete(err) { + return "前置已上报,但领养门槛未过(上游要求当日活跃),请稍后重试", nil + } + return "", fmt.Errorf("领取 Buddy: %w", err) + } + return "已领取 Buddy(+300 分 +8 能量)", nil +} + +// runRichMeow 完成 RichMeow_Chat(桌面端对话1次)。 +// 2026-09-12 三账号实测验证:以桌面指纹(extName=workbuddy-desktop)向 +// copilot.tencent.com/v2/report 上报完整对话事件链(agent_task_created → +// chat_message_response isSuccessful=true 等 6 事件),纯 API 即可点亮并领奖 +// (紫川/人杰2 两账号无桌面客户端登录状态下 3 秒内 0/1 → 1/1)。 +// Hp_Appearance 的纯 API set 不计分(需客户端在主题下活跃),区别对待。 +func runRichMeow(p *Panel, a *auth.Auth) (string, error) { + conv := session.NewConversationID() + req := session.NewMessageID() + msg := session.NewMessageID() + events := upstream.DesktopChatSequence(conv, req, msg, "fast-model", "fast-model") + if err := p.cfg.Upstream.ReportDesktopEvent(a, events...); err != nil { + return "", err + } + return "已按桌面端指纹上报完整对话事件链(agent_task_created→chat_response)", nil +} + +// runBuddyApp 完成 Buddy_App / Buddy_App_QQ(进入 Buddy 应用)。 +// 2026-09-12 两账号实测:buddyapp 五连事件(discover→show→enter→auth_confirm→ +// bind_skip)以 workbuddy-desktop 指纹上报即点亮,服务端不校验真实授权。 +// 用企鹅教师助手(Buddy_App_QQ 判据应用)作载体,同一组事件同时满足 +// Buddy_App「进入任一应用」——两个表项共用本 run,幂等由任务状态跳过兜底。 +func runBuddyApp(p *Panel, a *auth.Auth) (string, error) { + events := upstream.DesktopBuddyAppSequence("cb_y5Dy46tPQGGWtueMxXbe", "企鹅教师助手") + if err := p.cfg.Upstream.ReportDesktopEvent(a, events...); err != nil { + return "", err + } + return "已上报 buddyapp 进入五连事件(同时覆盖 Buddy_App 与 Buddy_App_QQ)", nil +} + +// runAutomationCreate 完成 automation_1(设置自动化任务)。 +// 2026-09-12 两账号实测:automated_task_create_suc 事件纯 API 上报即点亮, +// 无需真实创建定时任务。 +func runAutomationCreate(p *Panel, a *auth.Auth) (string, error) { + if err := p.cfg.Upstream.ReportDesktopEvent(a, + upstream.DesktopAutomationCreateEvent("自动化")); err != nil { + return "", err + } + return "已上报定时任务创建事件", nil +} + +// runLibraryRead 完成 Library_read(体验资料库)。 +// 2026-09-12 三账号实测:web 域 /v2/report 上报 web_element_click +// (elementId=library_doc_intro_click) 即点亮(space 的 open/WS/inlong 都不是判据)。 +func runLibraryRead(p *Panel, a *auth.Auth) (string, error) { + const docURL = "https://www.workbuddy.cn/space/d/o0KWYeynteVv06UnAZqIFm" + if err := p.cfg.Upstream.ReportWebEvent(a, "web_element_click", docURL, + "library_doc_intro_click", "WorkBuddy资料库介绍"); err != nil { + return "", err + } + return "已上报资料库介绍阅读事件", nil +} + +// runSkillFresh 完成 skill_1(尝鲜热门技能)。 +// 2026-09-12 判据(紫川手动完成抓包 row 209):`skill_info` 事件(桌面指纹)—— +// {id:<技能名>, skillId, skillVersion, toolStatus:"success", fileCount, +// source:"workbuddy-desktop"} JOIN 真实会话(conversationId/requestId=服务端 +// id)。此前的 skill_request_send/skill_installed/skill_action 全是错误方向。 +// 人杰2 实测 0/1 → 1/1 点亮。 +func runSkillFresh(p *Panel, a *auth.Auth) (string, error) { + conv, req, err := p.cfg.Upstream.DesktopChatWithExpert(a, "") + if err != nil { + return "", fmt.Errorf("真实对话: %w", err) + } + msgID := "msg-" + req[len(req)-8:] + events := upstream.DesktopChatSequence(conv, req, msgID, "fast-model", "fast-model") + for _, ev := range events { + if ev["eventCode"] == "chat_message_response" { + ev["finishReason"] = "tool_calls" // 模型发起工具调用(技能加载)语义 + } + } + events = append(events, upstream.DesktopEvent{ + "eventCode": "skill_info", + "id": "润泽小馆·日报撰写", + "skillId": "skill_2097350077599879168", + "skillVersion": "1.0.0", + "toolStatus": "success", + "fileCount": 56, + "source": "workbuddy-desktop", + "conversationId": conv, "requestId": req, "messageId": msgID, + "requestModelId": "fast-model", "requestModelName": "fast-model", + "traceId": req, + }) + if err := p.cfg.Upstream.ReportDesktopEvent(a, events...); err != nil { + return "", fmt.Errorf("skill_info 事件: %w", err) + } + return "已上报真实对话 + skill_info 技能加载事件", nil +} + +// runExpertLighthouse 完成 Expert_lighthouse(体验「腾讯轻量云」专家)。 +// 2026-09-12 判据(真实样本 Sunny row 868):与 expert_5 同构,但两处差异—— +// chat 链的 agent_task_created 需带 has_expert:true + expert_id(我们默认 false), +// expert_actual_use 的 mode 为 "LOCAL"(非 craft)。id 固定为轻量云专家 +// ex_2cvvUZQhDyeJ;requestId 必须是真实 chat 的服务端 id。紫川/人杰2 实测点亮。 +func runExpertLighthouse(p *Panel, a *auth.Auth) (string, error) { + const lhID = "ex_2cvvUZQhDyeJ" + lh := upstream.MarketExpert{ + ExpertID: lhID, ExpertType: "agent", + DisplayNameZH: "腾讯轻量云专家", ProfessionZH: "腾讯轻量云专家", Version: "1.0.2", + } + // 市场列表若命中真实条目则用其信息(version 等以服务端为准)。 + if experts, err := p.cfg.Upstream.MarketExpertList(a, "agent"); err == nil { + for _, e := range experts { + if e.ExpertID == lhID { + lh = e + break + } + } + } + if err := p.cfg.Upstream.ReportDesktopEvent(a, upstream.DesktopExpertSummonSequence(lh)...); err != nil { + return "", fmt.Errorf("召唤链: %w", err) + } + conv, req, err := p.cfg.Upstream.DesktopChatWithExpert(a, lhID) + if err != nil { + return "", fmt.Errorf("真实对话: %w", err) + } + events := upstream.DesktopChatSequence(conv, req, "msg-"+req[len(req)-8:], "fast-model", "fast-model") + for _, ev := range events { + if ev["eventCode"] == "agent_task_created" { + ev["has_expert"] = true + ev["expert_id"] = lh.ExpertID + ev["expert_name"] = lh.DisplayNameZH + ev["expert_industry_id"] = "" + } + } + events = append(events, upstream.DesktopExpertActualUseLocal(lh, conv, req)) + // 对齐真实样本细节:轻量云专家 actual_use 的 type 为空、cost=0。 + events[len(events)-1]["type"] = "" + events[len(events)-1]["cost"] = 0 + if err := p.cfg.Upstream.ReportDesktopEvent(a, events...); err != nil { + return "", fmt.Errorf("使用事件: %w", err) + } + return "已上报轻量云专家召唤+使用链(真实对话 requestId)", nil +} + +// runValorantExpert 完成 WorkBuddy_Valorant「体验「无畏契约拼豆专家」」(+100c+5e,截止 +// 2026-11-15)。判据口径同 Expert_lighthouse:召唤链 + 真实对话 + expert_actual_use(mode=LOCAL)。 +// 专家 id ex_xQHHD1u5Jkua(agent_name=valorant-perler-expert,version 1.2.1)。 +func runValorantExpert(p *Panel, a *auth.Auth) (string, error) { + const vID = "ex_xQHHD1u5Jkua" + v := upstream.MarketExpert{ + ExpertID: vID, ExpertType: "agent", + DisplayNameZH: "无畏契约拼豆专家", ProfessionZH: "无畏契约拼豆专家", Version: "1.2.1", + } + // 市场列表若命中真实条目则用其信息(version 等以服务端为准)。 + if experts, err := p.cfg.Upstream.MarketExpertList(a, "agent"); err == nil { + for _, e := range experts { + if e.ExpertID == vID { + v = e + break + } + } + } + if err := p.cfg.Upstream.ReportDesktopEvent(a, upstream.DesktopExpertSummonSequence(v)...); err != nil { + return "", fmt.Errorf("召唤链: %w", err) + } + conv, req, err := p.cfg.Upstream.DesktopChatWithExpert(a, vID) + if err != nil { + return "", fmt.Errorf("真实对话: %w", err) + } + tail := req + if len(tail) > 8 { + tail = tail[len(tail)-8:] + } + events := upstream.DesktopChatSequence(conv, req, "msg-"+tail, "fast-model", "fast-model") + for _, ev := range events { + if ev["eventCode"] == "agent_task_created" { + ev["has_expert"] = true + ev["expert_id"] = v.ExpertID + ev["expert_name"] = v.DisplayNameZH + ev["expert_industry_id"] = "" + } + } + events = append(events, upstream.DesktopExpertActualUseLocal(v, conv, req)) + // 对齐真实样本细节:actual_use 的 type 为空、cost=0(同轻量云)。 + events[len(events)-1]["type"] = "" + events[len(events)-1]["cost"] = 0 + if err := p.cfg.Upstream.ReportDesktopEvent(a, events...); err != nil { + return "", fmt.Errorf("使用事件: %w", err) + } + return "已上报无畏契约拼豆专家召唤+使用链(真实对话 requestId)", nil +} + +// expertExperienceTasks 「在专家页搜索并召唤「X」,完成一次对话」类活动的固定参数。 +// +// 专家 id 全部取自任务自身的 jump_url(PC 的 deeplink `experts?expertId=ex_…`、小程序的 +// `expert-center/detail?id=ex_…`),与专家市场真实条目一一对应(2026-10-23 实测: +// keyword 搜索命中的 expert_id 与 jump_url 完全一致)。DisplayNameZH 是专家的**昵称** +// (卖得好 / 斗音音 / 播旺旺),ProfessionZH 才是任务标题里的职业名——判据事件里 +// name 取昵称、expertTitle 取职业名,两者都参与服务端校验,不能互换。 +var expertExperienceTasks = map[string]upstream.MarketExpert{ + "expert_use_maidehao": { + ExpertID: "ex_GDl31WahyIH0", ExpertType: "agent", + DisplayNameZH: "卖得好", ProfessionZH: "中国电商运营专家", Version: "1.0.1", + }, + "expert_use_douyinyin": { + ExpertID: "ex_FbY5nlWTqDod", ExpertType: "agent", + DisplayNameZH: "斗音音", ProfessionZH: "抖音策略师", Version: "1.0.2", + }, + "expert_use_shangjia_xuanchuan": { + ExpertID: "ex_Weo3x2EZuSDm", ExpertType: "agent", + DisplayNameZH: "商家宣传设计师", ProfessionZH: "商家宣传页与海报设计师", Version: "1.6.0", + }, + "expert_use_bowangwang": { + ExpertID: "ex_WZY136wV5aMt", ExpertType: "agent", + DisplayNameZH: "播旺旺", ProfessionZH: "直播电商教练", Version: "1.0.2", + }, +} + +// runExpertExperienceFor 把任务码绑进 autoAction.run 的函数签名(run 只收 Panel/Auth)。 +func runExpertExperienceFor(code string) func(*Panel, *auth.Auth) (string, error) { + return func(p *Panel, a *auth.Auth) (string, error) { + return p.runExpertExperience(a, code) + } +} + +// runExpertExperience 完成「体验「X」专家」类任务:专家页搜索 → 召唤链 → 真实对话 +// (服务端 requestId)→ expert_actual_use(mode=LOCAL)。 +// +// 判据与 Expert_lighthouse / WorkBuddy_Valorant 同源(同一句任务文案、同一份 +// jump_url 形态);差异只在专家本身,故复用同一条事件链,仅按任务码换专家参数。 +// 市场搜索只用于校正 version/名称(服务端以市场条目为准),搜不到就退回表内静态值 +// ——召唤链本身不依赖搜索成功。 +func (p *Panel) runExpertExperience(a *auth.Auth, code string) (string, error) { + spec, ok := expertExperienceTasks[code] + if !ok { + return "", fmt.Errorf("未登记的专家体验任务: %s", code) + } + e := spec + if list, err := p.cfg.Upstream.MarketExpertSearch(a, spec.ProfessionZH); err == nil { + for _, m := range list { + // 关键词会命中多个同名专家(display_name_zh 与 profession_zh 都参与匹配), + // 必须按 jump_url 里的 expert_id 精确落位。 + if m.ExpertID == spec.ExpertID { + e = m + break + } + } + } + if e.ExpertType == "" { + e.ExpertType = "agent" + } + if err := p.cfg.Upstream.ReportDesktopEvent(a, upstream.DesktopExpertSummonSequence(e)...); err != nil { + return "", fmt.Errorf("召唤链: %w", err) + } + conv, req, err := p.cfg.Upstream.DesktopChatWithExpert(a, e.ExpertID) + if err != nil { + return "", fmt.Errorf("真实对话: %w", err) + } + msgID := "msg-" + req + if len(req) > 8 { + msgID = "msg-" + req[len(req)-8:] + } + events := upstream.DesktopChatSequence(conv, req, msgID, "fast-model", "fast-model") + for _, ev := range events { + if ev["eventCode"] == "agent_task_created" { + ev["has_expert"] = true + ev["expert_id"] = e.ExpertID + ev["expert_name"] = e.DisplayNameZH + ev["expert_industry_id"] = "" + } + } + events = append(events, upstream.DesktopExpertActualUseLocal(e, conv, req)) + // 对齐真实样本细节:专家页直连召唤的 actual_use 的 type 为空、cost=0。 + events[len(events)-1]["type"] = "" + events[len(events)-1]["cost"] = 0 + if err := p.cfg.Upstream.ReportDesktopEvent(a, events...); err != nil { + return "", fmt.Errorf("使用事件: %w", err) + } + return fmt.Sprintf("已上报「%s」召唤+使用链(真实对话 requestId)", e.ProfessionZH), nil +} + +// runAppearance 完成 Hp_Appearance(换主题)。 +// 2026-09-12 紫川/人杰2 实测(desktopverify12):判据是 appearance_skin_apply +// 事件 {action:"apply",source:"settings_close",id:,...}(客户端在 +// 主题生效状态下离开设置页时上报)——早期"纯 API set 不计分"的结论不准确, +// 真相是当时只调了 appearance/set 没发事件。组合:set API 留痕 + 事件上报。 +func runAppearance(p *Panel, a *auth.Auth) (string, error) { + const themeKey = "theme-tkmw7j" // 和平精英激战金秋(Hp_Appearance 判据主题) + if err := p.cfg.Upstream.SetAppearanceTheme(a, themeKey); err != nil { + return "", fmt.Errorf("设置主题: %w", err) + } + time.Sleep(2 * time.Second) + if err := p.cfg.Upstream.ReportDesktopEvent(a, upstream.DesktopEvent{ + "eventCode": "appearance_skin_apply", "action": "apply", "source": "settings_close", + "id": themeKey, "vipLevel": 0, "series": "", "type": "unknown", + }); err != nil { + return "", err + } + return "已设置主题并上报皮肤生效事件", nil +} + +// runTemplateUse 完成 template_5(使用 5 个模板创建任务)。 +// 2026-09-12 三账号实测:agent_task_created_with_template + template_used 事件组 +// (JOIN chat 链)一次上报 5 组即 5/5 点亮。template_id 服务端不校验真实性。 +func runTemplateUse(p *Panel, a *auth.Auth) (string, error) { + templates := [][2]string{{"1", "深度研究"}, {"2", "周报生成"}, {"3", "竞品分析"}, {"4", "活动策划"}, {"5", "代码评审"}} + for i, tp := range templates { + conv := session.NewConversationID() + req := session.NewMessageID() + events := upstream.DesktopTemplateUseSequence(conv, req, tp[0], tp[1]) + if err := p.cfg.Upstream.ReportDesktopEvent(a, events...); err != nil { + return "", fmt.Errorf("第 %d 组模板事件上报失败: %w", i+1, err) + } + time.Sleep(300 * time.Millisecond) + } + return "已上报 template_used ×5", nil +} + +// runPlaybookPrompt 完成 playbook_prompt(灵感案例 Dialog 中发送 Prompt)。 +// 判据是 playbook_prompt_send(Dialog 发送)而非卡片曝光/点击——asar 逆向确认。 +func runPlaybookPrompt(p *Panel, a *auth.Auth) (string, error) { + conv := session.NewConversationID() + req := session.NewMessageID() + events := upstream.DesktopPlaybookPromptSequence(conv, req, "pm-gtm-launch-plan", "新产品上市 GTM 发布计划一页纸") + if err := p.cfg.Upstream.ReportDesktopEvent(a, events...); err != nil { + return "", err + } + return "已上报 playbook_cta_click + playbook_prompt_send", nil +} + +// expertSummonGap 专家召唤链的间隔(真实使用节奏,v11 实测 8s 成功率 100%)。 +const expertSummonGap = 6 * time.Second + +// runExpertUse 完成 expert_5(使用 5 个平台专家)。 +// 2026-09-12 三账号实测公式:真实专家列表(id 必须真实存在)→ 召唤链 +// (summon_click/summoned)→ 真实 chat 拿服务端 requestId → expert_actual_use。 +// 自造专家 id 或自造 requestId 均不计数。 +func runExpertUse(p *Panel, a *auth.Auth) (string, error) { + return runExpertBatch(p, a, "agent", 5) +} + +// runExpertTeamUse 完成 Expert_team_use_3(使用 3 个专家团,expertType=team)。 +func runExpertTeamUse(p *Panel, a *auth.Auth) (string, error) { + return runExpertBatch(p, a, "team", 3) +} + +// runExpertBatch 专家召唤+使用的公共实现。失败逐个继续,返回汇总信息。 +func runExpertBatch(p *Panel, a *auth.Auth, expertType string, count int) (string, error) { + experts, err := p.cfg.Upstream.MarketExpertList(a, expertType) + if err != nil { + return "", fmt.Errorf("拉取专家列表: %w", err) + } + if len(experts) == 0 { + return "", fmt.Errorf("专家市场列表为空") + } + ok, fail := 0, 0 + for i, e := range experts { + if ok >= count { + break + } + // 召唤链(web_element_click + summon_click + summoned)。 + summonEvents := upstream.DesktopExpertSummonSequence(e) + if err := p.cfg.Upstream.ReportDesktopEvent(a, summonEvents...); err != nil { + fail++ + continue + } + // 真实 chat(带 X-Expert-Id)→ 服务端 requestId。 + conv, req, cerr := p.cfg.Upstream.DesktopChatWithExpert(a, e.ExpertID) + if cerr != nil { + fail++ + continue + } + // 使用事件(JOIN 服务端 requestId)+ chat 链。 + events := append(upstream.DesktopChatSequence(conv, req, "msg-"+req[len(req)-8:], "fast-model", "fast-model"), + upstream.DesktopExpertActualUseEvent(e, conv, req)) + if err := p.cfg.Upstream.ReportDesktopEvent(a, events...); err != nil { + fail++ + continue + } + ok++ + if i < len(experts)-1 { + time.Sleep(expertSummonGap) + } + } + if ok < count { + return "", fmt.Errorf("专家召唤+使用链仅成功 %d/%d 位(%d 位失败)", ok, count, fail) + } + return fmt.Sprintf("已对 %d 位真实专家完成召唤+使用链(类型 %s)", ok, expertType), nil +} + +// --------------------------------------------------------------------------- +// 全量自动完成 +// --------------------------------------------------------------------------- + +// runAutoAll 对单账号依次执行所有可自动化任务,返回逐项结果。 +// 供「一键完成全部可自动任务」使用;单项失败不影响后续项。 +// +// 流程:先把所有未接受的任务批量 accept(规范状态机;上游脚本建议"先 accept"), +// 再逐项执行行为链路。accept 不是进度产生的必要条件,但让后续状态流转规范。 +func (p *Panel) runAutoAll(a *auth.Auth) []map[string]any { + return p.runAutoAllObserved(context.Background(), a, nil) +} + +type autoTaskRunEvent struct { + Kind string // phase, task_start, result + TaskCode string + Result map[string]any + Completed bool // true only for an autoAction result, not batch acceptance +} + +// runAutoAllObserved 对全量任务执行流程提供进度事件。ctx 在每个网络阶段、 +// 自动任务项开始前检查;已有上游调用本身保持原超时语义,取消后不再发起下一项。 +func (p *Panel) runAutoAllObserved(ctx context.Context, a *auth.Auth, observe func(autoTaskRunEvent)) []map[string]any { + var out []map[string]any + if ctx == nil { + ctx = context.Background() + } + emit := func(event autoTaskRunEvent) { + if observe != nil { + observe(event) + } + } + if a == nil { + return []map[string]any{{"task_code": "(全部)", "status": "error", "message": "账号凭证不可用"}} + } + if a.IsGlobal() { + return []map[string]any{{"task_code": "(全部)", "status": "error", "message": globalTaskWriteMessage}} + } + // 兜底门控:企业版 / 静态 API Key 无个人成长体系。正常情况下作业入口已拒绝, + // 但直接调用 runAutoAll 的路径也必须不发起任何上游请求。 + if !a.SupportsPersonalGrowth() { + return []map[string]any{{"task_code": "(全部)", "status": "skipped", "message": noPersonalTaskMessage}} + } + if ctx.Err() != nil { + return out + } + + // have 本账号任务 code 全集(取自 mp 口径,它是默认口径的超集,见 upstream.ListTasksMP)。 + // nil = 列表没拿到 → 不筛选,全部照旧跑(宁可白跑也不能因为一次读失败把所有任务跳过)。 + // done 同源:阶段 0 已确认「已领奖/已锁定/已完成」的 code,逐项阶段直接跳过, + // 不再让 executeAutoTask 每项重新拉一次列表(issue #149:17 个任务 24 次列表查询, + // 背靠背打出后撞 429)。只信「明确已完成」的判定,进度未知的照旧逐项回读。 + var have, done map[string]bool + + // 阶段 0:批量接受尚未接受的任务(失败不阻塞——行为事件才是进度唯一判据)。 + emit(autoTaskRunEvent{Kind: "phase", TaskCode: "(批量接受)"}) + if ctx.Err() == nil { + if tasks, err := p.cfg.Upstream.ListTasks(a); err == nil && ctx.Err() == nil { + if done == nil { + done = make(map[string]bool, len(tasks)) + } + for _, t := range tasks { + if t.Claimed || t.Locked { + done[t.TaskCode] = true + } + } + codes := acceptPendingCodes(tasks) + if len(codes) > 0 && ctx.Err() == nil { + emit(autoTaskRunEvent{Kind: "phase", TaskCode: "(批量接受)"}) + if ctx.Err() != nil { + return out + } + if err := p.cfg.Upstream.AcceptTasks(a, codes); err != nil { + result := map[string]any{ + "task_code": "(批量接受)", "status": "error", + "message": "接受任务失败(不阻塞后续): " + err.Error(), + } + out = append(out, result) + emit(autoTaskRunEvent{Kind: "result", TaskCode: "(批量接受)", Result: result}) + } else { + result := map[string]any{ + "task_code": "(批量接受)", "status": "accepted", + "message": fmt.Sprintf("已接受 %d 个任务", len(codes)), + } + out = append(out, result) + emit(autoTaskRunEvent{Kind: "result", TaskCode: "(批量接受)", Result: result}) + waitForContext(ctx, reportGap) + } + } + } + } + + // 阶段 0b:小程序口径任务单独接受(默认列表不含 mp 码;失败不阻塞)。 + if ctx.Err() == nil { + emit(autoTaskRunEvent{Kind: "phase", TaskCode: "(批量接受-mp)"}) + if ctx.Err() == nil { + if mpTasks, err := p.cfg.Upstream.ListTasksMP(a); err == nil && ctx.Err() == nil { + have = make(map[string]bool, len(mpTasks)) + done = make(map[string]bool, len(mpTasks)) + for _, t := range mpTasks { + have[t.TaskCode] = true + if t.Claimed || t.Locked { + done[t.TaskCode] = true + } + } + mpCodes := acceptPendingCodes(mpTasks) + if len(mpCodes) > 0 && ctx.Err() == nil { + emit(autoTaskRunEvent{Kind: "phase", TaskCode: "(批量接受-mp)"}) + if ctx.Err() != nil { + return out + } + if err := p.cfg.Upstream.AcceptTasksMP(a, mpCodes); err != nil { + result := map[string]any{ + "task_code": "(批量接受-mp)", "status": "error", + "message": "接受小程序任务失败(不阻塞后续): " + err.Error(), + } + out = append(out, result) + emit(autoTaskRunEvent{Kind: "result", TaskCode: "(批量接受-mp)", Result: result}) + } else { + result := map[string]any{ + "task_code": "(批量接受-mp)", "status": "accepted", + "message": fmt.Sprintf("已接受 %d 个小程序任务", len(mpCodes)), + } + out = append(out, result) + emit(autoTaskRunEvent{Kind: "result", TaskCode: "(批量接受-mp)", Result: result}) + waitForContext(ctx, reportGap) + } + } + } + } + } + + for _, act := range autoActions { + if ctx.Err() != nil { + break + } + // 两个跳过条件共用一处输出:①本账号没有这个任务——上游下架或调走某任务后 + // account 列表里消失、autoActions 还在,此前每轮为它白打一次上游调用(26 个 + // 号 × 每个下架任务,还会撞软限流);②阶段 0 快照已确认「已领奖 / 已锁定」 + // ——不再每项重拉一次列表(issue #149:17 个任务 24 次列表查询),快照之后 + // 的进度变化由下一轮补上(任务动作幂等,晚一轮无损失)。 + // 这两类跳过都不打上游,所以不占 reportGap;节流留给真发请求的项。 + if msg := autoSkipReason(act.TaskCode, have, done); msg != "" { + result := map[string]any{"task_code": act.TaskCode, "status": "skipped", "message": msg} + out = append(out, result) + emit(autoTaskRunEvent{Kind: "result", TaskCode: act.TaskCode, Result: result, Completed: true}) + continue + } + emit(autoTaskRunEvent{Kind: "task_start", TaskCode: act.TaskCode}) + if ctx.Err() != nil { + break + } + outcome := p.executeAutoTask(a, &act) + result := outcome.resultMap(&act) + out = append(out, result) + emit(autoTaskRunEvent{Kind: "result", TaskCode: act.TaskCode, Result: result, Completed: true}) + // 每项之间统一留 reportGap:原来只在「真的执行了动作」后等,跳过/查询类 + // 结果背靠背连发(issue #149)。统一节流后一轮多花十几秒,换来不打 429。 + if !waitForContext(ctx, reportGap) { + break + } + } + return out +} + +// autoSkipReason 逐项执行前的快照判据:账号没有此任务 / 已完成或未解锁 → 跳过 +// 原因;空串 = 照旧执行。have 为 nil(列表没拿到)时不按「没有此任务」筛,一次 +// 读失败不该把所有任务跳过。 +func autoSkipReason(code string, have, done map[string]bool) string { + if have != nil && !have[code] { + return "该账号没有此任务" + } + if done[code] { + return "任务已完成或尚未解锁(快照)" + } + return "" +} + +func waitForContext(ctx context.Context, d time.Duration) bool { + if d <= 0 { + return ctx.Err() == nil + } + timer := time.NewTimer(d) + defer timer.Stop() + select { + case <-ctx.Done(): + return false + case <-timer.C: + return true + } +} + +// accountTaskAutoAll 一键完成该账号全部可自动任务。 +func (p *Panel) accountTaskAutoAll(w http.ResponseWriter, r *http.Request) { + uid := r.PathValue("uid") + a := p.accountByUID(w, uid) + if a == nil { + return + } + if a.IsGlobal() { + writeErr(w, http.StatusNotImplemented, globalTaskWriteMessage) + return + } + job, started, err := p.StartAccountTaskJob(uid, "manual") + if err != nil { + writeTaskJobError(w, err) + return + } + writeJSON(w, http.StatusAccepted, map[string]any{"ok": true, "started": started, "job": job}) +} diff --git a/internal/panel/autotask_lock_test.go b/internal/panel/autotask_lock_test.go index 04a28e91779e9a667b362eda2f6176a806f4f186..005179001068dc9ac937d5e2b834b206c30da09e 100644 --- a/internal/panel/autotask_lock_test.go +++ b/internal/panel/autotask_lock_test.go @@ -1,52 +1,79 @@ -package panel - -import ( - "testing" -) - -// TestTaskAccountLockSameAccountExclusive 同一账号的任务锁互斥:第二次 tryLock 必须失败, -// 解锁后可再次获取。这是「重复点一键完成不并发重跑」的核心保障。 -func TestTaskAccountLockSameAccountExclusive(t *testing.T) { - p := &Panel{} - uid := "u1" - - if !p.tryLockAccount(uid) { - t.Fatal("首次加锁应成功") - } - if p.tryLockAccount(uid) { - t.Fatal("同账号第二次加锁应失败(互斥)") - } - p.unlockAccount(uid) - - if !p.tryLockAccount(uid) { - t.Fatal("解锁后应可再次加锁") - } - p.unlockAccount(uid) -} - -// TestTaskAccountLockDifferentAccountsIndependent 不同账号的锁互不影响(并行照旧)。 -func TestTaskAccountLockDifferentAccountsIndependent(t *testing.T) { - p := &Panel{} - if !p.tryLockAccount("u1") { - t.Fatal("u1 加锁应成功") - } - if !p.tryLockAccount("u2") { - t.Fatal("u2 加锁应成功(不同账号不互斥)") - } - p.unlockAccount("u2") - p.unlockAccount("u1") -} - -// TestTaskAccountLockCrossEntryShared 单任务 auto 与全量 auto_all 共用同一把账号锁 -// (在 handler 层都走 tryLockAccount,这里验证锁命名空间一致)。 -func TestTaskAccountLockCrossEntryShared(t *testing.T) { - p := &Panel{} - if !p.tryLockAccount("u1") { - t.Fatal("u1 加锁应成功") - } - // 模拟全量入口对同一 uid 加锁——必须被挡(否则两入口可并发)。 - if p.tryLockAccount("u1") { - t.Fatal("同 uid 跨入口加锁应失败(共用锁)") - } - p.unlockAccount("u1") -} +package panel + +import ( + "testing" + + "github.com/misakano7545/workbuddy2api-panel/internal/upstream" +) + +// TestTaskAccountLockSameAccountExclusive 同一账号的任务锁互斥:第二次 tryLock 必须失败, +// 解锁后可再次获取。这是「重复点一键完成不并发重跑」的核心保障。 +func TestTaskAccountLockSameAccountExclusive(t *testing.T) { + p := &Panel{} + uid := "u1" + + if !p.tryLockAccount(uid) { + t.Fatal("首次加锁应成功") + } + if p.tryLockAccount(uid) { + t.Fatal("同账号第二次加锁应失败(互斥)") + } + p.unlockAccount(uid) + + if !p.tryLockAccount(uid) { + t.Fatal("解锁后应可再次加锁") + } + p.unlockAccount(uid) +} + +func TestTaskAccountLockDifferentAccountsIndependent(t *testing.T) { + p := &Panel{} + if !p.tryLockAccount("u1") { + t.Fatal("u1 加锁应成功") + } + if !p.tryLockAccount("u2") { + t.Fatal("u2 加锁应成功(不同账号不互斥)") + } + p.unlockAccount("u2") + p.unlockAccount("u1") +} + +// TestTaskAccountLockCrossEntryShared 单任务 auto 与全量 auto_all 共用同一把账号锁 +// (在 handler 层都走 tryLockAccount,这里验证锁命名空间一致)。 +func TestTaskAccountLockCrossEntryShared(t *testing.T) { + p := &Panel{} + if !p.tryLockAccount("u1") { + t.Fatal("u1 加锁应成功") + } + // 模拟全量入口对同一 uid 加锁——必须被挡(否则两入口可并发)。 + if p.tryLockAccount("u1") { + t.Fatal("同 uid 跨入口加锁应失败(共用锁)") + } + p.unlockAccount("u1") +} + +func TestGrowthPendingKeepsUnclaimed(t *testing.T) { + met := upstream.Task{TaskCode: "Sequential_Tasks_3", Target: 5, Current: 5} + if !growthPending(met) { + t.Fatal("达标未领应入队") + } + met.Claimed = true + if growthPending(met) { + t.Fatal("已领不应入队") + } + if growthPending(upstream.Task{TaskCode: "Sequential_Tasks_4", Locked: true}) { + t.Fatal("锁定不应入队") + } +} + +func TestMPChatTarget(t *testing.T) { + if mpChatTarget("Sequential_Tasks_3", 0) != 5 { + t.Fatal("空进度 Tasks_3 应为 5") + } + if mpChatTarget("Sequential_Tasks_3", 5) != 5 || mpChatTarget("Sequential_Tasks_1", 0) != 1 { + t.Fatal("已下发 target 优先,Tasks_1 空进度为 1") + } + if mpChatTarget("Sequential_Tasks_6", 0) != 10 { + t.Fatal("空进度 Tasks_6 应为 10") + } +} diff --git a/internal/panel/autotask_missing_test.go b/internal/panel/autotask_missing_test.go new file mode 100644 index 0000000000000000000000000000000000000000..8ca2c3d7f72aac6532ddf25063ec62083552d405 --- /dev/null +++ b/internal/panel/autotask_missing_test.go @@ -0,0 +1,213 @@ +package panel + +import ( + "encoding/json" + "io" + "net/http" + "net/http/httptest" + "strings" + "sync" + "testing" + "time" + + "github.com/misakano7545/workbuddy2api-panel/internal/auth" + "github.com/misakano7545/workbuddy2api-panel/internal/pool" + "github.com/misakano7545/workbuddy2api-panel/internal/upstream" +) + +// missingCodeFake 假上游:任务列表只下发 codes 里的 code,其余请求一律 200 空信封。 +// 记录所有请求的 path+body,供断言「没有为不存在的任务打上游」。 +type missingCodeFake struct { + codes []string + accept string // 列表响应下发的 accept_status;空 = 不带该字段(进度未知) + mu sync.Mutex + seen []string + mpErr bool // true = mp 口径任务列表回 500(列表拿不到 → 不筛选) +} + +func (f *missingCodeFake) handler() http.HandlerFunc { + return func(w http.ResponseWriter, r *http.Request) { + var buf strings.Builder + buf.WriteString(r.URL.Path) + if r.Header.Get("X-Client-Platform") != "" { + buf.WriteString(" mp") + } + if b, _ := readAllBody(r); len(b) > 0 { + buf.WriteString(" ") + buf.Write(b) + } + f.mu.Lock() + f.seen = append(f.seen, buf.String()) + mp, mpErr := r.Header.Get("X-Client-Platform") != "", f.mpErr + f.mu.Unlock() + + if strings.Contains(r.URL.Path, "/growth/tasks") { + if mp && mpErr { + w.WriteHeader(http.StatusInternalServerError) + return + } + tasks := make([]any, 0, len(f.codes)) + for _, c := range f.codes { + t := map[string]any{"task_code": c, "current": 0, "target": 1} + if f.accept != "" { + t["accept_status"] = f.accept + t["current"], t["target"] = 1, 1 + } + tasks = append(tasks, t) + } + body, _ := json.Marshal(map[string]any{"code": 0, "msg": "OK", "data": map[string]any{"tasks": tasks}}) + _, _ = w.Write(body) + return + } + _, _ = w.Write([]byte(`{"code":0,"msg":"OK","data":{}}`)) + } +} + +func readAllBody(r *http.Request) ([]byte, error) { + if r.Body == nil { + return nil, nil + } + defer r.Body.Close() + return io.ReadAll(r.Body) +} + +// missingCodePanel 装配指向 fake 上游的面板。接受 *missingCodeFake 或其扩展 +// (如 claimedFake,经 asMissing 接口解引用回内嵌基座)。 +type fakeProvider interface{ handler() http.HandlerFunc } + +func missingCodePanel(t *testing.T, f fakeProvider) (*Panel, *auth.Auth) { + t.Helper() + srv := httptest.NewServer(f.handler()) + t.Cleanup(srv.Close) + up := &upstream.Client{HTTP: srv.Client(), ChatBaseCN: srv.URL, BillingBaseCN: srv.URL, WebBaseCN: srv.URL} + a := &auth.Auth{UID: "cn-1", Nickname: "cn", AccessToken: "at"} + pl := pool.New("") + pl.Add(a) + return New(Config{Pool: pl, Upstream: up}), a +} + +// TestRunAutoAllSkipsCodesAccountDoesNotHave 账号任务列表里没有的 code 不再打上游 +// (线上 26 个 CN 号每轮为 4 个已下线的任务白打 104 次调用),但结果行照旧是 skipped。 +func TestRunAutoAllSkipsCodesAccountDoesNotHave(t *testing.T) { + old := reportGap + reportGap = 0 + t.Cleanup(func() { reportGap = old }) + + f := &missingCodeFake{codes: []string{"chat_5"}} + p, a := missingCodePanel(t, f) + res := p.runAutoAllObserved(nil, a, nil) + + var sawSkipped bool + for _, r := range res { + if r["task_code"] == "template_5" { + sawSkipped = r["status"] == "skipped" && r["message"] == "该账号没有此任务" + } + } + if !sawSkipped { + t.Errorf("template_5 应输出 skipped 行,实际结果 %+v", res) + } + f.mu.Lock() + defer f.mu.Unlock() + for _, req := range f.seen { + if strings.Contains(req, "template_5") { + t.Fatalf("不该为账号没有的任务打上游: %s", req) + } + } +} + +// TestRunAutoAllNoFilterWhenListFails 列表读失败时不能筛选:一次读失败不该把所有任务跳过。 +func TestRunAutoAllNoFilterWhenListFails(t *testing.T) { + old := reportGap + reportGap = 0 + t.Cleanup(func() { reportGap = old }) + + f := &missingCodeFake{codes: []string{"chat_5"}, mpErr: true} + p, a := missingCodePanel(t, f) + res := p.runAutoAllObserved(nil, a, nil) + if len(res) == 0 { + t.Fatal("列表失败时仍应逐项执行并输出结果") + } + f.mu.Lock() + defer f.mu.Unlock() + var sawNonList bool + for _, req := range f.seen { + if !strings.Contains(req, "/growth/tasks") { + sawNonList = true + } + } + if !sawNonList { + t.Error("列表失败时应照旧执行动作,不能只顾跳过") + } +} + +// TestRunAutoAllSnapshotSkipsClaimed 阶段 0 快照已确认「已领奖」的任务不再逐项重拉 +// 列表(issue #149):整轮列表查询次数应停在阶段 0 的两次(默认 + mp),而不是 +// 每个已领任务各多打一次。fake 的列表响应把所有 code 都标成 claimed。 +func TestRunAutoAllSnapshotSkipsClaimed(t *testing.T) { + old := reportGap + reportGap = 0 + t.Cleanup(func() { reportGap = old }) + + f := &claimedFake{missingCodeFake: missingCodeFake{codes: []string{"chat_5", "template_5", "Sequential_Tasks_1"}, accept: "claimed"}} + p, a := missingCodePanel(t, f) + res := p.runAutoAllObserved(nil, a, nil) + + var skipped int + for _, r := range res { + if r["status"] == "skipped" { + skipped++ + } + } + if skipped == 0 { + t.Fatalf("已领奖任务应输出 skipped 行: %+v", res) + } + if got := f.listCalls(); got != 2 { + t.Fatalf("列表查询 %d 次,want 2(阶段 0 默认+mp 各一次,逐项不再拉)", got) + } +} + +// TestRunAutoAllUniformGapBetweenItems 每项之间统一留 reportGap:原来只在「执行了 +// 动作」后等,查询类(进度未满、这一项没动作可跑)的项零间隔背靠背打上游,是 +// issue #149 里 429 的来源。快照跳过项不打上游,不占 gap。 +func TestRunAutoAllUniformGapBetweenItems(t *testing.T) { + old := reportGap + reportGap = 150 * time.Millisecond + t.Cleanup(func() { reportGap = old }) + + // 三个任务进度都已达标但没领奖:逐项都会查上游 + 领奖,但跑不出动作 + // (ActionRun=false),正好落在旧逻辑「只在 ActionRun 后等」的空档里。 + f := &missingCodeFake{codes: []string{"chat_5", "template_5", "Buddy_App"}, accept: "accepted"} + p, a := missingCodePanel(t, f) + start := time.Now() + _ = p.runAutoAllObserved(nil, a, nil) + // 旧逻辑(只在 ActionRun 后等)这三项之间零间隔,整轮远小于 3×gap。 + if elapsed := time.Since(start); elapsed < 3*reportGap { + t.Fatalf("整轮耗时 %s < 3×gap,查询类项之间没有统一节流", elapsed.Round(time.Millisecond)) + } +} + +// claimedFake 列表把全部任务下发为 claimed(已领奖)的 fake,并数列表查询次数。 +type claimedFake struct { + missingCodeFake + mu2 sync.Mutex + lists int +} + +// Handler 覆写:只统计列表查询次数,列表内容由 missingCodeFake.accept 决定。 +func (f *claimedFake) handler() http.HandlerFunc { + inner := f.missingCodeFake.handler() + return func(w http.ResponseWriter, r *http.Request) { + if strings.Contains(r.URL.Path, "/growth/tasks") { + f.mu2.Lock() + f.lists++ + f.mu2.Unlock() + } + inner(w, r) + } +} + +func (f *claimedFake) listCalls() int { + f.mu2.Lock() + defer f.mu2.Unlock() + return f.lists +} diff --git a/internal/panel/autotask_outcome_test.go b/internal/panel/autotask_outcome_test.go new file mode 100644 index 0000000000000000000000000000000000000000..f50f5026424eccb1fc76137092de5bd89d0f874d --- /dev/null +++ b/internal/panel/autotask_outcome_test.go @@ -0,0 +1,311 @@ +package panel + +import ( + "fmt" + "net/http" + "net/http/httptest" + "strings" + "sync" + "testing" + "time" + + "github.com/misakano7545/workbuddy2api-panel/internal/auth" + "github.com/misakano7545/workbuddy2api-panel/internal/pool" + "github.com/misakano7545/workbuddy2api-panel/internal/upstream" +) + +type autoTaskTestState struct { + mu sync.Mutex + current int64 + target int64 + acceptStatus string + taskCode string + listCalls int + failListAt int + claimError bool + claimCalls int + requests int +} + +func (s *autoTaskTestState) counters() (listCalls, claimCalls, requests int) { + s.mu.Lock() + defer s.mu.Unlock() + return s.listCalls, s.claimCalls, s.requests +} + +func newAutoTaskTestPanel(t *testing.T, current, target int64, acceptStatus string) (*Panel, *auth.Auth, *autoTaskTestState) { + t.Helper() + state := &autoTaskTestState{current: current, target: target, acceptStatus: acceptStatus, taskCode: "chat_5"} + server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { + state.mu.Lock() + state.requests++ + if strings.HasSuffix(r.URL.Path, "/claim") || strings.Contains(r.URL.Path, "/reward/claim") { + state.claimCalls++ + fail := state.claimError + state.mu.Unlock() + if fail { + http.Error(w, "upstream claim rejected", http.StatusBadGateway) + return + } + fmt.Fprint(w, `{"code":0,"msg":"OK","data":{"credit":100,"energy":0}}`) + return + } + if r.URL.Path == "/v2/activity/growth/tasks" { + state.listCalls++ + fail := state.failListAt > 0 && state.listCalls >= state.failListAt + current, target, status := state.current, state.target, state.acceptStatus + code := state.taskCode + state.mu.Unlock() + if fail { + http.Error(w, "upstream list failed", http.StatusBadGateway) + return + } + w.Header().Set("Content-Type", "application/json") + fmt.Fprintf(w, `{"code":0,"msg":"OK","data":{"tasks":[{"task_code":%q,"title":"对话5次","target":%d,"current":%d,"accept_status":%q}]}}`, code, target, current, status) + return + } + state.mu.Unlock() + http.NotFound(w, r) + })) + t.Cleanup(server.Close) + oldGap := claimPollGap + claimPollGap = 0 + t.Cleanup(func() { claimPollGap = oldGap }) + client := upstream.New() + client.HTTP = &http.Client{Timeout: 2 * time.Second} + client.ChatBaseCN, client.WebBaseCN, client.BillingBaseCN = server.URL, server.URL, server.URL + p := New(Config{Upstream: client}) + a := &auth.Auth{UID: "autotask-test", AccessToken: "token"} + return p, a, state +} + +func TestExecuteAutoTaskDoesNotMarkUncreditedProgressDone(t *testing.T) { + p, a, state := newAutoTaskTestPanel(t, 0, 5, "accepted") + actions := 0 + act := &autoAction{TaskCode: "chat_5", run: func(*Panel, *auth.Auth) (string, error) { + actions++ + return "action returned 200", nil + }} + + out := p.executeAutoTask(a, act) + if out.Status != "awaiting_progress" { + t.Fatalf("status = %q, want awaiting_progress (progress %s)", out.Status, out.ProgressAfter) + } + if out.ProgressAfter != "0/5" { + t.Fatalf("progress_after = %q, want 0/5", out.ProgressAfter) + } + if actions != 1 { + t.Fatalf("action calls = %d, want 1", actions) + } + _, claims, _ := state.counters() + if claims != 0 { + t.Fatalf("claim calls = %d, want 0", claims) + } +} + +func TestExecuteAutoTaskClaimsCompletedUnclaimedWithoutRunningAction(t *testing.T) { + p, a, state := newAutoTaskTestPanel(t, 5, 5, "completed") + actions := 0 + act := &autoAction{TaskCode: "chat_5", run: func(*Panel, *auth.Auth) (string, error) { + actions++ + return "must not run", nil + }} + + out := p.executeAutoTask(a, act) + if out.Status != "done" || !out.Claimed { + t.Fatalf("outcome = %#v, want done and claimed", out) + } + if actions != 0 { + t.Fatalf("action calls = %d, want 0", actions) + } + _, claims, _ := state.counters() + if claims != 1 { + t.Fatalf("claim calls = %d, want 1", claims) + } +} + +// TestExecuteAutoTaskFirstBuddyRunsAdoptionEvenWhenProgressFull 本仓定制语义: +// first_buddy 进度满≠可领(奖励在 agreement + buddy/first 链)——必须继续跑领养 +// 动作链、由动作后回读领奖,而不是像其它任务那样按"已达标"直接 claim。 +func TestExecuteAutoTaskFirstBuddyRunsAdoptionEvenWhenProgressFull(t *testing.T) { + p, a, state := newAutoTaskTestPanel(t, 1, 1, "completed") + state.taskCode = "first_buddy" + actions := 0 + act := &autoAction{TaskCode: "first_buddy", run: func(*Panel, *auth.Auth) (string, error) { + actions++ + return "已领取 Buddy", nil + }} + + out := p.executeAutoTask(a, act) + if actions != 1 { + t.Fatalf("first_buddy 进度满仍须走领养动作链:action calls = %d, want 1", actions) + } + if out.Status != "done" || !out.Claimed { + t.Fatalf("outcome = %#v, want done and claimed(动作后回读达标即领)", out) + } +} + +func TestExecuteAutoTaskReportsClaimFailureAsPending(t *testing.T) { + p, a, state := newAutoTaskTestPanel(t, 5, 5, "completed") + state.claimError = true + act := &autoAction{TaskCode: "chat_5", run: func(*Panel, *auth.Auth) (string, error) { + t.Fatal("completed task action must not run") + return "", nil + }} + + out := p.executeAutoTask(a, act) + if out.Status != "claim_pending" { + t.Fatalf("status = %q, want claim_pending; outcome=%#v", out.Status, out) + } + if strings.TrimSpace(out.ClaimError) == "" || !strings.Contains(out.Message, out.ClaimError) { + t.Fatalf("claim failure is not readable: %#v", out) + } + _, claims, _ := state.counters() + if claims != 1 { + t.Fatalf("claim calls = %d, want 1", claims) + } +} + +func TestExecuteAutoTaskActionErrorIsNotDone(t *testing.T) { + p, a, state := newAutoTaskTestPanel(t, 0, 5, "accepted") + act := &autoAction{TaskCode: "chat_5", run: func(*Panel, *auth.Auth) (string, error) { + return "", fmt.Errorf("action failed") + }} + + out := p.executeAutoTask(a, act) + if out.Status != "error" || !strings.Contains(out.Message, "action failed") { + t.Fatalf("outcome = %#v, want action error status", out) + } + listCalls, claims, _ := state.counters() + if listCalls != 1 || claims != 0 { + t.Fatalf("list calls=%d claim calls=%d, want 1 and 0", listCalls, claims) + } +} + +func TestExecuteAutoTaskReadErrorIsNotDone(t *testing.T) { + p, a, state := newAutoTaskTestPanel(t, 0, 5, "accepted") + act := &autoAction{TaskCode: "chat_5", run: func(*Panel, *auth.Auth) (string, error) { + state.mu.Lock() + state.failListAt = state.listCalls + 1 + state.mu.Unlock() + return "action returned 200", nil + }} + + out := p.executeAutoTask(a, act) + if out.Status != "error" || !strings.Contains(out.Message, "回读进度失败") { + t.Fatalf("outcome = %#v, want read error status", out) + } + _, claims, _ := state.counters() + if claims != 0 { + t.Fatalf("claim calls = %d, want 0", claims) + } +} + +func TestExecuteAutoTaskDoesNotRepeatClaimedTask(t *testing.T) { + p, a, state := newAutoTaskTestPanel(t, 5, 5, "claimed") + actions := 0 + act := &autoAction{TaskCode: "chat_5", run: func(*Panel, *auth.Auth) (string, error) { + actions++ + return "must not run", nil + }} + + out := p.executeAutoTask(a, act) + if out.Status != "done" || !out.Claimed { + t.Fatalf("outcome = %#v, want already claimed done", out) + } + _, claims, _ := state.counters() + if actions != 0 || claims != 0 { + t.Fatalf("action calls=%d claim calls=%d, want both 0", actions, claims) + } +} + +func TestAutoTaskGlobalWriteEntryPointsDoNotCallUpstream(t *testing.T) { + state := &autoTaskTestState{} + server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { + state.mu.Lock() + state.requests++ + state.mu.Unlock() + http.Error(w, "unexpected upstream request", http.StatusInternalServerError) + })) + t.Cleanup(server.Close) + a := &auth.Auth{UID: "global-test", Domain: "api.workbuddy.ai", AccessToken: "token"} + accounts := pool.New("") + accounts.Add(a) + client := upstream.New() + client.HTTP = &http.Client{Timeout: time.Second} + client.ChatBaseCN, client.WebBaseCN, client.BillingBaseCN = server.URL, server.URL, server.URL + p := New(Config{Pool: accounts, Upstream: client}) + + for _, handler := range []http.HandlerFunc{p.accountTaskAuto, p.accountTaskAutoAll} { + r := httptest.NewRequest(http.MethodPost, "/", strings.NewReader(`{"task_code":"chat_5"}`)) + r.SetPathValue("uid", a.UID) + w := httptest.NewRecorder() + handler(w, r) + if w.Code != http.StatusNotImplemented || !strings.Contains(w.Body.String(), globalTaskWriteMessage) { + t.Fatalf("response = %d %s, want 501 with global task explanation", w.Code, w.Body.String()) + } + } + results := p.runAutoAll(a) + if len(results) != 1 || results[0]["status"] != "error" { + t.Fatalf("runAutoAll(global) = %#v, want one guarded error", results) + } + _, _, requests := state.counters() + if requests != 0 { + t.Fatalf("upstream requests = %d, want 0", requests) + } +} + +func TestRunAutoAllDoesNotMarkUncreditedTaskDone(t *testing.T) { + p, a, _ := newAutoTaskTestPanel(t, 0, 5, "accepted") + oldAction, oldGap := autoActions[0], reportGap + autoActions[0].run = func(*Panel, *auth.Auth) (string, error) { return "action returned 200", nil } + reportGap = 0 + t.Cleanup(func() { + autoActions[0] = oldAction + reportGap = oldGap + }) + + found := false + for _, item := range p.runAutoAll(a) { + if item["task_code"] == "chat_5" && item["status"] == "done" { + t.Fatalf("0/5 task was reported done: %#v", item) + } + if item["task_code"] == "chat_5" { + found = true + if item["status"] != "awaiting_progress" { + t.Fatalf("chat_5 result = %#v, want awaiting_progress", item) + } + } + } + if !found { + t.Fatal("runAutoAll did not report chat_5") + } +} + +func TestRunAutoAllClaimsCompletedUnclaimedTaskWithoutAction(t *testing.T) { + p, a, state := newAutoTaskTestPanel(t, 5, 5, "completed") + actions := 0 + oldAction := autoActions[0] + autoActions[0].run = func(*Panel, *auth.Auth) (string, error) { + actions++ + return "must not run", nil + } + t.Cleanup(func() { autoActions[0] = oldAction }) + + found := false + for _, item := range p.runAutoAll(a) { + if item["task_code"] == "chat_5" { + found = true + if item["status"] != "done" || item["claimed"] != true { + t.Fatalf("chat_5 result = %#v, want done and claimed", item) + } + } + } + if !found { + t.Fatal("runAutoAll did not report chat_5") + } + _, claims, _ := state.counters() + if actions != 0 || claims != 1 { + t.Fatalf("action calls=%d claim calls=%d, want 0 and 1", actions, claims) + } +} diff --git a/internal/panel/autotask_softrate_test.go b/internal/panel/autotask_softrate_test.go new file mode 100644 index 0000000000000000000000000000000000000000..c7d82c62c146f02f064a3929b9e2b2cf2951d714 --- /dev/null +++ b/internal/panel/autotask_softrate_test.go @@ -0,0 +1,119 @@ +package panel + +import ( + "encoding/json" + "net/http" + "net/http/httptest" + "sync" + "testing" + "time" + + "github.com/misakano7545/workbuddy2api-panel/internal/auth" + "github.com/misakano7545/workbuddy2api-panel/internal/pool" + "github.com/misakano7545/workbuddy2api-panel/internal/upstream" +) + +// softRateFake 假上游:前 fail 次任务列表回 429(soft_rate),之后正常下发。 +type softRateFake struct { + mu sync.Mutex + fail int + calls int +} + +func (f *softRateFake) handler() http.HandlerFunc { + return func(w http.ResponseWriter, r *http.Request) { + f.mu.Lock() + f.calls++ + shouldFail := f.fail > 0 + if shouldFail { + f.fail-- + } + f.mu.Unlock() + if shouldFail { + w.WriteHeader(http.StatusTooManyRequests) + _, _ = w.Write([]byte(`{"code":6004,"msg":"rate limit exceeded, please retry later"}`)) + return + } + body, _ := json.Marshal(map[string]any{"code": 0, "msg": "OK", "data": map[string]any{ + "tasks": []any{map[string]any{"task_code": "chat_5", "current": 1, "target": 5}}, + }}) + _, _ = w.Write(body) + } +} + +func softRatePanel(t *testing.T, f *softRateFake) (*Panel, *auth.Auth) { + t.Helper() + srv := httptest.NewServer(f.handler()) + t.Cleanup(srv.Close) + up := &upstream.Client{HTTP: srv.Client(), ChatBaseCN: srv.URL, BillingBaseCN: srv.URL, WebBaseCN: srv.URL} + a := &auth.Auth{UID: "cn-1", Nickname: "cn", AccessToken: "at"} + pl := pool.New("") + pl.Add(a) + return New(Config{Pool: pl, Upstream: up}), a +} + +// 撞两次 429 后第三次成功:任务读得到,不再直接把「查询任务失败」写进结果。 +func TestTaskByCodeRetriesOnSoftRate(t *testing.T) { + oldGap, oldRetries := softRateGap, softRateRetries + softRateGap, softRateRetries = 0, 2 + t.Cleanup(func() { softRateGap, softRateRetries = oldGap, oldRetries }) + + f := &softRateFake{fail: 2} + p, a := softRatePanel(t, f) + task, err := p.taskByCode(a, "chat_5") + if err != nil { + t.Fatalf("软限流应等待重试后成功,实际 err=%v", err) + } + if task == nil || task.TaskCode != "chat_5" { + t.Fatalf("task=%+v want chat_5", task) + } + if f.calls != 3 { + t.Errorf("上游调用=%d want 3(首次 + 2 次重试)", f.calls) + } +} + +// 重试用尽后记冷却:同一轮后续动作快失败,不再打上游也不再睡窗口—— +// 否则一轮几十个动作各睡一遍,后台作业会卡几十分钟还占着账号锁。 +func TestTaskByCodeSoftRateExhaustedFailsFast(t *testing.T) { + oldGap, oldRetries := softRateGap, softRateRetries + softRateGap, softRateRetries = 0, 2 + t.Cleanup(func() { softRateGap, softRateRetries = oldGap, oldRetries }) + + f := &softRateFake{fail: 999} + p, a := softRatePanel(t, f) + if _, err := p.taskByCode(a, "chat_5"); err == nil { + t.Fatal("重试用尽应返回错误") + } else if !isSoftRateErr(err) { + t.Errorf("err=%v 应仍可识别为软限流(调用方据此提示稍后重跑)", err) + } + first := f.calls + if first != 1+softRateRetries { + t.Errorf("上游调用=%d want %d", first, 1+softRateRetries) + } + if d := p.softRateGate("cn-1"); d <= 0 { + t.Errorf("重试用尽应记冷却窗口,实际剩余=%v", d) + } + if _, err := p.taskByCode(a, "chat_5"); err == nil { + t.Error("冷却窗口内应快失败") + } + if f.calls != first { + t.Errorf("冷却窗口内不应再打上游,calls %d -> %d", first, f.calls) + } +} + +// 等待时长:上游 Retry-After 优先,缺省按次数递增,两者都封顶 softRateGapMax。 +func TestSoftRateWaitPrefersRetryAfterAndCaps(t *testing.T) { + oldGap := softRateGap + softRateGap = 10 * time.Second + t.Cleanup(func() { softRateGap = oldGap }) + + if got := softRateWait(&upstream.Error{Kind: upstream.ErrSoftRate, RetryAfter: 40 * time.Second}, 1); got != 40*time.Second { + t.Errorf("Retry-After 优先:got=%v want 40s", got) + } + if got := softRateWait(&upstream.Error{Kind: upstream.ErrSoftRate}, 2); got != 20*time.Second { + t.Errorf("无 Retry-After 按次数递增:got=%v want 20s", got) + } + if got := softRateWait(&upstream.Error{Kind: upstream.ErrSoftRate, RetryAfter: time.Hour}, 1); got != softRateGapMax { + t.Errorf("封顶:got=%v want %v", got, softRateGapMax) + } +} diff --git a/internal/panel/batch_models_test.go b/internal/panel/batch_models_test.go new file mode 100644 index 0000000000000000000000000000000000000000..a60aa395d0775a2b19a72c0c84f1cb6bdce4eebf --- /dev/null +++ b/internal/panel/batch_models_test.go @@ -0,0 +1,133 @@ +package panel + +import ( + "encoding/json" + "io" + "net/http" + "net/http/httptest" + "strings" + "sync/atomic" + "testing" + "time" + + "github.com/misakano7545/workbuddy2api-panel/internal/auth" + "github.com/misakano7545/workbuddy2api-panel/internal/pool" + "github.com/misakano7545/workbuddy2api-panel/internal/upstream" +) + +// TestBatchEndpointsRejectConcurrentRuns 五个手动全量运维接口共用防重入闸门: +// 一轮在跑时再次触发任何全量接口都返回 409,而不是并发再跑一轮逐号打上游。 +func TestBatchEndpointsRejectConcurrentRuns(t *testing.T) { + p := newTestPanel() + p.batchRunning.Store(true) // 模拟一轮全量任务执行中 + for _, path := range []string{ + "/panel/api/checkin_all", + "/panel/api/travel_all", + "/panel/api/activity_all", + "/panel/api/keepalive_all", + "/panel/api/balance_all", + } { + rec := httptest.NewRecorder() + req := httptest.NewRequest("POST", path, nil) + req.Header.Set("Authorization", "Bearer test-key") + p.ServeHTTP(rec, req) + if rec.Code != http.StatusConflict { + t.Errorf("%s: got %d want 409 (body=%s)", path, rec.Code, rec.Body.String()) + } + } + // 闸门释放后恢复 501(无 scheduler 的既有语义),不再 409。 + p.batchRunning.Store(false) + rec := httptest.NewRecorder() + req := httptest.NewRequest("POST", "/panel/api/checkin_all", nil) + req.Header.Set("Authorization", "Bearer test-key") + p.ServeHTTP(rec, req) + if rec.Code != http.StatusNotImplemented { + t.Errorf("闸门释放后应回到 501 语义, got %d", rec.Code) + } +} + +// fakeModelsUpstream 计数版假上游:目录探测回一份最小模型清单,繁忙度端点 +// (POST /v2/chat/busy)回合法空数组——不特判会让 ModelBusy 解析失败、结果带 +// fetchErr 而进不了缓存。 +func fakeModelsUpstream(calls *atomic.Int32) *upstream.Client { + return &upstream.Client{ + HTTP: &http.Client{Transport: fakeRoundTripper(func(r *http.Request) (*http.Response, error) { + calls.Add(1) + body := `{"code":0,"data":{"models":[{"id":"glm-5.2","name":"GLM-5.2","maxInputTokens":200000,"maxOutputTokens":32000}],` + + `"agents":[{"name":"cli","models":["glm-5.2"]}]}}` + if r.Method == http.MethodPost && strings.HasSuffix(r.URL.Path, "/v2/chat/busy") { + body = `{"code":0,"data":[]}` + } + return &http.Response{StatusCode: 200, + Header: http.Header{"Content-Type": []string{"application/json"}}, + Body: io.NopCloser(strings.NewReader(body))}, nil + })}, + ChatBaseCN: "https://cn.example", + BillingBaseCN: "https://cn.example", + } +} + +func fakeModelsPool() *pool.Pool { + p := pool.New("") + p.Add(&auth.Auth{UID: "c1", AccessToken: "at", ExpiresAt: 9999999999, Domain: "www.codebuddy.cn"}) + p.SetCredits("c1", 1000, 0) + return p +} + +// TestModelsCacheShortTTL /panel/api/models 的服务端短缓存:TTL 内重复请求不再 +// 打上游(cached=true),refresh=1 绕过缓存并刷新它,TTL 过期后重新聚合。 +func TestModelsCacheShortTTL(t *testing.T) { + var calls atomic.Int32 + pn := New(Config{Version: "test", APIKey: "k", Pool: fakeModelsPool(), Upstream: fakeModelsUpstream(&calls)}) + + get := func(query string) (int, bool) { + rec := httptest.NewRecorder() + req := httptest.NewRequest("GET", "/panel/api/models"+query, nil) + req.Header.Set("Authorization", "Bearer k") + pn.ServeHTTP(rec, req) + var resp struct { + Cached bool `json:"cached"` + Models []map[string]any `json:"models"` + } + _ = json.Unmarshal(rec.Body.Bytes(), &resp) + return rec.Code, resp.Cached + } + + if code, cached := get(""); code != 200 || cached { + t.Fatalf("首次请求: code=%d cached=%v", code, cached) + } + first := calls.Load() + if calls.Load() == 0 { + t.Fatal("前置失败:首次聚合未打上游") + } + if code, cached := get(""); code != 200 || !cached { + t.Fatalf("TTL 内二次请求应命中缓存: code=%d cached=%v", code, cached) + } + if calls.Load() != first { + t.Fatalf("缓存命中不应再打上游: calls=%d want %d", calls.Load(), first) + } + if code, cached := get("?refresh=1"); code != 200 || cached { + t.Fatalf("refresh=1 应绕过缓存: code=%d cached=%v", code, cached) + } + if calls.Load() == first { + t.Fatal("refresh=1 应重新探上游") + } + afterRefresh := calls.Load() + // refresh 聚合出的干净结果刷新缓存:再查一次应命中且不再打上游。 + if code, cached := get(""); code != 200 || !cached { + t.Fatalf("refresh 后缓存应更新: code=%d cached=%v", code, cached) + } + if calls.Load() != afterRefresh { + t.Fatalf("refresh 后的缓存命中不应打上游: calls=%d want %d", calls.Load(), afterRefresh) + } + // TTL 过期后重新聚合。 + pn.modelsMu.Lock() + pn.modelsCacheAt = time.Now().Add(-2 * modelsCacheTTL) + pn.modelsMu.Unlock() + if code, cached := get(""); code != 200 || cached { + t.Fatalf("TTL 过期应重新聚合: code=%d cached=%v", code, cached) + } + if calls.Load() == afterRefresh { + t.Fatal("TTL 过期应重新打上游") + } +} diff --git a/internal/panel/campaign.go b/internal/panel/campaign.go new file mode 100644 index 0000000000000000000000000000000000000000..171e16c435742d048752e4f004fb16878751762b --- /dev/null +++ b/internal/panel/campaign.go @@ -0,0 +1,234 @@ +// campaign.go 运营活动面板接口:批量读活动进度、批量领已达标的奖励。 +// +// 为什么只做「读 + 领」不做「做任务」:活动任务(AI 对话 N 次 / 召唤专家 / +// App 端体验)的判据在服务端,只认客户端真实会话;2026-11-12 实测六条服务端侧 +// 伪造路径全部不计数(见 docs/campaign-probe.md)。能做的是把已达标未领的奖励 +// 批量领回来——那一步目前得逐个账号进小程序点「领取」。 +package panel + +import ( + "encoding/json" + "log" + "net/http" + "sort" + "strings" + "sync" + + "github.com/misakano7545/workbuddy2api-panel/internal/auth" + "github.com/misakano7545/workbuddy2api-panel/internal/upstream" +) + +// campaignDefaultModule / campaignDefaultCode 当前在跑的活动(星巴克 11/12–11/16)。 +// 调用方可用 ?module= / ?code= 覆盖,免得每有活动就改代码。 +// +// module 留空是这期的真实形状(`/portal/activity/tasks`);早期咖啡节那期要 +// 传 module=coffee(`/portal/activity/coffee/tasks`)。 +const ( + campaignDefaultModule = "" + campaignDefaultCode = "campaign_starbucks_2026" +) + +// campaignAccount 单账号的活动状态行。 +type campaignAccount struct { + UID string `json:"uid"` + Nickname string `json:"nickname"` + Realm string `json:"realm"` + InPeriod bool `json:"in_period"` + Tasks []upstream.CampaignTask `json:"tasks,omitempty"` + Invite *upstream.CampaignInvite `json:"invite,omitempty"` + Vouchers []upstream.CampaignVoucher `json:"vouchers,omitempty"` + // Ready 已达标但未领的任务 code + Ready []string `json:"ready,omitempty"` + Err string `json:"error,omitempty"` +} + +func campaignQuery(r *http.Request) (string, string) { + module := strings.TrimSpace(r.URL.Query().Get("module")) + if module == "" { + module = campaignDefaultModule + } + code := strings.TrimSpace(r.URL.Query().Get("code")) + if code == "" { + code = campaignDefaultCode + } + return module, code +} + +// campaignStatus GET /panel/api/campaign?module=&code= +// +// 逐 CN 账号读活动任务表(3 并发,与券码/积分构成同款限流)。global 账号没有这套 +// 活动,直接标 skipped,不发上游调用——省一次必然失败的 4xx。 +func (p *Panel) campaignStatus(w http.ResponseWriter, r *http.Request) { + module, code := campaignQuery(r) + accts := p.cfg.Pool.List() + out := make([]campaignAccount, len(accts)) + sem := make(chan struct{}, 3) + var wg sync.WaitGroup + for i, st := range accts { + if st.Disabled { + continue + } + a := p.cfg.Pool.AuthByUID(st.UID) + if a == nil { + continue + } + wg.Add(1) + go func(i int, a *auth.Auth) { + defer wg.Done() + sem <- struct{}{} + defer func() { <-sem }() + it := campaignAccount{UID: a.UID, Nickname: a.Nickname, Realm: a.Realm()} + if a.IsGlobal() || a.IsAPIKey() || a.IsEnterprise() { + it.Err = "该领域/账号类型不参与本期活动" + out[i] = it + return + } + snap, err := p.cfg.Upstream.CampaignTasks(a, module, code) + if err != nil { + it.Err = err.Error() + out[i] = it + return + } + it.InPeriod = snap.InPeriod + it.Tasks = snap.Tasks + it.Vouchers = snap.Vouchers + inv := snap.Invite + it.Invite = &inv + for _, t := range snap.Tasks { + if upstream.CampaignTaskReady(t) { + it.Ready = append(it.Ready, t.Code) + } + } + sort.Strings(it.Ready) + out[i] = it + }(i, a) + } + wg.Wait() + res := make([]campaignAccount, 0, len(out)) + ready := 0 + for _, it := range out { + if it.UID == "" { + continue + } + if len(it.Ready) > 0 { + ready++ + } + res = append(res, it) + } + writeJSON(w, http.StatusOK, map[string]any{ + "ok": true, + "module": module, + "code": code, + "accounts": res, + "accounts_ready": ready, + }) +} + +// campaignClaim POST /panel/api/campaign/claim +// +// 请求体:{"module":"","code":"","uids":[],"dry_run":true} +// +// dryRun 默认 **true**:先看会给哪些账号领哪些任务,确认后再用 dry_run=false 真领。 +// 逐账号串行(活动接口有风控节奏要求),每个任务先 viewed 再 claim。 +func (p *Panel) campaignClaim(w http.ResponseWriter, r *http.Request) { + var req struct { + Module string `json:"module"` + Code string `json:"code"` + UIDs []string `json:"uids"` + DryRun *bool `json:"dry_run"` + } + if err := json.NewDecoder(r.Body).Decode(&req); err != nil { + writeErr(w, http.StatusBadRequest, "bad json: "+err.Error()) + return + } + module := strings.TrimSpace(req.Module) + if module == "" { + module = campaignDefaultModule + } + code := strings.TrimSpace(req.Code) + if code == "" { + code = campaignDefaultCode + } + dry := true + if req.DryRun != nil { + dry = *req.DryRun + } + + type result struct { + UID string `json:"uid"` + Nickname string `json:"nickname"` + Claimed []string `json:"claimed,omitempty"` + Would []string `json:"would_claim,omitempty"` + Skipped []string `json:"skipped,omitempty"` + Errors []string `json:"errors,omitempty"` + } + + want := map[string]bool{} + for _, u := range req.UIDs { + if u = strings.TrimSpace(u); u != "" { + want[u] = true + } + } + + var rows []result + for _, st := range p.cfg.Pool.List() { + if st.Disabled { + continue + } + if len(want) > 0 && !want[st.UID] { + continue + } + a := p.cfg.Pool.AuthByUID(st.UID) + if a == nil || a.IsGlobal() || a.IsAPIKey() || a.IsEnterprise() { + continue + } + snap, err := p.cfg.Upstream.CampaignTasks(a, module, code) + if err != nil { + rows = append(rows, result{UID: a.UID, Nickname: a.Nickname, Errors: []string{err.Error()}}) + continue + } + if !snap.InPeriod { + rows = append(rows, result{UID: a.UID, Nickname: a.Nickname, Skipped: []string{"活动不在进行中"}}) + continue + } + row := result{UID: a.UID, Nickname: a.Nickname} + for _, t := range snap.Tasks { + if !upstream.CampaignTaskReady(t) { + continue + } + if dry { + row.Would = append(row.Would, t.Code) + continue + } + if err := p.cfg.Upstream.CampaignViewTask(a, module, code, t.Code); err != nil { + row.Errors = append(row.Errors, t.Code+" viewed: "+err.Error()) + continue + } + if err := p.cfg.Upstream.CampaignClaimTask(a, module, code, t.Code); err != nil { + if upstream.IsCampaignNotMet(err) { + row.Skipped = append(row.Skipped, t.Code+"(未达标)") + continue + } + row.Errors = append(row.Errors, t.Code+" claim: "+err.Error()) + continue + } + row.Claimed = append(row.Claimed, t.Code) + log.Printf("campaign claim: uid=%s task=%s 已领取", a.UID[:min8(len(a.UID))], t.Code) + } + rows = append(rows, row) + } + writeJSON(w, http.StatusOK, map[string]any{ + "ok": true, + "module": module, + "code": code, + "dry_run": dry, + "rows": rows, + }) +} + +func min8(n int) int { + if n < 8 { + return n + } + return 8 +} diff --git a/internal/panel/campaign_test.go b/internal/panel/campaign_test.go new file mode 100644 index 0000000000000000000000000000000000000000..694f1790c253e8dd62efb0bc82c5027ac0a55380 --- /dev/null +++ b/internal/panel/campaign_test.go @@ -0,0 +1,152 @@ +package panel + +// campaign_test.go 钉住活动端点的两个行为:progress 逐号合并、dryRun 默认不领。 + +import ( + "encoding/json" + "net/http" + "net/http/httptest" + "strings" + "sync/atomic" + "testing" + + "github.com/misakano7545/workbuddy2api-panel/internal/pool" + "github.com/misakano7545/workbuddy2api-panel/internal/upstream" +) + +const campaignTasksJSON = `{"code":0,"msg":"OK","data":{ + "invite":{"count":2,"need":3,"open":false}, + "progress":[{"task_code":"ai_chat","progress":3}], + "tasks":[ + {"task_code":"ai_chat","title":"简单任务,AI 搞定","target_count":3,"reward_credit":100,"need_view":true,"enabled":1}, + {"task_code":"expert","title":"复杂任务,专家帮忙","target_count":1,"reward_credit":100,"need_view":true,"enabled":1}]}}` + +const campaignConfigJSON = `{"code":0,"msg":"OK","data":{"config":{"title":"星巴克协作","in_period":true}}}` + +func campaignPanel(t *testing.T, claimed *atomic.Int32) *Panel { + t.Helper() + srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { + switch { + case strings.Contains(r.URL.Path, "/config"): + _, _ = w.Write([]byte(campaignConfigJSON)) + case strings.HasSuffix(r.URL.Path, "/tasks"): + _, _ = w.Write([]byte(campaignTasksJSON)) + case strings.HasSuffix(r.URL.Path, "/vouchers"): + _, _ = w.Write([]byte(`{"code":0,"msg":"OK","data":{"items":[]}}`)) + case strings.HasSuffix(r.URL.Path, "/viewed"): + _, _ = w.Write([]byte(`{"code":0,"msg":"OK","data":{"ok":true}}`)) + case strings.HasSuffix(r.URL.Path, "/claim"): + claimed.Add(1) + _, _ = w.Write([]byte(`{"code":0,"msg":"OK","data":{}}`)) + default: + http.NotFound(w, r) + } + })) + t.Cleanup(srv.Close) + + up := upstream.New() + up.HTTP, up.ChatBaseCN = srv.Client(), srv.URL + p := pool.New("") + p.Add(testRealmAuth(t, "cn-1", "cn")) + return New(Config{Pool: p, Upstream: up}) +} + +func TestCampaignStatusExposesReady(t *testing.T) { + var claimed atomic.Int32 + p := campaignPanel(t, &claimed) + + rec := httptest.NewRecorder() + p.ServeHTTP(rec, httptest.NewRequest(http.MethodGet, "/panel/api/campaign", nil)) + if rec.Code != http.StatusOK { + t.Fatalf("status=%d body=%s", rec.Code, rec.Body.String()) + } + var out struct { + Accounts []struct { + UID string `json:"uid"` + InPeriod bool `json:"in_period"` + Ready []string `json:"ready"` + Tasks []struct { + Code string `json:"task_code"` + Progress int `json:"progress"` + } `json:"tasks"` + } `json:"accounts"` + Ready int `json:"accounts_ready"` + } + if err := json.Unmarshal(rec.Body.Bytes(), &out); err != nil { + t.Fatal(err) + } + if len(out.Accounts) != 1 || !out.Accounts[0].InPeriod { + t.Fatalf("accounts=%+v", out.Accounts) + } + // ai_chat 3/3 → ready;expert 0/1 → 不 ready + if len(out.Accounts[0].Ready) != 1 || out.Accounts[0].Ready[0] != "ai_chat" { + t.Fatalf("ready=%v want [ai_chat]", out.Accounts[0].Ready) + } + if out.Ready != 1 { + t.Fatalf("accounts_ready=%d want 1", out.Ready) + } + if claimed.Load() != 0 { + t.Fatal("读接口不应触发领奖") + } +} + +func TestCampaignClaimDryRunByDefault(t *testing.T) { + var claimed atomic.Int32 + p := campaignPanel(t, &claimed) + + rec := httptest.NewRecorder() + req := httptest.NewRequest(http.MethodPost, "/panel/api/campaign/claim", strings.NewReader(`{}`)) + req.Header.Set("Content-Type", "application/json") + p.ServeHTTP(rec, req) + if rec.Code != http.StatusOK { + t.Fatalf("status=%d body=%s", rec.Code, rec.Body.String()) + } + var out struct { + DryRun bool `json:"dry_run"` + Rows []struct { + Would []string `json:"would_claim"` + Claimed []string `json:"claimed"` + } `json:"rows"` + } + if err := json.Unmarshal(rec.Body.Bytes(), &out); err != nil { + t.Fatal(err) + } + if !out.DryRun { + t.Fatal("缺省必须 dry_run=true(不显式确认就不动手)") + } + if claimed.Load() != 0 { + t.Fatalf("dry run 却真的领了 %d 次", claimed.Load()) + } + if len(out.Rows) != 1 || len(out.Rows[0].Would) != 1 || out.Rows[0].Would[0] != "ai_chat" { + t.Fatalf("rows=%+v", out.Rows) + } +} + +func TestCampaignClaimRealRunClaimsReadyOnly(t *testing.T) { + var claimed atomic.Int32 + p := campaignPanel(t, &claimed) + + rec := httptest.NewRecorder() + req := httptest.NewRequest(http.MethodPost, "/panel/api/campaign/claim", + strings.NewReader(`{"dry_run":false}`)) + req.Header.Set("Content-Type", "application/json") + p.ServeHTTP(rec, req) + if rec.Code != http.StatusOK { + t.Fatalf("status=%d body=%s", rec.Code, rec.Body.String()) + } + var out struct { + Rows []struct { + Claimed []string `json:"claimed"` + } `json:"rows"` + } + if err := json.Unmarshal(rec.Body.Bytes(), &out); err != nil { + t.Fatal(err) + } + // 只有 ai_chat 达标;expert 0/1 不该被 claim + if claimed.Load() != 1 { + t.Fatalf("claim 次数=%d want 1(只领达标的 ai_chat)", claimed.Load()) + } + if len(out.Rows) != 1 || len(out.Rows[0].Claimed) != 1 || out.Rows[0].Claimed[0] != "ai_chat" { + t.Fatalf("rows=%+v", out.Rows) + } +} diff --git a/internal/panel/checkin_frontend_test.go b/internal/panel/checkin_frontend_test.go new file mode 100644 index 0000000000000000000000000000000000000000..b98b8bbc2be6e337ea07998670e7b3211f4ab2f6 --- /dev/null +++ b/internal/panel/checkin_frontend_test.go @@ -0,0 +1,60 @@ +// checkin_frontend_test.go 钉住签到结果文案:四态必须说出四件不同的事。 +// +// 为什么单独一条:判定在 Go 里、文案在 app.js 里,中间只靠 checkin_state 传话。 +// 前端一旦退回「checkin_done 为真 → 签到已完成(绿)」,后端判得再准也白费—— +// 重复点按钮照样看着像签到成功(hub#875 的原始症状)。 +package panel + +import ( + "os" + "os/exec" + "path/filepath" + "testing" +) + +func TestAppJSCheckinResultStates(t *testing.T) { + node, err := exec.LookPath("node") + if err != nil { + t.Skip("node not installed; checkin frontend test skipped") + } + script := `const fs=require('fs'),vm=require('vm'),assert=require('assert'); +const src=fs.readFileSync(process.argv[2],'utf8'); +const start=src.indexOf('function checkinResultNote('),end=src.indexOf('function taskOutcomeStatus('); +assert(start>=0&&end>start,'checkinResultNote 未找到'); +const ctx={};vm.createContext(ctx);vm.runInContext(src.slice(start,end)+'\nthis.note=checkinResultNote;',ctx); +const note=ctx.note; + +const already=note({checkin_state:'already',checkin_done:true,checkin_message:'今天已签到,请明天再来',credits:350}); +assert.equal(already.severity,''); +assert(already.message.includes('今天已签到'),'already 要说清今天已经签过:'+already.message); +assert(!already.message.includes('签到成功'),'already 不能说签到成功:'+already.message); +assert(!already.message.includes('+'),'already 不能出现积分增量:'+already.message); + +const checked=note({checkin_state:'checked',checkin_done:true,checkin_credit:100,credits:350,credits_total:400}); +assert.equal(checked.severity,'ok'); +assert(checked.message.includes('+100 积分'),'真签到要报本次发放的积分:'+checked.message); + +const noCredit=note({checkin_state:'checked',checkin_done:true,credits:350}); +assert.equal(noCredit.severity,'ok'); +assert(!noCredit.message.includes('+'),'上游没给积分数字时不得凭空造一个:'+noCredit.message); + +const failed=note({checkin_state:'failed',checkin_done:false,checkin_message:'签到失败,已签到天数不足 7 天'}); +assert.equal(failed.severity,'err'); +assert(failed.message.includes('不足 7 天'),'失败要透传上游原因:'+failed.message); + +const pending=note({checkin_state:'pending',checkin_done:false}); +assert.equal(pending.severity,'warn'); + +// 兼容老响应(没有 checkin_state):checkin_done 语义不变。 +assert.equal(note({checkin_done:true,credits:350}).severity,'ok'); +assert.equal(note({checkin_done:false,checkin_error:'活动未开启',credits:350}).severity,'err'); +assert.notEqual(note({skipped:true,skip_reason:'国际区不适用'}).severity,'ok'); +console.log('checkin result states passed');` + path := filepath.Join(t.TempDir(), "checkin-note.cjs") + if err := os.WriteFile(path, []byte(script), 0600); err != nil { + t.Fatal(err) + } + if out, err := exec.Command(node, path, "app.js").CombinedOutput(); err != nil { + t.Fatalf("node: %v\n%s", err, out) + } +} diff --git a/internal/panel/checkin_realm_test.go b/internal/panel/checkin_realm_test.go new file mode 100644 index 0000000000000000000000000000000000000000..c74f911dca6ac9a6bbad37ef2c104ef9bb0209d9 --- /dev/null +++ b/internal/panel/checkin_realm_test.go @@ -0,0 +1,27 @@ +package panel + +import ( + "strings" + "testing" +) + +// TestAccountCheckinRealmEcho 签到响应里的 realm 必须是账号自己的 realm。 +// +// 曾是字面量 "cn":当时靠上方 `a.IsGlobal()` 提前返回兜着,值恰好永远对。但门控一挪 +// (放宽成「国际号也走签到」、或提前返回被重构掉)国际号就会拿到 "cn",而这类错误在 +// 编译、池层测试里都看不见——只在响应体里。 +func TestAccountCheckinRealmEcho(t *testing.T) { + e := upgNewEnv(t, + upgSeed{uid: "cn-acct", nickname: "cn", credits: 10}, + upgSeed{uid: "gl-acct", nickname: "gl", realm: "global", credits: 10}, + ) + for uid, want := range map[string]string{"cn-acct": "cn", "gl-acct": "global"} { + code, body := upgPost(t, e.panel, "/panel/api/accounts/"+uid+"/checkin") + if code != 200 { + t.Fatalf("%s 签到应 200, got %d (%s)", uid, code, body) + } + if !strings.Contains(body, `"realm":"`+want+`"`) { + t.Fatalf("%s 回显 realm 应为 %q, got %s", uid, want, body) + } + } +} diff --git a/internal/panel/checkin_state_test.go b/internal/panel/checkin_state_test.go new file mode 100644 index 0000000000000000000000000000000000000000..171ce0da613be4366505668e578f9f253c2110fd --- /dev/null +++ b/internal/panel/checkin_state_test.go @@ -0,0 +1,135 @@ +// checkin_state_test.go 钉住面板签到端点对外暴露的四态回执。 +// +// 为什么要在 handler 层再钉一遍:判定逻辑在 upstream 里错了会造成「文案错」,但 +// 这里缺字段(比如没把 checkin_state 塞进响应)会让前端无处可判、只能退回 +// checkin_done 二选一,同样把幂等拒绝说成签到成功(hub#875)。 +package panel + +import ( + "encoding/json" + "net/http" + "net/http/httptest" + "strings" + "testing" + + "github.com/misakano7545/workbuddy2api-panel/internal/pool" + "github.com/misakano7545/workbuddy2api-panel/internal/upstream" +) + +type checkinResponse struct { + OK bool `json:"ok"` + Done bool `json:"checkin_done"` + State string `json:"checkin_state"` + Message string `json:"checkin_message"` + CheckinErr string `json:"checkin_error"` + Credit *int `json:"checkin_credit"` + Credits int64 `json:"credits"` + SkipReason string `json:"skip_reason"` +} + +// checkinTestServer 只为 daily-checkin 返回 scripted 回执,余额查询固定成功。 +func checkinTestServer(t *testing.T, status int, body string) *upstream.Client { + t.Helper() + srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { + switch r.URL.Path { + case "/v2/billing/meter/daily-checkin": + w.WriteHeader(status) + _, _ = w.Write([]byte(body)) + case "/v2/billing/meter/get-user-resource": + _, _ = w.Write([]byte(`{"code":0,"msg":"OK","data":{"Response":{"Data":{"Accounts":[{"CapacityRemain":7,"CapacitySize":12}]}}}}`)) + default: + t.Errorf("unexpected billing path %q", r.URL.Path) + http.NotFound(w, r) + } + })) + t.Cleanup(srv.Close) + up := upstream.New() + up.HTTP, up.BillingBaseCN = srv.Client(), srv.URL + return up +} + +func doCheckin(t *testing.T, up *upstream.Client) checkinResponse { + t.Helper() + p := New(Config{Pool: poolOfOne(t), Upstream: up}) + rec := httptest.NewRecorder() + p.ServeHTTP(rec, httptest.NewRequest(http.MethodPost, "/panel/api/accounts/cn-1/checkin", nil)) + if rec.Code != http.StatusOK { + t.Fatalf("status=%d body=%s", rec.Code, rec.Body.String()) + } + var resp checkinResponse + if err := json.Unmarshal(rec.Body.Bytes(), &resp); err != nil { + t.Fatalf("decode: %v body=%s", err, rec.Body.String()) + } + return resp +} + +func poolOfOne(t *testing.T) *pool.Pool { + t.Helper() + p := pool.New("") + p.Add(testRealmAuth(t, "cn-1", "cn")) + return p +} + +// TestCheckinAlreadyIsNotReportedAsFreshSuccess 重复签到:上游 HTTP 400 + +// code 10001「今天已签到,请明天再来」,本次一个积分都没发。 +// 面板必须报 already、不得出现积分数字、不得当成新签到(checkin_done 仍为真, +// 因为「今天确实已签」这个事实成立)。 +func TestCheckinAlreadyIsNotReportedAsFreshSuccess(t *testing.T) { + useRealmForTest(t) + up := checkinTestServer(t, http.StatusBadRequest, + `{"code":10001,"msg":"今天已签到,请明天再来","requestId":"32b11f2c"}`) + resp := doCheckin(t, up) + if !resp.Done || resp.State != "already" || !resp.OK { + t.Fatalf("resp=%+v want done=true state=already ok=true", resp) + } + if resp.Credit != nil { + t.Fatalf("already 不得带积分,got %d", *resp.Credit) + } + if !strings.Contains(resp.Message, "今天已签到") { + t.Fatalf("message=%q 应保留上游原文", resp.Message) + } + if resp.CheckinErr != "" { + t.Fatalf("already 不是失败,不该填 checkin_error:%q", resp.CheckinErr) + } +} + +// TestCheckinCheckedCarriesRealCredit 真签到:积分只取上游回执里带回的数字。 +func TestCheckinCheckedCarriesRealCredit(t *testing.T) { + useRealmForTest(t) + up := checkinTestServer(t, http.StatusOK, `{"credit":100,"streak_days":44,"is_streak_day":false}`) + resp := doCheckin(t, up) + if !resp.Done || !resp.OK || resp.State != "checked" { + t.Fatalf("resp=%+v want done=true ok=true state=checked", resp) + } + if resp.Credit == nil || *resp.Credit != 100 { + t.Fatalf("checkin_credit=%v want 100", resp.Credit) + } +} + +// TestCheckinCheckedWithoutCreditFieldStillOmitsNumber 上游没带回积分时不显示数字 +// (而不是显示 0,更不是硬编码 100)。 +func TestCheckinCheckedWithoutCreditFieldStillOmitsNumber(t *testing.T) { + useRealmForTest(t) + up := checkinTestServer(t, http.StatusOK, `{"code":0,"msg":"OK","data":{}}`) + resp := doCheckin(t, up) + if resp.State != "checked" || resp.Credit != nil { + t.Fatalf("resp=%+v want state=checked 且无 checkin_credit", resp) + } +} + +// TestCheckinFailureWordsBeatAlready 语义为失败的回执不能被 already 抢走 +// (「签到失败,已签到天数不足 7 天」同时含「失败」与「已签到」)。 +func TestCheckinFailureWordsBeatAlready(t *testing.T) { + useRealmForTest(t) + up := checkinTestServer(t, http.StatusOK, `{"code":10001,"msg":"签到失败,已签到天数不足 7 天"}`) + resp := doCheckin(t, up) + if resp.State != "failed" || resp.Done || resp.OK { + t.Fatalf("resp=%+v want state=failed done=false", resp) + } + if resp.CheckinErr == "" { + t.Fatal("失败必须带 checkin_error 供前端展示原因") + } +} + +// pending(429 请求处理中)由内部重试阶梯覆盖,handler 层不重复跑 17 秒退避: +// 见 internal/upstream/checkin_receipt_test.go 的 pending 用例。 diff --git a/internal/panel/config.go b/internal/panel/config.go index 73800ed383a8e696014e419dc5433b065a82d056..fd94c1a6080b7431dbb1417c0b46aee04130625a 100644 --- a/internal/panel/config.go +++ b/internal/panel/config.go @@ -1,57 +1,78 @@ -// config.go 面板配置页接口:读取当前配置、校验并保存(热生效 + 重启项标注)。 -// -// 分工:cmd/server 持有 Config 类型与校验逻辑(Load/normalize),此处只做 -// HTTP 编排——GET 回显、POST 透传给注入的 SaveConfig 闭包(由 main 完成 -// "校验 → 落盘 → 热应用 → 返回需重启字段列表")。 -package panel - -import ( - "io" - "log" - "net/http" -) - -// getConfig 返回当前配置文件内容与路径(前端按 schema 渲染表单)。 -func (p *Panel) getConfig(w http.ResponseWriter, r *http.Request) { - if p.cfg.LoadConfig == nil { - writeErr(w, http.StatusNotImplemented, "config api not available") - return - } - cfg, err := p.cfg.LoadConfig() - if err != nil { - writeErr(w, http.StatusInternalServerError, "load config: "+err.Error()) - return - } - writeJSON(w, http.StatusOK, map[string]any{ - "ok": true, - "path": p.cfg.ConfigPath, - "config": cfg, - }) -} - -// saveConfig 保存配置:body 直接是配置 JSON(前端按 schema 组装完整对象)。 -// SaveConfig 闭包内部完成校验+落盘+热应用;校验失败返回 400 且不写盘。 -func (p *Panel) saveConfig(w http.ResponseWriter, r *http.Request) { - if p.cfg.SaveConfig == nil { - writeErr(w, http.StatusNotImplemented, "config api not available") - return - } - raw, err := io.ReadAll(io.LimitReader(r.Body, 1<<20)) - if err != nil { - writeErr(w, http.StatusBadRequest, "read body: "+err.Error()) - return - } - restartRequired, err := p.cfg.SaveConfig(raw) - if err != nil { - writeErr(w, http.StatusBadRequest, err.Error()) - return - } - if restartRequired == nil { - restartRequired = []string{} - } - log.Printf("panel: 配置已保存(热生效完成;需重启字段 %d 个)", len(restartRequired)) - writeJSON(w, http.StatusOK, map[string]any{ - "ok": true, - "restart_required": restartRequired, - }) -} +// config.go 面板配置页接口:读取当前配置、校验并保存(热生效 + 重启项标注)。 +// +// 分工:cmd/server 持有 Config 类型与校验逻辑(Load/normalize),此处只做 +// HTTP 编排——GET 回显、POST 透传给注入的 SaveConfig 闭包(由 main 完成 +// "校验 → 落盘 → 热应用 → 返回需重启字段列表")。 +package panel + +import ( + "io" + "log" + "net/http" + "os" +) + +// getConfig 返回当前配置文件内容与路径(前端按 schema 渲染表单)。 +func (p *Panel) getConfig(w http.ResponseWriter, r *http.Request) { + if p.cfg.LoadConfig == nil { + writeErr(w, http.StatusNotImplemented, "config api not available") + return + } + cfg, err := p.cfg.LoadConfig() + if err != nil { + writeErr(w, http.StatusInternalServerError, "load config: "+err.Error()) + return + } + writeJSON(w, http.StatusOK, map[string]any{ + "ok": true, + "path": p.cfg.ConfigPath, + "config": cfg, + "api_key_env_managed": os.Getenv("WB2A_API_KEY") != "", + "panel_key_env_managed": os.Getenv("WB2A_PANEL_KEY") != "", + "environment_managed_fields": configManagedFields(cfg), + }) +} + +// saveConfig 保存配置:body 直接是配置 JSON(前端按 schema 组装完整对象)。 +// SaveConfig 闭包内部完成校验+落盘+热应用;校验失败返回 400 且不写盘。 +func (p *Panel) saveConfig(w http.ResponseWriter, r *http.Request) { + if p.cfg.SaveConfig == nil { + writeErr(w, http.StatusNotImplemented, "config api not available") + return + } + raw, err := io.ReadAll(io.LimitReader(r.Body, 1<<20)) + if err != nil { + writeErr(w, http.StatusBadRequest, "read body: "+err.Error()) + return + } + restartRequired, err := p.cfg.SaveConfig(raw) + if err != nil { + writeErr(w, http.StatusBadRequest, err.Error()) + return + } + if restartRequired == nil { + restartRequired = []string{} + } + log.Printf("panel: 配置已保存(热生效完成;需重启字段 %d 个)", len(restartRequired)) + var managedFields []string + if p.cfg.LoadConfig != nil { + if config, err := p.cfg.LoadConfig(); err == nil { + managedFields = configManagedFields(config) + } + } + writeJSON(w, http.StatusOK, map[string]any{ + "ok": true, + "restart_required": restartRequired, + "api_key_env_managed": os.Getenv("WB2A_API_KEY") != "", + "environment_managed_fields": managedFields, + }) +} + +// configManagedFields 读取配置对象的「被启动环境变量托管字段」清单(可选能力: +// 配置类型未提供该方法时返回 nil)。移植上游 PR #104。 +func configManagedFields(config any) []string { + if provider, ok := config.(interface{ EnvironmentManagedFields() []string }); ok { + return provider.EnvironmentManagedFields() + } + return nil +} diff --git a/internal/panel/config_env_test.go b/internal/panel/config_env_test.go new file mode 100644 index 0000000000000000000000000000000000000000..1c924c2437d4987e03fe240977da20c79fa16e51 --- /dev/null +++ b/internal/panel/config_env_test.go @@ -0,0 +1,29 @@ +package panel + +import ( + "encoding/json" + "net/http" + "net/http/httptest" + "strings" + "testing" +) + +// TestConfigAPIReportsEnvironmentManagedKey 配置读写接口都应报告「API key 由启动 +// 环境变量托管」,供前端禁用输入框 + 不把无效值写进本地会话密钥。移植上游 PR #104。 +func TestConfigAPIReportsEnvironmentManagedKey(t *testing.T) { + t.Setenv("WB2A_API_KEY", "environment-key") + p := New(Config{APIKey: "environment-key", LoadConfig: func() (any, error) { return map[string]any{"api_key": "environment-key"}, nil }, SaveConfig: func([]byte) ([]string, error) { return nil, nil }}) + for _, method := range []string{http.MethodGet, http.MethodPost} { + req := httptest.NewRequest(method, "/panel/api/config", strings.NewReader(`{"api_key":"other"}`)) + req.Header.Set("Authorization", "Bearer environment-key") + rec := httptest.NewRecorder() + p.ServeHTTP(rec, req) + var response map[string]any + if err := json.Unmarshal(rec.Body.Bytes(), &response); err != nil { + t.Fatal(err) + } + if rec.Code != 200 || response["api_key_env_managed"] != true { + t.Fatalf("method=%s status=%d response=%v", method, rec.Code, response) + } + } +} diff --git a/internal/panel/config_realm_tabs_test.go b/internal/panel/config_realm_tabs_test.go new file mode 100644 index 0000000000000000000000000000000000000000..6daaeff1da317cc1b09218e016224d256b048daf --- /dev/null +++ b/internal/panel/config_realm_tabs_test.go @@ -0,0 +1,89 @@ +package panel + +import ( + "os" + "os/exec" + "testing" +) + +// TestAppJSCfgRealmTabSelfHide 配置页分域切换不许把 tab 按钮自己过滤掉。 +// +// 背景:applyCfgRealmFilter 用 `#cfgForm [data-realm]` 全选,而三个 tab 按钮本身 +// 就带 data-realm 且就在 #cfgForm 里。于是选「国际版」时同一段逻辑把「全部」「国内版」 +// 两个按钮一起 display:none,tab 栏塌成只剩一个——字段过滤其实是对的,坏的是导航。 +// 这种错 Go 层全绿、JS 语法检查也发现不了,只能跑真实函数数元素。 +func TestAppJSCfgRealmTabSelfHide(t *testing.T) { + node, err := exec.LookPath("node") + if err != nil { + t.Skip("node not installed; cfg realm tab test skipped") + } + script := `const fs = require('fs'), vm = require('vm'), assert = require('assert'); +const src = fs.readFileSync(process.argv[2], 'utf8'); + +const s = src.indexOf('function applyCfgRealmFilter('); +const e = src.indexOf('\n}\n', s) + 2; +assert.ok(s >= 0 && e > s, 'applyCfgRealmFilter block not found'); + +// 最小 DOM 桩:tab 栏里的按钮 closest('#cfgRealmTabs') 命中,字段不命中。 +const tabsHost = {}; +const mk = (realm, inTabs) => { + const el = { + realm, style: {}, on: false, + dataset: { realm }, + getAttribute: k => (k === 'data-realm' ? realm : null), + closest: sel => (inTabs && sel === '#cfgRealmTabs' ? tabsHost : null), + classList: { toggle(cls, v) { el.on = v; } }, + }; + return el; +}; +const tabs = ['all', 'cn', 'global'].map(r => mk(r, true)); +const fields = [mk('cn', false), mk('cn', false), mk('global', false), mk('global', false)]; +const all = tabs.concat(fields); + +const tabsBox = { querySelectorAll: () => tabs }; +const ctx = { + String, Array, console, + cfgRealmFilter: 'all', + $: id => (id === 'cfgRealmTabs' ? tabsBox : null), + document: { querySelectorAll: sel => (sel === '#cfgForm [data-realm]' ? all : []) }, +}; +vm.createContext(ctx); +vm.runInContext(src.slice(s, e) + '\nthis.apply = applyCfgRealmFilter;', ctx); + +const hidden = el => el.style.display === 'none'; +const fieldStates = () => fields.map(f => f.style.display); +const assertTabsIntact = (when) => + assert.ok(!tabs.some(hidden), when + ':三个 tab 都不许被隐藏(实际 ' + JSON.stringify(tabs.map(b => String(b.style.display))) + ')'); + +ctx.cfgRealmFilter = 'global'; +ctx.apply(); +assertTabsIntact('选「国际版」'); +assert.deepStrictEqual(fieldStates(), ['none', 'none', '', ''], '国际版只留 global 字段'); +assert.deepStrictEqual(tabs.map(b => b.on), [false, false, true], '只有「国际版」tab 高亮'); + +ctx.cfgRealmFilter = 'cn'; +ctx.apply(); +assertTabsIntact('选「国内版」'); +assert.deepStrictEqual(fieldStates(), ['', '', 'none', 'none'], '国内版只留 cn 字段'); +assert.deepStrictEqual(tabs.map(b => b.on), [false, true, false], '只有「国内版」tab 高亮'); + +ctx.cfgRealmFilter = 'all'; +ctx.apply(); +assertTabsIntact('选「全部」'); +assert.ok(!fields.some(hidden), '「全部」要显示所有分域字段'); +console.log('CFG REALM OK'); +` + f, err := os.CreateTemp(t.TempDir(), "cfg-realm-*.cjs") + if err != nil { + t.Fatal(err) + } + if _, err := f.WriteString(script); err != nil { + t.Fatal(err) + } + f.Close() + cmd := exec.Command(node, f.Name(), "app.js") + cmd.Dir = "." // 测试工作目录 = internal/panel + if out, err := cmd.CombinedOutput(); err != nil { + t.Fatalf("cfg realm tab test failed:\n%s", out) + } +} diff --git a/internal/panel/control_size_test.go b/internal/panel/control_size_test.go new file mode 100644 index 0000000000000000000000000000000000000000..e1a93455d43f0ee9c4f00cab25cfa84c16bfd0e6 --- /dev/null +++ b/internal/panel/control_size_test.go @@ -0,0 +1,74 @@ +package panel + +import ( + "os" + "strings" + "testing" +) + +// TestCompactControlsSameHeight 钉住「同一行里的按钮与下拉同高」这条视觉约定。 +// +// 为什么需要:卡片头 / 筛选栏里的控件此前各写各的尺子—— +// - .xs 只作用于 button, 会吃全局 7px 13px / 14px") + } +} + +// cssRuleBody 返回选择器列表与 sel 完全一致的 CSS 规则的花括号内声明。 +// 只做字面前缀匹配(不解析层叠),够用于「某条规则里是否写了某个值」这类断言。 +func cssRuleBody(css, sel string) (string, bool) { + needle := sel + " {" + i := strings.Index(css, needle) + if i < 0 { + return "", false + } + rest := css[i+len(needle):] + j := strings.Index(rest, "}") + if j < 0 { + return "", false + } + return strings.TrimSpace(rest[:j]), true +} diff --git a/internal/panel/credit_frontend_adversarial_test.go b/internal/panel/credit_frontend_adversarial_test.go new file mode 100644 index 0000000000000000000000000000000000000000..6bae47827e753b9ad520d200028bf8a1bdb75e7d --- /dev/null +++ b/internal/panel/credit_frontend_adversarial_test.go @@ -0,0 +1,180 @@ +package panel + +// T5 前端对抗测试:node + vm 切片(仿 frontend_test.go 的 TestAppJSCreditHistoryFormatting)。 +// 脏数据 / XSS / 501 分支不得抛异常、不得输出未转义 HTML。只新增测试,不改业务代码。 + +import ( + "encoding/json" + "os" + "os/exec" + "strings" + "testing" +) + +// bndCreditNode 把脚本写到临时文件并用 node 执行(工作目录 = 包目录,读 app.js), +// 返回去掉首尾空白的 stdout;无 node 时跳过。 +func bndCreditNode(t *testing.T, script string) string { + t.Helper() + node, err := exec.LookPath("node") + if err != nil { + t.Skip("node not installed; credit history adversarial test skipped") + } + f, err := os.CreateTemp(t.TempDir(), "credit-adv-*.cjs") + if err != nil { + t.Fatal(err) + } + if _, err := f.WriteString(script); err != nil { + t.Fatal(err) + } + f.Close() + out, err := exec.Command(node, f.Name(), "app.js").CombinedOutput() + if err != nil { + t.Fatalf("credit history adversarial node test failed: %v\n%s", err, out) + } + return strings.TrimSpace(string(out)) +} + +// 脏数据 / XSS / 不可用分支。返回 JSON: +// +// *Ok = true 表示未抛异常;其余字段是渲染结果,供 Go 侧断言转义与文案。 +const bndCreditAdversarialScript = `const fs = require('fs'); +const vm = require('vm'); +const src = fs.readFileSync(process.argv[2], 'utf8'); +const escStart = src.indexOf('function esc('); +const escEnd = src.indexOf('function ago('); +const start = src.indexOf('function creditNum'); +const end = src.indexOf('function creditLimitValue'); +if ([escStart, escEnd, start, end].some(v => v < 0)) throw new Error('credit history helpers not found'); +const els = {}; +const $ = id => (els[id] || (els[id] = { innerHTML: '', textContent: '' })); +const ctx = { Date, Number, String, Math, RegExp, isNaN, $ }; +vm.createContext(ctx); +vm.runInContext(src.slice(escStart, escEnd) + src.slice(start, end) + + '\nthis.renderCreditHistory=renderCreditHistory;', ctx); +const t = new Date(2026, 8, 28, 14, 5, 6).toISOString(); +const out = {}; +const run = (key, fn) => { try { fn(); out[key] = true; } catch (e) { out[key] = String((e && e.stack) || e); } }; + +run('nullEntriesOk', () => ctx.renderCreditHistory({ entries: null })); +out.nullEntriesNote = els.creditNote.textContent; +out.nullEntriesBody = els.creditBody.innerHTML; + +run('missingFieldsOk', () => ctx.renderCreditHistory({ entries: [{}] })); +out.missingFieldsBody = els.creditBody.innerHTML; + +run('badDeltaOk', () => ctx.renderCreditHistory({ entries: [ + { time: t, uid: 'u1', delta: '50', before: '0', after: '50' }, + { time: t, uid: 'u2', delta: 'abc', before: 0, after: 0 }, + { time: t, uid: 'u3', delta: NaN, before: 0, after: 0 }, +] })); +out.badDeltaBody = els.creditBody.innerHTML; + +const evilAccount = '"\' onmouseover="x'; +run('xssOk', () => ctx.renderCreditHistory({ entries: [ + { time: t, uid: '', account: evilAccount, delta: 1, before: 0, after: 1 }, +] })); +out.xssBody = els.creditBody.innerHTML; + +run('unavailableOk', () => ctx.renderCreditHistory(null)); +out.unavailableNote = els.creditNote.textContent; +out.unavailableBody = els.creditBody.innerHTML; + +process.stdout.write(JSON.stringify(out));` + +func TestBndCreditFrontendAdversarial(t *testing.T) { + out := bndCreditNode(t, bndCreditAdversarialScript) + var got map[string]any + if err := json.Unmarshal([]byte(out), &got); err != nil { + t.Fatalf("node 输出不是 JSON: %v\n%s", err, out) + } + str := func(k string) string { + s, _ := got[k].(string) + return s + } + ok := func(k string) { + t.Helper() + if got[k] != true { + t.Fatalf("%s: 渲染抛异常或未执行: %v", k, got[k]) + } + } + + // entries=null:不抛异常,回「暂无」而不是「不可用」。 + ok("nullEntriesOk") + if note := str("nullEntriesNote"); note != "暂无积分变动记录" { + t.Fatalf("entries=null 的提示应为暂无,得到 %q", note) + } + if body := str("nullEntriesBody"); !strings.Contains(body, "暂无积分变动记录") { + t.Fatalf("entries=null 的表格应为暂无,得到 %s", body) + } + + // 字段全缺:不抛异常,以 — / 0 兜底。 + ok("missingFieldsOk") + if body := str("missingFieldsBody"); !strings.Contains(body, "余额 0 → 0") || !strings.Contains(body, "—") { + t.Fatalf("缺字段行应以 — / 0 兜底,得到 %s", body) + } + + // delta 为字符串 / 非法字符串 / NaN:不抛异常,不渲染出 NaN。 + ok("badDeltaOk") + badDelta := str("badDeltaBody") + if !strings.Contains(badDelta, "+50") { + t.Fatalf("字符串 50 应按数字渲染为 +50,得到 %s", badDelta) + } + if strings.Contains(badDelta, "NaN") { + t.Fatalf("delta 非法时不应渲染出 NaN,得到 %s", badDelta) + } + if n := strings.Count(badDelta, ""); n != 3 { + t.Fatalf("应渲染 3 行,得到 %d: %s", n, badDelta) + } + + // account / uid 含 - - + + + + + + + +WorkBuddy2API · 控制台 + + + + + +
+ + + +
+
+ +

账号池

+ / + - +
+ + + + +
+ + +
+
+
-
账号总数
+
-
可用
+
-
冷却中
+
-
已暂停选号
+
-
已禁用
+
-
积分剩余 / 总额
+
-
粘性会话
+
+ + +
+
+

积分到期提醒 按自然日聚合 · 日均需耗 = 该日到期积分 ÷ 距到期天数 · 上游按失效时刻先后自动优先扣减(FEFO)

+ + +
+
+ + + + + + +
账号最近到期距到期该日到期日均需耗
+
+ +
+ 跨账号合计 · 按到期日 +
+ + + + + + +
到期日距到期该日到期账号数
+
+
+
+ +
+
+

账号池

+ + + + + + + + + + + + + + + +
+
+ + + + + + + +
账号状态积分成功 / 失败在途用量最近成功
+
+
+ + +
+
+

模型锁池 哪些模型不能用、还要锁多久

+ + +
+
+ + + + + + +
模型域状态可选 / 总数锁定账号最早解锁全池解锁原因
+
+
+
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+
+ + +
+
+
+

账号任务

+
操作随账号能力开放;「领取」仅在进度达标后可用。
+
+
+
加载中
+ + +
+ + + + +
+
+
+ + + + + +
+
+
+ + +
+
+
+

添加账号

+
+ + + +
+
+
+ +
+
+
+ 站点: + + +
+
国际版登录后,网关自动完成注册地区、激活与试用额度领取,全程无需手动操作。(走 www.workbuddy.ai 桌面端口径)
+
+ + + + +
+ + + + +
+
+ + + + + + + +
+
+
+ + +
+
+
+

需要访问密钥

+
该网关已启用 api_key 鉴权,请输入 config.json 中的密钥。
+
+
+
+ +
+
+ + +
+
+
+ +
+ + +
+
+
+

请求上下文

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

账号备注与分组

+
备注只存在本机浏览器(localStorage: wb2api.remarks.v1),不写回后端;账号池与用量页会同时显示「备注 + 原昵称」。留空即清除该账号备注。
+ 分组写回服务端(state.json),用于账号池按组筛选与组内批量操作;只提交改动过的行。分组不参与选号 / 计费 / 鉴权。
+
+
+
+
+
+ + + + +
+
+
+ + +
+
+
+

开学季 · 我的券码

+
抽奖抽中的第三方券(KFC / 瑞幸 / 酷狗等),券码到店到对应app/小程序兑换。
+
+
+
+ + + + +
+
+
+ + + + diff --git a/internal/panel/issue159_160_routes_test.go b/internal/panel/issue159_160_routes_test.go new file mode 100644 index 0000000000000000000000000000000000000000..4f219f29d314cacdcb48c8d4ba26674486a6355a --- /dev/null +++ b/internal/panel/issue159_160_routes_test.go @@ -0,0 +1,74 @@ +package panel + +import ( + "net/http" + "net/http/httptest" + "strings" + "testing" + "time" + + "github.com/misakano7545/workbuddy2api-panel/internal/auth" + "github.com/misakano7545/workbuddy2api-panel/internal/pool" + "github.com/misakano7545/workbuddy2api-panel/internal/reqlog" +) + +// TestAccountGroupEndpoint 分组接口真的挂上了路由(issue #159)。 +// +// 池层的 SetGroup 有单测,但「路由没注册 / 路径写错 / body 没解」这三种错法在 Go +// 编译与池层测试里都看不见——面板上表现为点了保存什么都没发生。 +func TestAccountGroupEndpoint(t *testing.T) { + pl := pool.New("") + pl.Add(&auth.Auth{UID: "u1"}) + p := New(Config{Version: "test", APIKey: "k", Pool: pl}) + + call := func(path, body string) *httptest.ResponseRecorder { + req := httptest.NewRequest("POST", path, strings.NewReader(body)) + req.Header.Set("Authorization", "Bearer k") + rec := httptest.NewRecorder() + p.ServeHTTP(rec, req) + return rec + } + + if rec := call("/panel/api/accounts/u1/group", `{"group":"批量A"}`); rec.Code != http.StatusOK { + t.Fatalf("设置分组应 200, got %d (%s)", rec.Code, rec.Body.String()) + } + if st, _ := pl.Status("u1"); st.Group != "批量A" { + t.Fatalf("池里没落分组: %q", st.Group) + } + // 不存在账号回 404(否则 uid 打错时界面上看起来「保存成功」)。 + if rec := call("/panel/api/accounts/nope/group", `{"group":"A"}`); rec.Code != http.StatusNotFound { + t.Fatalf("未知账号应 404, got %d", rec.Code) + } + if rec := call("/panel/api/accounts/u1/group", `not-json`); rec.Code != http.StatusBadRequest { + t.Fatalf("坏 body 应 400, got %d", rec.Code) + } +} + +// TestRequestLogsClearEndpoint 清空归档接口:删文件 + 之后读回为空(issue #160)。 +func TestRequestLogsClearEndpoint(t *testing.T) { + rl := reqlog.New(reqlog.Config{Enabled: true, Dir: t.TempDir(), RetentionDays: 7}) + rl.Record(reqlog.Event{Time: time.Now().Add(-time.Minute), RequestID: "a", Status: 200, OK: true}) + p := New(Config{Version: "test", APIKey: "k", RequestLog: rl}) + + req := httptest.NewRequest("POST", "/panel/api/request_logs/clear", nil) + req.Header.Set("Authorization", "Bearer k") + rec := httptest.NewRecorder() + p.ServeHTTP(rec, req) + if rec.Code != http.StatusOK { + t.Fatalf("清空应 200, got %d (%s)", rec.Code, rec.Body.String()) + } + if !strings.Contains(rec.Body.String(), `"files":1`) { + t.Fatalf("应报删除文件数, got %s", rec.Body.String()) + } + + req = httptest.NewRequest("GET", "/panel/api/request_logs?limit=10", nil) + req.Header.Set("Authorization", "Bearer k") + rec = httptest.NewRecorder() + p.ServeHTTP(rec, req) + if rec.Code != http.StatusOK { + t.Fatalf("读取应 200, got %d", rec.Code) + } + if !strings.Contains(rec.Body.String(), `"entries":[]`) { + t.Fatalf("清空后应读到空列表, got %s", rec.Body.String()) + } +} diff --git a/internal/panel/logexport.go b/internal/panel/logexport.go new file mode 100644 index 0000000000000000000000000000000000000000..32fe739e3a3c63ab96ff4d4c60f01eb372e3bf65 --- /dev/null +++ b/internal/panel/logexport.go @@ -0,0 +1,119 @@ +// logexport.go 面板运行日志的按区间导出(GET /panel/api/logs/export)。 +// +// 动机:日志落盘之后,「把最近三天发我」就是运维最常要的动作。没有导出,人只能 +// SSH 上去翻文件——而面板存在的意义就是不必 SSH。 +// +// 导出的是**落盘文件**(按天 JSONL,原样打包),不是内存环: +// - 内存环只有 500/频道,导出它等于导出一份已经被冲掉的历史; +// - 事故复盘要的是原始行,重新序列化会引入一次口径漂移(字段名/时间格式)。 +// +// 区间口径: +// +// ?days=N 最近 N 天(含今天),1..retentionDays,缺省 3 +// ?from=&to= RFC3339 精确区间(同时给出时优先于 days) +// +// 响应 application/zip,文件名 panel-logs-_.zip。 +package panel + +import ( + "log" + "net/http" + "os" + "strconv" + "strings" + "time" + + "github.com/misakano7545/workbuddy2api-panel/internal/cst" +) + +// exportDefaultDays 缺省导出区间(天)。取 3 而不是 7:多数复盘看的是「前天到现在」, +// 7 天的包在请求体量大时能到几十 MB,浏览器下载体验差。 +const exportDefaultDays = 3 + +// logsExportHandler 打包指定区间内的落盘日志。 +func (p *Panel) logsExportHandler(w http.ResponseWriter, r *http.Request) { + p.logs.mu.Lock() + store := p.logs.store + p.logs.mu.Unlock() + if store == nil { + writeErr(w, http.StatusNotImplemented, "日志落盘未启用(检查 logging.panel_log_enabled 与数据目录权限)") + return + } + + now := cst.Now() + q := r.URL.Query() + from, to := now.AddDate(0, 0, -exportDefaultDays), now + if raw := strings.TrimSpace(q.Get("days")); raw != "" { + days, err := strconv.Atoi(raw) + if err != nil || days <= 0 { + writeErr(w, http.StatusBadRequest, "days 需为正整数") + return + } + // 上限取保留期:要更早的数据得先改配置,不能靠一个查询参数绕过保留策略。 + if maxDays := store.retentionDays; maxDays > 0 && days > maxDays { + days = maxDays + } + from = now.AddDate(0, 0, -days) + } + if raw := strings.TrimSpace(q.Get("from")); raw != "" { + t, err := time.Parse(time.RFC3339, raw) + if err != nil { + writeErr(w, http.StatusBadRequest, "from 需为 RFC3339(如 2026-11-09T00:00:00+08:00)") + return + } + from = t + } + if raw := strings.TrimSpace(q.Get("to")); raw != "" { + t, err := time.Parse(time.RFC3339, raw) + if err != nil { + writeErr(w, http.StatusBadRequest, "to 需为 RFC3339") + return + } + to = t + } + if !to.After(from) { + writeErr(w, http.StatusBadRequest, "to 必须晚于 from") + return + } + + // 先落盘到临时文件再整体回传:zip 是流式格式,边写边发时若中途出错,客户端会 + // 拿到一个**看起来完整**的坏包(zip 目录在尾部)。先落盘能把失败变成 HTTP 500。 + tmp, err := os.CreateTemp("", "panel-logs-*.zip") + if err != nil { + writeErr(w, http.StatusInternalServerError, "创建导出文件: "+err.Error()) + return + } + defer func() { + tmp.Close() + os.Remove(tmp.Name()) + }() + files, err := store.Export(tmp, from, to) + if err != nil { + writeErr(w, http.StatusInternalServerError, "打包日志: "+err.Error()) + return + } + if files == 0 { + // 空区间给明确答复,而不是一个只有空目录的 zip——后者会被当成"导出成功但没内容"。 + writeErr(w, http.StatusNotFound, "该区间没有落盘日志(可能是保留期外,或落盘刚启用)") + return + } + if _, err := tmp.Seek(0, 0); err != nil { + writeErr(w, http.StatusInternalServerError, "读取导出文件: "+err.Error()) + return + } + info, err := tmp.Stat() + if err != nil { + writeErr(w, http.StatusInternalServerError, "读取导出文件: "+err.Error()) + return + } + name := "panel-logs-" + from.In(cst.Loc).Format("20060102") + "_" + to.In(cst.Loc).Format("20060102") + ".zip" + w.Header().Set("Content-Type", "application/zip") + w.Header().Set("Content-Disposition", `attachment; filename="`+name+`"`) + w.Header().Set("Content-Length", strconv.FormatInt(info.Size(), 10)) + // 下载不缓冲:大包直接 sendfile 语义,别先读进内存。 + if _, err := tmp.Seek(0, 0); err == nil { + http.ServeContent(w, r, name, info.ModTime(), tmp) + return + } + log.Printf("WARN: panel: 日志导出回传失败: %v", err) +} diff --git a/internal/panel/logexport_test.go b/internal/panel/logexport_test.go new file mode 100644 index 0000000000000000000000000000000000000000..e86451b4ab4f29fb3df2ceee55a147998cd571f5 --- /dev/null +++ b/internal/panel/logexport_test.go @@ -0,0 +1,126 @@ +// logexport_test.go 导出端点的端到端断言(HTTP → 落盘文件 → ZIP)。 +// +// 只测 LogStore.Export 不够:真正决定「能不能把日志发我」的是这条 HTTP 路径—— +// 落盘未启用时的提示、空区间的 404、区间上限钳制、文件名与 Content-Type。 +package panel + +import ( + "net/http" + "net/http/httptest" + "net/url" + "testing" + "time" + + "github.com/misakano7545/workbuddy2api-panel/internal/cst" +) + +// newExportPanel 造一个挂了落盘存储的面板(只测日志导出,不需要 upstream)。 +func newExportPanel(t *testing.T) (*Panel, *LogStore) { + t.Helper() + p := New(Config{Version: "test", AuthDir: t.TempDir()}) + store := NewLogStore(t.TempDir(), 7, 0) + if store == nil { + t.Fatal("NewLogStore 返回 nil") + } + t.Cleanup(func() { store.Close() }) + if err := p.Logs().SetLogStore(store); err != nil { + t.Fatalf("SetLogStore: %v", err) + } + return p, store +} + +// TestLogsExportDisabled 落盘未启用时回 501 且说清原因。 +// +// 用 501 而不是 404:功能存在、只是没开(与 embeddings 关闭时的口径一致), +// 404 会让人以为端点根本不存在。 +func TestLogsExportDisabled(t *testing.T) { + p := New(Config{Version: "test", AuthDir: t.TempDir()}) + rec := httptest.NewRecorder() + p.logsExportHandler(rec, httptest.NewRequest(http.MethodGet, "/panel/api/logs/export?days=3", nil)) + if rec.Code != http.StatusNotImplemented { + t.Fatalf("status = %d want 501", rec.Code) + } +} + +// TestLogsExportServesZip 正常路径:回 200 + application/zip + 附件文件名。 +func TestLogsExportServesZip(t *testing.T) { + p, store := newExportPanel(t) + store.Append(LogEntry{TS: cst.Now().Add(-time.Minute), Ch: ChSys, Text: "export me"}) + store.Flush() + + rec := httptest.NewRecorder() + p.logsExportHandler(rec, httptest.NewRequest(http.MethodGet, "/panel/api/logs/export?days=1", nil)) + if rec.Code != http.StatusOK { + t.Fatalf("status = %d want 200(body=%s)", rec.Code, rec.Body.String()) + } + if ct := rec.Header().Get("Content-Type"); ct != "application/zip" { + t.Fatalf("Content-Type = %q want application/zip", ct) + } + if cd := rec.Header().Get("Content-Disposition"); cd == "" || cd[:10] != "attachment" { + t.Fatalf("Content-Disposition = %q(浏览器要靠它下载而不是内联渲染)", cd) + } + if rec.Body.Len() == 0 { + t.Fatal("响应体为空") + } +} + +// TestLogsExportEmptyRange404 区间内没有落盘文件时回 404 而不是空 zip。 +// +// 空 zip 会被当成「导出成功但没内容」,人去翻配置;404 + 文案能直接指向原因。 +func TestLogsExportEmptyRange404(t *testing.T) { + p, _ := newExportPanel(t) + // 未来区间:一定没有文件。 + rec := httptest.NewRecorder() + // RFC3339 的时区偏移里带 "+",裸拼进 query 会被解析成空格(服务端随即报 400), + // 必须编码——这也是给 curl 用户的提醒:from/to 记得 urlencode。 + req := httptest.NewRequest(http.MethodGet, + "/panel/api/logs/export?from="+url.QueryEscape(time.Now().Add(24*time.Hour).Format(time.RFC3339))+ + "&to="+url.QueryEscape(time.Now().Add(48*time.Hour).Format(time.RFC3339)), nil) + p.logsExportHandler(rec, req) + if rec.Code != http.StatusNotFound { + t.Fatalf("status = %d want 404(body=%s)", rec.Code, rec.Body.String()) + } +} + +// TestLogsExportClampsToRetention days 超过保留期时按保留期封顶。 +// +// 反向代价:不封顶等于用一个查询参数绕过保留策略——运维以为删干净了, +// 实际上还能导出来。 +func TestLogsExportClampsToRetention(t *testing.T) { + p := New(Config{Version: "test", AuthDir: t.TempDir()}) + store := NewLogStore(t.TempDir(), 3, 0) // 保留 3 天 + if store == nil { + t.Fatal("NewLogStore 返回 nil") + } + t.Cleanup(func() { store.Close() }) + if err := p.Logs().SetLogStore(store); err != nil { + t.Fatal(err) + } + store.Append(LogEntry{TS: cst.Now().Add(-time.Minute), Ch: ChSys, Text: "today"}) + store.Flush() + + // days=999 仍应成功(只是被钳到 3 天),不该因为参数越界直接报错。 + rec := httptest.NewRecorder() + p.logsExportHandler(rec, httptest.NewRequest(http.MethodGet, "/panel/api/logs/export?days=999", nil)) + if rec.Code != http.StatusOK { + t.Fatalf("status = %d want 200(days 应被钳制而不是拒绝)", rec.Code) + } +} + +// TestLogsExportRejectsBadRange 非法参数要明确报 400。 +func TestLogsExportRejectsBadRange(t *testing.T) { + p, _ := newExportPanel(t) + cases := []string{ + "/panel/api/logs/export?days=0", + "/panel/api/logs/export?days=abc", + "/panel/api/logs/export?from=2026-11-09", + "/panel/api/logs/export?from=2026-11-09T00:00:00%2B08:00&to=2026-11-08T00:00:00%2B08:00", + } + for _, target := range cases { + rec := httptest.NewRecorder() + p.logsExportHandler(rec, httptest.NewRequest(http.MethodGet, target, nil)) + if rec.Code != http.StatusBadRequest { + t.Errorf("%s → status %d want 400", target, rec.Code) + } + } +} diff --git a/internal/panel/login.go b/internal/panel/login.go index fe27dc0a53d00561073f3c64f52e33cb3ddb7b06..d0ce13005ecebc82b164356a240b2faa7670499d 100644 --- a/internal/panel/login.go +++ b/internal/panel/login.go @@ -1,322 +1,603 @@ -// login.go 面板内嵌的 WorkBuddy CN OAuth 设备授权流程(cmd/login 的进程内移植)。 -// -// POST /panel/api/login/start → 拿 state+authUrl,state 存进程内(不再落 /tmp, -// 原方案在 Windows 上不可用),返回授权 URL; -// GET /panel/api/login/poll → 面板前端每 3s 轮询本接口;未完成返回 done=false, -// 完成后取 uid/nickname、凭证落盘 auths/workbuddy-.json、热加载进池 -// (pool.Add + Revive),并顺带签到 + 余额刷新 —— 免重启加载新账号。 -// -// 无 PKCE(workbuddy 设备流由服务端签发 state),请求头与上游端点与 cmd/login 保持一致。 -package panel - -import ( - "bytes" - "encoding/json" - "fmt" - "io" - "log" - "net/http" - "os" - "path/filepath" - "time" - - "github.com/linguo2625469/workbuddy2api-panel/internal/auth" -) - -const ( - upstreamBaseCN = "https://copilot.tencent.com" - upstreamBaseGlobal = "https://www.workbuddy.ai" - clientUA = "CLI/2.63.2 CodeBuddy/2.63.2" - originRefererCN = "https://www.codebuddy.cn" - originRefererGlobal = "https://www.workbuddy.ai" -) - -// loginEndpoints 按 realm 返回设备授权三端点(auth/state、token、account)+ Origin。 -// realm=="global" → 国际版(workbuddy.ai 同域);cn/非法/缺省 → CN(零回归)。 -func loginEndpoints(realm string) (state, token, account, origin string) { - if realm == "global" { - base := upstreamBaseGlobal - return base + "/v2/plugin/auth/state?platform=CLI", - base + "/v2/plugin/auth/token?state=", - base + "/v2/plugin/login/account?state=", - originRefererGlobal - } - base := upstreamBaseCN - return base + "/v2/plugin/auth/state?platform=CLI", - base + "/v2/plugin/auth/token?state=", - base + "/v2/plugin/login/account?state=", - originRefererCN -} - -// loginHTTP 设备授权专用 client:短超时、无 cookie(每请求携带 state,无会话态)。 -var loginHTTP = &http.Client{Timeout: 30 * time.Second} - -func commonHeaders(req *http.Request, origin string) { - req.Header.Set("Content-Type", "application/json") - req.Header.Set("Accept", "application/json, text/plain, */*") - req.Header.Set("X-Requested-With", "XMLHttpRequest") - req.Header.Set("Origin", origin) - req.Header.Set("Referer", origin+"/") - req.Header.Set("User-Agent", clientUA) -} - -// validUID 校验上游返回的 uid 是否可安全用于拼文件名。 -// 只放行字母、数字、下划线、连字符(腾讯侧 uid 实测为 UUID 形态), -// 长度上限 64 兜底异常超长串;拒绝 . / \ 等路径字符与空串。 -func validUID(uid string) bool { - if uid == "" || len(uid) > 64 { - return false - } - for _, c := range uid { - switch { - case c >= 'a' && c <= 'z', c >= 'A' && c <= 'Z', c >= '0' && c <= '9', c == '-', c == '_': - default: - return false - } - } - return true -} - -// apiEnvelope 与 upstream 同形:{code,msg,data},code!=0 视为业务错误。 -type apiEnvelope struct { - Code int `json:"code"` - Msg string `json:"msg"` - Data json.RawMessage `json:"data"` -} - -// doJSON 发一次 JSON 请求并解信封。origin 为 Origin/Referer 基础域(随 realm 切)。 -func doJSON(method, fullURL, bearer string, body io.Reader, origin string) (json.RawMessage, int, error) { - req, err := http.NewRequest(method, fullURL, body) - if err != nil { - return nil, 0, err - } - commonHeaders(req, origin) - if bearer != "" { - req.Header.Set("Authorization", "Bearer "+bearer) - } - resp, err := loginHTTP.Do(req) - if err != nil { - return nil, 0, err - } - defer resp.Body.Close() - raw, _ := io.ReadAll(io.LimitReader(resp.Body, 1<<20)) - if resp.StatusCode >= 300 { - return nil, resp.StatusCode, fmt.Errorf("http_error: upstream %d", resp.StatusCode) - } - var env apiEnvelope - if err := json.Unmarshal(raw, &env); err != nil { - return nil, resp.StatusCode, fmt.Errorf("parse failed: %w", err) - } - if env.Code != 0 { - return nil, resp.StatusCode, fmt.Errorf("code=%d msg=%s", env.Code, env.Msg) - } - return env.Data, resp.StatusCode, nil -} - -// loginStart 发起设备授权:POST auth/state 拿授权 URL。 -// body 可带 {"realm":"global"}(缺省 cn);state 会话记 realm,poll 同 realm 落盘。 -func (p *Panel) loginStart(w http.ResponseWriter, r *http.Request) { - realm := "cn" - if r.Body != nil { - var reqBody struct { - Realm string `json:"realm"` - } - if err := json.NewDecoder(io.LimitReader(r.Body, 1<<12)).Decode(&reqBody); err == nil { - if reqBody.Realm == "global" { - realm = "global" - } - } - } - epState, _, _, origin := loginEndpoints(realm) - data, status, err := doJSON(http.MethodPost, epState, "", bytes.NewReader([]byte("{}")), origin) - if err != nil { - writeErr(w, http.StatusBadGateway, fmt.Sprintf("auth state (upstream %d): %v", status, err)) - return - } - var st struct { - State string `json:"state"` - AuthURL string `json:"authUrl"` - } - if err := json.Unmarshal(data, &st); err != nil || st.State == "" || st.AuthURL == "" { - writeErr(w, http.StatusBadGateway, "auth state: missing state or authUrl") - return - } - p.loginMu.Lock() - // 顺手回收过期会话,防"开弹窗走开"的 state 滞留。 - for s, sess := range p.logins { - if time.Since(sess.created) > loginTTL { - delete(p.logins, s) - } - } - p.logins[st.State] = loginSession{created: time.Now(), realm: realm} - p.loginMu.Unlock() - log.Printf("panel: 发起 OAuth 添加账号 realm=%s(state=%s...)", realm, st.State[:min(8, len(st.State))]) - writeJSON(w, http.StatusOK, map[string]any{"ok": true, "url": st.AuthURL, "state": st.State, "realm": realm}) -} - -// loginPoll 轮询登录态。未完成 → {done:false};完成 → 建凭证、落盘、热加载、签到。 -func (p *Panel) loginPoll(w http.ResponseWriter, r *http.Request) { - state := r.URL.Query().Get("state") - if state == "" { - writeErr(w, http.StatusBadRequest, "missing state") - return - } - p.loginMu.Lock() - sess, known := p.logins[state] - p.loginMu.Unlock() - if !known { - writeErr(w, http.StatusNotFound, "unknown or expired state(请重新发起添加账号)") - return - } - _, epToken, epAcct, origin := loginEndpoints(sess.realm) - - // auth/token 是权威登录状态端点:pending 时业务 code 非 0("login ing")。 - tokRaw, _, err := doJSON(http.MethodGet, epToken+state, "", nil, origin) - if err != nil { - // pending / 未完成:面板前端继续轮询。 - writeJSON(w, http.StatusOK, map[string]any{"done": false, "message": err.Error()}) - return - } - var tok struct { - AccessToken string `json:"accessToken"` - RefreshToken string `json:"refreshToken"` - ExpiresIn int64 `json:"expiresIn"` - Domain string `json:"domain"` - } - if err := json.Unmarshal(tokRaw, &tok); err != nil || tok.AccessToken == "" { - writeJSON(w, http.StatusOK, map[string]any{"done": false, "message": "waiting for login"}) - return - } - - // 完成:取 uid/nickname(失败不阻塞,仅缺展示名)。 - var acct struct { - UID string `json:"uid"` - EnterpriseID string `json:"enterpriseId"` - Nickname string `json:"nickname"` - } - if acctRaw, _, err := doJSON(http.MethodGet, epAcct+state, tok.AccessToken, nil, origin); err == nil { - _ = json.Unmarshal(acctRaw, &acct) - } - if acct.UID == "" { - writeErr(w, http.StatusBadGateway, "login done but no uid(token 已发但账号信息获取失败,请重试)") - return - } - // UID 来自上游响应,未经校验就用于拼文件名会被路径穿越利用 - // (filepath.Join("./auths", "workbuddy-../../evil.json") → auths/evil.json)。 - // UID 是腾讯侧账号标识,实测为 UUID(十六进制与连字符),故只放行 [A-Za-z0-9_-]。 - if !validUID(acct.UID) { - writeErr(w, http.StatusBadGateway, "上游返回的 uid 含非法字符,拒绝落盘(防路径穿越)") - return - } - - // 凭证落盘(嵌套形,与 auths/ 目录既有格式一致)→ 热加载进池。 - if err := os.MkdirAll(p.cfg.AuthDir, 0o755); err != nil { - writeErr(w, http.StatusInternalServerError, "mkdir auth dir: "+err.Error()) - return - } - a := &auth.Auth{ - AccessToken: tok.AccessToken, - RefreshToken: tok.RefreshToken, - ExpiresAt: time.Now().Add(time.Duration(tok.ExpiresIn) * time.Second).Unix(), - Domain: tok.Domain, - UID: acct.UID, - EnterpriseID: acct.EnterpriseID, - Nickname: acct.Nickname, - FilePath: filepath.Join(p.cfg.AuthDir, fmt.Sprintf("workbuddy-%s.json", acct.UID)), - } - // global 登录:落盘 auth.realm=global(Realm() 按此判域;不写则依赖 domain 后缀回落)。 - if sess.realm == "global" { - if _, err := auth.BackfillRealmFor(a, "global"); err != nil { - writeErr(w, http.StatusInternalServerError, "set realm: "+err.Error()) - return - } - } else { - // CN 也显式补 realm 键(幂等),让 auth 文件形态统一(与 LoadDir 存量迁移对齐)。 - _, _ = a.BackfillRealm() - } - if err := a.SaveAtomic(); err != nil { - writeErr(w, http.StatusInternalServerError, "save auth: "+err.Error()) - return - } - p.cfg.Pool.Add(a) - p.cfg.Pool.Revive(acct.UID) // 全新登录 = 人工恢复口径:清掉旧号遗留的禁用/冷却/熔断 - - // 顺带签到 + 余额刷新(幂等;失败不影响登录结果,只体现在返回字段里)。 - // realm 分支:CN 走 DailyCheckin;global 无 CN 签到体系,改为注册激活 + trial 领取 - // (D4 门控同 scheduler:CN 任务端点对 global 不发起任何调用)。 - checkinMsg := "" - remain := int64(-1) - total := int64(0) - if sess.realm == "global" { - // 注册激活(幂等):region required 时自动补地区(白名单首个,HK)后重新激活。 - // 失败不阻断登录结果(auth 已落盘),只在返回字段里体现。 - if activated, err := p.cfg.Upstream.GlobalCompleteRegistration(a); err != nil { - checkinMsg = "注册激活失败: " + err.Error() - log.Printf("panel: global 注册激活 uid=%s: %v", acct.UID, err) - } else if activated { - log.Printf("panel: global 注册激活 uid=%s 完成", acct.UID) - } - // trial 加油包(幂等 14051 = 已领过,非错误)。 - if claimed, err := p.cfg.Upstream.ClaimTrial(a); err != nil { - checkinMsg = joinMsg(checkinMsg, "trial 领取失败: "+err.Error()) - log.Printf("panel: global trial uid=%s: %v", acct.UID, err) - } else if claimed { - log.Printf("panel: global trial uid=%s 已领", acct.UID) - } - } else { - if err := p.cfg.Upstream.DailyCheckin(a); err != nil { - checkinMsg = err.Error() - } - } - if rm, tt, err := p.cfg.Upstream.UserResource(a); err == nil { - remain, total = rm, tt - p.cfg.Pool.ReenableIfCredits(acct.UID, rm, tt) - } - - p.loginMu.Lock() - delete(p.logins, state) - p.loginMu.Unlock() - log.Printf("panel: 新账号已热加载 uid=%s nickname=%q realm=%s(免重启生效)", acct.UID, acct.Nickname, sess.realm) - writeJSON(w, http.StatusOK, map[string]any{ - "done": true, - "uid": acct.UID, - "nickname": acct.Nickname, - "realm": sess.realm, - "credits": remain, - "credits_total": total, - "checkin_message": checkinMsg, - }) -} - -// joinMsg 拼接 login 完成后的提示消息(多段用「;」连接,空段跳过)。 -func joinMsg(parts ...string) string { - out := "" - for _, s := range parts { - if s == "" { - continue - } - if out != "" { - out += ";" - } - out += s - } - return out -} - -// loginRegions 返回 global 注册可选地区(panel 前端选地区弹窗用;CN 不调用)。 -// 未持账号时返回白名单静态兜底(前端只读展示,不依赖上游)。 -func (p *Panel) loginRegions(w http.ResponseWriter, r *http.Request) { - // 静态白名单(对齐国际版 web 展示集):面板前端只读展示,无需账号态。 - writeJSON(w, http.StatusOK, map[string]any{ - "ok": true, - "regions": []map[string]string{ - {"code": "HK", "name": "Hong Kong"}, - {"code": "MO", "name": "Macao"}, - {"code": "SG", "name": "Singapore"}, - {"code": "TH", "name": "Thailand"}, - {"code": "PH", "name": "Philippines"}, - {"code": "MY", "name": "Malaysia"}, - {"code": "ID", "name": "Indonesia"}, - }, - }) -} +// login.go 面板内嵌的 WorkBuddy CN OAuth 设备授权流程(cmd/login 的进程内移植)。 +// +// POST /panel/api/login/start → 拿 state+authUrl,state 存进程内(不再落 /tmp, +// 原方案在 Windows 上不可用),返回授权 URL; +// GET /panel/api/login/poll → 面板前端每 3s 轮询本接口;未完成返回 done=false, +// 完成后取 uid/nickname、凭证落盘 auths/workbuddy-.json、热加载进池 +// (pool.Add + Revive),并顺带签到 + 余额刷新 —— 免重启加载新账号。 +// +// 无 PKCE(workbuddy 设备流由服务端签发 state),请求头与上游端点与 cmd/login 保持一致。 +package panel + +import ( + "bytes" + "crypto/tls" + "encoding/json" + "errors" + "fmt" + "io" + "log" + "net" + "net/http" + "os" + "path/filepath" + "strings" + "time" + + "github.com/misakano7545/workbuddy2api-panel/internal/auth" + "github.com/misakano7545/workbuddy2api-panel/internal/loginsite" +) + +const ( + // clientUA 保留仅为兼容既有测试引用;设备码端点实际 UA 按站点取 + // (loginsite.Site.UserAgent → EndpointHeaders),登录链路已不再发 CodeBuddy CLI 串。 + clientUA = loginsite.ClientUA +) + +// loginSite 别名:站点定义来自 internal/loginsite(官方域表的唯一来源)。 +type loginSite = loginsite.Site + +// 站点标识别名(面板内部沿用短名)。 +const ( + siteCN = loginsite.SiteCN + siteIntl = loginsite.SiteIntl + siteWorkBuddy = loginsite.SiteWorkBuddy +) + +// siteResolver 站点表查询入口(测试可替换为指向 httptest 服务器的站点, +// 否则 loginStart/loginPoll 的单测必须打真实上游)。 +var siteResolver = loginsite.For + +// siteOrDefault 归一化站点标识:空/非法 → cn(老调用零回归)。 +func siteOrDefault(id string) loginSite { return siteResolver(id) } + +// siteForRealm 按 realm 映射站点:global → 旧桌面端 workbuddy.ai(历史行为, +// 保持 login.sh / 老前端 realm=global 的语义不变),cn → 国内站。 +// 新代码应直接用 siteOrDefault(官方国际站要显式 site=intl)。 +// 走 siteResolver 而非直接查表,使单测能把两站点都指到 httptest 服务器。 +func siteForRealm(realm string) loginSite { return siteResolver(loginsite.ForRealm(realm).ID) } + +// loginEndpointsFor 按站点返回设备授权三端点(auth/state、token、account)+ Origin。 +func loginEndpointsFor(s loginSite) (state, token, account, origin string) { return s.Endpoints() } + +// loginEndpoints 兼容旧签名:按 realm 选站点(global → workbuddy 旧桌面端)。 +func loginEndpoints(realm string) (state, token, account, origin string) { + return loginEndpointsFor(siteForRealm(realm)) +} + +// 官方登录码语义(码表与判定在 internal/loginsite,两处调用方共用)。 +const ( + loginCodeRetryFetchToken = loginsite.CodeRetryFetchToken + loginCodeRetryFetchAccount = loginsite.CodeRetryFetchAccount + loginCodeLicenseSeatLimit = loginsite.CodeLicenseSeatLimit + loginCodeLicenseExpired = loginsite.CodeLicenseExpired + loginCodeTrialExpired = loginsite.CodeTrialExpired +) + +// loginCodePending 报告该业务码是否表示「登录进行中,应继续轮询」。 +func loginCodePending(code int) bool { return loginsite.CodePending(code) } + +// loginCodeFatal 报告该业务码是否属于官方定义的终态许可错误(SignLicenseError)。 +func loginCodeFatal(code int) bool { return loginsite.CodeFatal(code) } + +// loginEnvelopeError 上游业务码非 0 的结构化错误:调用方按官方码表区分「继续 +// 轮询」与「终态失败」,不必解析错误字符串。 +type loginEnvelopeError struct { + Code int + Msg string + Status int +} + +func (e *loginEnvelopeError) Error() string { + return fmt.Sprintf("code=%d msg=%s", e.Code, e.Msg) +} + +// loginHTTP 设备授权专用 client:无 cookie(每请求携带 state,无会话态)。 +// +// ⚠️ 为什么不能直接用默认 transport(2026-10-24 实案,处置与 +// internal/upstream/transport.go 同源): +// 默认 transport 会经 ALPN 协商出 HTTP/2,而本网络下容器 DNS(127.0.0.11)偶发 +// 「server misbehaving」并留下半死连接——半死 h2 流被复用时会一直等响应头,直到 +// 客户端**总超时**才报错: +// +// auth state (upstream 0): Post "https://copilot.tencent.com/v2/plugin/auth/state?platform=CLI": +// context deadline exceeded (Client.Timeout exceeded while awaiting headers) +// +// 用户可见表现:国内版一直拿不到授权链接(国际版当时恰好没撞上抖动,看起来正常); +// 登录轮询走的 auth/token 是同一个 client,同样会卡——浏览器侧明明已登录成功, +// 网关却迟迟检测不到,面板像卡死。 +// +// 两层防护(与 newTransport 一致): +// - TLS 层:空 TLSNextProto 真正禁 h2(必须 make 而非 nil;只设 +// ForceAttemptHTTP2=false 无效,ALPN 仍会协商出 h2,见 transport.go 注释); +// - 连接层:DialContext 8s 建连 + 15s keepalive、TLS 握手 8s、响应头 15s, +// 让单次尝试在 ~15s 内失败而不是拖满 30s 总超时,配合下方 doJSON 重试。 +var loginHTTP = &http.Client{ + Timeout: 30 * time.Second, + Transport: &http.Transport{ + DialContext: (&net.Dialer{ + Timeout: 8 * time.Second, + KeepAlive: 15 * time.Second, + }).DialContext, + TLSNextProto: make(map[string]func(string, *tls.Conn) http.RoundTripper), + TLSHandshakeTimeout: 8 * time.Second, + ResponseHeaderTimeout: 15 * time.Second, + MaxIdleConns: 16, + MaxIdleConnsPerHost: 8, + IdleConnTimeout: 60 * time.Second, + }, +} + +// commonHeaders 设备码端点的公共头族(真机形态,见 loginsite.Site.EndpointHeaders)。 +// +// 不再发 Origin / Referer / X-Requested-With:2026-10-30 双版本真机抓包显示这三条 +// 端点(auth/state、auth/token、login/account)由桌面端 node fetch 发出,恒无这三个头 +// ——浏览器同源语义只出现在「打开授权页」那一步,不在 API 调用上。 +// +// 三端点的**差异头**(x-domain / x-no-* / x-device-token / Authorization)由 +// stateHeaders / tokenHeaders / accountHeaders 三个包装补,不要在这里抹平。 +func commonHeaders(req *http.Request, site loginSite) { + applyHeaders(req, site.EndpointHeaders()) +} + +// applyHeaders 把 map 头批量写到 req(空值跳过,避免发出空头)。 +func applyHeaders(req *http.Request, h map[string]string) { + for k, v := range h { + if v != "" { + req.Header.Set(k, v) + } + } +} + +// stateHeaders POST /v2/plugin/auth/state 的头族(含 x-device-token 与哨兵)。 +func stateHeaders(site loginSite, deviceToken string) map[string]string { + return site.HeadersForState(deviceToken) +} + +// tokenHeaders GET /v2/plugin/auth/token 的头族(真机唯一不带 x-domain 的端点)。 +func tokenHeaders(site loginSite) map[string]string { + return site.HeadersForToken() +} + +// accountHeaders GET /v2/plugin/login/account 的头族(带 Bearer,x-no-authorization 缺席)。 +func accountHeaders(site loginSite, accessToken string) map[string]string { + return site.HeadersForAccount(accessToken) +} + +// validUID 校验上游返回的 uid 是否可安全用于拼文件名。 +// 只放行字母、数字、下划线、连字符(腾讯侧 uid 实测为 UUID 形态), +// 长度上限 64 兜底异常超长串;拒绝 . / \ 等路径字符与空串。 +func validUID(uid string) bool { + if uid == "" || len(uid) > 64 { + return false + } + for _, c := range uid { + switch { + case c >= 'a' && c <= 'z', c >= 'A' && c <= 'Z', c >= '0' && c <= '9', c == '-', c == '_': + default: + return false + } + } + return true +} + +// apiEnvelope 与 upstream 同形:{code,msg,data},code!=0 视为业务错误。 +type apiEnvelope struct { + Code int `json:"code"` + Msg string `json:"msg"` + Data json.RawMessage `json:"data"` +} + +// loginAttempts 单次登录步骤的传输层重试次数(只对「一个 HTTP 响应都没拿到」的 +// 失败重试)。理由见 loginHTTP:容器 DNS 偶发 server misbehaving,单发失败不该让 +// 用户从头再点一遍;且三步都可安全重发(auth/state 重签一个 state、旧 state 由 +// loginTTL 回收;token/account 是只读查询)。已拿到响应(业务错误如 token 的 +// 11217 "login ing"、或 HTTP 4xx/5xx)绝不重试——那是确定结果,重试只会拖慢轮询。 +const loginAttempts = 3 + +// doJSON 发一次 JSON 请求并解信封,遇纯传输失败按 loginAttempts 重试。 +// site 决定头族与 UA(真机形态,见 commonHeaders);extra 为端点差异头 +// (state 的 x-device-token / 哨兵、account 的 Bearer 等),在公共头之后覆盖写入, +// nil 表示只发公共头。body 用 []byte 以便重放。 +func doJSON(method, fullURL string, extra map[string]string, body []byte, site loginSite) (json.RawMessage, int, error) { + var lastErr error + for attempt := 0; attempt < loginAttempts; attempt++ { + if attempt > 0 { + time.Sleep(time.Duration(attempt) * 400 * time.Millisecond) + } + data, status, err := doJSONOnce(method, fullURL, extra, body, site) + if err == nil { + return data, status, nil + } + if status != 0 { + return nil, status, err // 上游已应答:确定结果,不重试 + } + lastErr = err + } + return nil, 0, lastErr +} + +// doJSONOnce 单次尝试(不做重试)。 +func doJSONOnce(method, fullURL string, extra map[string]string, body []byte, site loginSite) (json.RawMessage, int, error) { + var rdr io.Reader + if body != nil { + rdr = bytes.NewReader(body) + } + req, err := http.NewRequest(method, fullURL, rdr) + if err != nil { + return nil, 0, err + } + commonHeaders(req, site) + applyHeaders(req, extra) + resp, err := loginHTTP.Do(req) + if err != nil { + return nil, 0, err + } + defer resp.Body.Close() + raw, _ := io.ReadAll(io.LimitReader(resp.Body, 1<<20)) + if resp.StatusCode >= 300 { + return nil, resp.StatusCode, fmt.Errorf("http_error: upstream %d", resp.StatusCode) + } + var env apiEnvelope + if err := json.Unmarshal(raw, &env); err != nil { + return nil, resp.StatusCode, fmt.Errorf("parse failed: %w", err) + } + if env.Code != 0 { + // 结构化错误:调用方按官方码表区分 pending / 终态(见 loginCodePending/Fatal)。 + return nil, resp.StatusCode, &loginEnvelopeError{Code: env.Code, Msg: env.Msg, Status: resp.StatusCode} + } + return env.Data, resp.StatusCode, nil +} + +// loginDeviceNonce 官方 ww_device_nonce 的来源(桌面端 Turing 设备指纹 SDK)。 +// 本仓无 SDK,取部署侧环境变量;空 = 不加该参数(不伪造设备指纹)。 +func loginDeviceNonce() string { + return strings.TrimSpace(os.Getenv("CODEBUDDY_LOGIN_DEVICE_NONCE")) +} + +// loginDeviceToken 设备风控 token(X-Device-Token),用于 auth/state 的出站头。 +// +// 真机(CN 5.9.3 / GL 5.9.4)该头恒为 `v3:` 形态,由客户端 qimei 组件 +// 本地生成后加密上报,**不是**能从 machineId 推导出来的东西。网关拿不到就返回空串, +// 调用方据此不发该头——伪造一个假 token 比缺这个头更容易被判定为非客户端。 +// +// 取值来源(按优先级): +// +// CODEBUDDY_LOGIN_DEVICE_TOKEN 环境变量 +// CODEBUDDY_LOGIN_DEVICE_TOKEN_FILE 指向的文件(宿主从桌面端落盘处导出) +func loginDeviceToken() string { + if v := strings.TrimSpace(os.Getenv("CODEBUDDY_LOGIN_DEVICE_TOKEN")); v != "" { + return v + } + if p := strings.TrimSpace(os.Getenv("CODEBUDDY_LOGIN_DEVICE_TOKEN_FILE")); p != "" { + if b, err := os.ReadFile(p); err == nil { + return strings.TrimSpace(string(b)) + } + } + return "" +} + +// loginStart 发起设备授权:POST auth/state 拿授权 URL。 +// body 可带 {"site":"cn"|"intl"|"workbuddy"}(官方域表,缺省 cn); +// 兼容老前端 {"realm":"global"} → 旧桌面端 workbuddy.ai(零回归)。 +// state 会话记站点,poll 用同一站点取 token/落盘。 +func (p *Panel) loginStart(w http.ResponseWriter, r *http.Request) { + site := siteOrDefault("") + if r.Body != nil { + var reqBody struct { + Realm string `json:"realm"` + Site string `json:"site"` + } + if err := json.NewDecoder(io.LimitReader(r.Body, 1<<12)).Decode(&reqBody); err == nil { + if reqBody.Site != "" { + // site 显式优先(官方国际站走 site=intl)。 + site = siteOrDefault(strings.ToLower(strings.TrimSpace(reqBody.Site))) + } else { + site = siteForRealm(reqBody.Realm) + } + } + } + epState, _, _, _ := loginEndpointsFor(site) + // auth/state:真机带 x-device-token(取到才发)+ x-custom-channel-id + 四个 x-no-*。 + data, status, err := doJSON(http.MethodPost, epState, stateHeaders(site, loginDeviceToken()), []byte("{}"), site) + if err != nil { + writeErr(w, http.StatusBadGateway, fmt.Sprintf("auth state (upstream %d): %v", status, err)) + return + } + var st struct { + State string `json:"state"` + AuthURL string `json:"authUrl"` + } + if err := json.Unmarshal(data, &st); err != nil || st.State == "" || st.AuthURL == "" { + writeErr(w, http.StatusBadGateway, "auth state: missing state or authUrl") + return + } + // 对齐官方:授权链接补 version(workbuddy 域再加设备 nonce)。 + st.AuthURL = loginsite.DecorateAuthURL(st.AuthURL, site, loginDeviceNonce(), loginsite.NewLoginSessionID()) + p.loginMu.Lock() + // 顺手回收过期会话,防"开弹窗走开"的 state 滞留。 + for s, sess := range p.logins { + if time.Since(sess.created) > loginTTL { + delete(p.logins, s) + } + } + p.logins[st.State] = loginSession{created: time.Now(), realm: site.Realm, site: site.ID} + p.loginMu.Unlock() + log.Printf("panel: 发起 OAuth 添加账号 realm=%s site=%s(state=%s...)", site.Realm, site.ID, st.State[:min(8, len(st.State))]) + writeJSON(w, http.StatusOK, map[string]any{"ok": true, "url": st.AuthURL, "state": st.State, "realm": site.Realm, "site": site.ID}) +} + +// logPollOnce 上游轮询结果变了才落一行日志(state 前缀 + 上游原文)。 +// +// 为什么需要:浏览器侧报「登录失败」时,面板此前只有「发起 OAuth」一行记录—— +// code/msg 全丢在轮询里,运维无法判断是「浏览器根本没授权成功」还是「授权了但 +// 取 token 被拒」。逐轮记不行:前端 3s 一轮、最长 loginTTL,一条 state 能刷出 +// 300 行,真正的一次性错误反而被淹掉。state 已不在表里(超时 / 已落盘)则不记。 +func (p *Panel) logPollOnce(state, msg string) { + p.loginMu.Lock() + s, ok := p.logins[state] + if !ok || s.lastMsg == msg { + p.loginMu.Unlock() + return + } + s.lastMsg = msg + p.logins[state] = s + p.loginMu.Unlock() + log.Printf("panel: 登录轮询 state=%s... 上游=%s", state[:min(8, len(state))], msg) +} + +// loginPoll 轮询登录态。未完成 → {done:false};完成 → 建凭证、落盘、热加载、签到。 +func (p *Panel) loginPoll(w http.ResponseWriter, r *http.Request) { + state := r.URL.Query().Get("state") + if state == "" { + writeErr(w, http.StatusBadRequest, "missing state") + return + } + p.loginMu.Lock() + sess, known := p.logins[state] + if known && sess.processing { + p.loginMu.Unlock() + writeJSON(w, http.StatusOK, map[string]any{"done": false, "message": "正在写入凭据…"}) + return + } + if known { + sess.processing = true + p.logins[state] = sess + } + p.loginMu.Unlock() + if !known { + // 410:state 已作废(进程重启或超过 loginTTL)。前端据此停止轮询;网络抖动 + // (5xx/超时)则继续重试——混成一个状态码时,一次抖动就让用户放弃等待, + // 而 OAuth 其实已在浏览器侧完成、账号却不会入池。 + writeErr(w, http.StatusGone, "login session 已过期,请关闭后重新添加账号") + return + } + // 失败路径复位闸门,供用户重试(成功路径 delete(state) 已经清掉)。 + defer func() { + p.loginMu.Lock() + if s, ok := p.logins[state]; ok { + s.processing = false + p.logins[state] = s + } + p.loginMu.Unlock() + }() + pollSite := siteOrDefault(sess.site) + _, epToken, epAcct, _ := loginEndpointsFor(pollSite) + + // auth/token 是权威登录状态端点。官方码表语义: + // 11217(RetryFetchToken)→ 还没登完,继续轮询; + // 12005/11212/11216(席位满/许可证过期/试用到期)→ 终态,立刻把上游 msg + // 抛给前端并停轮询(官方 SignLicenseError 行为),不再空转到 TTL。 + tokRaw, _, err := doJSON(http.MethodGet, epToken+state, tokenHeaders(pollSite), nil, pollSite) + if err != nil { + var envErr *loginEnvelopeError + if errors.As(err, &envErr) && loginCodeFatal(envErr.Code) { + p.loginMu.Lock() + delete(p.logins, state) + p.loginMu.Unlock() + log.Printf("panel: 登录被上游拒绝 state=%s... code=%d msg=%s", state[:min(8, len(state))], envErr.Code, envErr.Msg) + writeJSON(w, http.StatusOK, map[string]any{ + "done": false, + "fatal": true, + "code": envErr.Code, + "message": fmt.Sprintf("登录被上游拒绝(code=%d):%s", envErr.Code, envErr.Msg), + }) + return + } + // pending(11217/12151)或其它可重试错误:面板前端继续轮询。 + p.logPollOnce(state, err.Error()) + writeJSON(w, http.StatusOK, map[string]any{"done": false, "message": err.Error()}) + return + } + var tok struct { + AccessToken string `json:"accessToken"` + RefreshToken string `json:"refreshToken"` + ExpiresIn int64 `json:"expiresIn"` + Domain string `json:"domain"` + } + if err := json.Unmarshal(tokRaw, &tok); err != nil || tok.AccessToken == "" { + writeJSON(w, http.StatusOK, map[string]any{"done": false, "message": "waiting for login"}) + return + } + + // 完成:取 uid/nickname。官方 12151(RetryFetchAccount)是「token 已发但账号信息 + // 还在落库」,属于 pending,必须继续轮询而不是报错——否则刚登录成功的号会被 + // 误判成失败(用户重登又撞同一个窗口)。 + var acct struct { + UID string `json:"uid"` + EnterpriseID string `json:"enterpriseId"` + Nickname string `json:"nickname"` + } + acctRaw, _, errAcct := doJSON(http.MethodGet, epAcct+state, accountHeaders(pollSite, tok.AccessToken), nil, pollSite) + if errAcct == nil { + _ = json.Unmarshal(acctRaw, &acct) + } else { + var envErr *loginEnvelopeError + if errors.As(errAcct, &envErr) { + if loginCodePending(envErr.Code) { + p.logPollOnce(state, errAcct.Error()) + writeJSON(w, http.StatusOK, map[string]any{"done": false, "message": errAcct.Error()}) + return + } + if loginCodeFatal(envErr.Code) { + p.loginMu.Lock() + delete(p.logins, state) + p.loginMu.Unlock() + log.Printf("panel: 登录账号信息被上游拒绝 state=%s... code=%d msg=%s", state[:min(8, len(state))], envErr.Code, envErr.Msg) + writeJSON(w, http.StatusOK, map[string]any{ + "done": false, + "fatal": true, + "code": envErr.Code, + "message": fmt.Sprintf("登录被上游拒绝(code=%d):%s", envErr.Code, envErr.Msg), + }) + return + } + } + } + if acct.UID == "" { + writeErr(w, http.StatusBadGateway, "login done but no uid(token 已发但账号信息获取失败,请重试)") + return + } + // UID 来自上游响应,未经校验就用于拼文件名会被路径穿越利用 + // (filepath.Join("./auths", "workbuddy-../../evil.json") → auths/evil.json)。 + // UID 是腾讯侧账号标识,实测为 UUID(十六进制与连字符),故只放行 [A-Za-z0-9_-]。 + if !validUID(acct.UID) { + writeErr(w, http.StatusBadGateway, "上游返回的 uid 含非法字符,拒绝落盘(防路径穿越)") + return + } + + // 凭证落盘(嵌套形,与 auths/ 目录既有格式一致)→ 热加载进池。 + if err := os.MkdirAll(p.cfg.AuthDir, 0o755); err != nil { + writeErr(w, http.StatusInternalServerError, "mkdir auth dir: "+err.Error()) + return + } + a := &auth.Auth{ + AccessToken: tok.AccessToken, + RefreshToken: tok.RefreshToken, + ExpiresAt: time.Now().Add(time.Duration(tok.ExpiresIn) * time.Second).Unix(), + Domain: tok.Domain, + UID: acct.UID, + EnterpriseID: acct.EnterpriseID, + Nickname: acct.Nickname, + FilePath: filepath.Join(p.cfg.AuthDir, fmt.Sprintf("workbuddy-%s.json", acct.UID)), + } + // global 登录:落盘 auth.realm=global(Realm() 按此判域;不写则依赖 domain 后缀回落)。 + if sess.realm == "global" { + if _, err := auth.BackfillRealmFor(a, "global"); err != nil { + writeErr(w, http.StatusInternalServerError, "set realm: "+err.Error()) + return + } + } else { + // CN 也显式补 realm 键(幂等),让 auth 文件形态统一(与 LoadDir 存量迁移对齐)。 + _, _ = a.BackfillRealm() + } + // 落盘 + 入池与目录热重载串行化(issue #199 风险 3):登录刚写出半份文件时 + // 若正好被重载扫到,该账号会被判成「解析失败」进而在本轮拒绝删除——不会丢, + // 但这一轮的 upsert 顺序可能反过来把旧凭证盖回来。持同一把锁就没有这个窗口。 + p.reloadMu.Lock() + saveErr := a.SaveAtomic() + if saveErr == nil { + p.cfg.Pool.Add(a) + } + p.reloadMu.Unlock() + if saveErr != nil { + writeErr(w, http.StatusInternalServerError, "save auth: "+saveErr.Error()) + return + } + isNewAccount := p.cfg.Pool.AuthByUID(acct.UID) == nil + p.cfg.Pool.Revive(acct.UID) // 全新登录 = 人工恢复口径:清掉旧号遗留的禁用/冷却/熔断 + + // 顺带签到 + 余额刷新(幂等;失败不影响登录结果,只体现在返回字段里)。 + // realm 分支:CN 走 DailyCheckin;global 无 CN 签到体系,改为注册激活 + trial 领取 + // (D4 门控同 scheduler:CN 任务端点对 global 不发起任何调用)。 + checkinMsg := "" + remain := int64(-1) + total := int64(0) + if sess.realm == "global" { + // 注册激活(幂等):region required 时自动补地区(白名单首个,HK)后重新激活。 + // 失败不阻断登录结果(auth 已落盘),只在返回字段里体现。 + if activated, err := p.cfg.Upstream.GlobalCompleteRegistration(a); err != nil { + checkinMsg = "注册激活失败: " + err.Error() + log.Printf("panel: global 注册激活 uid=%s: %v", acct.UID, err) + } else if activated { + log.Printf("panel: global 注册激活 uid=%s 完成", acct.UID) + } + // trial 加油包(幂等 14051 = 已领过,非错误)。 + if claimed, err := p.cfg.Upstream.ClaimTrial(a); err != nil { + checkinMsg = joinMsg(checkinMsg, "trial 领取失败: "+err.Error()) + log.Printf("panel: global trial uid=%s: %v", acct.UID, err) + } else if claimed { + log.Printf("panel: global trial uid=%s 已领", acct.UID) + } + } else if a.SupportsPersonalGrowth() { + // 无个人成长体系的账号跳过签到:企业号上游 400 code 10001「企业账号不支持该 + // 操作」,静态 API Key(ck_/pt_)根本没有个人账号身份——发了只会把错误写进登录 + // 返回。判据与 import / 签到端点 / 成长任务同一把闸(SupportsPersonalGrowth), + // 不再单看 IsEnterprise 而漏掉 API Key。下方 UserResource 余额查询照常。 + if err := p.cfg.Upstream.DailyCheckin(a); err != nil { + checkinMsg = err.Error() + } + } + balanceErr := "" + if rm, tt, err := p.cfg.Upstream.UserResource(a); err == nil { + remain, total = rm, tt + p.cfg.Pool.ReenableIfCredits(acct.UID, rm, tt) + } else { + // 凭据已落盘但上游仍拒绝 billing(典型:旧会话没清干净 / 渠道降级 token)。 + // 不判登录失败(chat 可能可用),但必须如实回传,否则运维只会看到「已添加」 + // 却继续 401,误以为重新登录没用。 + balanceErr = err.Error() + log.Printf("panel: 登录后余额校验失败 uid=%s: %v", acct.UID, err) + } + + p.loginMu.Lock() + delete(p.logins, state) + p.loginMu.Unlock() + if isNewAccount { + p.StartNewAccountTasks(acct.UID) + } + log.Printf("panel: 新账号已热加载 uid=%s nickname=%q realm=%s(免重启生效)", acct.UID, acct.Nickname, sess.realm) + writeJSON(w, http.StatusOK, map[string]any{ + "done": true, + "uid": acct.UID, + "nickname": acct.Nickname, + "realm": sess.realm, + "credits": remain, + "credits_total": total, + "checkin_message": checkinMsg, + "balance_error": balanceErr, + }) +} + +// joinMsg 拼接 login 完成后的提示消息(多段用「;」连接,空段跳过)。 +func joinMsg(parts ...string) string { + out := "" + for _, s := range parts { + if s == "" { + continue + } + if out != "" { + out += ";" + } + out += s + } + return out +} + +// loginRegions 返回 global 注册可选地区(panel 前端选地区弹窗用;CN 不调用)。 +// 未持账号时返回白名单静态兜底(前端只读展示,不依赖上游)。 +func (p *Panel) loginRegions(w http.ResponseWriter, r *http.Request) { + // 静态白名单(对齐国际版 web 展示集):面板前端只读展示,无需账号态。 + writeJSON(w, http.StatusOK, map[string]any{ + "ok": true, + "regions": []map[string]string{ + {"code": "HK", "name": "Hong Kong"}, + {"code": "MO", "name": "Macao"}, + {"code": "SG", "name": "Singapore"}, + {"code": "TH", "name": "Thailand"}, + {"code": "PH", "name": "Philippines"}, + {"code": "MY", "name": "Malaysia"}, + {"code": "ID", "name": "Indonesia"}, + }, + }) +} diff --git a/internal/panel/login_http_test.go b/internal/panel/login_http_test.go new file mode 100644 index 0000000000000000000000000000000000000000..e799fdb34d55c39cffbd9afbbb0799b3c3c2ec17 --- /dev/null +++ b/internal/panel/login_http_test.go @@ -0,0 +1,111 @@ +package panel + +import ( + "io" + "net/http" + "net/http/httptest" + "sync" + "testing" + "time" +) + +// TestLoginHTTPDisablesH2 钉住「登录 client 必须禁 h2」这条(2026-10-24 实案): +// 默认 transport 经 ALPN 协商 h2,半死 h2 流被复用时表现为 +// 「context deadline exceeded (Client.Timeout exceeded while awaiting headers)」—— +// 国内版拿不到授权链接、登录轮询卡住看着像服务端卡死。 +// 判据:TLSNextProto 非 nil(真正禁 h2 的唯一写法,见 internal/upstream/transport.go) +// 且响应头/TLS 超时已配齐。 +func TestLoginHTTPDisablesH2(t *testing.T) { + tr, ok := loginHTTP.Transport.(*http.Transport) + if !ok || tr == nil { + t.Fatal("loginHTTP 必须有显式 *http.Transport(默认 transport 会启用 h2)") + } + if tr.TLSNextProto == nil { + t.Error("TLSNextProto 为 nil = 标准库会注入默认 h2 映射;必须 make 一个空映射才真正禁 h2") + } + if tr.ResponseHeaderTimeout <= 0 { + t.Error("ResponseHeaderTimeout 必须为正:否则半死连接会一直等响应头到总超时") + } + if tr.TLSHandshakeTimeout <= 0 || tr.DialContext == nil { + t.Error("建连/TLS 超时必须配齐") + } +} + +// TestDoJSONRetriesTransportFailure 纯传输失败(一个响应都没拿到)应自动重试; +// 这是 2026-10-24 DNS 抖动(127.0.0.11 server misbehaving)下「单发失败即报错」 +// 的兜底。 +func TestDoJSONRetriesTransportFailure(t *testing.T) { + var mu sync.Mutex + calls := 0 + srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { + mu.Lock() + calls++ + n := calls + mu.Unlock() + if n == 1 { + // 第一次直接断开:客户端拿到 EOF/连接重置,status=0,应触发重试。 + if hj, ok := w.(http.Hijacker); ok { + if c, _, err := hj.Hijack(); err == nil { + _ = c.Close() + return + } + } + } + _, _ = io.WriteString(w, `{"code":0,"msg":"OK","data":{"state":"s1","authUrl":"https://x/login"}}`) + })) + defer srv.Close() + + old := loginHTTP + loginHTTP = &http.Client{Timeout: 5 * time.Second} + defer func() { loginHTTP = old }() + + data, status, err := doJSON(http.MethodPost, srv.URL, nil, []byte("{}"), siteForRealm("cn")) + if err != nil { + t.Fatalf("传输失败后应重试成功,实际 err=%v status=%d", err, status) + } + if status != 200 { + t.Fatalf("status=%d want 200", status) + } + if len(data) == 0 { + t.Fatal("data 为空") + } + mu.Lock() + got := calls + mu.Unlock() + if got != 2 { + t.Fatalf("上游被调用 %d 次,want 2(第一次断开 + 一次重试)", got) + } +} + +// TestDoJSONDoesNotRetryBusinessError 已拿到响应(业务 code != 0)绝不重试: +// 登录轮询每秒都在打 token 端点,pending 时返回 11217 "login ing", +// 重试会把轮询拖慢 3 倍且毫无意义。 +func TestDoJSONDoesNotRetryBusinessError(t *testing.T) { + var mu sync.Mutex + calls := 0 + srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { + mu.Lock() + calls++ + mu.Unlock() + _, _ = io.WriteString(w, `{"code":11217,"msg":"login ing..."}`) + })) + defer srv.Close() + + old := loginHTTP + loginHTTP = &http.Client{Timeout: 5 * time.Second} + defer func() { loginHTTP = old }() + + _, status, err := doJSON(http.MethodGet, srv.URL, nil, nil, siteForRealm("cn")) + if err == nil { + t.Fatal("业务错误应返回 err") + } + if status != 200 { + t.Fatalf("status=%d want 200(有响应就不该重试)", status) + } + mu.Lock() + got := calls + mu.Unlock() + if got != 1 { + t.Fatalf("业务错误被调用 %d 次,want 1(不得重试)", got) + } +} diff --git a/internal/panel/login_poll_test.go b/internal/panel/login_poll_test.go new file mode 100644 index 0000000000000000000000000000000000000000..4178693f6a31d092ed53190733e23f257b2a24a1 --- /dev/null +++ b/internal/panel/login_poll_test.go @@ -0,0 +1,164 @@ +package panel + +import ( + "encoding/json" + "net/http" + "net/http/httptest" + "os" + "os/exec" + "strings" + "testing" + "time" +) + +// TestAppJSPollLoginResilience 登录轮询必须区分「抖动」与「终态」(借鉴上游 fork +// Albert-PZY f6abee7 / issue #215 复盘): +// - 网络抖动 / 5xx:继续轮询(OAuth 可能已在浏览器侧完成,停掉账号就永远不入池); +// - 404 / 410:会话作废,停止并提示重新发起; +// - 成功:作废 packages 缓存(否则「重新登录后点检查还是 401」)并回显余额校验失败。 +func TestAppJSPollLoginResilience(t *testing.T) { + node, err := exec.LookPath("node") + if err != nil { + t.Skip("node not installed; login poll test skipped") + } + script := `const fs = require('fs'); +const vm = require('vm'); +const src = fs.readFileSync(process.argv[2], 'utf8'); +const start = src.indexOf('function stopPoll()'); +const end = src.indexOf('function closeAdd()'); +if (start < 0 || end < start) throw new Error('pollLogin block not found'); +const els = {}; +function el(id) { + if (!els[id]) els[id] = { textContent: '', hidden: false }; + return els[id]; +} +let apiImpl = async () => ({}); +let invalidated = 0; +const ctx = { + Math, Number, String, JSON, encodeURIComponent, console, + $: el, + esc: (s) => String(s == null ? '' : s), + setInterval: () => 42, + clearInterval: () => {}, + setTimeout: () => {}, + loadOverview: () => {}, + invalidatePackages: () => { invalidated++; }, + api: (p) => apiImpl(p), + loginState: 'st1', + loginTimer: 7, + loginStartAt: 0, +}; +vm.createContext(ctx); +vm.runInContext(src.slice(start, end) + '\nthis.pollLogin = pollLogin; this.getFails = () => pollFails; this.getTimer = () => loginTimer;', ctx); + +const out = {}; +(async () => { + // 1) 抖动:保留轮询、计一次失败、提示自动重试。 + apiImpl = async () => { const e = new Error('HTTP 502'); e.status = 502; throw e; }; + await ctx.pollLogin(); + out.transientKeepsTimer = ctx.getTimer() !== null; + out.fails = ctx.getFails(); + out.transientText = els['addErr'].textContent; + + // 2) 终态 410:停止轮询并提示重新发起。 + apiImpl = async () => { const e = new Error('gone'); e.status = 410; throw e; }; + await ctx.pollLogin(); + out.terminalStops = ctx.getTimer() === null; + out.terminalText = els['addErr'].textContent; + + // 3) 成功:作废 packages 缓存 + 回显余额校验失败。 + apiImpl = async () => ({ done: true, uid: 'u1', nickname: 'n', credits: -1, credits_total: 0, balance_error: '401 invalid token' }); + await ctx.pollLogin(); + out.invalidated = invalidated; + out.doneText = els['addDone'].textContent; + + // 4) pending 超过 90s:浏览器侧可能已报「登录失败」,面板不能一直无声等待。 + els['addErr'].hidden = true; + apiImpl = async () => ({ done: false, message: 'code=11217 msg=login ing...' }); + ctx.loginStartAt = Date.now() - 95000; + await ctx.pollLogin(); + out.slowHintShown = !els['addErr'].hidden; + out.slowHintText = els['addErr'].textContent; + process.stdout.write(JSON.stringify(out)); +})();` + f, err := os.CreateTemp(t.TempDir(), "poll-login-*.cjs") + if err != nil { + t.Fatal(err) + } + if _, err := f.WriteString(script); err != nil { + t.Fatal(err) + } + f.Close() + out, err := exec.Command(node, f.Name(), "app.js").CombinedOutput() + if err != nil { + t.Fatalf("node failed: %v\n%s", err, out) + } + var got struct { + TransientKeepsTimer bool `json:"transientKeepsTimer"` + Fails int `json:"fails"` + TransientText string `json:"transientText"` + TerminalStops bool `json:"terminalStops"` + TerminalText string `json:"terminalText"` + Invalidated int `json:"invalidated"` + DoneText string `json:"doneText"` + SlowHintShown bool `json:"slowHintShown"` + SlowHintText string `json:"slowHintText"` + } + if err := json.Unmarshal(out, &got); err != nil { + t.Fatalf("bad output: %v\n%s", err, out) + } + if !got.TransientKeepsTimer { + t.Errorf("网络抖动不该停轮询(OAuth 可能已完成):%+v", got) + } + if got.Fails != 1 { + t.Errorf("失败计数=%d want 1", got.Fails) + } + if !strings.Contains(got.TransientText, "自动重试中(1/") { + t.Errorf("抖动应提示自动重试,得到 %q", got.TransientText) + } + if !got.TerminalStops || !strings.Contains(got.TerminalText, "登录会话已过期") { + t.Errorf("410 应停止轮询并提示重新发起:%+v", got) + } + if got.Invalidated != 1 { + t.Errorf("登录成功后应作废 packages 缓存(实际 %d 次)", got.Invalidated) + } + if !strings.Contains(got.DoneText, "余额校验失败") { + t.Errorf("余额校验失败必须回显(否则「已添加但一直 401」是静默失败):%q", got.DoneText) + } + if !got.SlowHintShown || !strings.Contains(got.SlowHintText, "重新获取授权链接") { + t.Errorf("pending 超时后应提示可操作的重试步骤(浏览器报「登录失败」时面板否则无声干等):%+v", got) + } +} + +// TestLoginPollGoneForUnknownState 未知/过期 state 必须回 410(终态):前端据此停止轮询 +// 并提示重新发起;若与网络抖动共用一个状态码,一次抖动就会让用户放弃等待。 +func TestLoginPollGoneForUnknownState(t *testing.T) { + p := New(Config{}) + rec := httptest.NewRecorder() + p.loginPoll(rec, httptest.NewRequest("GET", "/panel/api/login/poll?state=nope", nil)) + if rec.Code != http.StatusGone { + t.Fatalf("code=%d want 410 body=%s", rec.Code, rec.Body) + } +} + +// TestLoginPollProcessingGate 成功分支的副作用(落盘/签到/余额)可能耗时数秒,而前端每 +// 3s 轮询一次:并发 poll 必须被闸门挡住,否则整段流程会重跑一遍(重复落盘 + 重复签到)。 +func TestLoginPollProcessingGate(t *testing.T) { + p := New(Config{}) + p.logins = map[string]loginSession{"st": {created: time.Now(), realm: "cn", processing: true}} + rec := httptest.NewRecorder() + p.loginPoll(rec, httptest.NewRequest("GET", "/panel/api/login/poll?state=st", nil)) + if rec.Code != http.StatusOK { + t.Fatalf("code=%d body=%s", rec.Code, rec.Body) + } + var got map[string]any + if err := json.Unmarshal(rec.Body.Bytes(), &got); err != nil { + t.Fatalf("bad json: %v (%s)", err, rec.Body) + } + if got["done"] != false { + t.Fatalf("并发 poll 不应宣判完成:%v", got) + } + if msg, _ := got["message"].(string); !strings.Contains(msg, "正在写入凭据") { + t.Fatalf("message=%q want 正在写入凭据", msg) + } +} diff --git a/internal/panel/login_realm_test.go b/internal/panel/login_realm_test.go index ccec1229822ca31cb188c0b8547baccff5e7e7fe..73c73bbae475ca711c4d97dde3a126cd8681dfb5 100644 --- a/internal/panel/login_realm_test.go +++ b/internal/panel/login_realm_test.go @@ -1,43 +1,139 @@ -package panel - -import ( - "testing" -) - -// TestLoginEndpoints realm→端点映射:global 三端点全在 workbuddy.ai 域, -// cn/空/非法值 → copilot.tencent.com(零回归兜底)。 -func TestLoginEndpoints(t *testing.T) { - cases := []struct { - realm string - wantState string - wantOrigin string - }{ - {"global", "https://www.workbuddy.ai/v2/plugin/auth/state?platform=CLI", "https://www.workbuddy.ai"}, - {"cn", "https://copilot.tencent.com/v2/plugin/auth/state?platform=CLI", "https://www.codebuddy.cn"}, - {"", "https://copilot.tencent.com/v2/plugin/auth/state?platform=CLI", "https://www.codebuddy.cn"}, - {"weird", "https://copilot.tencent.com/v2/plugin/auth/state?platform=CLI", "https://www.codebuddy.cn"}, - } - for _, c := range cases { - t.Run(c.realm, func(t *testing.T) { - st, tok, acct, origin := loginEndpoints(c.realm) - if st != c.wantState { - t.Errorf("realm=%q state=%q want %q", c.realm, st, c.wantState) - } - if origin != c.wantOrigin { - t.Errorf("realm=%q origin=%q want %q", c.realm, origin, c.wantOrigin) - } - // token/account 端点必与 state 同 base。 - if c.realm == "global" { - if tok[:len("https://www.workbuddy.ai")] != "https://www.workbuddy.ai" || - acct[:len("https://www.workbuddy.ai")] != "https://www.workbuddy.ai" { - t.Errorf("global token/account endpoints should be workbuddy.ai: %q %q", tok, acct) - } - } else { - if tok[:len("https://copilot.tencent.com")] != "https://copilot.tencent.com" || - acct[:len("https://copilot.tencent.com")] != "https://copilot.tencent.com" { - t.Errorf("cn token/account endpoints should be copilot.tencent.com: %q %q", tok, acct) - } - } - }) - } -} +package panel + +import ( + "errors" + "testing" + + "github.com/misakano7545/workbuddy2api-panel/internal/loginsite" +) + +// TestLoginEndpoints realm→端点映射:global 保持历史语义(workbuddy.ai), +// cn/空/非法值 → copilot.tencent.com(零回归兜底)。 +// +// platform 取各站点的官方口径(product.json 的 authentication.attributes.platform, +// 2026-10-30 真机实测):global(workbuddy.ai)=workbuddy-ai、cn=workbuddy。 +// 旧期望是硬编码的 CLI —— 那是 product.json 的**顶层** platform 字段,不是授权用的那个。 +func TestLoginEndpoints(t *testing.T) { + cases := []struct { + realm string + wantState string + wantOrigin string + }{ + {"global", "https://www.workbuddy.ai/v2/plugin/auth/state?platform=workbuddy-ai", "https://www.workbuddy.ai"}, + {"cn", "https://copilot.tencent.com/v2/plugin/auth/state?platform=workbuddy", "https://www.codebuddy.cn"}, + {"", "https://copilot.tencent.com/v2/plugin/auth/state?platform=workbuddy", "https://www.codebuddy.cn"}, + {"weird", "https://copilot.tencent.com/v2/plugin/auth/state?platform=workbuddy", "https://www.codebuddy.cn"}, + } + for _, c := range cases { + t.Run(c.realm, func(t *testing.T) { + st, tok, acct, origin := loginEndpoints(c.realm) + if st != c.wantState { + t.Errorf("realm=%q state=%q want %q", c.realm, st, c.wantState) + } + if origin != c.wantOrigin { + t.Errorf("realm=%q origin=%q want %q", c.realm, origin, c.wantOrigin) + } + // token/account 端点必与 state 同 base。 + if c.realm == "global" { + if tok[:len("https://www.workbuddy.ai")] != "https://www.workbuddy.ai" || + acct[:len("https://www.workbuddy.ai")] != "https://www.workbuddy.ai" { + t.Errorf("global token/account endpoints should be workbuddy.ai: %q %q", tok, acct) + } + } else { + if tok[:len("https://copilot.tencent.com")] != "https://copilot.tencent.com" || + acct[:len("https://copilot.tencent.com")] != "https://copilot.tencent.com" { + t.Errorf("cn token/account endpoints should be copilot.tencent.com: %q %q", tok, acct) + } + } + }) + } +} + +// TestSiteOrDefault 覆盖面板侧站点归一化:空/未知回落 cn;intl 指向官方国际站 +// (product.json externalDomain),workbuddy 指向旧桌面端。 +func TestSiteOrDefault(t *testing.T) { + cases := []struct { + id string + wantID string + wantRealm string + wantAPI string + }{ + {id: "", wantID: siteCN, wantRealm: "cn", wantAPI: "https://copilot.tencent.com"}, + {id: "cn", wantID: siteCN, wantRealm: "cn", wantAPI: "https://copilot.tencent.com"}, + {id: "intl", wantID: siteIntl, wantRealm: "global", wantAPI: "https://www.codebuddy.ai"}, + {id: "workbuddy", wantID: siteWorkBuddy, wantRealm: "global", wantAPI: "https://www.workbuddy.ai"}, + // 未知值不猜域。 + {id: "global", wantID: siteCN, wantRealm: "cn", wantAPI: "https://copilot.tencent.com"}, + } + for _, c := range cases { + s := siteOrDefault(c.id) + if s.ID != c.wantID || s.Realm != c.wantRealm || s.API != c.wantAPI { + t.Errorf("siteOrDefault(%q)={%s %s %s} want {%s %s %s}", + c.id, s.ID, s.Realm, s.API, c.wantID, c.wantRealm, c.wantAPI) + } + } +} + +// TestLoginCodeSemantics 覆盖官方登录码在面板侧的分类:11217/12151 继续轮询, +// 12005/11212/11216 立刻终态。这两类混为一谈时,「席位满」要白等满 loginTTL +// 才报超时,用户根本看不到真实原因。 +func TestLoginCodeSemantics(t *testing.T) { + for _, c := range []int{loginCodeRetryFetchToken, loginCodeRetryFetchAccount} { + if !loginCodePending(c) { + t.Errorf("code %d 应判 pending", c) + } + if loginCodeFatal(c) { + t.Errorf("code %d 不应判终态", c) + } + } + for _, c := range []int{loginCodeLicenseSeatLimit, loginCodeLicenseExpired, loginCodeTrialExpired} { + if !loginCodeFatal(c) { + t.Errorf("code %d 应判终态", c) + } + if loginCodePending(c) { + t.Errorf("code %d 不应判 pending", c) + } + } + // 码值本身锁死(防手滑改数字导致语义漂移)。 + if loginCodeRetryFetchToken != 11217 || loginCodeRetryFetchAccount != 12151 || + loginCodeLicenseSeatLimit != 12005 || loginCodeLicenseExpired != 11212 || + loginCodeTrialExpired != 11216 { + t.Error("登录码常量与官方码表不一致") + } +} + +// TestLoginEnvelopeErrorAs 覆盖错误链:doJSON 返回的 *loginEnvelopeError 必须能被 +// errors.As 取出 code——轮询分支靠它区分 pending / 终态,退化成字符串解析就脆了。 +func TestLoginEnvelopeErrorAs(t *testing.T) { + var err error = &loginEnvelopeError{Code: 12005, Msg: "seat limit", Status: 200} + var envErr *loginEnvelopeError + if !errors.As(err, &envErr) { + t.Fatal("errors.As 未能取出 *loginEnvelopeError") + } + if envErr.Code != 12005 || envErr.Msg != "seat limit" { + t.Errorf("解出 %+v,字段不符", envErr) + } + if got, want := err.Error(), "code=12005 msg=seat limit"; got != want { + t.Errorf("Error()=%q want %q", got, want) + } +} + +// TestClientUAOfficial 覆盖 UA 与官方 CLI 版本同源(升级版本号时 UA/version 不能漂移)。 +// +// 注意:设备码三端点已改为按站点取桌面端 RPC 族 UA(Site.UserAgent), +// clientUA 只剩「未复核站点兜底」这一条用途;此处钉住它仍与 ClientVersion 同源。 +func TestClientUAOfficial(t *testing.T) { + if clientUA != loginsite.ClientUA { + t.Errorf("面板 UA=%q 与 loginsite.ClientUA=%q 不一致", clientUA, loginsite.ClientUA) + } + if loginsite.ClientVersion != "2.176.0" { + t.Errorf("官方 CLI 版本变了(%s),请同步核对登录页参数与码表", loginsite.ClientVersion) + } + // 真机复核过的两个站点必须发桌面端 RPC 族 UA,不能落回 CodeBuddy CLI 串。 + for _, id := range []string{loginsite.SiteCN, loginsite.SiteWorkBuddy} { + ua := loginsite.For(id).EndpointHeaders()["User-Agent"] + if ua == loginsite.ClientUA { + t.Errorf("站点 %s 的 UA 回落成了 CodeBuddy CLI 串 %q", id, ua) + } + } +} diff --git a/internal/panel/login_site_test.go b/internal/panel/login_site_test.go new file mode 100644 index 0000000000000000000000000000000000000000..344664c515fcfc57dd3e9229d736b69eec62070a --- /dev/null +++ b/internal/panel/login_site_test.go @@ -0,0 +1,245 @@ +package panel + +import ( + "bytes" + "encoding/json" + "fmt" + "log" + "net/http" + "net/http/httptest" + "net/url" + "strings" + "testing" + "time" + + "github.com/misakano7545/workbuddy2api-panel/internal/loginsite" +) + +// withTestSite 把站点解析临时指向 httptest 服务器(避免单测打真实上游), +// 测试结束恢复。返回的站点保留原 realm/ID/platform,仅替换 API 与 Origin。 +func withTestSite(t *testing.T, base string, id string) { + t.Helper() + orig := siteResolver + site := loginsite.For(id) + site.API = base + site.Origin = base + siteResolver = func(want string) loginsite.Site { + if loginsite.ValidID(want) && strings.EqualFold(want, id) { + return site + } + if loginsite.ValidID(want) { + // 其它站点也指向同一测试服务器(handler 只看是否命中测试 host)。 + other := loginsite.For(want) + other.API = base + other.Origin = base + return other + } + return site + } + t.Cleanup(func() { siteResolver = orig }) +} + +// TestLoginStartRecordsSiteAndDecoratesURL 覆盖 login/start:返回的授权链接不发 +// version(授权页只读 platform/fromSource),且会话记录 site(poll 据此选端点, +// 防止 codebuddy.ai 与 workbuddy.ai 混用)。 +func TestLoginStartRecordsSiteAndDecoratesURL(t *testing.T) { + var gotPlatform string + srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { + if !strings.HasSuffix(r.URL.Path, "/v2/plugin/auth/state") { + t.Errorf("unexpected path %s", r.URL.Path) + } + gotPlatform = r.URL.Query().Get("platform") + base := "http://" + r.Host + w.Header().Set("Content-Type", "application/json") + fmt.Fprintf(w, `{"code":0,"msg":"OK","data":{"state":"st-intl","authUrl":"%s/login?platform=CLI&state=st-intl"}}`, base) + })) + defer srv.Close() + + withTestSite(t, srv.URL, loginsite.SiteIntl) + + p := New(Config{}) + rec := httptest.NewRecorder() + p.loginStart(rec, httptest.NewRequest("POST", "/panel/api/login/start", + strings.NewReader(`{"site":"intl"}`))) + if rec.Code != http.StatusOK { + t.Fatalf("code=%d body=%s", rec.Code, rec.Body) + } + var resp map[string]any + if err := json.Unmarshal(rec.Body.Bytes(), &resp); err != nil { + t.Fatalf("bad json: %v (%s)", err, rec.Body) + } + if resp["site"] != "intl" { + t.Errorf("site=%v want intl", resp["site"]) + } + if resp["realm"] != "global" { + t.Errorf("realm=%v want global", resp["realm"]) + } + rawURL, _ := resp["url"].(string) + u, err := url.Parse(rawURL) + if err != nil { + t.Fatalf("解析授权 URL 失败 %q: %v", rawURL, err) + } + if v := u.Query().Get("version"); v != "" { + t.Errorf("授权链接不该带 version:%q", rawURL) + } + if gotPlatform != "workbuddy-ai" { + t.Errorf("platform=%q want workbuddy-ai(intl 站点真机口径)", gotPlatform) + } + + // 会话必须记住站点,否则 poll 会按 cn 端点去问,永远拿不到 token。 + p.loginMu.Lock() + sess, ok := p.logins["st-intl"] + p.loginMu.Unlock() + if !ok { + t.Fatal("state 未记录") + } + if sess.site != "intl" || sess.realm != "global" { + t.Errorf("session={site:%s realm:%s} want {intl global}", sess.site, sess.realm) + } +} + +// TestLoginStartLegacyRealm 覆盖老前端兼容:只传 {"realm":"global"} 时映射到旧桌面端 +// 站点(workbuddy.ai),保持历史语义不变。 +func TestLoginStartLegacyRealm(t *testing.T) { + var gotPath string + srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { + gotPath = r.URL.Path + base := "http://" + r.Host + w.Header().Set("Content-Type", "application/json") + fmt.Fprintf(w, `{"code":0,"msg":"OK","data":{"state":"st-wb","authUrl":"%s/login?state=st-wb"}}`, base) + })) + defer srv.Close() + + withTestSite(t, srv.URL, loginsite.SiteWorkBuddy) + + p := New(Config{}) + rec := httptest.NewRecorder() + p.loginStart(rec, httptest.NewRequest("POST", "/panel/api/login/start", + strings.NewReader(`{"realm":"global"}`))) + if rec.Code != http.StatusOK { + t.Fatalf("code=%d body=%s", rec.Code, rec.Body) + } + var resp map[string]any + _ = json.Unmarshal(rec.Body.Bytes(), &resp) + if resp["site"] != "workbuddy" { + t.Errorf("site=%v want workbuddy(realm=global 兼容映射)", resp["site"]) + } + if !strings.HasSuffix(gotPath, "/v2/plugin/auth/state") { + t.Errorf("path=%q", gotPath) + } +} + +// TestLoginPollFatalLicenseCode 覆盖许可类终态码:上游回 12005(席位满)时必须 +// 立即返回 fatal=true + 上游 msg,并清掉会话(不再让前端每 3s 空转到 TTL)。 +func TestLoginPollFatalLicenseCode(t *testing.T) { + srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { + w.Header().Set("Content-Type", "application/json") + fmt.Fprint(w, `{"code":12005,"msg":"license seat limit reached"}`) + })) + defer srv.Close() + + withTestSite(t, srv.URL, loginsite.SiteCN) + + p := New(Config{}) + p.logins = map[string]loginSession{"st1": {created: time.Now(), realm: "cn", site: "cn"}} + rec := httptest.NewRecorder() + p.loginPoll(rec, httptest.NewRequest("GET", "/panel/api/login/poll?state=st1", nil)) + if rec.Code != http.StatusOK { + t.Fatalf("code=%d body=%s", rec.Code, rec.Body) + } + var got map[string]any + if err := json.Unmarshal(rec.Body.Bytes(), &got); err != nil { + t.Fatalf("bad json: %v (%s)", err, rec.Body) + } + if got["fatal"] != true { + t.Fatalf("fatal=%v want true(12005 应终态,不该继续轮询): %s", got["fatal"], rec.Body) + } + if code, _ := got["code"].(float64); int(code) != 12005 { + t.Errorf("code=%v want 12005", got["code"]) + } + if msg, _ := got["message"].(string); !strings.Contains(msg, "license seat limit reached") { + t.Errorf("message=%q 应透出上游原话", msg) + } + // 会话已作废:后续 poll 应 410(前端停止轮询)。 + p.loginMu.Lock() + _, still := p.logins["st1"] + p.loginMu.Unlock() + if still { + t.Error("终态后会话未清除") + } +} + +// TestLoginPollPendingCodeKeepsPolling 覆盖 pending 码:11217(还没登完)必须 +// done=false 且**不**标 fatal,否则用户还没在浏览器点完就被判失败。 +func TestLoginPollPendingCodeKeepsPolling(t *testing.T) { + srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { + w.Header().Set("Content-Type", "application/json") + fmt.Fprint(w, `{"code":11217,"msg":"login ing..."}`) + })) + defer srv.Close() + + withTestSite(t, srv.URL, loginsite.SiteCN) + + p := New(Config{}) + p.logins = map[string]loginSession{"st2": {created: time.Now(), realm: "cn", site: "cn"}} + rec := httptest.NewRecorder() + p.loginPoll(rec, httptest.NewRequest("GET", "/panel/api/login/poll?state=st2", nil)) + if rec.Code != http.StatusOK { + t.Fatalf("code=%d body=%s", rec.Code, rec.Body) + } + var got map[string]any + if err := json.Unmarshal(rec.Body.Bytes(), &got); err != nil { + t.Fatalf("bad json: %v (%s)", err, rec.Body) + } + if got["done"] != false { + t.Errorf("done=%v want false", got["done"]) + } + if got["fatal"] == true { + t.Errorf("11217 是 pending,不该判终态:%s", rec.Body) + } + // 会话保留,前端可继续轮询。 + p.loginMu.Lock() + _, still := p.logins["st2"] + p.loginMu.Unlock() + if !still { + t.Error("pending 时不该清会话") + } +} + +// TestLogPollOnceDedupes 覆盖轮询日志节流:同一上游结果只记一行(前端 3s 一轮, +// 逐轮落盘会把 15 分钟刷成 300 行),结果变化后再记一行,会话消失后不再记。 +func TestLogPollOnceDedupes(t *testing.T) { + var buf bytes.Buffer + orig := log.Writer() + log.SetOutput(&buf) + t.Cleanup(func() { log.SetOutput(orig) }) + + p := New(Config{}) + p.logins = map[string]loginSession{"st-abcdef12": {created: time.Now(), realm: "cn", site: "cn"}} + + lines := func() int { return strings.Count(buf.String(), "登录轮询") } + + p.logPollOnce("st-abcdef12", "code=11217 msg=login ing...") + p.logPollOnce("st-abcdef12", "code=11217 msg=login ing...") + if got := lines(); got != 1 { + t.Fatalf("同一上游结果记了 %d 行,want 1: %q", got, buf.String()) + } + if !strings.Contains(buf.String(), "st-abcde...") { + t.Errorf("日志缺 state 前缀(定位要用): %q", buf.String()) + } + if !strings.Contains(buf.String(), "login ing...") { + t.Errorf("日志缺上游原文: %q", buf.String()) + } + + p.logPollOnce("st-abcdef12", "http_error: upstream 502") + if got := lines(); got != 2 { + t.Fatalf("上游结果变化后应再记一行,got %d: %q", got, buf.String()) + } + + // 会话已清(超时 / 已落盘):迟到的一次 poll 不该再记。 + delete(p.logins, "st-abcdef12") + p.logPollOnce("st-abcdef12", "code=11217 msg=late") + if got := lines(); got != 2 { + t.Fatalf("会话消失后仍记了日志,got %d: %q", got, buf.String()) + } +} diff --git a/internal/panel/logstore.go b/internal/panel/logstore.go new file mode 100644 index 0000000000000000000000000000000000000000..3e3465ed560356d64ccb798f28992b9f43bc025c --- /dev/null +++ b/internal/panel/logstore.go @@ -0,0 +1,392 @@ +// logstore.go 面板「运行日志」的按天 JSONL 落盘、重启回填与按区间导出。 +// +// 为什么需要(此前只有内存环 + 任务频道的一份 JSON 快照): +// +// 环形缓冲每频道 500 条,对话一多就把上午的行冲掉;进程一重启全部归零。 +// 于是「昨天下午那波 429 是什么时候开始的」这类问题,只能靠当时有没有人截屏。 +// 事故复盘要看的是**过去几天的原始行**,这是一个纯粹的可观测性缺口。 +// +// 与 reqlog 的分工(不要合并): +// +// reqlog 逐请求的**结构化元数据**(模型/账号/时延/结果),用于统计与筛选 +// logstore 面板三频道(chat/task/sys)的**原始文本行**,用于照着日志读事故 +// +// 与 Ring.SetTaskArchive 的关系:那份 JSON 只存任务频道、只存最近 500 条、跨天即丢。 +// 本文件上线后由它接管回填(见 Ring.SetLogStore);task-logs.json 保留为落盘目录 +// 不可用时的兜底,不再作为主路径。 +package panel + +import ( + "archive/zip" + "bufio" + "encoding/json" + "fmt" + "os" + "path/filepath" + "sort" + "strings" + "sync" + "time" + + "github.com/misakano7545/workbuddy2api-panel/internal/cst" +) + +const ( + // logStoreDefaultDays / logStoreDefaultMaxMB 配置缺省(与 reqlog 的默认量级对齐)。 + logStoreDefaultDays = 7 + logStoreDefaultMaxMB = 50 + // logStoreFlushBytes 攒到这么多字节才落盘一次。 + // 不逐行 flush:日志是高频写入,每行一次 syscall 会在长流式会话里明显吃掉 CPU。 + logStoreFlushBytes = 48 << 10 + // logStoreBackfillMax 回填上限(条)。环路只有 500/频道,回填更多也留不住。 + logStoreBackfillMax = 3000 +) + +// LogStore 面板运行日志的按天落盘存储。目录不可用时降级为纯内存,绝不阻塞主流程。 +type LogStore struct { + mu sync.Mutex + dir string + retentionDays int + maxBytes int64 + file *os.File + bw *bufio.Writer + day string // 当前文件对应的自然日(CST,与切天口径一致) + written int64 // 当前文件已写字节(上限判定用) + err string // 最近一次写盘失败原因(面板可提示) +} + +// NewLogStore 创建存储并做一次保留期清理。dir 为空或建目录失败时返回 nil +// (调用方据此退回纯内存行为)。retentionDays<=0 回退 7,maxMB<=0 回退 50。 +func NewLogStore(dir string, retentionDays, maxMB int) *LogStore { + if strings.TrimSpace(dir) == "" { + return nil + } + if retentionDays <= 0 { + retentionDays = logStoreDefaultDays + } + if maxMB <= 0 { + maxMB = logStoreDefaultMaxMB + } + if err := os.MkdirAll(dir, 0o700); err != nil { + return nil + } + s := &LogStore{dir: dir, retentionDays: retentionDays, maxBytes: int64(maxMB) << 20} + s.cleanup() + return s +} + +// Dir 落盘目录(导出时用于展示,测试也可断言)。 +func (s *LogStore) Dir() string { + if s == nil { + return "" + } + return s.dir +} + +// Error 最近一次写盘失败原因(空 = 正常)。面板 logsHandler 透出。 +func (s *LogStore) Error() string { + if s == nil { + return "" + } + s.mu.Lock() + defer s.mu.Unlock() + return s.err +} + +// pathForDay 某自然日的日志文件路径。 +func (s *LogStore) pathForDay(day string) string { + return filepath.Join(s.dir, "panel-"+day+"."+logStoreExt) +} + +// logStoreExt 文件扩展名(导出 ZIP 时按它挑文件)。 +const logStoreExt = "jsonl" + +// Append 追加一条日志;跨天自动切文件,超单文件上限时截断重开。 +// +// 失败一律只记 s.err 不返回错误:日志系统不能反过来拖垮在处理的请求。 +func (s *LogStore) Append(e LogEntry) { + if s == nil || strings.TrimSpace(e.Text) == "" { + return + } + s.mu.Lock() + defer s.mu.Unlock() + + day := e.TS.In(cst.Loc).Format("2006-01-02") + needRotate := s.file == nil || day != s.day + // 单文件超上限:同一天内换个序号文件继续写,而不是覆盖(否则当天日志只剩一半)。 + // 只在「跨天」或「已经超限」时轮转;上限是软约束,避免逐行 stat。 + if !needRotate && s.maxBytes > 0 && s.written >= s.maxBytes { + needRotate = true + } + if needRotate { + s.rotateLocked(day) + if s.file == nil { + return + } + } + line, err := json.Marshal(e) + if err != nil { + s.err = err.Error() + return + } + line = append(line, '\n') + n, err := s.bw.Write(line) + s.written += int64(n) + if err != nil { + s.err = err.Error() + return + } + if s.bw.Buffered() >= logStoreFlushBytes { + if err := s.bw.Flush(); err != nil { + s.err = err.Error() + return + } + } + s.err = "" +} + +// rotateLocked 关闭当前文件并打开新的一天(fileName 带序号避让超限轮转)。 +// 调用方必须持 s.mu。 +func (s *LogStore) rotateLocked(day string) { + s.closeLocked() + path := s.pathForDay(day) + // 同一天里因为超限轮转出来的后续文件:panel-.2.jsonl、.3.jsonl … + if s.day == day { + for i := 2; i < 100; i++ { + candidate := filepath.Join(s.dir, fmt.Sprintf("panel-%s.%d.%s", day, i, logStoreExt)) + if _, statErr := os.Stat(candidate); os.IsNotExist(statErr) { + path = candidate + break + } + } + } + f, err := os.OpenFile(path, os.O_CREATE|os.O_WRONLY|os.O_APPEND, 0o600) + if err != nil { + s.err = err.Error() + s.day = "" + return + } + // 续写已有文件时把既有大小算进上限,否则重启后同一天的文件会长到两倍。 + if info, statErr := f.Stat(); statErr == nil { + s.written = info.Size() + } else { + s.written = 0 + } + s.file = f + s.bw = bufio.NewWriterSize(f, 64<<10) + s.day = day +} + +// closeLocked 刷盘并关闭当前文件。调用方必须持 s.mu。 +func (s *LogStore) closeLocked() { + if s.bw != nil { + if err := s.bw.Flush(); err != nil && s.err == "" { + s.err = err.Error() + } + s.bw = nil + } + if s.file != nil { + _ = s.file.Close() + s.file = nil + } +} + +// Flush 立即刷盘(导出前调用,保证文件里有内存中尚未落盘的尾巴)。 +func (s *LogStore) Flush() { + if s == nil { + return + } + s.mu.Lock() + defer s.mu.Unlock() + if s.bw != nil { + if err := s.bw.Flush(); err != nil { + s.err = err.Error() + } + } +} + +// Close 刷盘并关闭(进程退出时调用)。 +func (s *LogStore) Close() error { + if s == nil { + return nil + } + s.mu.Lock() + defer s.mu.Unlock() + s.closeLocked() + return nil +} + +// files 返回目录内的日志文件,按文件名(即日期)升序。 +func (s *LogStore) files() []string { + entries, err := os.ReadDir(s.dir) + if err != nil { + return nil + } + out := make([]string, 0, len(entries)) + for _, entry := range entries { + name := entry.Name() + if entry.IsDir() || !strings.HasPrefix(name, "panel-") || !strings.HasSuffix(name, "."+logStoreExt) { + continue + } + out = append(out, filepath.Join(s.dir, name)) + } + sort.Strings(out) + return out +} + +// dayOfFile 从文件名取自然日(panel-2026-11-09.jsonl / panel-2026-11-09.2.jsonl)。 +func dayOfFile(path string) string { + base := strings.TrimSuffix(filepath.Base(path), "."+logStoreExt) + base = strings.TrimPrefix(base, "panel-") + if len(base) < 10 { + return "" + } + return base[:10] +} + +// Backfill 读最近的文件,按时间升序返回最多 limit 条(limit<=0 回退上限)。 +// +// 从**最新**的文件倒着读、读够就停:回填的目的是「重启后还能看到最近的日志」, +// 不是重建全部历史。读失败的文件跳过(一个坏文件不该让面板日志整页空掉)。 +func (s *LogStore) Backfill(limit int) []LogEntry { + if s == nil { + return nil + } + if limit <= 0 || limit > logStoreBackfillMax { + limit = logStoreBackfillMax + } + s.mu.Lock() + // 先把内存里的尾巴刷下去,否则回填会漏掉重启前最后几行。 + if s.bw != nil { + _ = s.bw.Flush() + } + files := s.files() + s.mu.Unlock() + + var out []LogEntry + for i := len(files) - 1; i >= 0 && len(out) < limit; i-- { + chunk := readLogFile(files[i]) + // 从最新文件往前拼,插到前面保持全局升序。 + if need := limit - len(out); len(chunk) > need { + chunk = chunk[len(chunk)-need:] + } + out = append(chunk, out...) + } + if len(out) > limit { + out = out[len(out)-limit:] + } + return out +} + +// readLogFile 读一个 JSONL 文件,跳过坏行。 +func readLogFile(path string) []LogEntry { + f, err := os.Open(path) + if err != nil { + return nil + } + defer f.Close() + var out []LogEntry + sc := bufio.NewScanner(f) + sc.Buffer(make([]byte, 0, 64<<10), 1<<20) + for sc.Scan() { + line := strings.TrimSpace(sc.Text()) + if line == "" { + continue + } + var e LogEntry + if json.Unmarshal([]byte(line), &e) != nil || e.Text == "" { + continue + } + out = append(out, e) + } + return out +} + +// Export 把 [from, to] 区间内的日志打成 ZIP 写到 w,返回写入的文件数。 +// +// 按天选文件(文件名即日期),再按行内的 TS 精确裁剪——这样跨天区间不会带进 +// 区间外的行,且不必把全部历史读进内存两遍(每行独立判定,直接流式写 zip)。 +func (s *LogStore) Export(w *os.File, from, to time.Time) (int, error) { + if s == nil { + return 0, fmt.Errorf("日志落盘未启用") + } + s.Flush() + zw := zip.NewWriter(w) + written := 0 + for _, path := range s.files() { + day := dayOfFile(path) + if day == "" { + continue + } + fileDay, err := time.ParseInLocation("2006-01-02", day, cst.Loc) + if err != nil { + continue + } + // 快速跳过完全落在区间外的日子(一天一个文件,含超限轮转的序号文件)。 + if fileDay.AddDate(0, 0, 1).Before(from) || fileDay.After(to) { + continue + } + if err := copyFilteredToZip(zw, path, filepath.Base(path), from, to); err != nil { + _ = zw.Close() + return written, err + } + written++ + } + if err := zw.Close(); err != nil { + return written, err + } + return written, nil +} + +// copyFilteredToZip 把一个日志文件里落在区间内的行写进 zip。 +func copyFilteredToZip(zw *zip.Writer, path, name string, from, to time.Time) error { + src, err := os.Open(path) + if err != nil { + return nil // 单个文件读不了不拖累整体导出 + } + defer src.Close() + dst, err := zw.Create(name) + if err != nil { + return err + } + sc := bufio.NewScanner(src) + sc.Buffer(make([]byte, 0, 64<<10), 1<<20) + bw := bufio.NewWriterSize(dst, 64<<10) + defer bw.Flush() + for sc.Scan() { + line := sc.Bytes() + if len(line) == 0 { + continue + } + var probe struct { + TS time.Time `json:"ts"` + } + // 只解析 ts:整行反序列化再重排是白费(一行最多几 KB,但一天上万行)。 + if json.Unmarshal(line, &probe) != nil { + continue + } + if probe.TS.Before(from) || probe.TS.After(to) { + continue + } + if _, err := bw.Write(line); err != nil { + return err + } + if err := bw.WriteByte('\n'); err != nil { + return err + } + } + return nil +} + +// cleanup 删除保留期之外的文件(启动时跑一次)。 +func (s *LogStore) cleanup() { + cutoff := cst.Now().AddDate(0, 0, -s.retentionDays).Format("2006-01-02") + for _, path := range s.files() { + day := dayOfFile(path) + // 文件名为空(畸形名)不删:宁可留着让人自己看,也不误删别人的文件。 + if day == "" || day >= cutoff { + continue + } + _ = os.Remove(path) + } +} diff --git a/internal/panel/logstore_test.go b/internal/panel/logstore_test.go new file mode 100644 index 0000000000000000000000000000000000000000..24088d547f864779ebf9fbcc1975e3d91de1d89d --- /dev/null +++ b/internal/panel/logstore_test.go @@ -0,0 +1,240 @@ +// logstore_test.go 运行日志落盘 / 回填 / 导出的回归钉。 +// +// 这些用例守的是「事故现场还在」这件事:内存环每频道 500 条、重启即归零, +// 落盘是唯一能让「昨天下午那波 429」还可查的东西。 +package panel + +import ( + "archive/zip" + "encoding/json" + "os" + "path/filepath" + "strings" + "testing" + "time" + + "github.com/misakano7545/workbuddy2api-panel/internal/cst" +) + +// dayTS 指定自然日的某个时刻(CST)。 +func dayTS(day string, hour int) time.Time { + t, err := time.ParseInLocation("2006-01-02 15", day+" "+string(rune('0'+hour/10))+string(rune('0'+hour%10)), cst.Loc) + if err != nil { + panic(err) + } + return t +} + +// TestLogStoreWritesPerDayFiles 跨天必须切文件,且文件名按 CST 自然日。 +func TestLogStoreWritesPerDayFiles(t *testing.T) { + dir := t.TempDir() + s := NewLogStore(dir, 7, 0) + if s == nil { + t.Fatal("NewLogStore 返回 nil") + } + defer s.Close() + s.Append(LogEntry{TS: dayTS("2026-11-08", 23), Ch: ChChat, Text: "row-a"}) + s.Append(LogEntry{TS: dayTS("2026-11-09", 1), Ch: ChSys, Text: "row-b"}) + s.Flush() + + for _, day := range []string{"2026-11-08", "2026-11-09"} { + path := filepath.Join(dir, "panel-"+day+".jsonl") + if _, err := os.Stat(path); err != nil { + t.Fatalf("%s 未落盘: %v", day, err) + } + } + // 读回来确认内容与频道都在(导出的可读性依赖这两个字段)。 + got := readLogFile(filepath.Join(dir, "panel-2026-11-09.jsonl")) + if len(got) != 1 || got[0].Text != "row-b" || got[0].Ch != ChSys { + t.Fatalf("11-09 文件内容 = %+v", got) + } +} + +// TestLogStoreRotatesOnMaxBytes 单文件超上限时换序号文件续写,而不是覆盖。 +// +// 反向代价:若实现改成覆盖,当天日志只剩最后几行——而这恰恰是流量暴增、 +// 最需要看全天日志的那一天。 +func TestLogStoreRotatesOnMaxBytes(t *testing.T) { + dir := t.TempDir() + // 上限 1MiB 太大测不出来,直接用小值:NewLogStore 的 maxMB 是 MiB 单位, + // 这里绕过构造函数手工给一个小上限。 + s := &LogStore{dir: dir, retentionDays: 7, maxBytes: 200} + s.cleanup() + ts := dayTS("2026-11-09", 12) + for i := 0; i < 20; i++ { + s.Append(LogEntry{TS: ts, Ch: ChSys, Text: "0123456789012345678901234567890123456789"}) + } + s.Close() + + first := filepath.Join(dir, "panel-2026-11-09.jsonl") + second := filepath.Join(dir, "panel-2026-11-09.2.jsonl") + if _, err := os.Stat(first); err != nil { + t.Fatalf("首个文件缺失: %v", err) + } + if _, err := os.Stat(second); err != nil { + t.Fatalf("超限后未轮转到 .2 文件: %v", err) + } + // 上限是 200 字节(约 2 行),20 条会摊到多个序号文件里——统计**全部**匹配 + // 文件,断言一条都没丢。丢日志等于丢事故现场,这是这条用例唯一的重点。 + all, err := filepath.Glob(filepath.Join(dir, "panel-2026-11-09*.jsonl")) + if err != nil { + t.Fatal(err) + } + total := 0 + for _, path := range all { + total += len(readLogFile(path)) + } + if total != 20 { + t.Fatalf("轮转后总条数 = %d want 20(共 %d 个文件;丢日志 = 丢事故现场)", total, len(all)) + } +} + +// TestLogStoreBackfillNewestFirst 回填按时间升序返回最近的 limit 条。 +func TestLogStoreBackfillNewestFirst(t *testing.T) { + dir := t.TempDir() + s := NewLogStore(dir, 7, 0) + for i := 0; i < 5; i++ { + s.Append(LogEntry{TS: dayTS("2026-11-08", 10).Add(time.Duration(i) * time.Minute), Ch: ChSys, Text: "old-" + string(rune('0'+i))}) + } + for i := 0; i < 3; i++ { + s.Append(LogEntry{TS: dayTS("2026-11-09", 10).Add(time.Duration(i) * time.Minute), Ch: ChSys, Text: "new-" + string(rune('0'+i))}) + } + s.Close() + + // 重新打开(模拟重启),回填只看落盘文件。 + fresh := NewLogStore(dir, 7, 0) + got := fresh.Backfill(4) + if len(got) != 4 { + t.Fatalf("回填条数 = %d want 4", len(got)) + } + if got[0].Text != "old-4" || got[3].Text != "new-2" { + t.Fatalf("回填顺序/内容 = %v ~ %v want old-4 ~ new-2(升序取最近)", got[0].Text, got[3].Text) + } + // 升序必须是严格成立的:环里的顺序就是面板展示顺序。 + for i := 1; i < len(got); i++ { + if got[i].TS.Before(got[i-1].TS) { + t.Fatalf("回填未按时间升序: %v 在 %v 之前", got[i].TS, got[i-1].TS) + } + } +} + +// TestLogStoreExportFiltersByRange 导出按区间逐行裁剪,且只含区间内的行。 +func TestLogStoreExportFiltersByRange(t *testing.T) { + dir := t.TempDir() + s := NewLogStore(dir, 7, 0) + defer s.Close() // 不关会一直占着文件句柄,TempDir 清理在 Windows 上会失败 + base := dayTS("2026-11-09", 8) + for i := 0; i < 6; i++ { + s.Append(LogEntry{TS: base.Add(time.Duration(i) * time.Hour), Ch: ChSys, Text: "line-" + string(rune('0'+i))}) + } + s.Append(LogEntry{TS: dayTS("2026-11-07", 8), Ch: ChSys, Text: "too-old"}) + + tmp, err := os.CreateTemp(t.TempDir(), "export-*.zip") + if err != nil { + t.Fatal(err) + } + defer tmp.Close() + files, err := s.Export(tmp, base.Add(time.Hour), base.Add(3*time.Hour)) + if err != nil { + t.Fatalf("Export: %v", err) + } + if files != 1 { + t.Fatalf("导出文件数 = %d want 1(只该含 11-09 那天)", files) + } + entries, err := zip.OpenReader(tmp.Name()) + if err != nil { + t.Fatalf("打开 zip: %v", err) + } + defer entries.Close() + var lines []string + for _, f := range entries.File { + rc, err := f.Open() + if err != nil { + t.Fatal(err) + } + var rec struct{ Text string } + dec := json.NewDecoder(rc) + for dec.More() { + if err := dec.Decode(&rec); err != nil { + break + } + lines = append(lines, rec.Text) + } + rc.Close() + } + want := []string{"line-1", "line-2", "line-3"} + if len(lines) != len(want) { + t.Fatalf("区间内行数 = %d want %d(%v)", len(lines), len(want), lines) + } + for i := range want { + if lines[i] != want[i] { + t.Fatalf("第 %d 行 = %q want %q", i, lines[i], want[i]) + } + } +} + +// TestLogStoreCleanupDropsExpired 保留期外的文件必须清掉(否则磁盘只增不减)。 +func TestLogStoreCleanupDropsExpired(t *testing.T) { + dir := t.TempDir() + oldDay := cst.Now().AddDate(0, 0, -30).Format("2006-01-02") + oldPath := filepath.Join(dir, "panel-"+oldDay+".jsonl") + if err := os.WriteFile(oldPath, []byte("{}\n"), 0o600); err != nil { + t.Fatal(err) + } + keepDay := cst.Now().Format("2006-01-02") + keepPath := filepath.Join(dir, "panel-"+keepDay+".jsonl") + if err := os.WriteFile(keepPath, []byte("{}\n"), 0o600); err != nil { + t.Fatal(err) + } + s := NewLogStore(dir, 7, 0) + if s == nil { + t.Fatal("NewLogStore 返回 nil") + } + defer s.Close() + if _, err := os.Stat(oldPath); !os.IsNotExist(err) { + t.Fatalf("30 天前的文件应被清理: %v", err) + } + if _, err := os.Stat(keepPath); err != nil { + t.Fatalf("当天文件不该被清理: %v", err) + } +} + +// TestRingBackfillsFromLogStore 挂上 store 后,重启的环必须能看到旧行。 +// +// 这是「重启后还能查昨天」的端到端断言:只测 LogStore 自己的 Backfill 不够, +// 真正决定面板有没有内容的是一环接不接得上。 +func TestRingBackfillsFromLogStore(t *testing.T) { + dir := t.TempDir() + store := NewLogStore(dir, 7, 0) + store.Append(LogEntry{TS: cst.Now().Add(-time.Hour), Ch: ChChat, Text: "| #1 | old row"}) + store.Close() + + // 模拟重启:新 store + 新环,只靠落盘文件回填。 + store2 := NewLogStore(dir, 7, 0) + defer store2.Close() + r := NewRing(10) + if err := r.SetLogStore(store2); err != nil { + t.Fatalf("SetLogStore: %v", err) + } + snap := r.Snapshot() + if len(snap) != 1 || snap[0].Text != "| #1 | old row" { + t.Fatalf("回填后的环 = %+v want 一条旧 chat 行", snap) + } + // 新写入必须照常入环 + 落盘(回填不能把写路径挂掉)。 + r.Write([]byte("2026-11-09 10:00:00 fresh line\n")) + store2.Flush() + if got := r.Snapshot(); len(got) != 2 { + t.Fatalf("新写入后环条数 = %d want 2", len(got)) + } + // 落盘文件里必须出现刚才那行(回填的旧行同一天也在同一个文件里,故按内容找)。 + found := false + for _, entry := range readLogFile(filepath.Join(dir, "panel-"+cst.Now().Format("2006-01-02")+".jsonl")) { + // Ring.Write 只剥 log 包形态的时间戳(斜杠分隔),所以按包含判定。 + if strings.Contains(entry.Text, "fresh line") { + found = true + } + } + if !found { + t.Fatal("新写入未落盘(回填不能把写路径挂掉)") + } +} diff --git a/internal/panel/model_effort.go b/internal/panel/model_effort.go new file mode 100644 index 0000000000000000000000000000000000000000..71dd4bca7fb4f2050f2e3f17b10bd8ae75df0fe7 --- /dev/null +++ b/internal/panel/model_effort.go @@ -0,0 +1,107 @@ +// model_effort.go 模型能力页的行内「网关档位」下拉:把单个模型的网关目标思考档位 +// 写进 config thinking.model_defaults(键 "cn:模型名" / "global:模型名"),经 main +// 注入的 SaveConfig 走 normalizeThinking 校验 + 落盘 + 热生效(livecfg 快照与 +// upstream.Client 的 EffortPolicy 同批更新,下一次出站请求即按新档位注入)。 +// +// 只提交 thinking.model_defaults 一个键:main.saveConfig 对嵌套对象做深合并, +// thinking 的兄弟键(enabled / default_effort / client_priority / override_scope) +// 保持用户原样。档位只增改不删;值可以是具体档位或 off(该模型固定关闭思考)。 +package panel + +import ( + "encoding/json" + "fmt" + "net/http" + "strings" + + "github.com/misakano7545/workbuddy2api-panel/internal/upstream" +) + +// setModelEffort 设置单个模型的网关目标思考档位。 +// +// 请求:POST /panel/api/model_effort {"id":"cn:glm-5.2","effort":"high"} +// id 必须带域前缀(面板展示 id 即调用值);effort 取 max/minimal/low/medium/high/ +// xhigh/off。off 表示该模型网关侧固定关闭思考(面板只给 canDisableThinking 的 +// 模型列出该选项;scope=level 下客户端显式档位仍优先,见 ensureEffortPolicy)。 +func (p *Panel) setModelEffort(w http.ResponseWriter, r *http.Request) { + if p.cfg.LoadConfig == nil || p.cfg.SaveConfig == nil { + writeErr(w, http.StatusNotImplemented, "config api not available") + return + } + var req struct { + ID string `json:"id"` + Effort string `json:"effort"` + } + if err := json.NewDecoder(http.MaxBytesReader(w, r.Body, 1<<16)).Decode(&req); err != nil { + writeErr(w, http.StatusBadRequest, "parse body: "+err.Error()) + return + } + id := strings.TrimSpace(req.ID) + realm, bare, ok := strings.Cut(id, ":") + if !ok || bare == "" || (realm != "cn" && realm != "global") { + writeErr(w, http.StatusBadRequest, "id 需为 cn:模型名 或 global:模型名") + return + } + effort := strings.ToLower(strings.TrimSpace(req.Effort)) + if effort == "" { + writeErr(w, http.StatusBadRequest, "effort 不能为空(默认取模型支持的最高档;off = 关闭该模型思考)") + return + } + if !upstream.IsEffortLevel(effort) { + writeErr(w, http.StatusBadRequest, fmt.Sprintf("effort %q 不是合法档位(max/xhigh/high/medium/low/minimal/off)", req.Effort)) + return + } + + cfgAny, err := p.cfg.LoadConfig() + if err != nil { + writeErr(w, http.StatusInternalServerError, "load config: "+err.Error()) + return + } + raw, err := json.Marshal(cfgAny) + if err != nil { + writeErr(w, http.StatusInternalServerError, "marshal config: "+err.Error()) + return + } + var root map[string]any + if err := json.Unmarshal(raw, &root); err != nil { + writeErr(w, http.StatusInternalServerError, "decode config: "+err.Error()) + return + } + + // 保留既有条目(裸名两域共用、别的域的精确键、已删除模型的残留键都原样带上), + // 只覆盖当前模型的键;键统一小写,与 EffortPolicy.DefaultEffortFor 的查找口径一致。 + entries := effortDefaults(root) + entries[realm+":"+strings.ToLower(bare)] = effort + body, err := json.Marshal(map[string]any{"thinking": map[string]any{"model_defaults": entries}}) + if err != nil { + writeErr(w, http.StatusInternalServerError, "marshal config: "+err.Error()) + return + } + if _, err := p.cfg.SaveConfig(body); err != nil { + writeErr(w, http.StatusBadRequest, err.Error()) + return + } + writeJSON(w, http.StatusOK, map[string]any{ + "ok": true, + "id": id, + "effort": effort, + "entries": len(entries), + }) +} + +// effortDefaults 取 config.thinking.model_defaults 现值(保留用户原有键写法与顺序 +// 无关);非字符串条目忽略,避免把脏数据再喂回校验。 +func effortDefaults(root map[string]any) map[string]string { + out := map[string]string{} + thinking, _ := root["thinking"].(map[string]any) + if thinking == nil { + return out + } + m, _ := thinking["model_defaults"].(map[string]any) + for k, v := range m { + if s, ok := v.(string); ok && strings.TrimSpace(s) != "" { + out[k] = s + } + } + return out +} diff --git a/internal/panel/model_effort_frontend_test.go b/internal/panel/model_effort_frontend_test.go new file mode 100644 index 0000000000000000000000000000000000000000..f0694beec58af450e32c293aa3fb0af594922f92 --- /dev/null +++ b/internal/panel/model_effort_frontend_test.go @@ -0,0 +1,68 @@ +package panel + +import ( + "os" + "os/exec" + "strings" + "testing" +) + +// TestAppJSGatewayEffortCell 模型行内「网关档位」下拉的形状: +// 选项原样取该模型 supported_efforts(可关思考的模型再补 off),不做「最高档(x)」 +// 之类的合成文案;默认选中支持的最高档(= 缺省 default_effort=max 的语义); +// 显示当前实际生效档;策略关闭时置灰;上游固定档(没有 supported_efforts)也给一个 +// 单选项表示网关跟随该档(不可调);出图与完全没有档位声明的模型不渲染下拉。 +func TestAppJSGatewayEffortCell(t *testing.T) { + node, err := exec.LookPath("node") + if err != nil { + t.Skip("node not installed; gateway effort cell test skipped") + } + script := `const fs = require('fs'); +const vm = require('vm'); +const src = fs.readFileSync(process.argv[2], 'utf8'); +const start = src.indexOf('function mdRowHtml'); +const end = src.indexOf('function renderModels'); +if (start < 0 || end < 0) throw new Error('mdRowHtml region not found'); +const ctx = { + esc: s => String(s), + rateCell: () => 'RATE', + outCell: () => 'OUT', + mdAvailabilityTag: () => '', + BUSY_WORDS: { busy: '繁忙', congested: '拥堵', unavailable: '不可用' }, +}; +vm.createContext(ctx); +vm.runInContext("'use strict';\n" + src.slice(start, end) + '\nthis.mdRowHtml=mdRowHtml;', ctx); +const base = { id: 'cn:glm-5.2', name: 'GLM', supported_efforts: ['xhigh', 'high', 'medium'], default_effort: 'high', can_disable_thinking: true, supports_reasoning: true, context_length: 200000 }; +const html = m => ctx.mdRowHtml(Object.assign({}, base, m), null); +const sel = html({ gateway_effort: 'xhigh', gateway_policy_enabled: true }); +const offSel = html({ gateway_effort: 'off', gateway_policy_enabled: true }); +const fixed = html({ supported_efforts: [], default_effort: 'medium', can_disable_thinking: false }); +process.stdout.write(JSON.stringify({ + hasSelect: sel.includes('data-effort-id="cn:glm-5.2"'), + topOption: sel.includes(''), + offOption: sel.includes(''), + offSelected: offSel.includes(''), + tiers: (sel.match(/') && fixed.includes('disabled'), + noImage: html({ image_generation: true }).includes('data-effort-id'), + noTier: html({ supported_efforts: [], supports_reasoning: true, default_effort: '' }).includes('data-effort-id'), +}));` + f, err := os.CreateTemp(t.TempDir(), "gateway-effort-*.cjs") + if err != nil { + t.Fatal(err) + } + if _, err := f.WriteString(script); err != nil { + t.Fatal(err) + } + f.Close() + out, err := exec.Command(node, f.Name(), "app.js").CombinedOutput() + if err != nil { + t.Fatalf("gateway effort node test failed: %v\n%s", err, out) + } + const want = `{"hasSelect":true,"topOption":true,"offOption":true,"offSelected":true,"tiers":4,"noSynthetic":true,"disabled":true,"fixedCell":true,"noImage":false,"noTier":false}` + if strings.TrimSpace(string(out)) != want { + t.Fatalf("gateway effort=%s want %s", strings.TrimSpace(string(out)), want) + } +} diff --git a/internal/panel/model_effort_test.go b/internal/panel/model_effort_test.go new file mode 100644 index 0000000000000000000000000000000000000000..44e40ed0b0bff18809a73d5991c786feb8ee5024 --- /dev/null +++ b/internal/panel/model_effort_test.go @@ -0,0 +1,112 @@ +package panel + +import ( + "encoding/json" + "net/http/httptest" + "strings" + "testing" +) + +// TestSetModelEffortWritesDomainKey 行内「网关档位」写 thinking.model_defaults 的 +// 「域:模型」精确键:既有裸名覆盖(两域共用)与别的域条目必须原样保留,模型名统一小写。 +func TestSetModelEffortWritesDomainKey(t *testing.T) { + var saved map[string]any + pn := New(Config{ + Version: "test", APIKey: "k", + LoadConfig: func() (any, error) { + return map[string]any{ + "thinking": map[string]any{ + "client_priority": true, + "model_defaults": map[string]any{ + "glm-5.2": "high", + "global:deepseek-v4": "xhigh", + }, + }, + }, nil + }, + SaveConfig: func(raw []byte) ([]string, error) { + if err := json.Unmarshal(raw, &saved); err != nil { + t.Fatalf("saved body is not JSON: %v (%s)", err, raw) + } + return nil, nil + }, + }) + rec := httptest.NewRecorder() + req := httptest.NewRequest("POST", "/panel/api/model_effort", + strings.NewReader(`{"id":"cn:GLM-5.2","effort":"Max"}`)) + pn.setModelEffort(rec, req) + if rec.Code != 200 { + t.Fatalf("code=%d body=%s", rec.Code, rec.Body.String()) + } + thinking, _ := saved["thinking"].(map[string]any) + got, _ := thinking["model_defaults"].(map[string]any) + if got["cn:glm-5.2"] != "max" { + t.Errorf("精确键应小写写入 max:%v", got) + } + if got["glm-5.2"] != "high" || got["global:deepseek-v4"] != "xhigh" { + t.Errorf("既有条目被改写:%v", got) + } + if _, ok := saved["models"]; ok { + t.Errorf("不应顺带提交其它配置节:%v", saved) + } +} + +// TestSetModelEffortAcceptsOff off 是面板下拉里与 supportedEfforts 同列的选项: +// 表示该模型网关侧固定关闭思考,允许写入(是否生效由 scope 与客户端意图决定)。 +func TestSetModelEffortAcceptsOff(t *testing.T) { + var saved map[string]any + pn := New(Config{ + Version: "test", APIKey: "k", + LoadConfig: func() (any, error) { + return map[string]any{"thinking": map[string]any{"model_defaults": map[string]any{"cn:glm-5.2": "high"}}}, nil + }, + SaveConfig: func(raw []byte) ([]string, error) { + if err := json.Unmarshal(raw, &saved); err != nil { + t.Fatalf("saved body is not JSON: %v (%s)", err, raw) + } + return nil, nil + }, + }) + rec := httptest.NewRecorder() + req := httptest.NewRequest("POST", "/panel/api/model_effort", + strings.NewReader(`{"id":"cn:glm-5.2","effort":"off"}`)) + pn.setModelEffort(rec, req) + if rec.Code != 200 { + t.Fatalf("code=%d body=%s", rec.Code, rec.Body.String()) + } + thinking, _ := saved["thinking"].(map[string]any) + got, _ := thinking["model_defaults"].(map[string]any) + if got["cn:glm-5.2"] != "off" { + t.Errorf("off 应原样写入:%v", got) + } +} + +// TestSetModelEffortRejectsInvalid 非法输入一律 400 且不落盘:id 必须带域前缀, +// effort 只能是合法档位或 off。 +func TestSetModelEffortRejectsInvalid(t *testing.T) { + cases := []struct{ name, body string }{ + {"无域前缀", `{"id":"glm-5.2","effort":"max"}`}, + {"未知域", `{"id":"eu:glm-5.2","effort":"max"}`}, + {"空模型名", `{"id":"cn:","effort":"max"}`}, + {"乱填档位", `{"id":"cn:glm-5.2","effort":"ultra"}`}, + {"空档位", `{"id":"cn:glm-5.2","effort":""}`}, + } + for _, c := range cases { + t.Run(c.name, func(t *testing.T) { + saved := false + pn := New(Config{ + Version: "test", APIKey: "k", + LoadConfig: func() (any, error) { return map[string]any{}, nil }, + SaveConfig: func([]byte) ([]string, error) { saved = true; return nil, nil }, + }) + rec := httptest.NewRecorder() + pn.setModelEffort(rec, httptest.NewRequest("POST", "/panel/api/model_effort", strings.NewReader(c.body))) + if rec.Code != 400 { + t.Errorf("code=%d want 400 body=%s", rec.Code, rec.Body.String()) + } + if saved { + t.Error("非法输入不应触发保存") + } + }) + } +} diff --git a/internal/panel/model_hidden.go b/internal/panel/model_hidden.go new file mode 100644 index 0000000000000000000000000000000000000000..493a46b4fe3c2a1348197a3a0488cfb912405de3 --- /dev/null +++ b/internal/panel/model_hidden.go @@ -0,0 +1,99 @@ +// model_hidden.go 模型能力页的行内「下游可见」开关:把单个模型增删进 +// config models.hidden,并经 main 注入的 SaveConfig 走校验+落盘+热生效 +// (livecfg 快照重建,下一次 /v1/models 与点名调用立即按新状态执行)。 +// +// 只提交 models.hidden 一个键:main.saveConfig 对嵌套对象做深合并,models.allowed / +// models.aliases 等兄弟键保持用户原样。 +package panel + +import ( + "encoding/json" + "net/http" + "strings" +) + +// setModelHidden 切换单个模型的「下游可见」状态。 +// +// 请求:POST /panel/api/model_hidden {"id":"cn:glm-5.2","hidden":true} +// id 必须带域前缀(面板展示 id 即调用值);hidden=true 进黑名单,false 移出。 +func (p *Panel) setModelHidden(w http.ResponseWriter, r *http.Request) { + if p.cfg.LoadConfig == nil || p.cfg.SaveConfig == nil { + writeErr(w, http.StatusNotImplemented, "config api not available") + return + } + var req struct { + ID string `json:"id"` + Hidden bool `json:"hidden"` + } + if err := json.NewDecoder(http.MaxBytesReader(w, r.Body, 1<<16)).Decode(&req); err != nil { + writeErr(w, http.StatusBadRequest, "parse body: "+err.Error()) + return + } + id := strings.TrimSpace(req.ID) + realm, bare, ok := strings.Cut(id, ":") + if !ok || bare == "" || (realm != "cn" && realm != "global") { + writeErr(w, http.StatusBadRequest, "id 需为 cn:模型名 或 global:模型名") + return + } + + cfgAny, err := p.cfg.LoadConfig() + if err != nil { + writeErr(w, http.StatusInternalServerError, "load config: "+err.Error()) + return + } + raw, err := json.Marshal(cfgAny) + if err != nil { + writeErr(w, http.StatusInternalServerError, "marshal config: "+err.Error()) + return + } + var root map[string]any + if err := json.Unmarshal(raw, &root); err != nil { + writeErr(w, http.StatusInternalServerError, "decode config: "+err.Error()) + return + } + + // 幂等增删:已存在时先剔除再按请求追加,避免重复条目(hiddenModel 按集合判定, + // 但配置里出现重复会让人看不懂面板的黑名单输入框)。 + out := make([]string, 0, len(hiddenList(root))+1) + for _, it := range hiddenList(root) { + if strings.EqualFold(it, id) { + continue + } + out = append(out, it) + } + if req.Hidden { + out = append(out, id) + } + body, err := json.Marshal(map[string]any{"models": map[string]any{"hidden": out}}) + if err != nil { + writeErr(w, http.StatusInternalServerError, "marshal config: "+err.Error()) + return + } + if _, err := p.cfg.SaveConfig(body); err != nil { + writeErr(w, http.StatusBadRequest, err.Error()) + return + } + writeJSON(w, http.StatusOK, map[string]any{ + "ok": true, + "id": id, + "hidden": req.Hidden, + "entries": len(out), + }) +} + +// hiddenList 取 config.models.hidden,保留用户原有顺序与条目写法 +// (裸名 = 两域同时生效,cn:/global: 只该域);非字符串条目忽略。 +func hiddenList(root map[string]any) []string { + models, _ := root["models"].(map[string]any) + if models == nil { + return nil + } + items, _ := models["hidden"].([]any) + out := make([]string, 0, len(items)) + for _, it := range items { + if s, ok := it.(string); ok && strings.TrimSpace(s) != "" { + out = append(out, strings.TrimSpace(s)) + } + } + return out +} diff --git a/internal/panel/model_probes_test.go b/internal/panel/model_probes_test.go index ead3be6cf4d700f820a9218706a6697fe9e92336..8576f4b2788d643f2b1bf1a256390989d23db5c0 100644 --- a/internal/panel/model_probes_test.go +++ b/internal/panel/model_probes_test.go @@ -1,92 +1,92 @@ -package panel - -import ( - "encoding/json" - "net/http" - "net/http/httptest" - "os" - "path/filepath" - "testing" -) - -// model_probes 端点三态:文件存在 → 透传 + exists:true + updated_at; -// 未配置 / 文件缺失 → 空集(面板退化为无标注);文件损坏 → 502。 -// 契约字段(claimed/measured/verdict…)由前端消费,网关只透传不解析。 -func TestModelProbesEndpoint(t *testing.T) { - dir := t.TempDir() - f := filepath.Join(dir, "output_probes.json") - body := `{"version":1,"probes":{"cn:glm-5.2":{"claimed":131072,"measured":48000,` + - `"verdict":"clamped","note":"钳制","tested_at":"2026-09-15 18:30:00","source":"probe_max_tokens.py"}}}` - if err := os.WriteFile(f, []byte(body), 0o600); err != nil { - t.Fatal(err) - } - - get := func(cfg Config) *httptest.ResponseRecorder { - p := New(cfg) - req := httptest.NewRequest("GET", "/panel/api/model_probes", nil) - req.Header.Set("Authorization", "Bearer test-key") - rec := httptest.NewRecorder() - p.ServeHTTP(rec, req) - return rec - } - - // 1) 文件存在:透传 + exists + updated_at - rec := get(Config{Version: "test", APIKey: "test-key", ProbeFile: f}) - if rec.Code != http.StatusOK { - t.Fatalf("code=%d body=%s", rec.Code, rec.Body.String()) - } - var got struct { - Probes map[string]json.RawMessage `json:"probes"` - Exists bool `json:"exists"` - UpdatedAt string `json:"updated_at"` - } - if err := json.Unmarshal(rec.Body.Bytes(), &got); err != nil { - t.Fatal(err) - } - if !got.Exists || len(got.Probes) != 1 || got.UpdatedAt == "" { - t.Fatalf("exists=%v probes=%d updated_at=%q", got.Exists, len(got.Probes), got.UpdatedAt) - } - var rec1 struct { - Verdict string `json:"verdict"` - Measured int64 `json:"measured"` - } - if err := json.Unmarshal(got.Probes["cn:glm-5.2"], &rec1); err != nil { - t.Fatal(err) - } - if rec1.Verdict != "clamped" || rec1.Measured != 48000 { - t.Fatalf("probe passthrough = %+v", rec1) - } - - // 2) 文件缺失:空集 200(不是错误——无数据 = 无标注)。 - // 注意每个 case 用全新结构体:向已非 nil 的 map 再次 Unmarshal 是合并不是替换。 - rec = get(Config{Version: "test", APIKey: "test-key", ProbeFile: filepath.Join(dir, "nope.json")}) - if rec.Code != http.StatusOK { - t.Fatalf("missing file: code=%d want 200", rec.Code) - } - var gotEmpty struct { - Probes map[string]json.RawMessage `json:"probes"` - Exists bool `json:"exists"` - } - if err := json.Unmarshal(rec.Body.Bytes(), &gotEmpty); err != nil { - t.Fatal(err) - } - if gotEmpty.Exists || len(gotEmpty.Probes) != 0 { - t.Fatalf("missing file: exists=%v probes=%d, want false/0", gotEmpty.Exists, len(gotEmpty.Probes)) - } - - // 3) 未配置:同文件缺失 - rec = get(Config{Version: "test", APIKey: "test-key"}) - if rec.Code != http.StatusOK { - t.Fatalf("unconfigured: code=%d want 200", rec.Code) - } - - // 4) 文件损坏:502(让面板显示读取失败而不是静默空白) - bad := filepath.Join(dir, "bad.json") - if err := os.WriteFile(bad, []byte(`{not json`), 0o600); err != nil { - t.Fatal(err) - } - rec = get(Config{Version: "test", APIKey: "test-key", ProbeFile: bad}) - if rec.Code != http.StatusBadGateway { - t.Fatalf("corrupt file: code=%d want 502", rec.Code) - } -} +package panel + +import ( + "encoding/json" + "net/http" + "net/http/httptest" + "os" + "path/filepath" + "testing" +) + +// model_probes 端点三态:文件存在 → 透传 + exists:true + updated_at; +// 未配置 / 文件缺失 → 空集(面板退化为无标注);文件损坏 → 502。 +// 契约字段(claimed/measured/verdict…)由前端消费,网关只透传不解析。 +func TestModelProbesEndpoint(t *testing.T) { + dir := t.TempDir() + f := filepath.Join(dir, "output_probes.json") + body := `{"version":1,"probes":{"cn:glm-5.2":{"claimed":131072,"measured":48000,` + + `"verdict":"clamped","note":"钳制","tested_at":"2026-09-15 18:30:00","source":"probe_max_tokens.py"}}}` + if err := os.WriteFile(f, []byte(body), 0o600); err != nil { + t.Fatal(err) + } + + get := func(cfg Config) *httptest.ResponseRecorder { + p := New(cfg) + req := httptest.NewRequest("GET", "/panel/api/model_probes", nil) + req.Header.Set("Authorization", "Bearer test-key") + rec := httptest.NewRecorder() + p.ServeHTTP(rec, req) + return rec + } + + // 1) 文件存在:透传 + exists + updated_at + rec := get(Config{Version: "test", APIKey: "test-key", ProbeFile: f}) + if rec.Code != http.StatusOK { + t.Fatalf("code=%d body=%s", rec.Code, rec.Body.String()) + } + var got struct { + Probes map[string]json.RawMessage `json:"probes"` + Exists bool `json:"exists"` + UpdatedAt string `json:"updated_at"` + } + if err := json.Unmarshal(rec.Body.Bytes(), &got); err != nil { + t.Fatal(err) + } + if !got.Exists || len(got.Probes) != 1 || got.UpdatedAt == "" { + t.Fatalf("exists=%v probes=%d updated_at=%q", got.Exists, len(got.Probes), got.UpdatedAt) + } + var rec1 struct { + Verdict string `json:"verdict"` + Measured int64 `json:"measured"` + } + if err := json.Unmarshal(got.Probes["cn:glm-5.2"], &rec1); err != nil { + t.Fatal(err) + } + if rec1.Verdict != "clamped" || rec1.Measured != 48000 { + t.Fatalf("probe passthrough = %+v", rec1) + } + + // 2) 文件缺失:空集 200(不是错误——无数据 = 无标注)。 + // 注意每个 case 用全新结构体:向已非 nil 的 map 再次 Unmarshal 是合并不是替换。 + rec = get(Config{Version: "test", APIKey: "test-key", ProbeFile: filepath.Join(dir, "nope.json")}) + if rec.Code != http.StatusOK { + t.Fatalf("missing file: code=%d want 200", rec.Code) + } + var gotEmpty struct { + Probes map[string]json.RawMessage `json:"probes"` + Exists bool `json:"exists"` + } + if err := json.Unmarshal(rec.Body.Bytes(), &gotEmpty); err != nil { + t.Fatal(err) + } + if gotEmpty.Exists || len(gotEmpty.Probes) != 0 { + t.Fatalf("missing file: exists=%v probes=%d, want false/0", gotEmpty.Exists, len(gotEmpty.Probes)) + } + + // 3) 未配置:同文件缺失 + rec = get(Config{Version: "test", APIKey: "test-key"}) + if rec.Code != http.StatusOK { + t.Fatalf("unconfigured: code=%d want 200", rec.Code) + } + + // 4) 文件损坏:502(让面板显示读取失败而不是静默空白) + bad := filepath.Join(dir, "bad.json") + if err := os.WriteFile(bad, []byte(`{not json`), 0o600); err != nil { + t.Fatal(err) + } + rec = get(Config{Version: "test", APIKey: "test-key", ProbeFile: bad}) + if rec.Code != http.StatusBadGateway { + t.Fatalf("corrupt file: code=%d want 502", rec.Code) + } +} diff --git a/internal/panel/models_busy_cache_test.go b/internal/panel/models_busy_cache_test.go new file mode 100644 index 0000000000000000000000000000000000000000..28cc36781261717753b0bcb01e8fb81b226cc9d8 --- /dev/null +++ b/internal/panel/models_busy_cache_test.go @@ -0,0 +1,102 @@ +package panel + +import ( + "encoding/json" + "io" + "net/http" + "net/http/httptest" + "strings" + "testing" + + "github.com/misakano7545/workbuddy2api-panel/internal/auth" + "github.com/misakano7545/workbuddy2api-panel/internal/pool" + "github.com/misakano7545/workbuddy2api-panel/internal/upstream" +) + +// TestPanelModelsBusyFailureDoesNotBlockCache 国际版池(global realm)下, +// /v2/chat/busy 恒 404(2026-10-29 真机实测)。 +// +// 回归目标:繁忙度是纯观测数据,它的失败**不得**阻断模型目录缓存。此前 busy 失败 +// 与目录失败共用同一份错误切片,于是「只要池里有 global 账号」→ 错误切片恒非空 +// → 缓存永远写不进去 → 面板每次刷新都实打上游(1h TTL 形同虚设)。 +// +// 断言:首轮 200 且给出 busy_errs(失败可见,不静默);第二轮命中缓存(cached=true, +// 上游 v3/config 不再被请求)。 +func TestPanelModelsBusyFailureDoesNotBlockCache(t *testing.T) { + prev := auth.GlobalEnabled() + auth.SetGlobalEnabled(true) + defer auth.SetGlobalEnabled(prev) + + var cfgHits, busyHits int + up := &upstream.Client{ + HTTP: &http.Client{Transport: fakeRoundTripper(func(r *http.Request) (*http.Response, error) { + status := 200 + var body string + switch { + case strings.HasSuffix(r.URL.Path, "/v2/chat/busy"): + busyHits++ + status = http.StatusNotFound + body = `{"error_msg":"404 Route Not Found"}` + case strings.HasSuffix(r.URL.Path, "/v3/config"): + cfgHits++ + body = `{"code":0,"data":{"models":[` + + `{"id":"fast-model","name":"Fast","maxInputTokens":200000,"maxOutputTokens":32000},` + + `{"id":"gpt-6-astra","name":"GPT-6-Astra","maxInputTokens":1000000,"maxOutputTokens":128000,` + + `"contextWindow":{"defaultLength":400000,"supportedLengths":[400000,1000000]}}]}}` + default: + // 企业端点家族:本用例不关心,失败可容忍(v3 成功即够)。 + status = http.StatusInternalServerError + } + return &http.Response{StatusCode: status, + Header: http.Header{"Content-Type": []string{"application/json"}}, + Body: io.NopCloser(strings.NewReader(body))}, nil + })}, + ChatBaseGlobal: "https://www.workbuddy.ai", + BillingBaseGlobal: "https://www.workbuddy.ai", + GlobalEnabled: true, + } + p := pool.New("") + p.Add(&auth.Auth{UID: "g1", AccessToken: "at", ExpiresAt: 9999999999, Domain: "www.workbuddy.ai"}) + p.SetCredits("g1", 1000, 0) + + pn := New(Config{Version: "test", APIKey: "k", Pool: p, Upstream: up}) + + call := func() (int, map[string]any) { + rec := httptest.NewRecorder() + req := httptest.NewRequest("GET", "/panel/api/models", nil) + req.Header.Set("Authorization", "Bearer k") + pn.ServeHTTP(rec, req) + var resp map[string]any + _ = json.Unmarshal(rec.Body.Bytes(), &resp) + return rec.Code, resp + } + + code, first := call() + if code != 200 { + t.Fatalf("首轮 code=%d(繁忙度失败不该让目录视图失败)", code) + } + models, _ := first["models"].([]any) + if len(models) == 0 { + t.Fatalf("首轮没有模型: %v", first) + } + if _, ok := first["busy_errs"]; !ok { + t.Errorf("繁忙度失败应在 busy_errs 里可见(不静默): %v", first) + } + if cfgHits == 0 { + t.Fatal("首轮应真探过 /v3/config") + } + cfgAfterFirst := cfgHits + + // 第二轮:目录缓存必须已写入(此前的实现因为 busy 404 恒非空而永不写缓存)。 + code, second := call() + if code != 200 { + t.Fatalf("第二轮 code=%d", code) + } + if cached, _ := second["cached"].(bool); !cached { + t.Fatalf("繁忙度失败后目录仍应进缓存,实际 cached=%v(cfgHits=%d busyHits=%d)", + second["cached"], cfgHits, busyHits) + } + if cfgHits != cfgAfterFirst { + t.Fatalf("命中缓存后不应再探 /v3/config,首轮 %d → 现在 %d", cfgAfterFirst, cfgHits) + } +} diff --git a/internal/panel/models_test.go b/internal/panel/models_test.go new file mode 100644 index 0000000000000000000000000000000000000000..5a208f404f1038b9be81463effbe16d4f7f5fa52 --- /dev/null +++ b/internal/panel/models_test.go @@ -0,0 +1,148 @@ +package panel + +import ( + "encoding/json" + "io" + "net/http" + "net/http/httptest" + "strings" + "testing" + + "github.com/misakano7545/workbuddy2api-panel/internal/auth" + "github.com/misakano7545/workbuddy2api-panel/internal/pool" + "github.com/misakano7545/workbuddy2api-panel/internal/upstream" +) + +// TestPanelModelsIncludesImageModels 面板「模型与档位」必须列出出图模型: +// 它们被目录按 tag(text-to-image)从对话列表剔掉,若不单列,面板上就看不到 +// hunyuan-image-alpha / gpt-image-2.5-sunburst —— 用户不知道有哪些出图模型可调。 +func TestPanelModelsIncludesImageModels(t *testing.T) { + up := &upstream.Client{ + HTTP: &http.Client{Transport: fakeRoundTripper(func(r *http.Request) (*http.Response, error) { + body := `{"code":0,"data":{"models":[` + + `{"id":"glm-5.2","name":"GLM-5.2","maxInputTokens":200000,"maxOutputTokens":32000},` + + `{"id":"hunyuan-image-alpha","name":"Hunyuan Image Alpha","tags":["text-to-image"]},` + + `{"id":"seedance-2.5","name":"Seedance-2.5","tags":["text-to-video","image-to-video"]}],` + + `"agents":[{"name":"cli","models":["glm-5.2"]}]}}` + if strings.HasSuffix(r.URL.Path, "/v3/config") { + body = `{"code":0,"data":{"models":[` + + `{"id":"glm-5.2","name":"GLM-5.2","maxInputTokens":200000,"maxOutputTokens":32000},` + + `{"id":"hunyuan-image-alpha","name":"Hunyuan Image Alpha","tags":["text-to-image"]},` + + `{"id":"seedance-2.5","name":"Seedance-2.5","tags":["text-to-video"]}]}}` + } + return &http.Response{StatusCode: 200, + Header: http.Header{"Content-Type": []string{"application/json"}}, + Body: io.NopCloser(strings.NewReader(body))}, nil + })}, + ChatBaseCN: "https://cn.example", + BillingBaseCN: "https://cn.example", + } + p := pool.New("") + p.Add(&auth.Auth{UID: "c1", AccessToken: "at", ExpiresAt: 9999999999, Domain: "www.codebuddy.cn"}) + p.SetCredits("c1", 1000, 0) + + // 目录解析会顺手把出图模型留存在 client 上(面板 API 直接读它,不再打上游)。 + if _, err := up.FetchModels(p.AuthByUID("c1")); err != nil { + t.Fatalf("FetchModels: %v", err) + } + + pn := New(Config{Version: "test", APIKey: "k", Pool: p, Upstream: up}) + rec := httptest.NewRecorder() + req := httptest.NewRequest("GET", "/panel/api/models", nil) + req.Header.Set("Authorization", "Bearer k") + pn.ServeHTTP(rec, req) + if rec.Code != 200 { + t.Fatalf("code=%d body=%s", rec.Code, rec.Body.String()) + } + var resp struct { + Models []map[string]any `json:"models"` + } + if err := json.Unmarshal(rec.Body.Bytes(), &resp); err != nil { + t.Fatal(err) + } + var chat, image, video bool + for _, m := range resp.Models { + switch m["id"] { + case "cn:glm-5.2": + chat = true + if m["image_generation"] == true { + t.Errorf("对话模型不应带 image_generation:%v", m) + } + case "cn:seedance-2.5": + // 视频端点 2026-11 起已实现:视频模型照常列出,但要打 video_generation 而不是 image_generation。 + video = m["video_generation"] == true + if m["image_generation"] == true { + t.Errorf("视频模型不该带 image_generation:%v", m) + } + case "cn:hunyuan-image-alpha": + image = m["image_generation"] == true + if m["name"] != "Hunyuan Image Alpha" { + t.Errorf("出图模型应带名字:%v", m) + } + } + } + if !chat || !image { + t.Fatalf("面板模型列表缺项:chat=%v image=%v(%d 条)", chat, image, len(resp.Models)) + } + if !video { + t.Fatal("视频端点 2026-11 起已实现:视频模型应出现在面板模型列表并带 video_generation") + } +} + +// fakeRoundTripper 测试用 http.RoundTripper(本包内没有现成的,server 包那个不跨包)。 +type fakeRoundTripper func(*http.Request) (*http.Response, error) + +func (f fakeRoundTripper) RoundTrip(r *http.Request) (*http.Response, error) { return f(r) } + +// TestPanelModelsAttachesBusyLevels 面板「模型与档位」附带上游繁忙度(/v2/chat/busy,只读): +// 按域问对应账号,只附到该域的行上;上游没返回的模型不填字段(不编造)。 +func TestPanelModelsAttachesBusyLevels(t *testing.T) { + up := &upstream.Client{ + HTTP: &http.Client{Transport: fakeRoundTripper(func(r *http.Request) (*http.Response, error) { + body := `{"code":0,"data":{"models":[{"id":"glm-5.2","name":"GLM-5.2"}]}}` + switch { + case strings.HasSuffix(r.URL.Path, "/v2/chat/busy"): + body = `{"code":0,"msg":"OK","data":[{"model":"glm-5.2","busy_level":"congested"}]}` + case strings.HasSuffix(r.URL.Path, "/v3/config"): + body = `{"code":0,"data":{"models":[{"id":"glm-5.2","name":"GLM-5.2"},` + + `{"id":"glm-5.3-flash","name":"GLM-5.3 Flash"}]}}` + } + return &http.Response{StatusCode: 200, + Header: http.Header{"Content-Type": []string{"application/json"}}, + Body: io.NopCloser(strings.NewReader(body))}, nil + })}, + ChatBaseCN: "https://cn.example", + BillingBaseCN: "https://cn.example", + } + p := pool.New("") + p.Add(&auth.Auth{UID: "c1", AccessToken: "at", ExpiresAt: 9999999999, Domain: "www.codebuddy.cn"}) + p.SetCredits("c1", 1000, 0) + up.FetchModels(p.AuthByUID("c1")) + + pn := New(Config{Version: "test", APIKey: "k", Pool: p, Upstream: up}) + rec := httptest.NewRecorder() + req := httptest.NewRequest("GET", "/panel/api/models", nil) + req.Header.Set("Authorization", "Bearer k") + pn.ServeHTTP(rec, req) + if rec.Code != 200 { + t.Fatalf("code=%d body=%s", rec.Code, rec.Body.String()) + } + var resp struct { + Models []map[string]any `json:"models"` + } + if err := json.Unmarshal(rec.Body.Bytes(), &resp); err != nil { + t.Fatal(err) + } + seen := map[string]string{} + for _, m := range resp.Models { + if v, ok := m["busy"]; ok { + seen[m["id"].(string)] = v.(string) + } + } + if seen["cn:glm-5.2"] != "congested" { + t.Fatalf("cn:glm-5.2 繁忙度未附上: %v(全部 entry=%v)", seen, resp.Models) + } + if _, ok := seen["cn:glm-5.3-flash"]; ok { + t.Fatalf("上游未返回的模型不该凭空有繁忙度: %v", seen) + } +} diff --git a/internal/panel/overview_expiry_test.go b/internal/panel/overview_expiry_test.go new file mode 100644 index 0000000000000000000000000000000000000000..8dc1f950ee2fa2096feb8774489bfb1b88c24abc --- /dev/null +++ b/internal/panel/overview_expiry_test.go @@ -0,0 +1,55 @@ +package panel + +import ( + "encoding/json" + "net/http" + "net/http/httptest" + "testing" + "time" + + "github.com/misakano7545/workbuddy2api-panel/internal/auth" + "github.com/misakano7545/workbuddy2api-panel/internal/pool" +) + +// TestOverviewIncludesExpiryBuckets 首页快照的数据源接线:overview 必须把池内按日 +// 到期批次原样透出,并给出余额后台刷新的节奏/年龄(没有调度器时为 0)。 +// 前端 renderExpirySnapshot 只吃这两个字段,缺一个就会退回「只列最早一批」的旧口径。 +func TestOverviewIncludesExpiryBuckets(t *testing.T) { + p := pool.New("") + p.Add(&auth.Auth{UID: "u1", Nickname: "A", AccessToken: "at"}) + at := time.Now().Add(72 * time.Hour) + p.SetCreditsSnapshot("u1", pool.CreditsSnapshot{ + Remain: 100, Total: 100, + ExpiryBuckets: []pool.ExpiryBucket{ + {Date: at.Format("2006-01-02"), ExpireAt: at, Remain: 40}, + }, + }) + pn := New(Config{Version: "test", Pool: p}) + + rec := httptest.NewRecorder() + pn.ServeHTTP(rec, httptest.NewRequest(http.MethodGet, "/panel/api/overview", nil)) + if rec.Code != http.StatusOK { + t.Fatalf("overview code=%d body=%s", rec.Code, rec.Body) + } + var d struct { + BalanceRefreshSec int `json:"balance_refresh_sec"` + BalanceRefreshedAt time.Time `json:"balance_refreshed_at"` + Accounts []struct { + UID string `json:"uid"` + CreditsExpiryBuckets []pool.ExpiryBucket `json:"credits_expiry_buckets"` + } `json:"accounts"` + } + if err := json.Unmarshal(rec.Body.Bytes(), &d); err != nil { + t.Fatal(err) + } + if len(d.Accounts) != 1 || len(d.Accounts[0].CreditsExpiryBuckets) != 1 { + t.Fatalf("overview 未透出 buckets: %s", rec.Body) + } + b := d.Accounts[0].CreditsExpiryBuckets[0] + if b.Date != at.Format("2006-01-02") || b.Remain != 40 { + t.Fatalf("bucket=%+v want %s/40", b, at.Format("2006-01-02")) + } + if d.BalanceRefreshSec != 0 { + t.Fatalf("无调度器时 balance_refresh_sec=%d want 0", d.BalanceRefreshSec) + } +} diff --git a/internal/panel/panel.go b/internal/panel/panel.go index 9f7d7bfdb819c5eacb29e9534ba6f744e18b6fa2..0b8469e29868cd490365fe33c7351ea9b64f55a0 100644 --- a/internal/panel/panel.go +++ b/internal/panel/panel.go @@ -1,845 +1,1886 @@ -// Package panel 内嵌式 Web 管理面板:账号池总览、单号运维(解冻/禁用/签到/ -// 刷新余额/移除)、浏览器内 OAuth 添加账号(免重启热加载进池)、手动批量 -// 签到/保活,以及运行日志环形缓冲(镜像 log 包与 chat 表格日志)。 -// -// 设计约束: -// - 前端 go:embed 单文件(index.html),无任何外部构建依赖,与二进制同体部署; -// - 鉴权复用网关 api_key(Bearer),与 /v1/* 同一口径;api_key 为空 = 不鉴权 -// (仅本机/私网使用)。面板 HTML 本身无秘密,可匿名加载,密钥只发给 /panel/api/*; -// - 不改写既有池语义:所有运维操作落到 pool 已有入口(Revive/Disable/Remove...), -// 添加账号走 auth.SaveAtomic + pool.Add,重启后与 auths/ 目录天然对齐。 -package panel - -import ( - "encoding/json" - "log" - "net/http" - "os" - "sort" - "strconv" - "strings" - "sync" - "time" - - "github.com/linguo2625469/workbuddy2api-panel/internal/auth" - "github.com/linguo2625469/workbuddy2api-panel/internal/httpauth" - "github.com/linguo2625469/workbuddy2api-panel/internal/livecfg" - "github.com/linguo2625469/workbuddy2api-panel/internal/pool" - "github.com/linguo2625469/workbuddy2api-panel/internal/reqlog" - "github.com/linguo2625469/workbuddy2api-panel/internal/scheduler" - "github.com/linguo2625469/workbuddy2api-panel/internal/upstream" - "github.com/linguo2625469/workbuddy2api-panel/internal/usage" -) - -// Config 面板依赖(main 装配注入)。 -type Config struct { - Pool *pool.Pool - Upstream *upstream.Client - Scheduler *scheduler.Scheduler // 手动触发签到/保活;nil 时对应接口返回 501 - AuthDir string // OAuth 登录完成后凭证落盘目录 - APIKey string // 空 = 不鉴权(与主服务同语义);与 Live 同时给出时 Live 优先 - RedisMode string // "upstash" / "noop",仅观测透出 - Version string // 面板版本号(展示用) - - // Live 运行期可变配置(在线改配置立即生效)。 - Live *livecfg.Holder - - // ConfigPath config.json 路径与加载器(配置页读写用)。 - // LoadConfig 返回解析后的配置对象(前端展示/校验用,具体类型由 main 注入的闭包决定); - // nil 时配置页返回 501。 - ConfigPath string - LoadConfig func() (any, error) - // SaveConfig 校验并落盘配置,返回需要重启才能生效的字段列表;随后由 main 注入的 - // ApplyConfig 闭包完成热生效(池参数/排程/密钥/脱敏)。error 时配置不写盘。 - SaveConfig func(raw []byte) (restartRequired []string, err error) - - // StickyCount 返回粘性会话绑定数;nil 时报告 0。 - StickyCount func() int - - // Usage 逐请求用量记录器(nil = 用量接口返回 501)。 - Usage *usage.Recorder - // RequestLog 请求指标与归档(nil = 对应接口返回 501)。 - RequestLog *reqlog.Recorder - - // ProbeFile 模型输出上限探测结果文件(scripts/probe_max_tokens.py --panel-out - // 写入;空或文件不存在 = model_probes 端点返回空集,面板不显示任何实测标注)。 - // 只读展示:网关不解析、不依赖其内容做任何路由/出站决策。 - ProbeFile string -} - -// Panel 管理面板 handler。挂载方式:外层 mux Handle("/panel/", panel), -// 本 mux 的 pattern 均带 /panel 前缀(外层不做前缀剥离)。 -type Panel struct { - cfg Config - mux *http.ServeMux - started time.Time - logs *Ring - - // logins 进行中的 OAuth 设备授权会话(state → 会话信息)。 - // poll 成功或超时(loginTTL)后剔除;面板常驻进程,容量天然有界。 - loginMu sync.Mutex - logins map[string]loginSession - - // taskMu/taskLocks 一键完成任务的 per-account 互斥:同一账号的任务动作 - // (单任务 / 全量)同时只允许一条在跑。重复点击直接返回 409"仍在执行", - // 而不是并发跑两遍浪费上游请求(动作虽幂等,expert 系每遍含 8 次真实对话)。 - // 不同账号之间不互斥(并行照旧)。TryLock 语义,锁条目常驻(账号数有界)。 - taskMu sync.Mutex - taskLocks map[string]*sync.Mutex - - // 任务中心执行队列(taskcenter.go)。 - queueOnce sync.Once - q *queueState -} - -// tryLockAccount 尝试锁定账号的任务执行;已在执行返回 false。 -func (p *Panel) tryLockAccount(uid string) bool { - p.taskMu.Lock() - if p.taskLocks == nil { - p.taskLocks = make(map[string]*sync.Mutex) - } - mu := p.taskLocks[uid] - if mu == nil { - mu = &sync.Mutex{} - p.taskLocks[uid] = mu - } - p.taskMu.Unlock() - return mu.TryLock() -} - -// unlockAccount 释放账号任务锁(与 tryLockAccount 配对)。 -func (p *Panel) unlockAccount(uid string) { - p.taskMu.Lock() - mu := p.taskLocks[uid] - p.taskMu.Unlock() - if mu != nil { - mu.Unlock() - } -} - -// loginTTL 授权 URL 的最长有效期:超时的 state 直接回收, -// 防止"开了添加账号弹窗就走开"的会话永久滞留。 -const loginTTL = 15 * time.Minute - -// loginSession 进行中的 OAuth 会话:创建时刻 + realm(cn/global,用于落盘与端点切换)。 -type loginSession struct { - created time.Time - realm string // "cn" / "global",缺省 cn -} - -// New 构建面板。 -func New(cfg Config) *Panel { - if cfg.RedisMode == "" { - cfg.RedisMode = "noop" - } - p := &Panel{ - cfg: cfg, - mux: http.NewServeMux(), - started: time.Now(), - logs: NewRing(500), - logins: map[string]loginSession{}, - } - p.routes() - return p -} - -// Logs 返回日志环形缓冲(main 经 MultiWriter 镜像 log 与 chat 表格日志进来)。 -func (p *Panel) Logs() *Ring { return p.logs } - -func (p *Panel) routes() { - p.mux.HandleFunc("GET /panel/{$}", p.index) - p.mux.HandleFunc("GET /panel/app.js", p.appScript) - p.mux.HandleFunc("GET /panel/api/overview", p.withAuth(p.overview)) - p.mux.HandleFunc("GET /panel/api/logs", p.withAuth(p.logsHandler)) - p.mux.HandleFunc("GET /panel/api/request_metrics", p.withAuth(p.requestMetrics)) - p.mux.HandleFunc("GET /panel/api/request_logs", p.withAuth(p.requestLogs)) - p.mux.HandleFunc("GET /panel/api/models", p.withAuth(p.models)) - p.mux.HandleFunc("POST /panel/api/login/start", p.withAuth(p.loginStart)) - p.mux.HandleFunc("GET /panel/api/login/poll", p.withAuth(p.loginPoll)) - p.mux.HandleFunc("GET /panel/api/login/regions", p.withAuth(p.loginRegions)) - p.mux.HandleFunc("POST /panel/api/import/cockpit", p.withAuth(p.importCockpit)) - p.mux.HandleFunc("POST /panel/api/accounts/{uid}/revive", p.withAuth(p.accountRevive)) - p.mux.HandleFunc("POST /panel/api/accounts/{uid}/disable", p.withAuth(p.accountDisable)) - p.mux.HandleFunc("POST /panel/api/accounts/{uid}/pause", p.withAuth(p.accountPause)) - p.mux.HandleFunc("POST /panel/api/accounts/{uid}/resume", p.withAuth(p.accountResume)) - p.mux.HandleFunc("POST /panel/api/accounts/{uid}/checkin", p.withAuth(p.accountCheckin)) - p.mux.HandleFunc("POST /panel/api/accounts/{uid}/balance", p.withAuth(p.accountBalance)) - p.mux.HandleFunc("POST /panel/api/accounts/{uid}/remove", p.withAuth(p.accountRemove)) - p.mux.HandleFunc("GET /panel/api/accounts/{uid}/tasks", p.withAuth(p.accountTasks)) - p.mux.HandleFunc("POST /panel/api/accounts/{uid}/tasks/accept", p.withAuth(p.accountTaskAccept)) - p.mux.HandleFunc("POST /panel/api/accounts/{uid}/tasks/accept_all", p.withAuth(p.taskAcceptAll)) - p.mux.HandleFunc("POST /panel/api/accounts/{uid}/tasks/claim", p.withAuth(p.accountTaskClaim)) - p.mux.HandleFunc("POST /panel/api/accounts/{uid}/tasks/auto", p.withAuth(p.accountTaskAuto)) - p.mux.HandleFunc("POST /panel/api/accounts/{uid}/tasks/auto_all", p.withAuth(p.accountTaskAutoAll)) - p.mux.HandleFunc("POST /panel/api/tasks/scan_all", p.withAuth(p.tasksScanAll)) - p.mux.HandleFunc("POST /panel/api/tasks/run_queue", p.withAuth(p.tasksRunQueue)) - p.mux.HandleFunc("GET /panel/api/tasks/queue", p.withAuth(p.tasksQueueStatus)) - p.mux.HandleFunc("GET /panel/api/school/vouchers", p.withAuth(p.schoolVouchers)) - p.mux.HandleFunc("POST /panel/api/checkin_all", p.withAuth(p.checkinAll)) - p.mux.HandleFunc("POST /panel/api/travel_all", p.withAuth(p.travelAll)) - p.mux.HandleFunc("POST /panel/api/activity_all", p.withAuth(p.activityAll)) - p.mux.HandleFunc("POST /panel/api/keepalive_all", p.withAuth(p.keepaliveAll)) - p.mux.HandleFunc("POST /panel/api/balance_all", p.withAuth(p.balanceAll)) - p.mux.HandleFunc("GET /panel/api/packages", p.withAuth(p.packages)) - p.mux.HandleFunc("GET /panel/api/usage", p.withAuth(p.usage)) - p.mux.HandleFunc("POST /panel/api/usage/save", p.withAuth(p.usageSave)) - p.mux.HandleFunc("GET /panel/api/model_probes", p.withAuth(p.modelProbes)) - p.mux.HandleFunc("GET /panel/api/config", p.withAuth(p.getConfig)) - p.mux.HandleFunc("POST /panel/api/config", p.withAuth(p.saveConfig)) -} - -// ServeHTTP 统一入口:先写安全响应头再分发,保证页面、静态资源、API -// 与 401 错误响应全都带上(API 也可能在浏览器里被直接打开)。 -func (p *Panel) ServeHTTP(w http.ResponseWriter, r *http.Request) { - setSecurityHeaders(w) - p.mux.ServeHTTP(w, r) -} - -// withAuth 与 server 包同口径的 Bearer 鉴权(经 httpauth 常量时间比较); -// api_key 为空时放行。密钥经 livecfg 快照读取:面板里改了 api_key,下一个请求 -// 即用新值(无需重启)。 -func (p *Panel) withAuth(next http.HandlerFunc) http.HandlerFunc { - return func(w http.ResponseWriter, r *http.Request) { - if !httpauth.VerifyBearer(r, p.apiKey()) { - writeErr(w, http.StatusUnauthorized, "invalid_api_key") - return - } - next(w, r) - } -} - -// apiKey 当前生效密钥(Live 优先,回落静态字段)。 -func (p *Panel) apiKey() string { - if p.cfg.Live != nil { - return p.cfg.Live.Load().APIKey - } - return p.cfg.APIKey -} - -// expiringSoonWindow 返回调度器当前生效的快过期路由窗口;测试面板无调度器时返回 0。 -func (p *Panel) expiringSoonWindow() time.Duration { - if p.cfg.Scheduler == nil { - return 0 - } - return p.cfg.Scheduler.ExpiringSoonWindow() -} - -// --------------------------------------------------------------------------- -// 只读接口 -// --------------------------------------------------------------------------- - -// overview 总览:池计数 + 每账号状态 + 面板元信息。 -func (p *Panel) overview(w http.ResponseWriter, r *http.Request) { - total, healthy, cooling, disabled, inFlightFull := p.cfg.Pool.CountsDetailed() - sticky := 0 - if p.cfg.StickyCount != nil { - sticky = p.cfg.StickyCount() - } - writeJSON(w, http.StatusOK, map[string]any{ - "version": p.cfg.Version, - "uptime_sec": int(time.Since(p.started).Seconds()), - "auth_required": p.apiKey() != "", - "redis_mode": p.cfg.RedisMode, - "sticky_sessions": sticky, - "total": total, - "healthy": healthy, - "cooling": cooling, - "disabled": disabled, - "in_flight_full": inFlightFull, - "accounts": p.cfg.Pool.List(), - // model_locks 模型级限流全清单(哪些模型不能用、锁了几个号、还要锁多久): - // 与 accounts 的账号池视图互补,前端「模型锁池」表直接渲染。无锁时为 null。 - "model_locks": p.cfg.Pool.ModelLockView(), - }) -} - -// logsHandler 返回日志环形缓冲快照(时间升序,含频道标记 chat/task/sys)。 -func (p *Panel) logsHandler(w http.ResponseWriter, r *http.Request) { - writeJSON(w, http.StatusOK, map[string]any{"entries": p.logs.Snapshot()}) -} - -// requestMetrics 返回进程内请求指标、最近 100 条与归档状态。 -func (p *Panel) requestMetrics(w http.ResponseWriter, r *http.Request) { - if p.cfg.RequestLog == nil { - writeErr(w, http.StatusNotImplemented, "request logger not available") - return - } - writeJSON(w, http.StatusOK, p.cfg.RequestLog.Snapshot()) -} - -// requestLogs 从 JSONL 归档读取最近请求;limit 默认 200、最大 1000。 -// 支持按 outcome/account/model/client_ip/user_agent 过滤(字符串字段为包含匹配) -// 与 from/to 时间区间(闭区间,unix 秒或 RFC3339)——面板「运行日志」的筛选框、 -// 来源查询与「今天 / 自定义区间」都走这里。 -func (p *Panel) requestLogs(w http.ResponseWriter, r *http.Request) { - if p.cfg.RequestLog == nil { - writeErr(w, http.StatusNotImplemented, "request logger not available") - return - } - limit := 200 - if v := r.URL.Query().Get("limit"); v != "" { - if n, err := strconv.Atoi(v); err == nil && n > 0 { - limit = n - } - } - if limit > 1000 { - limit = 1000 - } - q := r.URL.Query() - rows, err := p.cfg.RequestLog.ReadArchive(limit, reqlog.Filter{ - Outcome: q.Get("outcome"), - Account: q.Get("account"), - Model: q.Get("model"), - ClientIP: q.Get("client_ip"), - UserAgent: q.Get("user_agent"), - From: parseTimeParam(q.Get("from")), - To: parseTimeParam(q.Get("to")), - }) - if err != nil { - writeErr(w, http.StatusInternalServerError, err.Error()) - return - } - // 空结果回 [](而不是 JSON null):前端把 null 与"归档关闭"混在一起会走错分支, - // 显示成不满足筛选条件的最近请求。 - if rows == nil { - rows = []reqlog.Event{} - } - writeJSON(w, http.StatusOK, map[string]any{"entries": rows, "limit": limit}) -} - -// models 实时查询上游模型列表与 reasoning 实际档位(直连上游,不读路由层 1h 缓存): -// 回答"该模型到底支持哪几档思考"。顺带刷新 client 的 effort 降级能力缓存。 -// 与 /v1/models 同口径的双域输出:CN 域模型加 "cn:" 前缀、global 域加 "global:" 前缀 -// (gateway 路由协议,前端显示的 id 就是调用时要填的完整 model 值)。 -// 各域独立探测、独立容错:某域无可用账号则整域跳过;两域全空时才报错 -// (有错误明细回 502,一个账号都没有回 503)。 -func (p *Panel) models(w http.ResponseWriter, r *http.Request) { - out := make([]map[string]any, 0) - var fetchErrs []string - - // CN 域:有可用 CN 账号才查(此前无条件 Pool.Pick()+FetchModels——选中 global - // 账号时打 CN 端点必然失败,混合池表现为偶发 502,纯 global 池必炸)。 - if uids := p.cfg.Pool.AvailableUIDsForRealm("cn"); len(uids) > 0 { - if acct := p.cfg.Pool.AuthByUID(uids[0]); acct != nil { - infos, err := p.cfg.Upstream.FetchModels(acct) - if err != nil { - fetchErrs = append(fetchErrs, "cn: "+err.Error()) - } else { - for _, mi := range infos { - out = append(out, panelModelEntry("cn", mi, mi.Efforts, mi.DefaultEffort, p.cfg.Upstream.HTTP)) - } - } - } - } - - // global 域:路由开关开且有可用 global 账号才查(独立目录端点,FetchGlobalModelInfos; - // Upstream.GlobalEnabled 是探测侧同一道闸,与 main 装配的 config global.enabled 一致)。 - if p.cfg.Upstream.GlobalEnabled { - if uids := p.cfg.Pool.AvailableUIDsForRealm("global"); len(uids) > 0 { - if acct := p.cfg.Pool.AuthByUID(uids[0]); acct != nil { - infos := p.cfg.Upstream.FetchGlobalModelInfos(acct) - if len(infos) == 0 { - fetchErrs = append(fetchErrs, "global: 上游未返回可用模型") - } else { - efforts, defaults := p.cfg.Upstream.GlobalEffortSnapshot() - for _, mi := range infos { - out = append(out, panelModelEntry("global", mi, efforts[mi.ID], defaults[mi.ID], p.cfg.Upstream.HTTP)) - } - } - } - } - } - - if len(out) == 0 { - if len(fetchErrs) > 0 { - writeErr(w, http.StatusBadGateway, "fetch models: "+strings.Join(fetchErrs, "; ")) - return - } - writeErr(w, http.StatusServiceUnavailable, "没有可用账号:请先在面板添加账号再查询") - return - } - writeJSON(w, http.StatusOK, map[string]any{"ok": true, "models": out}) -} - -// panelModelEntry 构造单个模型条目(两域共用):id 带 realm 前缀(调用值即显示值), -// context_length / max_output_tokens 走四级查找链,effort 档位按 realm 域取 -// EffortListing(远端权威 ∪ 静态兜底表)——与 /v1/models 同一口径,两侧不再漂移。 -func panelModelEntry(realm string, mi upstream.ModelInfo, remoteEfforts []string, remoteDefault string, httpc *http.Client) map[string]any { - entry := map[string]any{ - "id": realm + ":" + mi.ID, - "name": mi.Name, - "default_effort": mi.DefaultEffort, - "supported_efforts": mi.Efforts, - "can_disable_thinking": mi.CanDisableThinking, - "supports_reasoning": mi.SupportsReasoning, - "supports_images": mi.SupportsImages, - "credits": mi.Credits, - "description": mi.Description, - "tags": mi.Tags, - "vendor": mi.Vendor, - "is_default": mi.IsDefault, - "supports_tool_call": mi.SupportsToolCall, - "only_reasoning": mi.OnlyReasoning, - "reasoning_effort": mi.ReasoningEffort, - "reasoning_summary": mi.ReasoningSummary, - } - // 限时优惠(modelPromotions):credits 是牌价,promo_* 是当前生效折扣 - //(WorkBuddy 客户端显示的就是这个生效价)。前端据此显示「生效价+标签+划线牌价」。 - if mi.PromoFactor != nil { - entry["promo_factor"] = *mi.PromoFactor - entry["promo_credits"] = mi.PromoCredits - } - if mi.PromoLabel != "" { - entry["promo_label"] = mi.PromoLabel - } - if mi.PromoNote != "" { - entry["promo_note"] = mi.PromoNote - } - if mi.MaxAllowedSize > 0 { - entry["max_allowed_size"] = mi.MaxAllowedSize - } - entry["context_length"] = upstream.ContextWindowListingV4(mi.ID, mi.ContextWindow, httpc) - if mo, ok := upstream.MaxOutputTokensListingV4(mi.ID, mi.MaxTokens, httpc); ok { - entry["max_output_tokens"] = mo - } - if efforts, def := upstream.EffortListing(realm, mi.ID, remoteEfforts, remoteDefault); efforts != nil { - entry["supported_efforts"] = efforts - if def != "" { - entry["default_effort"] = def - } - } - return entry -} - -// modelProbes 返回模型输出上限的探测结果(scripts/probe_max_tokens.py --panel-out -// 写入的契约文件),供前端在「模型与档位」的实测列做风险标注。 -// -// 设计边界:纯只读透传——文件缺失/未配置返回空集(面板退化为无标注,与历史行为 -// 一致),网关自身不解析字段语义、不据此做任何路由或出站决策;上游改了限制后 -// 重跑一次工具、下次查询即刷新,无需重启网关。 -func (p *Panel) modelProbes(w http.ResponseWriter, r *http.Request) { - out := map[string]any{"probes": map[string]json.RawMessage{}, "exists": false} - if p.cfg.ProbeFile == "" { - writeJSON(w, http.StatusOK, out) - return - } - raw, err := os.ReadFile(p.cfg.ProbeFile) - if err != nil { - if os.IsNotExist(err) { - writeJSON(w, http.StatusOK, out) - return - } - writeErr(w, http.StatusInternalServerError, "read probes: "+err.Error()) - return - } - var f struct { - Version int `json:"version"` - Probes map[string]json.RawMessage `json:"probes"` - } - if err := json.Unmarshal(raw, &f); err != nil { - writeErr(w, http.StatusBadGateway, "parse probes: "+err.Error()) - return - } - if f.Probes == nil { - f.Probes = map[string]json.RawMessage{} - } - out["probes"] = f.Probes - out["exists"] = true - if fi, err := os.Stat(p.cfg.ProbeFile); err == nil { - out["updated_at"] = fi.ModTime().Format(time.RFC3339) - } - writeJSON(w, http.StatusOK, out) -} - -// --------------------------------------------------------------------------- -// 账号运维 -// --------------------------------------------------------------------------- - -// accountRevive 手动复活:清禁用 + 冷却 + 熔断(运维口径无条件恢复)。 -func (p *Panel) accountRevive(w http.ResponseWriter, r *http.Request) { - uid := r.PathValue("uid") - if _, ok := p.cfg.Pool.Status(uid); !ok { - writeErr(w, http.StatusNotFound, "account not found") - return - } - p.cfg.Pool.Revive(uid) - log.Printf("panel: revive uid=%s(人工清除禁用/冷却/熔断)", uid) - writeJSON(w, http.StatusOK, map[string]any{"ok": true}) -} - -// accountDisable 人工禁用(不再参与选号,需面板 revive 或重登恢复)。 -func (p *Panel) accountDisable(w http.ResponseWriter, r *http.Request) { - uid := r.PathValue("uid") - if _, ok := p.cfg.Pool.Status(uid); !ok { - writeErr(w, http.StatusNotFound, "account not found") - return - } - p.cfg.Pool.Disable(uid, "manual disable (panel)") - log.Printf("panel: disable uid=%s(人工禁用)", uid) - writeJSON(w, http.StatusOK, map[string]any{"ok": true}) -} - -// accountPause 暂停选号:账号退出选号候选,但**照常参与**签到 / 活跃上报 / 保活 / -// 余额刷新。与 disable 的区别:不写 reason、不清冷却域、不重置计数——账号是「临时 -// 让位」而非「判死」,点「恢复选号」即可立刻回到池子(无需重登或解冻)。 -func (p *Panel) accountPause(w http.ResponseWriter, r *http.Request) { - uid := r.PathValue("uid") - if !p.cfg.Pool.Pause(uid) { - writeErr(w, http.StatusNotFound, "account not found") - return - } - log.Printf("panel: pause uid=%s(暂停选号,保号任务照常)", uid) - writeJSON(w, http.StatusOK, map[string]any{"ok": true}) -} - -// accountResume 解除暂停选号(幂等,对未暂停账号为空操作)。 -func (p *Panel) accountResume(w http.ResponseWriter, r *http.Request) { - uid := r.PathValue("uid") - if !p.cfg.Pool.Resume(uid) { - writeErr(w, http.StatusNotFound, "account not found") - return - } - log.Printf("panel: resume uid=%s(恢复参与选号)", uid) - writeJSON(w, http.StatusOK, map[string]any{"ok": true}) -} - -// accountCheckin 单号签到:DailyCheckin + 余额查询解冻(已签到等业务错误不阻塞余额刷新), -// 与 scheduler.RunCheckinNow 的单号语义一致。 -func (p *Panel) accountCheckin(w http.ResponseWriter, r *http.Request) { - uid := r.PathValue("uid") - a := p.cfg.Pool.AuthByUID(uid) - if a == nil { - writeErr(w, http.StatusNotFound, "account not found") - return - } - checkinMsg := "" - checkinDone := false - if err := p.cfg.Upstream.DailyCheckin(a); err != nil { - checkinMsg = err.Error() // "今天已签到"等业务错误照常查余额 - // 幂等拒绝同样是「今日已签」,标记后按钮显示「已签」。 - if upstream.IsAlreadyCheckin(err) { - p.cfg.Pool.NoteCheckinDone(uid) - checkinDone = true - } - } else { - p.cfg.Pool.NoteCheckinDone(uid) - checkinDone = true - } - resp := map[string]any{"ok": true, "checkin_done": checkinDone} - if checkinMsg != "" { - resp["checkin_message"] = checkinMsg - } - remain, total, expiring, earliestAt, earliestRemaining, err := p.cfg.Upstream.UserResourceDetailedWithExpiry(a, p.expiringSoonWindow()) - if err != nil { - resp["balance_error"] = err.Error() - writeJSON(w, http.StatusOK, resp) - return - } - p.cfg.Pool.ReenableIfCredits(uid, remain, total) - p.cfg.Pool.SetCreditsDetailed(uid, remain, total, expiring, earliestAt, earliestRemaining) - resp["credits"] = remain - resp["credits_total"] = total - log.Printf("panel: checkin uid=%s msg=%q credits=%d/%d", uid, checkinMsg, remain, total) - writeJSON(w, http.StatusOK, resp) -} - -// accountBalance 单号余额刷新:更新余额与到期快照,不触碰冷却状态。 -func (p *Panel) accountBalance(w http.ResponseWriter, r *http.Request) { - uid := r.PathValue("uid") - a := p.cfg.Pool.AuthByUID(uid) - if a == nil { - writeErr(w, http.StatusNotFound, "account not found") - return - } - remain, total, expiring, earliestAt, earliestRemaining, err := p.cfg.Upstream.UserResourceDetailedWithExpiry(a, p.expiringSoonWindow()) - if err != nil { - writeErr(w, http.StatusBadGateway, "user resource: "+err.Error()) - return - } - p.cfg.Pool.SetCreditsDetailed(uid, remain, total, expiring, earliestAt, earliestRemaining) - writeJSON(w, http.StatusOK, map[string]any{"ok": true, "credits": remain, "credits_total": total}) -} - -// accountRemove 移除账号:先出池(立即落盘 state),再删 auth 文件。 -func (p *Panel) accountRemove(w http.ResponseWriter, r *http.Request) { - uid := r.PathValue("uid") - a := p.cfg.Pool.Remove(uid) - if a == nil { - writeErr(w, http.StatusNotFound, "account not found") - return - } - fileMsg := "" - if a.FilePath != "" { - if err := os.Remove(a.FilePath); err != nil && !os.IsNotExist(err) { - fileMsg = err.Error() - } - } - if fileMsg != "" { - log.Printf("panel: remove uid=%s(auth 文件删除失败: %s)", uid, fileMsg) - writeJSON(w, http.StatusOK, map[string]any{"ok": true, "file_error": fileMsg}) - return - } - log.Printf("panel: remove uid=%s(已出池并删除凭证文件)", uid) - writeJSON(w, http.StatusOK, map[string]any{"ok": true}) -} - -// --------------------------------------------------------------------------- -// 批量任务 -// --------------------------------------------------------------------------- - -// checkinAll 手动触发全量签到(异步执行,进度看日志区/账号状态变化)。 -func (p *Panel) checkinAll(w http.ResponseWriter, r *http.Request) { - if p.cfg.Scheduler == nil { - writeErr(w, http.StatusNotImplemented, "scheduler not available") - return - } - go p.cfg.Scheduler.RunCheckinNow() - log.Printf("panel: 手动全量签到已触发(含猫猫旅行)") - writeJSON(w, http.StatusOK, map[string]any{"ok": true, "started": true}) -} - -// travelAll 手动触发全量猫猫旅行巡检(异步执行)。 -func (p *Panel) travelAll(w http.ResponseWriter, r *http.Request) { - if p.cfg.Scheduler == nil { - writeErr(w, http.StatusNotImplemented, "scheduler not available") - return - } - go p.cfg.Scheduler.RunTravelNow() - log.Printf("panel: 手动全量旅行巡检已触发") - writeJSON(w, http.StatusOK, map[string]any{"ok": true, "started": true}) -} - -// activityAll 手动触发全量活跃上报(异步执行;点亮连登 + 解锁领养前置)。 -func (p *Panel) activityAll(w http.ResponseWriter, r *http.Request) { - if p.cfg.Scheduler == nil { - writeErr(w, http.StatusNotImplemented, "scheduler not available") - return - } - go p.cfg.Scheduler.RunActivityNow() - log.Printf("panel: 手动全量活跃上报已触发") - writeJSON(w, http.StatusOK, map[string]any{"ok": true, "started": true}) -} - -// keepaliveAll 手动触发全量 token 保活(异步执行)。 -func (p *Panel) keepaliveAll(w http.ResponseWriter, r *http.Request) { - if p.cfg.Scheduler == nil { - writeErr(w, http.StatusNotImplemented, "scheduler not available") - return - } - go p.cfg.Scheduler.RunKeepaliveNow() - log.Printf("panel: 手动全量保活已触发") - writeJSON(w, http.StatusOK, map[string]any{"ok": true, "started": true}) -} - -// balanceAll 手动全量刷新余额:并发查上游、写回池内 credits(含解冻语义), -// 完成后返回——面板紧接着拉 overview 即是最新值。账号量小(个位数), -// 同步等待(上限受短 RPC 超时约束)比"触发后盲刷"体验更确定。 -func (p *Panel) balanceAll(w http.ResponseWriter, r *http.Request) { - if p.cfg.Scheduler == nil { - writeErr(w, http.StatusNotImplemented, "scheduler not available") - return - } - p.cfg.Scheduler.RunBalanceRefreshNow() - p.syncNicknames() - log.Printf("panel: 手动全量余额刷新完成") - writeJSON(w, http.StatusOK, map[string]any{"ok": true, "accounts": p.cfg.Pool.List()}) -} - -// syncNicknames 手动刷新时的昵称同步(issue #94:上游改名免重登)。 -// 只在面板手动「刷新」路径调用——后台余额定时器不触发(用户明确要求资料接口 -// 仅手动触达)。逐号拉 /console/account,只取 nickname(手机号等敏感字段在 -// upstream.FetchAccountProfile 内即被丢弃);单号失败静默跳过,不打断余额刷新 -// 的既有结果。 -func (p *Panel) syncNicknames() { - type job struct { - uid string - a *auth.Auth - } - var jobs []job - for _, st := range p.cfg.Pool.List() { - if st.Disabled { - continue - } - if a := p.cfg.Pool.AuthByUID(st.UID); a != nil && a.AccessTokenValue() != "" { - jobs = append(jobs, job{uid: st.UID, a: a}) - } - } - if len(jobs) == 0 { - return - } - var ( - mu sync.Mutex - updated int - failed int - sem = make(chan struct{}, 3) - wg sync.WaitGroup - ) - for _, j := range jobs { - wg.Add(1) - go func(j job) { - defer wg.Done() - sem <- struct{}{} - defer func() { <-sem }() - nick, err := p.cfg.Upstream.FetchAccountProfile(j.a) - if err != nil { - mu.Lock() - failed++ - mu.Unlock() - return - } - if p.cfg.Pool.SetNickname(j.uid, nick) { - mu.Lock() - updated++ - mu.Unlock() - } - }(j) - } - wg.Wait() - if updated > 0 || failed > 0 { - log.Printf("panel: 昵称同步:更新 %d 个,失败 %d 个(未变化不计数)", updated, failed) - } -} - -// --------------------------------------------------------------------------- -// helpers -// --------------------------------------------------------------------------- - -// usage 返回逐请求用量聚合。统计窗口三选一: -// - from/to(unix 秒):显式区间,用于「今天」与「自定义」——区间由浏览器按 -// 本地时区算好再发,服务端时区与浏览器不一致时「今天」才不会被算错; -// - hours:滚动窗口(默认 72,上限 1440=60 天),卡片汇总/按域/按账号/按模型/ -// 时序**全部**按该窗口统计;显式 hours=0 表示全部历史(含 90 天前折叠出的日桶); -// - 都不给:等同于 hours=72(保持旧调用方行为)。 -func (p *Panel) usage(w http.ResponseWriter, r *http.Request) { - if p.cfg.Usage == nil { - writeErr(w, http.StatusNotImplemented, "usage recorder not available") - return - } - q := r.URL.Query() - win := usage.Window{} - win.From = parseTimeParam(q.Get("from")) - win.To = parseTimeParam(q.Get("to")) - if win.From.IsZero() && win.To.IsZero() { - win.Hours = 72 - if v := q.Get("hours"); v != "" { - if n, err := strconv.Atoi(v); err == nil && n >= 0 { - win.Hours = n - } - } - if win.Hours > 1440 { - win.Hours = 1440 - } - } - // 昵称仅用于展示,取自池快照(不含任何凭证)。 - nicks := map[string]string{} - for _, s := range p.cfg.Pool.List() { - if s.Nickname != "" { - nicks[s.UID] = s.Nickname - } - } - var currentRate func(realm, model string) string - if p.cfg.Upstream != nil { - currentRate = p.cfg.Upstream.ModelRate - } - writeJSON(w, http.StatusOK, p.cfg.Usage.SnapshotWindow(win, nicks, currentRate)) -} - -// parseTimeParam 解析时间查询参数:unix 秒(前端默认)或 RFC3339(便于手工调 -// 接口/写脚本)。空串与非法值都返回零值 = 该侧不设界,不报错——区间参数是可选 -// 增强,拼错一个 from 不该让整页用量打不开。 -func parseTimeParam(v string) time.Time { - v = strings.TrimSpace(v) - if v == "" { - return time.Time{} - } - if n, err := strconv.ParseInt(v, 10, 64); err == nil { - if n <= 0 { - return time.Time{} - } - // 兼容秒与毫秒(前端可能直接把 Date.now() 传上来)。 - if n > 1e12 { - return time.UnixMilli(n) - } - return time.Unix(n, 0) - } - if t, err := time.Parse(time.RFC3339, v); err == nil { - return t - } - if t, err := time.ParseInLocation("2006-01-02T15:04", v, time.Local); err == nil { - return t - } - return time.Time{} -} - -// usageSave 立即把内存中的用量桶落盘(正常由后台 30s 防抖刷新负责)。 -func (p *Panel) usageSave(w http.ResponseWriter, r *http.Request) { - if p.cfg.Usage == nil { - writeErr(w, http.StatusNotImplemented, "usage recorder not available") - return - } - p.cfg.Usage.Save() - writeJSON(w, http.StatusOK, map[string]any{"ok": true}) -} - -// packages 返回全部账号的积分包构成,供「积分构成」视图对比。 -// -// 逐个账号向上游查(并发有上限,避免瞬时打满上游限流),失败只在对应账号上 -// 标 error,不影响其它账号——一个号 token 失效不该让整页空白。 -func (p *Panel) packages(w http.ResponseWriter, r *http.Request) { - accts := p.cfg.Pool.List() - type row struct { - UID string `json:"uid"` - Nickname string `json:"nickname"` - Realm string `json:"realm"` - Remain int64 `json:"remain"` - Size int64 `json:"size"` - Packages []upstream.CreditPackage `json:"packages"` - Error string `json:"error,omitempty"` - } - out := make([]row, len(accts)) - - sem := make(chan struct{}, 3) - var wg sync.WaitGroup - for i, s := range accts { - wg.Add(1) - go func(i int, s pool.Status) { - defer wg.Done() - sem <- struct{}{} - defer func() { <-sem }() - - it := row{UID: s.UID, Nickname: s.Nickname, Realm: s.Realm} - a := p.cfg.Pool.AuthByUID(s.UID) - if a == nil { - it.Error = "account not loaded" - out[i] = it - return - } - packs, remain, size, err := p.cfg.Upstream.CreditPackages(a) - if err != nil { - it.Error = err.Error() - out[i] = it - return - } - it.Packages = packs - it.Remain = remain - it.Size = size - out[i] = it - }(i, s) - } - wg.Wait() - - // 余额降序:多的在前,便于和少的对比。 - sort.SliceStable(out, func(i, j int) bool { return out[i].Remain > out[j].Remain }) - writeJSON(w, http.StatusOK, map[string]any{"accounts": out}) -} - -func writeJSON(w http.ResponseWriter, status int, v any) { - raw, _ := json.Marshal(v) - w.Header().Set("Content-Type", "application/json") - w.WriteHeader(status) - _, _ = w.Write(raw) -} - -func writeErr(w http.ResponseWriter, status int, msg string) { - writeJSON(w, status, map[string]any{"ok": false, "error": msg}) -} +// Package panel 内嵌式 Web 管理面板:账号池总览、单号运维(解冻/禁用/签到/ +// 刷新余额/移除)、浏览器内 OAuth 添加账号(免重启热加载进池)、手动批量 +// 签到/保活,以及运行日志环形缓冲(镜像 log 包与 chat 表格日志)。 +// +// 设计约束: +// - 前端 go:embed 单文件(index.html),无任何外部构建依赖,与二进制同体部署; +// - 鉴权复用网关 api_key(Bearer),与 /v1/* 同一口径;api_key 为空 = 不鉴权 +// (仅本机/私网使用)。面板 HTML 本身无秘密,可匿名加载,密钥只发给 /panel/api/*; +// - 不改写既有池语义:所有运维操作落到 pool 已有入口(Revive/Disable/Remove...), +// 添加账号走 auth.SaveAtomic + pool.Add,重启后与 auths/ 目录天然对齐。 +package panel + +import ( + "encoding/json" + "errors" + "log" + "math" + "net/http" + "os" + "sort" + "strconv" + "strings" + "sync" + "sync/atomic" + "time" + + "github.com/misakano7545/workbuddy2api-panel/internal/auth" + "github.com/misakano7545/workbuddy2api-panel/internal/balance" + "github.com/misakano7545/workbuddy2api-panel/internal/credithist" + "github.com/misakano7545/workbuddy2api-panel/internal/extstore" + "github.com/misakano7545/workbuddy2api-panel/internal/freemodel" + "github.com/misakano7545/workbuddy2api-panel/internal/httpauth" + "github.com/misakano7545/workbuddy2api-panel/internal/livecfg" + "github.com/misakano7545/workbuddy2api-panel/internal/pool" + "github.com/misakano7545/workbuddy2api-panel/internal/proxypool" + "github.com/misakano7545/workbuddy2api-panel/internal/reqlog" + "github.com/misakano7545/workbuddy2api-panel/internal/scheduler" + "github.com/misakano7545/workbuddy2api-panel/internal/updater" + "github.com/misakano7545/workbuddy2api-panel/internal/upstream" + "github.com/misakano7545/workbuddy2api-panel/internal/usage" +) + +// Config 面板依赖(main 装配注入)。 +type Config struct { + Pool *pool.Pool + ProxyPool *proxypool.Manager + Upstream *upstream.Client + Scheduler *scheduler.Scheduler // 手动触发签到/保活;nil 时对应接口返回 501 + // AutoTasksEnabled 与成长任务开关共用热配置;nil 时只允许手动启动后台任务。 + AutoTasksEnabled func() bool + AuthDir string // OAuth 登录完成后凭证落盘目录 + APIKey string // 空 = 不鉴权(与主服务同语义);与 Live 同时给出时 Live 优先 + RedisMode string // "upstash" / "noop",仅观测透出 + Version string // 面板版本号(展示用) + Updater *updater.Manager + + // PollIntervalSec 前端自动刷新间隔(秒)。0 = 用前端缺省值。 + // 面板每轮刷新会重建若干表格并打一批接口;账号多、或只是开着面板当监控用 + // 时,把间隔调大(乃至关闭)能显著降低浏览器与服务端的负担。透出到 + // /panel/api/overview 由前端读取。 + PollIntervalSec int + + // Live 运行期可变配置(在线改配置立即生效)。 + Live *livecfg.Holder + + // ConfigPath config.json 路径与加载器(配置页读写用)。 + // LoadConfig 返回解析后的配置对象(前端展示/校验用,具体类型由 main 注入的闭包决定); + // nil 时配置页返回 501。 + ConfigPath string + LoadConfig func() (any, error) + // SaveConfig 校验并落盘配置,返回需要重启才能生效的字段列表;随后由 main 注入的 + // ApplyConfig 闭包完成热生效(池参数/排程/密钥/脱敏)。error 时配置不写盘。 + SaveConfig func(raw []byte) (restartRequired []string, err error) + + // StickyCount 返回粘性会话绑定数;nil 时报告 0。 + StickyCount func() int + + // Usage 逐请求用量记录器(nil = 用量接口返回 501)。 + Usage *usage.Recorder + // RequestLog 请求指标与归档(nil = 对应接口返回 501)。 + RequestLog *reqlog.Recorder + // CreditHistory 积分变动账本(nil = 积分历史接口返回 501)。只读展示: + // 留痕由余额查询路径(upstream.Client 的余额观察者)写入。 + CreditHistory *credithist.Ledger + + // ProbeFile 模型输出上限探测结果文件(scripts/probe_max_tokens.py --panel-out + // 写入;空或文件不存在 = model_probes 端点返回空集,面板不显示任何实测标注)。 + // 只读展示:网关不解析、不依赖其内容做任何路由/出站决策。 + ProbeFile string + // Balance 余额趋势采样记录器(nil = 该视图返回 501) + Balance *balance.Recorder + // ModelFallback 模型降级路由表(读 live 快照,支持热更)。nil = 未配置。 + // 面板据它在限流提示里标注「已路由至 X」—— 否则用户看到「v4.1 限流」 + // 会以为服务断了,实际请求已被自动改道到等价模型继续服务。 + ModelFallback func() map[string]string + + // Extensions 面板扩展存储(免登录免费模型 / 自定义模型 / 访问密钥)。 + // nil 时对应接口返回 501(老测试路径零回归)。 + Extensions *extstore.Store + // FreeModels 免费模型客户端(刷新上游清单用)。 + FreeModels *freemodel.Client +} + +// Panel 管理面板 handler。挂载方式:外层 mux Handle("/panel/", panel), +// 本 mux 的 pattern 均带 /panel 前缀(外层不做前缀剥离)。 +type Panel struct { + proxyAccountMu sync.Mutex + cfg Config + mux *http.ServeMux + started time.Time + logs *Ring + + // 账号目录热重载(issue #199,见 reload.go)。 + // - reloadMu 同时保护下面几个字段与「一次重载的全程」:两次重载不并发, + // 面板读状态也不会读到半更新的结果。 + // - reloadMissing 是「连续几轮扫描都没见到」的缺席计数:删除要连续 + // reloadDeleteConfirm 次确认,避免半写文件/临时移走把账号踢掉。 + // - reloadFingerprint 是上次成功重载后的目录内容指纹,轮询据此跳过无变化的轮次。 + reloadMu sync.Mutex + reloadInterval time.Duration + reloadDeleteConfirm int + reloadMissing map[string]int + reloadFingerprint string + reloadLastAt time.Time + reloadLast ReloadResult + + // logins 进行中的 OAuth 设备授权会话(state → 会话信息)。 + // poll 成功或超时(loginTTL)后剔除;面板常驻进程,容量天然有界。 + loginMu sync.Mutex + logins map[string]loginSession + + // taskMu/taskLocks 一键完成任务的 per-account 互斥:同一账号的任务动作 + // (单任务 / 全量)同时只允许一条在跑。重复点击直接返回 409"仍在执行", + // 而不是并发跑两遍浪费上游请求(动作虽幂等,expert 系每遍含 8 次真实对话)。 + // 不同账号之间不互斥(并行照旧)。TryLock 语义,锁条目常驻(账号数有界)。 + taskMu sync.Mutex + taskLocks map[string]*sync.Mutex + + // softRateMu/softRateUntil 上游软限流(429)的账号级冷却截止:撞过一次就记下来, + // 同一轮里后续任务动作直接快失败,不每个动作都再睡一遍——一轮全量任务有几十个 + // 动作,逐个睡会让后台作业卡住几十分钟,还占着 taskLocks 把手动触发一起堵死。 + softRateMu sync.Mutex + softRateUntil map[string]time.Time + + // batchRunning 手动全量运维接口(签到/旅行/活跃/保活/余额)共用的防重入闸门: + // 这些动作都是逐号打上游,并发跑两轮 = 每号至少翻倍上游请求,正是批间节流 + // 要避免的场景。TryLock 语义,见 tryStartBatch。 + batchRunning atomic.Bool + + // modelsMu/modelsCache* /panel/api/models 的短 TTL 结果缓存:该接口是 + // 「CN 目录直连 + global 目录 + 繁忙度」的实时上游聚合,前端自己都按 + // 「很贵」在节流——服务端再兜一层,挡住异常前端循环与外部脚本。 + modelsMu sync.Mutex + modelsCacheAt time.Time + modelsCache *modelsCacheEntry + + // 任务中心执行队列(taskcenter.go)。 + queueOnce sync.Once + q *queueState + + // 持久化的账号后台任务(taskjobs.go),由 main 管理生命周期。 + taskJobs *taskJobManager + + // growthConc 排程轮次的账号间并发(config schedule.growth_concurrency,热生效)。 + // 0 = 未配置 → 1。 + growthConc atomic.Int64 + // notifier 排程轮次结束后的汇总通知出口(main 装配期注入 alerting webhook; + // nil = 只落面板日志)。装配期设定、运行期只读,不需要锁。 + notifier func(string) +} + +// SetGrowthConcurrency 设置排程轮次的账号间并发(1-4;<=0 视为默认 1)。面板保存配置时热改。 +func (p *Panel) SetGrowthConcurrency(n int) { + p.growthConc.Store(int64(n)) +} + +// SetNotifier 注入汇总通知出口(nil = 关闭推送,只写日志)。装配期调用。 +func (p *Panel) SetNotifier(fn func(string)) { p.notifier = fn } + +// tryLockAccount 尝试锁定账号的任务执行;已在执行返回 false。 +func (p *Panel) tryLockAccount(uid string) bool { + p.taskMu.Lock() + if p.taskLocks == nil { + p.taskLocks = make(map[string]*sync.Mutex) + } + mu := p.taskLocks[uid] + if mu == nil { + mu = &sync.Mutex{} + p.taskLocks[uid] = mu + } + p.taskMu.Unlock() + return mu.TryLock() +} + +// unlockAccount 释放账号任务锁(与 tryLockAccount 配对)。 +func (p *Panel) unlockAccount(uid string) { + p.taskMu.Lock() + mu := p.taskLocks[uid] + p.taskMu.Unlock() + if mu != nil { + mu.Unlock() + } +} + +// loginTTL 授权 URL 的最长有效期:超时的 state 直接回收, +// 防止"开了添加账号弹窗就走开"的会话永久滞留。 +const loginTTL = 15 * time.Minute + +// modelsCacheTTL 面板模型列表的结果缓存时长(测试可注入短值)。只缓存「零 +// fetchErr」的完整成功响应;部分失败的结果每次照常重探,直到拿到干净目录。 +var modelsCacheTTL = 60 * time.Second + +// modelsCacheEntry 一次成功聚合的结果(global_source 一并冻结——它描述的就是 +// 这份目录的来源,目录换源缓存必须跟着失效)。 +type modelsCacheEntry struct { + models []map[string]any + globalSource string +} + +// loginSession 进行中的 OAuth 会话:创建时刻 + realm(cn/global,用于落盘与端点切换)。 +type loginSession struct { + created time.Time + realm string // "cn" / "global",缺省 cn + // site 登录站点(cn/intl/workbuddy,对齐官方域表)。决定 poll 用哪套端点: + // 国际域 codebuddy.ai 与 workbuddy.ai 同后端不同主机,混用会把请求打到非签发域。 + // 空 = 老会话/未指定,按 cn 处理(siteOrDefault 归一)。 + site string + // processing 该 state 正在落盘(含签到/余额校验等副作用)。前端每 3s 轮询,而成功 + // 分支的副作用可能耗时数秒:没有这个闸门,第二个并发 poll 会把整段流程再跑一遍。 + processing bool + // lastMsg 上一次落日志的上游结果。前端每 3s 一轮、最长 loginTTL,逐轮记日志会 + // 把 15 分钟刷成 300 行,真正的一次性错误反被淹掉;只在结果变化时记一行。 + lastMsg string +} + +// New 构建面板。 +func New(cfg Config) *Panel { + if cfg.RedisMode == "" { + cfg.RedisMode = "noop" + } + p := &Panel{ + cfg: cfg, + mux: http.NewServeMux(), + started: time.Now(), + logs: NewRing(500), + logins: map[string]loginSession{}, + // 热重载(issue #199):默认 2 次连续缺席才删;间隔由 main 按 config 注入。 + reloadDeleteConfirm: 2, + reloadMissing: map[string]int{}, + } + p.routes() + return p +} + +// Logs 返回日志环形缓冲(main 经 MultiWriter 镜像 log 与 chat 表格日志进来)。 +func (p *Panel) Logs() *Ring { return p.logs } + +func (p *Panel) routes() { + p.mux.HandleFunc("GET /panel/{$}", p.index) + p.mux.HandleFunc("GET /panel/theme.js", p.themeScript) + p.mux.HandleFunc("GET /panel/app.js", p.appScript) + p.mux.HandleFunc("GET /panel/api/overview", p.overview) + // 账号目录热重载(issue #199):脚本/编排服务的确定性入口;后台轮询走同一实现。 + p.mux.HandleFunc("POST /panel/api/accounts/reload", p.reloadAccounts) + p.proxyRoutes() + p.mux.HandleFunc("GET /panel/api/logs", p.logsHandler) + // 落盘日志按区间导出(zip):事故复盘「把最近三天发我」不必 SSH 上去翻文件。 + p.mux.HandleFunc("GET /panel/api/logs/export", p.logsExportHandler) + p.mux.HandleFunc("GET /panel/api/error_summary", p.errorSummary) + p.mux.HandleFunc("GET /panel/api/request_metrics", p.requestMetrics) + p.mux.HandleFunc("GET /panel/api/request_logs", p.requestLogs) + // 清空请求事件归档(issue #160):日志留存归运营自己管,别只能等定期 prune。 + p.mux.HandleFunc("POST /panel/api/request_logs/clear", p.requestLogsClear) + p.mux.HandleFunc("GET /panel/api/credit_history", p.creditHistory) + p.mux.HandleFunc("GET /panel/api/models", p.models) + // (账号 × 模型) 手动开关:运维显式禁用某账号的某模型(永久语义,仅手动解)。 + // 与上游触发的临时冷却(6004/11102)正交,且手动优先。 + p.mux.HandleFunc("POST /panel/api/accounts/{uid}/model_toggle", p.modelToggle) + // 封禁账号探活:只读探测上游是否已解封,不 revive、不参与选号。 + p.mux.HandleFunc("POST /panel/api/accounts/{uid}/probe_ban", p.accountProbeBan) + p.mux.HandleFunc("POST /panel/api/login/start", p.loginStart) + p.mux.HandleFunc("GET /panel/api/login/poll", p.loginPoll) + p.mux.HandleFunc("GET /panel/api/login/regions", p.loginRegions) + p.mux.HandleFunc("POST /panel/api/import/cockpit", p.importCockpit) + p.mux.HandleFunc("POST /panel/api/accounts/add_apikey", p.addAPIKey) + p.mux.HandleFunc("POST /panel/api/accounts/{uid}/revive", p.accountRevive) + p.mux.HandleFunc("POST /panel/api/accounts/{uid}/disable", p.accountDisable) + p.mux.HandleFunc("POST /panel/api/accounts/{uid}/pause", p.accountPause) + p.mux.HandleFunc("POST /panel/api/accounts/{uid}/resume", p.accountResume) + // 账号分组标签(issue #159):纯管理维度,落 state.json,供面板按组筛选与组内批量。 + p.mux.HandleFunc("POST /panel/api/accounts/{uid}/group", p.accountGroup) + p.mux.HandleFunc("POST /panel/api/accounts/{uid}/checkin", p.accountCheckin) + p.mux.HandleFunc("POST /panel/api/accounts/{uid}/balance", p.accountBalance) + p.mux.HandleFunc("POST /panel/api/accounts/{uid}/remove", p.accountRemove) + p.mux.HandleFunc("GET /panel/api/accounts/{uid}/tasks", p.accountTasks) + p.mux.HandleFunc("POST /panel/api/accounts/{uid}/tasks/accept", p.accountTaskAccept) + p.mux.HandleFunc("POST /panel/api/accounts/{uid}/tasks/accept_all", p.taskAcceptAll) + p.mux.HandleFunc("POST /panel/api/accounts/{uid}/tasks/claim", p.accountTaskClaim) + p.mux.HandleFunc("POST /panel/api/accounts/{uid}/tasks/auto", p.accountTaskAuto) + p.mux.HandleFunc("POST /panel/api/accounts/{uid}/tasks/auto_all", p.accountTaskAutoAll) + p.mux.HandleFunc("POST /panel/api/tasks/scan_all", p.tasksScanAll) + p.mux.HandleFunc("POST /panel/api/tasks/run_queue", p.tasksRunQueue) + p.mux.HandleFunc("GET /panel/api/tasks/queue", p.tasksQueueStatus) + p.mux.HandleFunc("GET /panel/api/tasks/jobs", p.taskJobsHandler) + p.mux.HandleFunc("GET /panel/api/accounts/{uid}/tasks/job", p.taskJobStatus) + p.mux.HandleFunc("POST /panel/api/checkin_all", p.checkinAll) + p.mux.HandleFunc("POST /panel/api/travel_all", p.travelAll) + p.mux.HandleFunc("POST /panel/api/accounts/{uid}/travel", p.accountTravel) + p.mux.HandleFunc("POST /panel/api/activity_all", p.activityAll) + p.mux.HandleFunc("POST /panel/api/keepalive_all", p.keepaliveAll) + p.mux.HandleFunc("POST /panel/api/balance_all", p.balanceAll) + p.mux.HandleFunc("GET /panel/api/packages", p.packages) + p.mux.HandleFunc("GET /panel/api/balance_history", p.balanceHistory) + p.mux.HandleFunc("GET /panel/api/school/vouchers", p.schoolVouchers) + // 运营活动(星巴克等):批量读进度 + 批量领已达标的奖励。 + // 只做「读 + 领」——任务本身要客户端真实会话,服务端侧伪造不计数(见 docs/campaign-probe.md)。 + p.mux.HandleFunc("GET /panel/api/campaign", p.campaignStatus) + p.mux.HandleFunc("POST /panel/api/campaign/claim", p.campaignClaim) + p.mux.HandleFunc("GET /panel/api/usage", p.usage) + p.mux.HandleFunc("POST /panel/api/usage/save", p.usageSave) + p.mux.HandleFunc("GET /panel/api/model_probes", p.modelProbes) + p.mux.HandleFunc("GET /panel/api/config", p.getConfig) + p.mux.HandleFunc("POST /panel/api/config", p.saveConfig) + p.mux.HandleFunc("POST /panel/api/model_hidden", p.setModelHidden) + p.mux.HandleFunc("POST /panel/api/model_effort", p.setModelEffort) + p.mux.HandleFunc("GET /panel/api/update", p.updateStatus) + p.mux.HandleFunc("POST /panel/api/update/check", p.checkUpdate) + p.mux.HandleFunc("POST /panel/api/update/install", p.installUpdate) + // 更新通道探测(issue #198):分别探版本元数据与资产下载两条路。 + p.mux.HandleFunc("POST /panel/api/update/probe", p.probeUpdate) + // 扩展模型:免登录免费模型 / 自定义模型映射 / 访问密钥。 + p.mux.HandleFunc("GET /panel/api/extensions", p.getExtensions) + p.mux.HandleFunc("POST /panel/api/extensions/free", p.saveFreeSettings) + p.mux.HandleFunc("POST /panel/api/extensions/free/refresh", p.refreshFreeModels) + p.mux.HandleFunc("POST /panel/api/extensions/free/model", p.toggleFreeModel) + p.mux.HandleFunc("POST /panel/api/extensions/free/provider/delete", p.deleteFreeProvider) + p.mux.HandleFunc("POST /panel/api/extensions/custom", p.saveCustomModel) + p.mux.HandleFunc("POST /panel/api/extensions/custom/delete", p.deleteCustomModel) + p.mux.HandleFunc("POST /panel/api/extensions/keys", p.createAccessKey) + p.mux.HandleFunc("POST /panel/api/extensions/keys/update", p.updateAccessKey) + p.mux.HandleFunc("POST /panel/api/extensions/keys/delete", p.deleteAccessKey) + p.mux.HandleFunc("POST /panel/api/extensions/keys/toggle", p.toggleAccessKey) +} + +// publicPanelPaths 免鉴权的精确路径:静态页面与脚本本身不含秘密,其余一律要密钥。 +var publicPanelPaths = map[string]struct{}{ + "/panel/": {}, + "/panel/theme.js": {}, + "/panel/app.js": {}, +} + +// ServeHTTP 统一入口:先写安全响应头再分发,保证页面、静态资源、API +// 与 401 错误响应全都带上(API 也可能在浏览器里被直接打开)。 +// +// 鉴权在这里默认拒绝,而不是逐条包在路由上:逐条包的话,新增一条路由忘了包 +// 就是静默公开;这里的失效方向是「忘了登记白名单 → 401」,看得见。 +func (p *Panel) ServeHTTP(w http.ResponseWriter, r *http.Request) { + setSecurityHeaders(w) + if _, ok := publicPanelPaths[r.URL.Path]; !ok && !httpauth.VerifyBearer(r, p.apiKey()) { + // 密钥经 livecfg 快照读取:面板里改了 api_key,下一个请求即用新值。 + writeErr(w, http.StatusUnauthorized, "invalid_api_key") + return + } + p.mux.ServeHTTP(w, r) +} + +// apiKey 当前生效密钥(WB2A_PANEL_KEY 优先,其次 Live,最后静态字段)。 +// +// 环境变量存在时面板密钥完全由部署环境托管:面板里改 api_key 不会影响面板登录, +// 也不会出现「面板里改了 key 把自己锁在外面」的情况。 +func (p *Panel) apiKey() string { + if key := strings.TrimSpace(os.Getenv("WB2A_PANEL_KEY")); key != "" { + return key + } + if p.cfg.Live != nil { + return p.cfg.Live.Load().APIKey + } + return p.cfg.APIKey +} + +// expiringSoonWindow 返回调度器当前生效的快过期路由窗口;测试面板无调度器时返回 0。 +func (p *Panel) expiringSoonWindow() time.Duration { + if p.cfg.Scheduler == nil { + return 0 + } + return p.cfg.Scheduler.ExpiringSoonWindow() +} + +// poolExpiryBuckets 把 upstream 的按日到期批次转换为 pool 结构。两个包字段同构, +// 手工转换是为了不让底层 pool 反向依赖 upstream。 +func poolExpiryBuckets(in []upstream.ExpiryBucket) []pool.ExpiryBucket { + if len(in) == 0 { + return nil + } + out := make([]pool.ExpiryBucket, len(in)) + for i, b := range in { + out[i] = pool.ExpiryBucket{Date: b.Date, ExpireAt: b.ExpireAt, Remain: b.Remain} + } + return out +} + +// --------------------------------------------------------------------------- +// 只读接口 +// --------------------------------------------------------------------------- + +// overview 总览:池计数 + 每账号状态 + 面板元信息。 +func (p *Panel) overview(w http.ResponseWriter, r *http.Request) { + // 用 WithPaused 而不是 CountsDetailed:后者把暂停号并进 disabled(/status 的「不可用」 + // 口径),而面板概况卡片要分开展示(吸收上游 PR #130,issue #125)。 + total, healthy, cooling, disabled, paused, inFlightFull := p.cfg.Pool.CountsDetailedWithPaused() + sticky := 0 + if p.cfg.StickyCount != nil { + sticky = p.cfg.StickyCount() + } + writeJSON(w, http.StatusOK, map[string]any{ + "version": p.cfg.Version, + "poll_interval_sec": p.cfg.PollIntervalSec, + "update": p.updateSnapshot(), + "uptime_sec": int(time.Since(p.started).Seconds()), + "auth_required": p.apiKey() != "", + "panel_key_env_managed": strings.TrimSpace(os.Getenv("WB2A_PANEL_KEY")) != "", + "redis_mode": p.cfg.RedisMode, + "sticky_sessions": sticky, + "total": total, + "healthy": healthy, + "cooling": cooling, + "disabled": disabled, + "paused": paused, + "in_flight_full": inFlightFull, + // 模型降级路由表:前端据它标注「⤳ 已路由至 X」(限流的模型若配了等价模型)。 + "model_fallback": p.modelFallbackSnapshot(), + "accounts": p.cfg.Pool.List(), + "proxy_pool": p.proxySnapshot(), + // model_locks 模型级限流全清单(哪些模型不能用、锁了几个号、还要锁多久,移植上游 + // PR #120):与 accounts 的账号池视图互补,前端「模型锁池」表直接渲染。无锁时为 null。 + "model_locks": p.cfg.Pool.ModelLockView(), + // 到期提醒快照的节奏与年龄:界面轮询是 5 秒级,但卡片数据只随余额后台刷新 + // 更新(默认每 5 分钟)——把这两个数透出,前端才能如实标注「x 分钟前更新」。 + "balance_refresh_sec": p.balanceRefreshSec(), + "balance_refreshed_at": p.balanceRefreshedAt(), + // 账号目录热重载(issue #199):面板显示「上次重载时间/结果摘要」。 + "reload": p.reloadSnapshot(), + }) +} + +// reloadSnapshot 热重载状态(面板展示用)。无轮询时 interval_sec=0,前端据此 +// 标注「仅手动」。 +func (p *Panel) reloadSnapshot() map[string]any { + at, res := p.ReloadStatus() + p.reloadMu.Lock() + interval := p.reloadInterval + confirm := p.reloadDeleteConfirm + p.reloadMu.Unlock() + out := map[string]any{ + "interval_sec": int(interval.Seconds()), + "delete_confirm": confirm, + } + if !at.IsZero() { + out["at"] = at + out["added"] = res.Added + out["updated"] = res.Updated + out["removed"] = res.Removed + out["parse_errors"] = res.ParseErrors + out["skipped"] = res.Skipped + } + return out +} + +// balanceRefreshSec 余额后台刷新间隔(秒);无调度器/未开启时为 0。 +func (p *Panel) balanceRefreshSec() int { + if p.cfg.Scheduler == nil { + return 0 + } + return int(p.cfg.Scheduler.BalanceInterval() / time.Second) +} + +// balanceRefreshedAt 最近一次后台余额刷新完成时刻;无调度器或尚未跑过为零值。 +func (p *Panel) balanceRefreshedAt() time.Time { + if p.cfg.Scheduler == nil { + return time.Time{} + } + return p.cfg.Scheduler.BalanceRefreshedAt() +} + +func (p *Panel) updateSnapshot() any { + if p.cfg.Updater == nil { + return nil + } + return p.cfg.Updater.Status() +} + +// logsHandler 返回日志环形缓冲快照(时间升序,含频道标记 chat/task/sys)。 +// archive_error:任务日志落盘故障(写失败不影响请求;前端可提示)。 +// +// ?since= 时只返回**该时刻之后**的条目(增量拉取)。面板「运行日志」页 +// 每 5 秒拉一次全量(500 行,~90KB),绝大多数轮次这 500 行根本没变。 +// +// 增量优先认 ?since_seq=(只回 Seq 更大的条目)——这是**唯一可靠**的游标: +// TS 在同一时钟刻度内的多次写入完全相同(Windows 实测 ~15.6ms 粒度,一次 Write +// 的多行 + 背靠背的多次 Write 都会撞),按 TS 过滤必然要么重复、要么整批漏掉。 +// 连「带纳秒的原始 TS 串」也救不了同一刻度内的多条。 +// +// ?since 保留兼容(旧前端 / 手工 curl),语义仍是「TS 严格晚于 since」。 +// +// 语义与全量一致:响应仍是 {entries, archive_error},前端把新条目追加到已有列表。 +// 游标过期时客户端自己做一次全量拉(环形缓冲淘汰最旧行时,被淘汰的行不会再来)。 +func (p *Panel) logsHandler(w http.ResponseWriter, r *http.Request) { + entries := p.logs.Snapshot() + q := r.URL.Query() + if raw := q.Get("since_seq"); raw != "" { + if since, ok := parseSeqParam(raw); ok { + filtered := entries[:0:0] // 新切片:不改 Snapshot 返回的底层数组 + for _, e := range entries { + if e.Seq > since { + filtered = append(filtered, e) + } + } + entries = filtered + } + } else if raw := q.Get("since"); raw != "" { + if since, ok := parseSinceParam(raw); ok { + filtered := entries[:0:0] // 新切片:不改 Snapshot 返回的底层数组 + for _, e := range entries { + if e.TS.After(since) { + filtered = append(filtered, e) + } + } + entries = filtered + } + } + writeJSON(w, http.StatusOK, map[string]any{"entries": entries, "archive_error": p.logs.ArchiveError()}) +} + +// parseSeqParam 解析 ?since_seq=。 +// +// 非法值回落全量(与 parseSinceParam 同口径:宁可多给不可少给)。 +// seq 初值是启动时刻的毫秒数(见 NewRing),远大于 0,故 since_seq=0 等价于 +// 全量——正是首次加载想要的语义。 +func parseSeqParam(raw string) (uint64, bool) { + v, err := strconv.ParseUint(strings.TrimSpace(raw), 10, 64) + if err != nil { + return 0, false + } + return v, true +} + +// parseSinceParam 解析 ?since= 参数。 +// +// 两种形态都要接受: +// - 标准 RFC3339(带时区偏移,如 2026-10-25T08:59:32.05+08:00); +// - 偏移里的 "+" 被 URL 解码成空格(2026-...T08:59:32.05 08:00)——query +// string 里的 "+" 会被解成空格,而 RFC3339 的正偏移恰好用 "+" 表示。 +// +// 失败一律回落全量(宁可多给不可少给),不报错。 +func parseSinceParam(raw string) (time.Time, bool) { + raw = strings.TrimSpace(raw) + if raw == "" { + return time.Time{}, false + } + if t, err := time.Parse(time.RFC3339, raw); err == nil { + return t, true + } + // "+" 被解成空格的形态:把第一个空格还原成 "+" 再试。 + if i := strings.IndexByte(raw, ' '); i > 0 { + fixed := raw[:i] + "+" + raw[i+1:] + if t, err := time.Parse(time.RFC3339, fixed); err == nil { + return t, true + } + } + return time.Time{}, false +} + +// errorSummary 把日志环里的 WARN/ERR 按「账号 × 类型」聚合(见 errors.go)。 +// 与日志同源、零新增存储:环里有几行就聚合几行。 +func (p *Panel) errorSummary(w http.ResponseWriter, r *http.Request) { + entries := p.logs.Snapshot() + lines := make([]LogLine, 0, len(entries)) + for _, e := range entries { + lines = append(lines, LogLine{Text: e.Text, TS: e.TS}) + } + writeJSON(w, http.StatusOK, map[string]any{ + "rows": AggregateErrors(lines), + "scanned": len(entries), + "updated_at": time.Now().Format("15:04:05"), + }) +} + +// requestMetrics 返回进程内请求指标、最近 100 条与归档状态。 +// +// ?recent=0 时**不返回** recent 数组(只回指标与归档状态)。面板「运行日志」页在 +// 归档开启时用归档数据当请求记录表(request_logs),recent 数组用不上——但它有 +// 100 条事件(~35KB),每 5 秒白拉一次、白解析一次、白 GC 一次。这里给前端一个 +// 显式开关,让它按需索取。 +func (p *Panel) requestMetrics(w http.ResponseWriter, r *http.Request) { + if p.cfg.RequestLog == nil { + writeErr(w, http.StatusNotImplemented, "request logger not available") + return + } + snap := p.cfg.RequestLog.Snapshot() + // 显式 "0"/"false" 才跳过;缺省保持原行为(recent 在),避免破坏既有调用方。 + if v := r.URL.Query().Get("recent"); v == "0" || strings.EqualFold(v, "false") { + snap.Recent = nil + } + writeJSON(w, http.StatusOK, snap) +} + +// requestLogs 从 JSONL 归档读取最近请求;limit 默认 200、最大 1000。 +// 支持按 outcome/account/model/client_ip/user_agent 过滤(字符串字段为包含匹配) +// 与 from/to 时间区间(闭区间,unix 秒或 RFC3339)——面板「运行日志」的筛选框、 +// 来源查询与「今天 / 自定义区间」都走这里。 +func (p *Panel) requestLogs(w http.ResponseWriter, r *http.Request) { + if p.cfg.RequestLog == nil { + writeErr(w, http.StatusNotImplemented, "request logger not available") + return + } + limit := 200 + if v := r.URL.Query().Get("limit"); v != "" { + if n, err := strconv.Atoi(v); err == nil && n > 0 { + limit = n + } + } + if limit > 1000 { + limit = 1000 + } + q := r.URL.Query() + rows, err := p.cfg.RequestLog.ReadArchive(limit, reqlog.Filter{ + Outcome: q.Get("outcome"), + Account: q.Get("account"), + Model: q.Get("model"), + ClientIP: q.Get("client_ip"), + UserAgent: q.Get("user_agent"), + From: parseTimeParam(q.Get("from")), + To: parseTimeParam(q.Get("to")), + }) + if err != nil { + writeErr(w, http.StatusInternalServerError, err.Error()) + return + } + // 空结果回 [](而不是 JSON null):前端把 null 与"归档关闭"混在一起会走错分支, + // 显示成不满足筛选条件的最近请求。 + if rows == nil { + rows = []reqlog.Event{} + } + writeJSON(w, http.StatusOK, map[string]any{"entries": rows, "limit": limit}) +} + +// requestLogsClear 清空归档目录里的请求事件文件(面板「清空归档」)。 +// 只删 requests-*.jsonl,与定期 prune 同口径;目录里的其它文件不碰。 +// 删除由归档写循环执行(它是文件句柄的唯一持有者),所以这一步是串行的、不会把 +// 正在写的文件删成「已删除但仍在写」。 +func (p *Panel) requestLogsClear(w http.ResponseWriter, r *http.Request) { + if p.cfg.RequestLog == nil { + writeErr(w, http.StatusNotImplemented, "request logger not available") + return + } + res, err := p.cfg.RequestLog.Purge() + if err != nil { + writeErr(w, http.StatusInternalServerError, err.Error()) + return + } + log.Printf("panel: 清空请求事件归档,删除 %d 个文件(%d 字节)", res.Files, res.Bytes) + writeJSON(w, http.StatusOK, map[string]any{"ok": true, "files": res.Files, "bytes": res.Bytes}) +} + +// creditHistory 返回积分变动流水(新的在前),供「运行日志 → 积分历史」展示。 +// limit 默认 200、上限 1000(与 requestLogs 同口径);可带 uid 精确过滤。 +// 账号昵称在读取时用池快照填充——账本只存 uid,上游改名后旧流水也跟着更新, +// 且留痕路径不必碰 auth 的昵称锁。 +func (p *Panel) creditHistory(w http.ResponseWriter, r *http.Request) { + if p.cfg.CreditHistory == nil { + writeErr(w, http.StatusNotImplemented, "credit history not available") + return + } + limit := 200 + if v := r.URL.Query().Get("limit"); v != "" { + if n, err := strconv.Atoi(v); err == nil && n > 0 { + limit = n + } + } + if limit > 1000 { + limit = 1000 + } + uid := r.URL.Query().Get("uid") + nicks := p.nicknames() + // 有 uid 过滤时必须先全量取回(账本上限默认 2000 条):先截断再过滤会让 + // 筛选后的条数看起来像历史缺失。无过滤时只取 limit 条,不为一次展示拷贝整个账本。 + readLimit := limit + if uid != "" { + readLimit = 0 + } + all := p.cfg.CreditHistory.Read(readLimit) + out := make([]map[string]any, 0, limit) + for _, e := range all { + if uid != "" && e.UID != uid { + continue + } + out = append(out, map[string]any{ + "time": e.Time, + "uid": e.UID, + "account": nicks[e.UID], + "delta": e.Delta, + "before": e.Before, + "after": e.After, + }) + if len(out) >= limit { + break + } + } + writeJSON(w, http.StatusOK, map[string]any{"entries": out, "limit": limit}) +} + +// nicknames 池内 uid → 昵称映射(仅展示用,不含任何凭证)。 +func (p *Panel) nicknames() map[string]string { + nicks := map[string]string{} + if p.cfg.Pool == nil { + return nicks + } + for _, s := range p.cfg.Pool.List() { + if s.Nickname != "" { + nicks[s.UID] = s.Nickname + } + } + return nicks +} + +// models 实时查询上游模型列表与 reasoning 实际档位(直连上游,不读路由层 1h 缓存): +// 回答"该模型到底支持哪几档思考"。顺带刷新 client 的 effort 降级能力缓存。 +// 与 /v1/models 同口径的双域输出:CN 域模型加 "cn:" 前缀、global 域加 "global:" 前缀 +// (gateway 路由协议,前端显示的 id 就是调用时要填的完整 model 值)。 +// 各域独立探测、独立容错:某域无可用账号则整域跳过;两域全空时才报错 +// (有错误明细回 502,一个账号都没有回 503)。 +func (p *Panel) models(w http.ResponseWriter, r *http.Request) { + out := make([]map[string]any, 0) + // catalogErrs = 目录探测失败(决定「整份视图是否可信」→ 报 502 / 不写缓存); + // busyErrs = 繁忙度观测失败(**只是少一列**,目录本身已经拿到)。 + // + // 两者必须分开:此前只有 fetchErrs 一个切片,国际版 /v2/chat/busy 恒 404(见 + // upstream/modelbusy.go)就永久占着一条错误,于是 `len(fetchErrs)==0` 的写缓存条件 + // 永远不成立——只要池里有 global 账号,模型目录缓存完全失效,面板每次刷新都实打上游。 + var catalogErrs []string + var busyErrs []string + + // refresh=1:强制重探 global 目录(issue #216 现象 3)。此前按钮只是重读 1h 缓存, + // 上游目录变了也纹丝不动。CN 侧本来就是每请求直连上游(无缓存),无需处理。 + refresh := r.URL.Query().Get("refresh") == "1" + if refresh { + p.cfg.Upstream.InvalidateGlobalModelsCache() + } else if entry := p.loadModelsCache(); entry != nil { + models := append(p.withLiveFlags(entry.models), p.extensionPanelModels()...) + writeJSON(w, http.StatusOK, map[string]any{ + "ok": true, + "models": models, + "global_source": entry.globalSource, + "cached": true, + }) + return + } + + // CN 域:有可用 CN 账号才查(此前无条件 Pool.Pick()+FetchModels——选中 global + // 账号时打 CN 端点必然失败,混合池表现为偶发 502,纯 global 池必炸)。 + var cnAcct, globalAcct *auth.Auth // 供下方模型繁忙度复用同一批账号 + if uids := p.cfg.Pool.AvailableUIDsForRealm("cn"); len(uids) > 0 { + if acct := p.cfg.Pool.AuthByUID(uids[0]); acct != nil { + cnAcct = acct + infos, err := p.cfg.Upstream.FetchModels(acct) + if err != nil { + catalogErrs = append(catalogErrs, "cn: "+err.Error()) + } else { + for _, mi := range infos { + out = append(out, panelModelEntry("cn", mi, mi.Efforts, mi.DefaultEffort, p.cfg.Upstream.HTTP)) + } + } + } + } + + // global 域:路由开关开且有可用 global 账号才查(独立目录端点,FetchGlobalModelInfos; + // Upstream.GlobalEnabled 是探测侧同一道闸,与 main 装配的 config global.enabled 一致)。 + if p.cfg.Upstream.GlobalEnabled { + if uids := p.cfg.Pool.AvailableUIDsForRealm("global"); len(uids) > 0 { + if acct := p.cfg.Pool.AuthByUID(uids[0]); acct != nil { + globalAcct = acct + infos := p.cfg.Upstream.FetchGlobalModelInfos(acct) + if len(infos) == 0 { + catalogErrs = append(catalogErrs, "global: 上游未返回可用模型") + } else { + efforts, defaults := p.cfg.Upstream.GlobalEffortSnapshot() + for _, mi := range infos { + out = append(out, panelModelEntry("global", mi, efforts[mi.ID], defaults[mi.ID], p.cfg.Upstream.HTTP)) + } + } + } + } + } + + // 出图/出视频模型:目录按 tag 把它们从**对话**列表剔掉了(/v1/models 同样单列),面板 + // 「模型与档位」也必须看得到——否则用户不知道有哪些能调。字段与对话模型同口径, + // 另加 image_generation / video_generation 标记(前端据此标「出图」「出视频」)。 + // 视频端点 2026-11 起已实现(POST /v1/videos/generations + GET /v1/videos/{id}), + // 所以视频模型与出图模型同一个口径列出;出图专有的分档实扣(charge_variants)只对 image 生效。 + // + // 倍率口径(2026-10-22 复测,两个个人号直连上游): + // - 目录**不再给出图模型报 credits**:CN hunyuan-image-alpha 的条目只有 + // id/name/tags(2026-10-18 曾报 x5.00,现已无该键),所以「倍率」只能来自 + // 出图回执里的 usage.credit——牌价这列现在对出图模型基本恒空; + // - CN hunyuan-image-alpha 实扣每张固定 5.71,回执带 output_image_coefficient:1; + // - global hy-image-3.5 实扣每张固定 0.27,回执恒 output_image_tokens:15000, + // 不带 coefficient;旧 global 模型 gpt-image-2.5-sunburst 已下架(14401)。 + // 故这里三个字段并列输出,前端各按语义展示,绝不用均值覆盖牌价: + // credits 上游目录牌价(可能没有) + // measured_credit 账本里该模型的平均实扣(落盘口径,跨重启) + // charge_variants 本次运行按「尺寸×画质」分档的实扣(含最近一次与图像 token), + // 无样本时省略——它是判断「这价是哪一档」的唯一依据。 + measured := map[string]string{} + if p.cfg.Usage != nil { + for _, c := range p.cfg.Usage.Snapshot(0, nil).CreditByModel { + if c.CreditSamples > 0 && c.Credits > 0 { + measured[c.Key] = strconv.FormatFloat(c.Credits/float64(c.CreditSamples), 'f', 2, 64) + } + } + } + for _, realm := range []string{"cn", "global"} { + if realm == "global" && !p.cfg.Upstream.GlobalEnabled { + continue + } + for _, mi := range p.cfg.Upstream.GenerationModels(realm) { + if mi.GenerationKind != "image" && mi.GenerationKind != "video" { + continue + } + e := panelModelEntry(realm, mi, nil, "", p.cfg.Upstream.HTTP) + if mi.GenerationKind == "video" { + e["video_generation"] = true + } else { + e["image_generation"] = true + } + // 有牌价也照样带实测(此前只在 credits 为空时才带,导致 CN 的 5.71 被 + // x5.00 盖住、用户看到的价格比实付低)。 + if v, ok := measured[realm+":"+mi.ID]; ok { + e["measured_credit"] = v + } + if variants := p.cfg.Upstream.ImageCharges(realm, mi.ID); mi.GenerationKind == "image" && len(variants) > 0 { + e["charge_variants"] = variants + last := variants[0] + for _, v := range variants { + if v.LastAt > last.LastAt { + last = v + } + } + e["charge_last"] = map[string]any{ + "credit": math.Round(last.Last*100) / 100, + "size": last.Size, + "quality": last.Quality, + "output_image_tokens": last.LastTokens, + "at": last.LastAt, + } + // 上游回执里的「倍率」原值(CN 恒 1;global 不回该字段则省略)—— + // 只透传不重算:它是上游口径,拿它乘单价得出的数会跟 credit 对不上。 + if last.LastCoefficient > 0 { + e["charge_last"].(map[string]any)["output_image_coefficient"] = last.LastCoefficient + } + } + if _, hasCatalog := e["credits"]; hasCatalog && e["credits"] != "" { + e["credit_source"] = "catalog+usage_receipt" + } else { + e["credit_source"] = "usage_receipt" + } + out = append(out, e) + } + } + + // 模型繁忙度(官方 /v2/chat/busy,只读观测,见 upstream/modelbusy.go):与目录同一批 + // 账号查,附到对应域的行上。查不到就不填字段(不编造);失败只并入 busyErrs(目录本身 + // 已经拿到了,不该因为繁忙度查询失败把整个视图打成 502,更不该阻断目录缓存)。 + for realm, acct := range map[string]*auth.Auth{"cn": cnAcct, "global": globalAcct} { + if acct == nil { + continue + } + prefix := realm + ":" + var ids []string + for _, e := range out { + if id, _ := e["id"].(string); strings.HasPrefix(id, prefix) { + ids = append(ids, strings.TrimPrefix(id, prefix)) + } + } + if len(ids) == 0 { + continue + } + levels, err := p.cfg.Upstream.ModelBusy(acct, ids) + if err != nil { + busyErrs = append(busyErrs, realm+" busy: "+err.Error()) + continue + } + for _, e := range out { + if id, _ := e["id"].(string); strings.HasPrefix(id, prefix) { + if lv := levels[strings.TrimPrefix(id, prefix)]; lv != "" { + e["busy"] = lv + } + } + } + } + + // 扩展模型(免费渠道 / 自定义映射)与账号池无关,即使池为空也要列出来。 + extModels := p.extensionPanelModels() + if len(out) == 0 && len(extModels) == 0 { + if errs := append(append([]string{}, catalogErrs...), busyErrs...); len(errs) > 0 { + writeErr(w, http.StatusBadGateway, "fetch models: "+strings.Join(errs, "; ")) + return + } + writeErr(w, http.StatusServiceUnavailable, "没有可用账号:请先在面板添加账号再查询") + return + } + globalSource := p.cfg.Upstream.GlobalCatalogSource() + // 只有目录错误才拒绝写缓存;繁忙度失败不阻断(否则国际版恒 404 会让缓存永久失效)。 + if len(catalogErrs) == 0 { + p.storeModelsCache(&modelsCacheEntry{models: out, globalSource: globalSource}) + } + writeJSON(w, http.StatusOK, map[string]any{ + "ok": true, + "models": append(p.withLiveFlags(out), extModels...), + // fetch_errors 分域取数失败清单(域成功但另一域失败时也要让前端看到—— + // 否则 global 探测失败(如 DNS 抖动 → 5min 负缓存)时页面只剩 CN 模型, + // 用户不知道国际模型「为什么没了」。2026-10-25 实案。 + // 上游已把单一的 fetchErrs 拆成 catalogErrs / busyErrs,这里取目录失败即可 + // (繁忙度失败另有 busy_errs,前端单独提示)。 + "fetch_errors": catalogErrs, + // global_source global 目录来源(v3-desktop / v3-union / enterprise)。 + // 前端据此提示「拿到的是回落/降级目录」——issue #216 里用户只看到「少了 11 个模型」, + // 完全不知道已经降级到企业端点(那份目录只有 18 条、hy4-preview 的倍率还是旧值)。 + "global_source": globalSource, + // busy_errs 繁忙度观测失败明细(目录不受影响):国际版没有 /v2/chat/busy, + // 首轮会在这里出现一条,之后按域短路不再产生。 + "busy_errs": busyErrs, + }) +} + +// loadModelsCache 返回未过期的聚合结果;TTL 过期或从未成功过返回 nil。 +func (p *Panel) loadModelsCache() *modelsCacheEntry { + p.modelsMu.Lock() + defer p.modelsMu.Unlock() + if p.modelsCache == nil || time.Since(p.modelsCacheAt) >= modelsCacheTTL { + return nil + } + return p.modelsCache +} + +// storeModelsCache 记录一次成功聚合(refresh=1 的强制重探同样刷新缓存)。 +func (p *Panel) storeModelsCache(entry *modelsCacheEntry) { + p.modelsMu.Lock() + defer p.modelsMu.Unlock() + p.modelsCache = entry + p.modelsCacheAt = time.Now() +} + +// withLiveFlags 给模型条目补运行期标记(每次响应按 live 快照现算,不写进 60s +// 缓存:面板里切换「下游可见」或改思考档位策略后,同一缓存周期内也要立刻看到变化)。 +// +// - hidden:是否对下游暴露(models.hidden); +// - gateway_policy_enabled:思考档位策略是否开启(关闭时行内「网关档位」下拉置灰); +// - gateway_effort:按当前策略算出的**实际会注入的档位**——先按 +// model_defaults → 全局 default_effort 求目标档,再由模型真实支持的档位解析 +// (与出站 applyEffortPolicy 同一套 ResolveGatewayEffort,列表与注入不再漂移)。 +// - gateway_effort_wanted:解析前的目标档。与 gateway_effort 不同即说明该模型 +// 不支持这一档、会降级(前端据此给「默认网关档位」下拉做实时提示)。 +// +// 返回浅拷贝切片,缓存条目本身不被改写——并发请求共享同一份缓存。 +func (p *Panel) withLiveFlags(entries []map[string]any) []map[string]any { + var hidden map[string]struct{} + policy := upstream.EffortPolicy{} + if p.cfg.Live != nil { + s := p.cfg.Live.Load() + hidden = s.HiddenModels + policy = upstream.EffortPolicy{ + Enabled: s.ThinkingEnabled, + DefaultEffort: s.ThinkingDefaultEffort, + ClientPriority: s.ThinkingClientPriority, + OverrideScope: s.ThinkingOverrideScope, + ModelDefaults: s.ThinkingModelDefaults, + }.Normalized() + } + out := make([]map[string]any, len(entries)) + for i, e := range entries { + cp := make(map[string]any, len(e)+3) + for k, v := range e { + cp[k] = v + } + if id, ok := e["id"].(string); ok { + _, hide := hidden[id] + cp["hidden"] = hide + cp["gateway_policy_enabled"] = policy.Enabled + realm, bare, hasRealm := strings.Cut(id, ":") + if !hasRealm { + realm, bare = "", id + } + supported, _ := e["supported_efforts"].([]string) + want := policy.DefaultEffortFor(realm, bare) + if eff := upstream.ResolveGatewayEffort(want, supported); eff != "" { + cp["gateway_effort"] = eff + } + // 目标档独立给出(即使解析不出实际档也保留):前端拿它与 gateway_effort + // 对比,判断「这个模型会降级吗」,进而给默认档下拉做聚合提示。 + if want != "" { + cp["gateway_effort_wanted"] = want + } + } + out[i] = cp + } + return out +} + +// panelModelEntry 构造单个模型条目(两域共用):id 带 realm 前缀(调用值即显示值), +// context_length / max_output_tokens 走四级查找链,effort 档位按 realm 域取 +// EffortListing(远端权威 ∪ 静态兜底表)——与 /v1/models 同一口径,两侧不再漂移。 +func panelModelEntry(realm string, mi upstream.ModelInfo, remoteEfforts []string, remoteDefault string, httpc *http.Client) map[string]any { + entry := map[string]any{ + "id": realm + ":" + mi.ID, + "name": mi.Name, + "default_effort": mi.DefaultEffort, + "supported_efforts": mi.Efforts, + "can_disable_thinking": mi.CanDisableThinking, + "supports_reasoning": mi.SupportsReasoning, + "supports_images": mi.SupportsImages, + "credits": mi.Credits, + "description": mi.Description, + "tags": mi.Tags, + "vendor": mi.Vendor, + "tier": mi.Tier, + "is_default": mi.IsDefault, + "supports_tool_call": mi.SupportsToolCall, + "only_reasoning": mi.OnlyReasoning, + "reasoning_effort": mi.ReasoningEffort, + "reasoning_summary": mi.ReasoningSummary, + } + // 限时优惠(modelPromotions):credits 是牌价,promo_* 是当前生效折扣 + //(WorkBuddy 客户端显示的就是这个生效价)。前端据此显示「生效价+标签+划线牌价」。 + if mi.PromoFactor != nil { + entry["promo_factor"] = *mi.PromoFactor + entry["promo_credits"] = mi.PromoCredits + } + if mi.PromoLabel != "" { + entry["promo_label"] = mi.PromoLabel + } + if mi.PromoNote != "" { + entry["promo_note"] = mi.PromoNote + } + if mi.MaxAllowedSize > 0 { + entry["max_allowed_size"] = mi.MaxAllowedSize + } + entry["context_length"] = upstream.ContextWindowListingV4(mi.ID, mi.ContextWindow, httpc) + if mo, ok := upstream.MaxOutputTokensListingV4(mi.ID, mi.MaxTokens, httpc); ok { + entry["max_output_tokens"] = mo + } + if efforts, def := upstream.EffortListing(realm, mi.ID, remoteEfforts, remoteDefault); efforts != nil { + entry["supported_efforts"] = efforts + if def != "" { + entry["default_effort"] = def + } + } + return entry +} + +// modelProbes 返回模型输出上限的探测结果(scripts/probe_max_tokens.py --panel-out +// 写入的契约文件),供前端在「模型与档位」的实测列做风险标注。 +// +// 设计边界:纯只读透传——文件缺失/未配置返回空集(面板退化为无标注,与历史行为 +// 一致),网关自身不解析字段语义、不据此做任何路由或出站决策;上游改了限制后 +// 重跑一次工具、下次查询即刷新,无需重启网关。 +func (p *Panel) modelProbes(w http.ResponseWriter, r *http.Request) { + out := map[string]any{"probes": map[string]json.RawMessage{}, "exists": false} + if p.cfg.ProbeFile == "" { + writeJSON(w, http.StatusOK, out) + return + } + raw, err := os.ReadFile(p.cfg.ProbeFile) + if err != nil { + if os.IsNotExist(err) { + writeJSON(w, http.StatusOK, out) + return + } + writeErr(w, http.StatusInternalServerError, "read probes: "+err.Error()) + return + } + var f struct { + Version int `json:"version"` + Probes map[string]json.RawMessage `json:"probes"` + } + if err := json.Unmarshal(raw, &f); err != nil { + writeErr(w, http.StatusBadGateway, "parse probes: "+err.Error()) + return + } + if f.Probes == nil { + f.Probes = map[string]json.RawMessage{} + } + out["probes"] = f.Probes + out["exists"] = true + if fi, err := os.Stat(p.cfg.ProbeFile); err == nil { + out["updated_at"] = fi.ModTime().Format(time.RFC3339) + } + writeJSON(w, http.StatusOK, out) +} + +// --------------------------------------------------------------------------- +// 账号运维 +// --------------------------------------------------------------------------- + +// accountRevive 手动复活:清禁用 + 冷却 + 熔断(运维口径无条件恢复)。 +func (p *Panel) accountRevive(w http.ResponseWriter, r *http.Request) { + uid := r.PathValue("uid") + if _, ok := p.cfg.Pool.Status(uid); !ok { + writeErr(w, http.StatusNotFound, "account not found") + return + } + p.cfg.Pool.Revive(uid) + log.Printf("panel: revive uid=%s(人工清除禁用/冷却/熔断)", uid) + writeJSON(w, http.StatusOK, map[string]any{"ok": true}) +} + +// accountDisable 人工禁用(不再参与选号,需面板 revive 或重登恢复)。 +func (p *Panel) accountDisable(w http.ResponseWriter, r *http.Request) { + uid := r.PathValue("uid") + if _, ok := p.cfg.Pool.Status(uid); !ok { + writeErr(w, http.StatusNotFound, "account not found") + return + } + // reason 可选:面板人工禁用默认记「管理员操作」,但允许调用方指定真实原因 + // (例:补录历史禁用、脚本按上游判定结果禁用)。不带则沿用默认文案。 + reason := "面板手动禁用(管理员操作)" + var req struct { + Reason string `json:"reason"` + } + if r.Body != nil { + _ = json.NewDecoder(r.Body).Decode(&req) // 空 body/非法 JSON 不算错:保持默认 + } + if v := strings.TrimSpace(req.Reason); v != "" { + reason = v + } + p.cfg.Pool.Disable(uid, reason) + log.Printf("panel: disable uid=%s(人工禁用)reason=%s", uid, reason) + writeJSON(w, http.StatusOK, map[string]any{"ok": true}) +} + +// accountPause 暂停选号:账号退出选号候选,但**照常参与**签到 / 活跃上报 / 保活 / +// 余额刷新。与 disable 的区别:不写 reason、不清冷却域、不重置计数——账号是「临时 +// 让位」而非「判死」,点「恢复选号」即可立刻回到池子(无需重登或解冻)。 +// (吸收上游 fd835df) +func (p *Panel) accountPause(w http.ResponseWriter, r *http.Request) { + uid := r.PathValue("uid") + if !p.cfg.Pool.Pause(uid) { + writeErr(w, http.StatusNotFound, "account not found") + return + } + log.Printf("panel: pause uid=%s(暂停选号,保号任务照常)", uid) + writeJSON(w, http.StatusOK, map[string]any{"ok": true}) +} + +// accountResume 解除暂停选号(幂等,对未暂停账号为空操作)。 +func (p *Panel) accountResume(w http.ResponseWriter, r *http.Request) { + uid := r.PathValue("uid") + if !p.cfg.Pool.Resume(uid) { + writeErr(w, http.StatusNotFound, "account not found") + return + } + log.Printf("panel: resume uid=%s(恢复参与选号)", uid) + writeJSON(w, http.StatusOK, map[string]any{"ok": true}) +} + +// accountGroup 设置 / 清除账号分组标签(body: {"group":"..."},空串 = 取消分组)。 +// 纯管理维度:不参与选号 / 计费 / 鉴权,只影响面板按组筛选与组内批量操作。 +// 返回库里真正落下的值——超长会被池层截断,前端据此回显而不是显示用户输入的原值。 +func (p *Panel) accountGroup(w http.ResponseWriter, r *http.Request) { + uid := r.PathValue("uid") + var req struct { + Group string `json:"group"` + } + if err := json.NewDecoder(r.Body).Decode(&req); err != nil { + writeErr(w, http.StatusBadRequest, "invalid json") + return + } + if !p.cfg.Pool.SetGroup(uid, req.Group) { + writeErr(w, http.StatusNotFound, "account not found") + return + } + group := "" + if st, ok := p.cfg.Pool.Status(uid); ok { + group = st.Group + } + writeJSON(w, http.StatusOK, map[string]any{"ok": true, "group": group}) +} + +// accountCheckin 单号签到:DailyCheckin + 余额查询解冻(已签到等业务错误不阻塞余额刷新), +// 与 scheduler.RunCheckinNow 的单号语义一致。 +func (p *Panel) accountCheckin(w http.ResponseWriter, r *http.Request) { + uid := r.PathValue("uid") + a := p.cfg.Pool.AuthByUID(uid) + if a == nil { + writeErr(w, http.StatusNotFound, "account not found") + return + } + if a.IsGlobal() { + writeJSON(w, http.StatusOK, map[string]any{ + "ok": true, + "realm": "global", + "skipped": true, + "skip_reason": "国际区账号不适用国内区签到", + "checkin_done": false, + }) + return + } + checkinMsg := "" + checkinDone := false + // checkin_state 是「这次签到到底发生了什么」的权威答复,四态见 upstream.CheckinState: + // checked(本次真签到、上游发了积分)/ already(今天早就签过、一个积分都没发)/ + // pending(上游处理中,可稍后重试)/ failed。前端据此出文案与配色——只凭 + // checkin_done 会把 already 和 checked 说成同一句话(同类项目 hub#875 的坑)。 + checkinState := "" + checkinCredit, checkinCreditKnown := 0, false + // 企业版无签到体系(上游 400 code 10001「企业账号不支持该操作」):不发起该调用, + // 端点退化为「刷新额度」——企业额度走 get-enterprise-user-usage 口径(见 upstream)。 + // 前端对企业号不渲染「签到」按钮;此处是 API 侧防御(外部脚本/旧缓存前端仍可能调用)。 + if !a.SupportsPersonalGrowth() { + checkinState = "skipped" + // 静态 API Key 与企业版同列:都没有签到端点可调,但余额照旧刷新(企业口径)。 + if a.IsAPIKey() { + checkinMsg = "API Key 账号无签到体系(已跳过签到,仅刷新额度)" + } else { + checkinMsg = "企业账号无签到体系(已跳过签到,仅刷新额度)" + } + } else { + receipt, err := p.cfg.Upstream.CheckinReceipt(a) + checkinState = string(receipt.State) + checkinMsg = receipt.Msg + if err != nil && checkinMsg == "" { + checkinMsg = err.Error() + } + // 幂等拒绝(already)同样是「今日已签」,标记后按钮显示「已签」。 + if receipt.State == upstream.CheckinChecked || receipt.State == upstream.CheckinAlready { + p.cfg.Pool.NoteCheckinDone(uid) + checkinDone = true + } + // 积分只取上游这次真实发放的数:already 没发、失败没发,都不能给数字。 + if receipt.State == upstream.CheckinChecked && receipt.CreditKnown { + checkinCredit, checkinCreditKnown = receipt.Credit, true + } + } + // realm 取账号真值,不写字面量:上面 global 分支一旦被改(提前返回挪走、门控放宽), + // 这里硬写的 "cn" 会让国际号拿到错误回显。 + resp := map[string]any{"ok": checkinDone, "realm": a.Realm(), "checkin_done": checkinDone, "checkin_state": checkinState} + if checkinCreditKnown { + resp["checkin_credit"] = checkinCredit + } + if a.IsEnterprise() { + resp["enterprise"] = true + } + if a.IsAPIKey() { + resp["api_key"] = true + } + if checkinMsg != "" { + resp["checkin_message"] = checkinMsg + if !checkinDone { + resp["checkin_error"] = checkinMsg + } + } + remain, total, expiring, earliestAt, earliestRemaining, buckets, err := p.cfg.Upstream.UserResourceSnapshot(a, p.expiringSoonWindow()) + if err != nil { + resp["balance_error"] = err.Error() + writeJSON(w, http.StatusOK, resp) + return + } + p.cfg.Pool.ReenableIfCredits(uid, remain, total) + p.cfg.Pool.SetCreditsSnapshot(uid, pool.CreditsSnapshot{ + Remain: remain, + Total: total, + Expiring: expiring, + EarliestAt: earliestAt, + EarliestRemaining: earliestRemaining, + ExpiryBuckets: poolExpiryBuckets(buckets), + }) + resp["credits"] = remain + resp["credits_total"] = total + log.Printf("panel: checkin uid=%s msg=%q credits=%d/%d", uid, checkinMsg, remain, total) + writeJSON(w, http.StatusOK, resp) +} + +// accountBalance 单号余额刷新:更新余额与到期快照,不触碰冷却状态。 +func (p *Panel) accountBalance(w http.ResponseWriter, r *http.Request) { + uid := r.PathValue("uid") + a := p.cfg.Pool.AuthByUID(uid) + if a == nil { + writeErr(w, http.StatusNotFound, "account not found") + return + } + remain, total, expiring, earliestAt, earliestRemaining, buckets, err := p.cfg.Upstream.UserResourceSnapshot(a, p.expiringSoonWindow()) + if err != nil { + writeErr(w, http.StatusBadGateway, "user resource: "+err.Error()) + return + } + p.cfg.Pool.SetCreditsSnapshot(uid, pool.CreditsSnapshot{ + Remain: remain, + Total: total, + Expiring: expiring, + EarliestAt: earliestAt, + EarliestRemaining: earliestRemaining, + ExpiryBuckets: poolExpiryBuckets(buckets), + }) + writeJSON(w, http.StatusOK, map[string]any{"ok": true, "credits": remain, "credits_total": total}) +} + +// accountRemove 移除账号:先出池(立即落盘 state),再删 auth 文件。 +func (p *Panel) accountRemove(w http.ResponseWriter, r *http.Request) { + p.proxyAccountMu.Lock() + defer p.proxyAccountMu.Unlock() + // 与目录热重载串行化(issue #199 风险 3):重载正在对齐池时插入一次移除, + // 可能出现「重载刚按扫描结果 upsert 回来、这边又删掉」的交错,两边都以为 + // 自己是对的。锁序固定为 proxyAccountMu → reloadMu → pool.mu:全仓只有本函数 + // 同时持有前两个(proxies.go 那两处只取 proxyAccountMu),不存在反向路径。 + p.reloadMu.Lock() + defer p.reloadMu.Unlock() + uid := r.PathValue("uid") + if p.cfg.Pool.AuthByUID(uid) == nil { + writeErr(w, http.StatusNotFound, "account not found") + return + } + if p.cfg.ProxyPool != nil { + if err := p.cfg.ProxyPool.Unbind(uid); err != nil { + writeErr(w, http.StatusInternalServerError, "save account proxy binding failed") + return + } + } + a := p.cfg.Pool.Remove(uid) + if a == nil { + writeErr(w, http.StatusNotFound, "account not found") + return + } + fileMsg := "" + if a.FilePath != "" { + if err := os.Remove(a.FilePath); err != nil && !os.IsNotExist(err) { + fileMsg = err.Error() + } + } + if fileMsg != "" { + log.Printf("panel: remove uid=%s(auth 文件删除失败: %s)", uid, fileMsg) + writeJSON(w, http.StatusOK, map[string]any{"ok": true, "file_error": fileMsg}) + return + } + log.Printf("panel: remove uid=%s(已出池并删除凭证文件)", uid) + writeJSON(w, http.StatusOK, map[string]any{"ok": true}) +} + +// --------------------------------------------------------------------------- +// 批量任务 +// --------------------------------------------------------------------------- + +// tryStartBatch 手动全量运维接口的防重入闸门:五个动作(签到/旅行/活跃/保活/ +// 余额)共用一把——它们都是逐号打上游,并发跑两轮 = 每号至少翻倍上游请求,正是 +// 批间节流要避免的场景(与任务中心 tryLockAccount 的 409 语义一致)。 +func (p *Panel) tryStartBatch(w http.ResponseWriter, action string) bool { + if !p.batchRunning.CompareAndSwap(false, true) { + writeErr(w, http.StatusConflict, "已有全量任务在执行中,请等待本轮完成后再触发") + log.Printf("panel: %s 重复触发被拒绝(已有全量任务在跑)", action) + return false + } + return true +} + +// finishBatch 归还防重入闸门。 +func (p *Panel) finishBatch() { p.batchRunning.Store(false) } + +// checkinAll 手动触发全量签到(异步执行,进度看日志区/账号状态变化)。 +func (p *Panel) checkinAll(w http.ResponseWriter, r *http.Request) { + if !p.tryStartBatch(w, "全量签到") { + return + } + if p.cfg.Scheduler == nil { + p.finishBatch() + writeErr(w, http.StatusNotImplemented, "scheduler not available") + return + } + go func() { + defer p.finishBatch() + p.cfg.Scheduler.RunCheckinNow() + }() + log.Printf("panel: 手动全量签到已触发(含猫猫旅行)") + writeJSON(w, http.StatusOK, map[string]any{"ok": true, "started": true}) +} + +// travelAll 手动触发全量猫猫旅行巡检(异步执行)。 +func (p *Panel) travelAll(w http.ResponseWriter, r *http.Request) { + if !p.tryStartBatch(w, "全量旅行巡检") { + return + } + if p.cfg.Scheduler == nil { + p.finishBatch() + writeErr(w, http.StatusNotImplemented, "scheduler not available") + return + } + go func() { + defer p.finishBatch() + p.cfg.Scheduler.RunTravelNow() + }() + log.Printf("panel: 手动全量旅行巡检已触发") + writeJSON(w, http.StatusOK, map[string]any{"ok": true, "started": true}) +} + +// accountTravel POST /panel/api/accounts/{uid}/travel:单号推进一趟猫猫旅行(issue #227)。 +// 与 checkin 同构——同步返回,外部调度器据此知道这一号本轮有没有动。门控在 +// Scheduler.RunTravelNowFor 里(禁用/暂停/无 refresh token/global/企业一律跳过)。 +func (p *Panel) accountTravel(w http.ResponseWriter, r *http.Request) { + if p.cfg.Scheduler == nil { + writeErr(w, http.StatusNotImplemented, "scheduler not available") + return + } + uid := r.PathValue("uid") + if p.cfg.Pool.AuthByUID(uid) == nil { + writeErr(w, http.StatusNotFound, "account not found") + return + } + ran := p.cfg.Scheduler.RunTravelNowFor(uid) + if !ran { + writeJSON(w, http.StatusOK, map[string]any{ + "ok": true, "ran": false, "skipped": true, + "skip_reason": "禁用/暂停/无 refresh token/国际区/企业版账号不参与旅行", + }) + return + } + log.Printf("panel: 按号旅行巡检 uid=%s 完成", uid) + writeJSON(w, http.StatusOK, map[string]any{"ok": true, "ran": true}) +} + +// activityAll 手动触发全量活跃上报(异步执行;点亮连登 + 解锁领养前置)。 +func (p *Panel) activityAll(w http.ResponseWriter, r *http.Request) { + if !p.tryStartBatch(w, "全量活跃上报") { + return + } + if p.cfg.Scheduler == nil { + p.finishBatch() + writeErr(w, http.StatusNotImplemented, "scheduler not available") + return + } + go func() { + defer p.finishBatch() + p.cfg.Scheduler.RunActivityNow() + }() + log.Printf("panel: 手动全量活跃上报已触发") + writeJSON(w, http.StatusOK, map[string]any{"ok": true, "started": true}) +} + +// keepaliveAll 手动触发全量 token 保活(异步执行)。 +func (p *Panel) keepaliveAll(w http.ResponseWriter, r *http.Request) { + if !p.tryStartBatch(w, "全量保活") { + return + } + if p.cfg.Scheduler == nil { + p.finishBatch() + writeErr(w, http.StatusNotImplemented, "scheduler not available") + return + } + go func() { + defer p.finishBatch() + p.cfg.Scheduler.RunKeepaliveNow() + }() + log.Printf("panel: 手动全量保活已触发") + writeJSON(w, http.StatusOK, map[string]any{"ok": true, "started": true}) +} + +// balanceAll 手动全量刷新余额:并发查上游、写回池内 credits(含解冻语义), +// 完成后返回——面板紧接着拉 overview 即是最新值。账号量小(个位数), +// 同步等待(上限受短 RPC 超时约束)比"触发后盲刷"体验更确定。 +func (p *Panel) balanceAll(w http.ResponseWriter, r *http.Request) { + if !p.tryStartBatch(w, "全量余额刷新") { + return + } + defer p.finishBatch() + if p.cfg.Scheduler == nil { + writeErr(w, http.StatusNotImplemented, "scheduler not available") + return + } + p.cfg.Scheduler.RunBalanceRefreshNow() + p.syncNicknames() + log.Printf("panel: 手动全量余额刷新完成") + writeJSON(w, http.StatusOK, map[string]any{"ok": true, "accounts": p.cfg.Pool.List()}) +} + +// syncNicknames 手动刷新时的昵称同步(issue #94 同步:上游改名免重登)。 +// 只在面板手动「刷新」路径调用——后台余额定时器不触发(用户明确要求资料接口 +// 仅手动触达)。逐号拉 /console/account,只取 nickname(手机号等敏感字段在 +// upstream.FetchAccountProfile 内即被丢弃);单号失败静默跳过,不打断余额刷新 +// 的既有结果。 +func (p *Panel) syncNicknames() { + type job struct { + uid string + a *auth.Auth + } + var jobs []job + for _, st := range p.cfg.Pool.List() { + if st.Disabled { + continue + } + if a := p.cfg.Pool.AuthByUID(st.UID); a != nil && a.AccessTokenValue() != "" { + jobs = append(jobs, job{uid: st.UID, a: a}) + } + } + if len(jobs) == 0 { + return + } + var ( + mu sync.Mutex + updated int + failed int + sem = make(chan struct{}, 3) + wg sync.WaitGroup + ) + for _, j := range jobs { + wg.Add(1) + go func(j job) { + defer wg.Done() + sem <- struct{}{} + defer func() { <-sem }() + nick, err := p.cfg.Upstream.FetchAccountProfile(j.a) + if err != nil { + mu.Lock() + failed++ + mu.Unlock() + return + } + if p.cfg.Pool.SetNickname(j.uid, nick) { + mu.Lock() + updated++ + mu.Unlock() + } + }(j) + } + wg.Wait() + if updated > 0 || failed > 0 { + log.Printf("panel: 昵称同步:更新 %d 个,失败 %d 个(未变化不计数)", updated, failed) + } +} + +// --------------------------------------------------------------------------- +// helpers +// --------------------------------------------------------------------------- + +// usage 返回逐请求用量聚合。统计窗口三选一: +// - from/to(unix 秒):显式区间,用于「今天」与「自定义」——区间由浏览器按 +// 本地时区算好再发,服务端时区与浏览器不一致时「今天」才不会被算错; +// - hours:滚动窗口(默认 72,上限 1440=60 天),卡片汇总/按域/按账号/按模型/ +// 时序**全部**按该窗口统计;显式 hours=0 表示全部历史(含 90 天前折叠出的日桶); +// - 都不给:等同于 hours=72(保持旧调用方行为)。 +func (p *Panel) usage(w http.ResponseWriter, r *http.Request) { + if p.cfg.Usage == nil { + writeErr(w, http.StatusNotImplemented, "usage recorder not available") + return + } + q := r.URL.Query() + win := usage.Window{} + win.From = parseTimeParam(q.Get("from")) + win.To = parseTimeParam(q.Get("to")) + if win.From.IsZero() && win.To.IsZero() { + win.Hours = 72 + if v := q.Get("hours"); v != "" { + if n, err := strconv.Atoi(v); err == nil && n >= 0 { + win.Hours = n + } + } + if win.Hours > 1440 { + win.Hours = 1440 + } + } + // 昵称仅用于展示,取自池快照(不含任何凭证)。 + nicks := p.nicknames() + var currentRate func(realm, model string) string + if p.cfg.Upstream != nil { + currentRate = p.cfg.Upstream.ModelRate + } + writeJSON(w, http.StatusOK, p.cfg.Usage.SnapshotWindow(win, nicks, currentRate)) +} + +// parseTimeParam 解析时间查询参数:unix 秒(前端默认)或 RFC3339(便于手工调 +// 接口/写脚本)。空串与非法值都返回零值 = 该侧不设界,不报错——区间参数是可选 +// 增强,拼错一个 from 不该让整页用量打不开。 +func parseTimeParam(v string) time.Time { + v = strings.TrimSpace(v) + if v == "" { + return time.Time{} + } + if n, err := strconv.ParseInt(v, 10, 64); err == nil { + if n <= 0 { + return time.Time{} + } + // 兼容秒与毫秒(前端可能直接把 Date.now() 传上来)。 + if n > 1e12 { + return time.UnixMilli(n) + } + return time.Unix(n, 0) + } + if t, err := time.Parse(time.RFC3339, v); err == nil { + return t + } + if t, err := time.ParseInLocation("2006-01-02T15:04", v, time.Local); err == nil { + return t + } + return time.Time{} +} + +// usageSave 立即把内存中的用量桶落盘(正常由后台 30s 防抖刷新负责)。 +func (p *Panel) usageSave(w http.ResponseWriter, r *http.Request) { + if p.cfg.Usage == nil { + writeErr(w, http.StatusNotImplemented, "usage recorder not available") + return + } + p.cfg.Usage.Save() + writeJSON(w, http.StatusOK, map[string]any{"ok": true}) +} + +// packages 返回全部账号的积分包构成,供「积分构成」视图对比。 +// +// 逐个账号向上游查(并发有上限,避免瞬时打满上游限流),失败只在对应账号上 +// 标 error,不影响其它账号——一个号 token 失效不该让整页空白。 +func (p *Panel) packages(w http.ResponseWriter, r *http.Request) { + accts := p.cfg.Pool.List() + type row struct { + UID string `json:"uid"` + Nickname string `json:"nickname"` + Realm string `json:"realm"` + Remain int64 `json:"remain"` + Size int64 `json:"size"` + Packages []upstream.CreditPackage `json:"packages"` + // Plan/PlanEvidence 账号套餐分类(见 pool.ClassifyPlan):包名派生,无包时 unknown。 + Plan pool.PlanKind `json:"plan"` + PlanEvidence string `json:"plan_evidence,omitempty"` + Error string `json:"error,omitempty"` + } + out := make([]row, len(accts)) + + sem := make(chan struct{}, 3) + var wg sync.WaitGroup + for i, s := range accts { + wg.Add(1) + go func(i int, s pool.Status) { + defer wg.Done() + sem <- struct{}{} + defer func() { <-sem }() + + it := row{UID: s.UID, Nickname: s.Nickname, Realm: s.Realm} + a := p.cfg.Pool.AuthByUID(s.UID) + if a == nil { + it.Error = "account not loaded" + out[i] = it + return + } + packs, remain, size, err := p.cfg.Upstream.CreditPackages(a) + if err != nil { + it.Error = err.Error() + out[i] = it + return + } + it.Packages = packs + it.Remain = remain + it.Size = size + names := make([]string, 0, len(packs)) + for _, pk := range packs { + names = append(names, pk.Name) + } + it.Plan, it.PlanEvidence = pool.ClassifyPlan(names) + out[i] = it + }(i, s) + } + wg.Wait() + + // 余额降序:多的在前,便于和少的对比。 + sort.SliceStable(out, func(i, j int) bool { return out[i].Remain > out[j].Remain }) + writeJSON(w, http.StatusOK, map[string]any{"accounts": out}) +} + +func writeJSON(w http.ResponseWriter, status int, v any) { + raw, _ := json.Marshal(v) + w.Header().Set("Content-Type", "application/json") + w.WriteHeader(status) + _, _ = w.Write(raw) +} + +func writeErr(w http.ResponseWriter, status int, msg string) { + writeJSON(w, status, map[string]any{"ok": false, "error": msg}) +} + +// balanceHistory 返回余额采样序列,供「余额趋势」视图画折线。 +// days 查询参数控制窗口(默认 30,上限 30 = detailedKeep;更早的数据已折叠为日粒度, +// 传更大值也只能拿到日粒度点)。 +func (p *Panel) balanceHistory(w http.ResponseWriter, r *http.Request) { + if p.cfg.Balance == nil { + writeErr(w, http.StatusNotImplemented, "balance recorder not available") + return + } + days := 30 + if v := r.URL.Query().Get("days"); v != "" { + if n, err := strconv.Atoi(v); err == nil && n > 0 { + days = n + } + } + if days > 30 { + days = 30 + } + since := time.Now().AddDate(0, 0, -days) + // 昵称仅用于展示,取自池快照(不含任何凭证);实时值优先,历史值兜底。 + // 昵称与域仅用于展示,取自池快照(不含任何凭证);实时值优先,历史值兜底。 + // realm 必须在 Snapshot 前注入:cn 与 global 的积分不同源、不可互换, + // 跨域求和语义不成立,前端需按域分组渲染。 + for _, st := range p.cfg.Pool.List() { + if st.Nickname != "" { + p.cfg.Balance.SetName(st.UID, st.Nickname) + } + if st.Realm != "" { + p.cfg.Balance.SetRealm(st.UID, st.Realm) + } + } + series, now := p.cfg.Balance.Snapshot(since) + writeJSON(w, http.StatusOK, map[string]any{ + "ok": true, + "now": now.Format(time.RFC3339), + "days": days, + "series": series, + }) +} + +// modelToggle 手动开关某 (账号, 模型) 组合。 +// +// 语义:这是**人工意图**(永久),与 modelCooldowns(上游触发、临时、过期自动删) +// 正交。手动关掉的组合自动机制不能恢复 —— 见 internal/pool/toggle.go 的说明。 +// +// model 接受带前缀形式(cn:gpt-4)也接受裸名;入库前统一剥前缀,与出站口径一致 +// (上游只认裸名,且带前缀存会在模型改名/换域时对不上)。 +func (p *Panel) modelToggle(w http.ResponseWriter, r *http.Request) { + uid := r.PathValue("uid") + if _, ok := p.cfg.Pool.Status(uid); !ok { + writeErr(w, http.StatusNotFound, "account not found") + return + } + var req struct { + Model string `json:"model"` + Off bool `json:"off"` + Note string `json:"note"` + } + if err := json.NewDecoder(r.Body).Decode(&req); err != nil { + writeErr(w, http.StatusBadRequest, "bad json: "+err.Error()) + return + } + model := strings.TrimSpace(req.Model) + if model == "" { + writeErr(w, http.StatusBadRequest, "model is required") + return + } + // 剥 realm 前缀(与出站口径一致:上游只认裸名) + if i := strings.Index(model, ":"); i >= 0 { + model = model[i+1:] + } + if req.Off { + if !p.cfg.Pool.SetModelOff(uid, model, req.Note) { + writeErr(w, http.StatusBadRequest, "set model off failed") + return + } + } else { + p.cfg.Pool.SetModelOn(uid, model) + } + writeJSON(w, http.StatusOK, map[string]any{ + "ok": true, "uid": uid, "model": model, "off": req.Off, + "list": p.cfg.Pool.ModelOffOf(uid), + }) +} + +// modelFallbackSnapshot 返回当前降级路由表(nil 安全)。 +// 走回调而非持有 map:live 快照会随面板保存配置替换,持有旧 map 会读到过期表。 +func (p *Panel) modelFallbackSnapshot() map[string]string { + if p.cfg.ModelFallback == nil { + return nil + } + return p.cfg.ModelFallback() +} + +// accountProbeBan 探测被封禁账号在上游是否已解封(**只读**,不改池状态)。 +// +// 为什么需要(用户需求):账号被 11140「账号存在异常行为」判死后,唯一的确认方式 +// 是反复 revive —— 但每次 revive 都会让账号重新参与选号、立刻再撞 11140, +// 反复触发可能加重上游风控判定。需要一个「不惊动它」的问法。 +// +// 用什么探:UserResource(余额查询)是最轻的只读端点,且 11140 会在这里原样返回 +// (上游 auth/auth_forbidden 在 billing 侧同样生效)。不用 chat —— 那会占在途、 +// 记连败、可能被计入风控。 +// +// 判据: +// - 200 → 已解封(可以 revive 了) +// - 11140/封禁类 → 仍被封(继续等) +// - 401/session → 不是封禁问题,是登录失效(该重登) +// - 其它 → 无结论(网络/限流等,稍后再试) +// +// 不写任何池状态:探测是观测行为,不该改变账号的可用性判断 —— 否则运维点一下 +// 探活就把号放回池子,等于变相 revive。 +func (p *Panel) accountProbeBan(w http.ResponseWriter, r *http.Request) { + uid := r.PathValue("uid") + st, ok := p.cfg.Pool.Status(uid) + if !ok { + writeErr(w, http.StatusNotFound, "account not found") + return + } + a := p.cfg.Pool.AuthByUID(uid) + if a == nil { + writeErr(w, http.StatusNotFound, "account credentials not found") + return + } + resp := map[string]any{ + "ok": true, + "uid": uid, + "nickname": st.Nickname, + "was_disabled": st.Disabled, + "was_reason": st.DisabledReason, + "probed_at": time.Now().Format(time.RFC3339), + } + if p.cfg.Upstream == nil { + resp["verdict"] = "unknown" + resp["detail"] = "upstream client not configured" + writeJSON(w, http.StatusOK, resp) + return + } + _, _, err := p.cfg.Upstream.UserResource(a) + // 302/401 的求证与 chat 路径同一套逻辑(见 server/handler.go 的网关 401 分支): + // 网关 401 的响应体是 APISIX 的 HTML 页,**封禁(11140)与登录失效看起来完全一样**, + // 单看 401 分不出来。refresh 才是权威判词:refresh 成功 = 会话仍活(那 401 就是 + // 风控拦截,含 11140 封禁);refresh 被明确拒绝 = 登录态真失效。 + // 网关 401 的求证与 chat 路径同一套判据(upstream.VerifySessionByRefresh): + // 封禁(11140)与登录失效的响应体都是 APISIX HTML 页,单看 401 分不出来。 + if err != nil && isSessionDeadErr(err) { + switch p.cfg.Upstream.VerifySessionByRefresh(a) { + case upstream.VerifyAlive: + resp["verdict"] = "blocked" + resp["detail"] = err.Error() + resp["advice"] = "会话仍有效,但请求被上游风控拦截(可能仍是 11140 封禁)—— 继续观察,勿反复 revive" + log.Printf("panel: probe_ban uid=%s → 被拦截但会话有效(refresh ok)", uid) + writeJSON(w, http.StatusOK, resp) + return + case upstream.VerifyInconclusive: + resp["verdict"] = "inconclusive" + resp["detail"] = err.Error() + resp["advice"] = "refresh 未给出明确判词(网络/限流等),稍后再试" + log.Printf("panel: probe_ban uid=%s → 无明确结论", uid) + writeJSON(w, http.StatusOK, resp) + return + } + // VerifyDead:落到下面的 session_dead 分支。 + } + switch { + case err == nil: + resp["verdict"] = "lifted" + resp["advice"] = "上游已解封,可以点「解冻」恢复使用" + log.Printf("panel: probe_ban uid=%s → 已解封", uid) + case isAccountFaultErr(err): + resp["verdict"] = "still_banned" + resp["detail"] = err.Error() + resp["advice"] = "仍被封禁,继续等待;勿反复 revive(可能加重风控)" + log.Printf("panel: probe_ban uid=%s → 仍被封", uid) + case isSessionDeadErr(err): + resp["verdict"] = "session_dead" + resp["detail"] = err.Error() + resp["advice"] = "不是封禁问题,是登录态失效 —— 需重新登录" + log.Printf("panel: probe_ban uid=%s → 登录失效(非封禁)", uid) + default: + resp["verdict"] = "inconclusive" + resp["detail"] = err.Error() + resp["advice"] = "无明确结论(网络/限流等),稍后再试" + log.Printf("panel: probe_ban uid=%s → 无结论: %v", uid, err) + } + writeJSON(w, http.StatusOK, resp) +} + +// isAccountFaultErr 判断错误是否为账号级封禁/风控(11140 request illegal 等)。 +func isAccountFaultErr(err error) bool { + var ue *upstream.Error + if !errors.As(err, &ue) { + return false + } + return ue.Kind == upstream.ErrAccountFault +} + +// isSessionDeadErr 判断错误是否为登录态失效。 +func isSessionDeadErr(err error) bool { + var ue *upstream.Error + if !errors.As(err, &ue) { + return false + } + return ue.Kind == upstream.ErrSessionDead +} diff --git a/internal/panel/paused_test.go b/internal/panel/paused_test.go new file mode 100644 index 0000000000000000000000000000000000000000..a8195190418459da480fe8068d1e1408e10f37ae --- /dev/null +++ b/internal/panel/paused_test.go @@ -0,0 +1,296 @@ +package panel + +import ( + "encoding/json" + "net/http" + "net/http/httptest" + "os" + "os/exec" + "path/filepath" + "testing" + "time" + + "github.com/misakano7545/workbuddy2api-panel/internal/auth" + "github.com/misakano7545/workbuddy2api-panel/internal/pool" +) + +// 暂停选号(paused)的面板接线:POST /pause 与 /resume 必须落到池状态上, +// 且全程不动 disabled(吸收上游 fd835df)。 +func TestAccountPauseAndResumeWireToPool(t *testing.T) { + p := pool.New("") + p.Add(&auth.Auth{UID: "u1", Nickname: "A", AccessToken: "at1"}) + pn := New(Config{Version: "test", Pool: p}) + + call := func(path string) *httptest.ResponseRecorder { + rec := httptest.NewRecorder() + pn.ServeHTTP(rec, httptest.NewRequest(http.MethodPost, path, nil)) + return rec + } + if rec := call("/panel/api/accounts/u1/pause"); rec.Code != http.StatusOK { + t.Fatalf("pause code=%d body=%s", rec.Code, rec.Body) + } + st, _ := p.Status("u1") + if !st.Paused { + t.Errorf("pause 后 Status.Paused 应为 true: %+v", st) + } + if st.Disabled { + t.Errorf("暂停不是禁用:Disabled 必须为 false: %+v", st) + } + // 暂停后选号应跳过该号(唯一号 → nil) + if got := p.Pick(); got != nil { + t.Errorf("暂停号不应被选中,got %+v", got) + } + + if rec := call("/panel/api/accounts/u1/resume"); rec.Code != http.StatusOK { + t.Fatalf("resume code=%d body=%s", rec.Code, rec.Body) + } + if st, _ := p.Status("u1"); st.Paused { + t.Errorf("resume 后 Paused 应为 false: %+v", st) + } + if got := p.Pick(); got == nil || got.UID != "u1" { + t.Errorf("resume 后应可选,got %+v", got) + } + + // 未知 uid → 404(供前端区分「账号不存在」) + if rec := call("/panel/api/accounts/nope/pause"); rec.Code != http.StatusNotFound { + t.Errorf("pause 未知 uid code=%d want 404", rec.Code) + } + if rec := call("/panel/api/accounts/nope/resume"); rec.Code != http.StatusNotFound { + t.Errorf("resume 未知 uid code=%d want 404", rec.Code) + } +} + +// overview 必须把 paused 透出给面板(前端据此渲染「已暂停选号」与「恢复选号」按钮)。 +func TestOverviewExposesPausedFlag(t *testing.T) { + p := pool.New("") + p.Add(&auth.Auth{UID: "u1", Nickname: "A", AccessToken: "at1"}) + p.Pause("u1") + pn := New(Config{Version: "test", Pool: p}) + + rec := httptest.NewRecorder() + pn.ServeHTTP(rec, httptest.NewRequest(http.MethodGet, "/panel/api/overview", nil)) + if rec.Code != http.StatusOK { + t.Fatalf("overview code=%d", rec.Code) + } + var d struct { + Disabled int `json:"disabled"` + Paused int `json:"paused"` + Accounts []struct { + UID string `json:"uid"` + Paused bool `json:"paused"` + } `json:"accounts"` + } + if err := json.Unmarshal(rec.Body.Bytes(), &d); err != nil { + t.Fatal(err) + } + if len(d.Accounts) != 1 || !d.Accounts[0].Paused { + t.Fatalf("overview 未透出 paused: %s", rec.Body) + } + // 概况卡片分开计数(吸收上游 PR #130 / issue #125):暂停只关选号、照常签到保活, + // 与禁用是两种运维状态。此前这里断言 paused 计入 disabled——那正是被修掉的口径。 + if d.Paused != 1 { + t.Errorf("overview.paused=%d want 1(暂停单独计数)", d.Paused) + } + if d.Disabled != 0 { + t.Errorf("overview.disabled=%d want 0(暂停不得算进已禁用)", d.Disabled) + } +} + +// TestAppJSAccountRowPausedBadgeAndButton 面板账号行必须把 paused 渲染成 +// 「已暂停选号」标签 + 「恢复选号」按钮,正常号则是「暂停选号」按钮。 +// +// 为什么值得一测:s.paused 拼错/字段名漂移时前端会静默退回「可用」+「禁用」, +// 后端全绿而功能在界面上不存在(本仓踩过一次同类的静默渲染回归)。 +func TestAppJSAccountRowPausedBadgeAndButton(t *testing.T) { + node, err := exec.LookPath("node") + if err != nil { + t.Skip("node not installed; account row paused test skipped") + } + script := `const fs = require('fs'); +const vm = require('vm'); +const assert = require('assert'); +const src = fs.readFileSync(process.argv[2], 'utf8'); +const start = src.indexOf('function renderAccounts('), end = src.indexOf('async function loadOverview('); +assert.ok(start >= 0 && end > start, 'renderAccounts not found'); +const tb = { innerHTML: '' }; +const ctx = { + String, Number, Math, Date, Object, Array, JSON, RegExp, console, + document: { activeElement: null }, + accountProxyHTML: () => '', + $: id => (id === 'accBody' ? tb : null), + setHTML: (el, html) => { el.innerHTML = html; }, + esc: s => String(s == null ? '' : s), dur: () => '1m', ago: () => '刚刚', + remarkName: (uid, html) => html, // 备注是展示层增强,本测试只关心 paused 徽标/按钮 + // 账号池域分类是模块级状态(定义在 renderAccounts 之前的抽取范围外),按真实初值注入。 + accRealmFilter: 'all', lastAccountsList: [], + // 分组筛选是 renderAccounts 里新增的模块级状态(同上,抽取范围外):按真实初值注入。 + accGroupFilter: '', lastVisibleAccounts: [], syncGroupFilter: () => {}, + rateLimitRowsHtml: () => '', formatTokenCount: () => '0', formatLatency: () => '-', formatRate: () => '-', + // 禁用原因分类与时长:定义在 renderAccounts 之前(抽取范围外),此处按真实实现注入, + // 否则 renderAccounts 一进禁用分支就 ReferenceError。 + disabledKind: reason => { + const r = String(reason || '').toLowerCase(); + if (/11140|banned|restricted|request illegal/.test(r)) return { label: '上游封禁', tone: 'bad', action: '需在官方申诉,revive 无效' }; + if (/refresh.*失败/.test(r)) return { label: '登录失效', tone: 'bad', action: '需重新登录' }; + if (/12153/.test(r)) return { label: '登录失效', tone: 'bad', action: '需重新登录' }; + if (/401/.test(r)) return { label: '鉴权失败', tone: 'warn', action: '确认后重登或恢复' }; + if (/manual|手动/.test(r)) return { label: '手动禁用', tone: 'warn', action: '随时可恢复' }; + return { label: '已禁用', tone: 'warn', action: '' }; + }, + disabledAge: () => '3 天前', +}; +vm.createContext(ctx); +vm.runInContext(src.slice(start, end) + '\nthis.renderAccounts = renderAccounts;', ctx); +const base = { uid: 'u1', nickname: 'A', credits: 100, credits_total: 100, success_count: 1, err_total: 0 }; +ctx.renderAccounts([Object.assign({}, base, { paused: true })]); +assert.ok(tb.innerHTML.includes('已暂停选号'), 'paused 行应显示已暂停选号: ' + tb.innerHTML); +assert.ok(tb.innerHTML.includes('data-a="resume"'), 'paused 行应给「恢复选号」按钮: ' + tb.innerHTML); +assert.ok(!tb.innerHTML.includes('data-a="pause"'), 'paused 行不该再出现「暂停选号」按钮'); +ctx.renderAccounts([base]); +assert.ok(tb.innerHTML.includes('data-a="pause"'), '正常行应有「暂停选号」按钮: ' + tb.innerHTML); +assert.ok(tb.innerHTML.includes('data-a="disable"'), '正常行仍应有「禁用」按钮'); +assert.ok(!tb.innerHTML.includes('已暂停选号'), '正常行不该出现已暂停选号'); +ctx.renderAccounts([Object.assign({}, base, { disabled: true, paused: false })]); +assert.ok(tb.innerHTML.includes('已禁用'), '禁用行仍显示已禁用'); +assert.ok(!tb.innerHTML.includes('data-a="disable"'), '禁用行不再显示「禁用」按钮'); +console.log('account row paused render passed');` + path := filepath.Join(t.TempDir(), "accrow.cjs") + if err := os.WriteFile(path, []byte(script), 0600); err != nil { + t.Fatal(err) + } + if out, err := exec.Command(node, path, "app.js").CombinedOutput(); err != nil { + t.Fatalf("node: %v\n%s", err, out) + } +} + +// TestAppJSRenderModelLocks 模型锁池表的渲染:空态文案、状态标签、时间与原因转义。 +// 数据来自 /panel/api/overview 的 model_locks(后端已排序,前端只展示)。 +func TestAppJSRenderModelLocks(t *testing.T) { + node, err := exec.LookPath("node") + if err != nil { + t.Skip("node not installed; model lock render skipped") + } + script := `const fs = require('fs'); +const vm = require('vm'); +const assert = require('assert'); +const src = fs.readFileSync(process.argv[2], 'utf8'); +const start = src.indexOf('const ML_STATE'); +assert.ok(start >= 0, 'ML_STATE not found'); +const host = { mlBody: { innerHTML: '' }, mlNote: { textContent: '' } }; +const ctx = { Object, Array, String, RegExp, + // overviewData:fallbackTargetFor 的数据源,形状与 /panel/api/overview 响应 + // 一致(model_fallback 挂在响应对象下);键带域前缀的场景必须能命中—— + // 这是「已路由至」标注的核心路径。 + overviewData: { model_fallback: { 'global:deepseek-v4.1-flash': 'deepseek-v4.1-flash-sg' } }, + $: id => host[id], + setHTML: (el, html) => { el.innerHTML = html; }, + esc: s => String(s == null ? '' : s), + fmtLocalDateTime: ms => 'T(' + ms + ')' }; +vm.createContext(ctx); +vm.runInContext(src.slice(start, src.indexOf('async function loadOverview(')) + '\nthis.render = renderModelLocks;', ctx); +// ① 空清单(后端 null)→ 空态文案,不留空表 +ctx.render(null); +assert.ok(host.mlBody.innerHTML.includes('当前没有模型级限流'), host.mlBody.innerHTML); +assert.equal(host.mlNote.textContent, ''); +// ② 一行 locked:状态标签 + 可选/总数 + 时间渲染 + 原因 +ctx.render([{ model: 'glm-5.3', realm: 'cn', state: 'locked', servable: 0, total: 3, locked: 3, + unlock_at: '2026-10-06T23:00:00+08:00', fully_unlock_at: '2026-10-06T23:17:00+08:00', reason: '6004 model rate limit' }]); +const html = host.mlBody.innerHTML; +assert.ok(html.includes('全池锁定') && html.includes('0 / 3') && html.includes('T(2026-10-06T23:00:00+08:00)'), html); +assert.ok(html.includes('6004 model rate limit'), html); +assert.equal(host.mlNote.textContent, '1 个模型受限'); +// ②′ 带域前缀的降级键命中 → 行内标注「⤳ 已路由至」(锁了但请求已被改道,不是服务中断) +ctx.render([{ model: 'deepseek-v4.1-flash', realm: 'global', state: 'locked', servable: 0, total: 2, locked: 2 }]); +assert.ok(host.mlBody.innerHTML.includes('⤳ 已路由至 deepseek-v4.1-flash-sg'), + host.mlBody.innerHTML); +// ③ 零值时间(上游没给重置时刻)→ 破折号,不显示 0001-01-01 +ctx.render([{ model: 'x', realm: 'global', state: 'partial', servable: 1, total: 2, locked: 1, + unlock_at: '0001-01-01T00:00:00Z', fully_unlock_at: '0001-01-01T00:00:00Z', reason: '' }]); +assert.ok(host.mlBody.innerHTML.includes('部分限流') && host.mlBody.innerHTML.includes('—'), host.mlBody.innerHTML); +assert.ok(!host.mlBody.innerHTML.includes('0001'), '零值时间不得直接显示'); +console.log('model lock render passed');` + path := filepath.Join(t.TempDir(), "mlrender.cjs") + if err := os.WriteFile(path, []byte(script), 0600); err != nil { + t.Fatal(err) + } + if out, err := exec.Command(node, path, "app.js").CombinedOutput(); err != nil { + t.Fatalf("node: %v\n%s", err, out) + } +} + +// 模型锁池的接线:overview 的 model_locks 必须与池内真实的模型级冷却同源,无锁时为 null。 +func TestOverviewExposesModelLocks(t *testing.T) { + p := pool.New("") + p.Add(&auth.Auth{UID: "u1", Nickname: "A", AccessToken: "at1"}) + p.Add(&auth.Auth{UID: "u2", Nickname: "B", AccessToken: "at2"}) + pn := New(Config{Version: "test", Pool: p}) + + read := func() []map[string]any { + rec := httptest.NewRecorder() + pn.ServeHTTP(rec, httptest.NewRequest(http.MethodGet, "/panel/api/overview", nil)) + if rec.Code != 200 { + t.Fatalf("overview code=%d", rec.Code) + } + var d struct { + ModelLocks []map[string]any `json:"model_locks"` + } + if err := json.Unmarshal(rec.Body.Bytes(), &d); err != nil { + t.Fatal(err) + } + return d.ModelLocks + } + if got := read(); len(got) != 0 { + t.Fatalf("无冷却时 model_locks 应为空,得到 %+v", got) + } + // 一个号对该模型停车 → 出一个 partial 行(口径与选号一致)。 + p.CooldownSoftForModel("u1", 10*time.Minute, time.Time{}, "glm-5.3", "model rate limit") + rows := read() + if len(rows) != 1 || rows[0]["model"] != "glm-5.3" || rows[0]["state"] != "partial" { + t.Fatalf("model_locks = %+v want 一行 partial glm-5.3", rows) + } +} + +// TestAppJSOverviewWiresModelLocks 接线:loadOverview 必须把 overview 的 model_locks +// 交给 renderModelLocks。少了这一行,锁池表永远空态——渲染函数本身测不到这个缺口。 +func TestAppJSOverviewWiresModelLocks(t *testing.T) { + node, err := exec.LookPath("node") + if err != nil { + t.Skip("node not installed; overview wiring test skipped") + } + script := `const fs = require('fs'); +const vm = require('vm'); +const assert = require('assert'); +const src = fs.readFileSync(process.argv[2], 'utf8'); +// 切片起点带上 overviewSig 的声明:它是 loadOverview 轮询指纹跳过的模块级状态, +// 从函数签名切会把它漏在窗口外(ReferenceError: overviewSig is not defined)。 +const start = src.indexOf("let overviewSig = ''"); +const end = src.indexOf("$('accBody').addEventListener"); +assert.ok(start >= 0 && end > start, 'overviewSig declaration not found'); +assert.ok(src.slice(start, end).includes('async function loadOverview('), 'slice missed loadOverview'); +const inert = new Proxy(function () {}, { + get(t, k) { if (k === Symbol.toPrimitive) return () => ''; return inert; }, + set() { return true; }, apply() { return inert; }, +}); +let painted = null, accountsPainted = null; +const fake = { version: 'v-test', total: 2, healthy: 2, cooling: 0, disabled: 0, sticky_sessions: 0, + redis_mode: 'memory', in_flight_full: 0, uptime_sec: 60, accounts: [], model_locks: [{ model: 'glm-5.3', realm: 'cn', state: 'locked' }] }; +const ctx = { Math, Object, Array, JSON, Number, String, + api: async () => fake, $: () => inert, toast: () => {}, + renderAccounts: v => { accountsPainted = v; }, + renderModelLocks: v => { painted = v; } }; +vm.createContext(ctx); +vm.runInContext(src.slice(start, end) + '\nthis.loadOverview = loadOverview;', ctx); +(async () => { + await ctx.loadOverview(true); + assert.ok(Array.isArray(accountsPainted), '账号表应被渲染'); + assert.ok(Array.isArray(painted) && painted[0].model === 'glm-5.3', 'overview 的 model_locks 必须交给 renderModelLocks,得到 ' + JSON.stringify(painted)); + process.stdout.write('overview wiring passed\n'); +})().catch(e => { console.error(e); process.exit(1); });` + path := filepath.Join(t.TempDir(), "mlwire.cjs") + if err := os.WriteFile(path, []byte(script), 0600); err != nil { + t.Fatal(err) + } + if out, err := exec.Command(node, path, "app.js").CombinedOutput(); err != nil { + t.Fatalf("node: %v\n%s", err, out) + } +} diff --git a/internal/panel/perf_endpoints_test.go b/internal/panel/perf_endpoints_test.go new file mode 100644 index 0000000000000000000000000000000000000000..c86e2ee7f53d12ce84793f8fae533105662f0b57 --- /dev/null +++ b/internal/panel/perf_endpoints_test.go @@ -0,0 +1,236 @@ +package panel + +import ( + "encoding/json" + "net/http" + "net/http/httptest" + "net/url" + "strconv" + "strings" + "testing" + "time" +) + +// TestLogsHandlerSinceIncremental /panel/api/logs?since= 的增量语义: +// 只回该时刻之后的条目;不带 since 时回全量。面板「运行日志」页每 5 秒拉一次, +// 常态只需要新增行——全量是 500 行(~90KB),每轮重拉 + 重建 DOM 都在做无用功。 +// +// 注意 Ring 的 TS 是**写入时刻**(不是日志行里的时间戳),所以增量判据用 +// 「写入时刻晚于 since」——多条日志同一批写入时时间戳相同,此时 since 取的是 +// 上一批最后一条的 ts,同批的条目靠「>」判定会被漏掉。 +// 这正是前端用「已见到的最大 ts + 同一批兜底」策略的原因(见 app.js 的 logSinceTs)。 +// 本测试用「分批写入 + 显式 sleep」构造可区分的时间戳。 +func TestLogsHandlerSinceIncremental(t *testing.T) { + p := New(Config{Version: "test", APIKey: "test-key"}) + + // 第一批:2 行。 + p.logs.Write([]byte("2026/10/24 12:00:00 line-0\n2026/10/24 12:00:01 line-1\n")) + first := p.logs.Snapshot() + if len(first) != 2 { + t.Fatalf("第一批应为 2 条,实际 %d", len(first)) + } + + // 隔开一点再写第二批,保证 TS 可区分。 + time.Sleep(5 * time.Millisecond) + p.logs.Write([]byte("2026/10/24 12:00:02 line-2\n2026/10/24 12:00:03 line-3\n")) + + get := func(since string) []LogEntry { + u := "/panel/api/logs" + if since != "" { + u += "?since=" + since + } + req := httptest.NewRequest(http.MethodGet, u, nil) + req.Header.Set("Authorization", "Bearer test-key") + rec := httptest.NewRecorder() + p.ServeHTTP(rec, req) + if rec.Code != http.StatusOK { + t.Fatalf("code=%d body=%s", rec.Code, rec.Body.String()) + } + var out struct { + Entries []LogEntry `json:"entries"` + } + if err := json.Unmarshal(rec.Body.Bytes(), &out); err != nil { + t.Fatalf("decode: %v", err) + } + return out.Entries + } + + all := get("") + if len(all) != 4 { + t.Fatalf("全量应为 4 条,实际 %d", len(all)) + } + + // since = 第一批最后一条的 ts → 只回第二批的 2 条。 + inc := get(first[len(first)-1].TS.Format(time.RFC3339Nano)) + if len(inc) != 2 { + t.Fatalf("增量应为 2 条,实际 %d(%+v)", len(inc), inc) + } + if inc[0].Text != "line-2" || inc[1].Text != "line-3" { + t.Fatalf("增量内容不对:%q %q", inc[0].Text, inc[1].Text) + } + + // 边界:since 早于全部 → 全量;since 晚于全部 → 空。 + if got := get(time.Now().Add(-time.Hour).Format(time.RFC3339Nano)); len(got) != 4 { + t.Fatalf("since 早于全部应为 4 条,实际 %d", len(got)) + } + if got := get(time.Now().Add(time.Hour).Format(time.RFC3339Nano)); len(got) != 0 { + t.Fatalf("since 晚于全部应为 0 条,实际 %d", len(got)) + } + + // 非法 since → 回落全量(不报错,也不返回空——宁可多给不可少给)。 + if got := get("not-a-time"); len(got) != 4 { + t.Fatalf("非法 since 应回落全量(4 条),实际 %d", len(got)) + } +} + +// TestParseSinceParamPlusDecodedAsSpace RFC3339 的正时区偏移用 "+"(+08:00), +// 而 query string 里的 "+" 会被解码成空格。客户端直接拼 URL(不编码)时 +// since 会变成 "2026-...T08:59:32.05 08:00"——必须能解析,否则增量静默失效 +// (回落全量,表现为「优化没生效」而不是报错,最难查)。 +func TestParseSinceParamPlusDecodedAsSpace(t *testing.T) { + ts := time.Date(2026, 10, 25, 8, 59, 32, 50751881, time.Local) + std := ts.Format(time.RFC3339Nano) + + got, ok := parseSinceParam(std) + if !ok { + t.Fatalf("标准 RFC3339 应能解析: %q", std) + } + if !got.Equal(ts) { + t.Fatalf("解析结果不等: %v vs %v", got, ts) + } + + // 模拟 "+" 被解成空格。 + spaced := strings.Replace(std, "+", " ", 1) + got2, ok2 := parseSinceParam(spaced) + if !ok2 { + t.Fatalf("「+」被解成空格的形态应能解析: %q", spaced) + } + if !got2.Equal(ts) { + t.Fatalf("解析结果不等: %v vs %v", got2, ts) + } + + // 真正非法的 → 失败(调用方回落全量)。 + if _, ok3 := parseSinceParam("not-a-time"); ok3 { + t.Fatal("非法值不应解析成功") + } + if _, ok4 := parseSinceParam(""); ok4 { + t.Fatal("空值不应解析成功") + } +} + +// TestRequestMetricsRecentOptOut /panel/api/request_metrics?recent=0 时不返回 +// recent 数组(只回指标与归档状态)。面板在归档开启时用归档数据当请求记录表, +// recent 那 100 条(~35KB)用不上——每 5 秒白拉一次、白解析、白 GC。 +func TestRequestMetricsRecentOptOut(t *testing.T) { + p := New(Config{Version: "test", APIKey: "test-key"}) + + // RequestLog 为 nil 时端点返回 501——本测试验证各参数组合都不会 500, + // 且参数解析不因取值不同而改变响应码。真正的「有没有 recent」由 reqlog 层的 + // Snapshot 裁剪(服务端在 recent=0 时把 Recent 置 nil)。 + for _, q := range []string{"", "?recent=0", "?recent=false", "?recent=1"} { + req := httptest.NewRequest(http.MethodGet, "/panel/api/request_metrics"+q, nil) + req.Header.Set("Authorization", "Bearer test-key") + rec := httptest.NewRecorder() + p.ServeHTTP(rec, req) + if rec.Code != http.StatusNotImplemented { + t.Fatalf("q=%q 未装配 RequestLog 时应 501,实际 %d", q, rec.Code) + } + } +} + +// TestLogsSinceSeqAdvancesWithinSameTick 同一时钟刻度内的多条日志,用 since_seq +// 增量必须能逐条推进、不重复、不漏行。 +// +// 这是核心回归位:TS 来自 time.Now(),Windows 实测 ~15.6ms 粒度,一次 Write 的 +// 多行、背靠背的多次 Write 全都拿到**完全相同**的 TS。按 TS 过滤时 +// 「晚于最后一条的 ts」永远为空或永远为真——要么漏、要么重复刷最后一条 +// (用户看到的现象)。seq 单调递增,不受时钟精度影响。 +func TestLogsSinceSeqAdvancesWithinSameTick(t *testing.T) { + p := New(Config{Version: "test", APIKey: "test-key"}) + // 一次 Write 多行:这些行必然共享同一个 TS(同一次 time.Now())。 + p.logs.Write([]byte("a\nb\nc\n")) + + getSeq := func(seq uint64) []LogEntry { + u := "/panel/api/logs?since_seq=" + strconv.FormatUint(seq, 10) + req := httptest.NewRequest(http.MethodGet, u, nil) + req.Header.Set("Authorization", "Bearer test-key") + rec := httptest.NewRecorder() + p.ServeHTTP(rec, req) + var out struct { + Entries []LogEntry `json:"entries"` + } + if err := json.Unmarshal(rec.Body.Bytes(), &out); err != nil { + t.Fatalf("decode: %v", err) + } + return out.Entries + } + + all := getSeq(0) + if len(all) != 3 { + t.Fatalf("since_seq=0 应回全部 3 条,实际 %d", len(all)) + } + // 三行 TS 相同(同一批写入)——正是 ts 游标失效的场景。 + if !all[0].TS.Equal(all[2].TS) { + t.Skip("本机时钟足够精细,三行未共享 TS;该用例无法体现同刻度场景") + } + // seq 必须严格递增且唯一。 + if !(all[0].Seq < all[1].Seq && all[1].Seq < all[2].Seq) { + t.Fatalf("seq 未单调递增: %d %d %d", all[0].Seq, all[1].Seq, all[2].Seq) + } + + // 用第 1 条的 seq 推进 → 只应拿到后 2 条(不重复第 1 条)。 + rest := getSeq(all[0].Seq) + if len(rest) != 2 || rest[0].Text != "b" || rest[1].Text != "c" { + t.Fatalf("since_seq 推进后应得 b,c,实际 %+v", rest) + } + // 用最后一条的 seq 推进 → 空(游标真正到位,不再重复最后一条)。 + if last := getSeq(all[2].Seq); len(last) != 0 { + t.Fatalf("游标到末尾后应返回 0 条,实际 %d 条(这就是「日志重复最后一条」的成因)", len(last)) + } +} + +// TestLogsSinceTSStillDropsTailWithinSameTick 钉住 ?since=(旧接口)的已知局限: +// 同一刻度的多条无法增量区分,按 ts 推进会漏掉同刻度的后几行。保留 since 只为 +// 兼容旧前端/手工 curl;新代码一律用 since_seq。 +func TestLogsSinceTSStillDropsTailWithinSameTick(t *testing.T) { + p := New(Config{Version: "test", APIKey: "test-key"}) + p.logs.Write([]byte("a\nb\nc\n")) + + all := p.logs.Snapshot() + if !all[0].TS.Equal(all[2].TS) { + t.Skip("本机时钟足够精细,无法构造同刻度场景") + } + u := "/panel/api/logs?since=" + url.QueryEscape(all[0].TS.Format(time.RFC3339Nano)) + req := httptest.NewRequest(http.MethodGet, u, nil) + req.Header.Set("Authorization", "Bearer test-key") + rec := httptest.NewRecorder() + p.ServeHTTP(rec, req) + var out struct { + Entries []LogEntry `json:"entries"` + } + _ = json.Unmarshal(rec.Body.Bytes(), &out) + // 同一 TS → After 全为假 → 后两行被漏掉。这是 since 的固有限制。 + if len(out.Entries) != 0 { + t.Fatalf("同刻度时 since 无法推进(应漏掉全部),实际返回 %d 条", len(out.Entries)) + } +} + +// TestLogsSeqMonotonicAcrossRestart 重启后新环的 seq 必须大于旧环的 seq。 +// +// 否则浏览器里残留的旧游标(重启前可能已到几万)会大于新进程的序号, +// ?since_seq= 一直返回空——「运行日志」页空白,最长要等游标老化(5 分钟)才恢复。 +// 做法:seq 初值取启动时刻毫秒数(见 NewRing)。 +func TestLogsSeqMonotonicAcrossRestart(t *testing.T) { + old := NewRing(10) + old.Write([]byte("before-restart\n")) + oldTip := old.Snapshot()[0].Seq + + time.Sleep(2 * time.Millisecond) + fresh := NewRing(10) + fresh.Write([]byte("after-restart\n")) + newTip := fresh.Snapshot()[0].Seq + + if newTip <= oldTip { + t.Fatalf("重启后 seq 未保持单调:旧 %d → 新 %d(旧游标会把新日志全部过滤掉)", oldTip, newTip) + } +} diff --git a/internal/panel/perf_frontend_test.go b/internal/panel/perf_frontend_test.go new file mode 100644 index 0000000000000000000000000000000000000000..f5825f238821f629e0330611bf0aa4dcb3d116ab --- /dev/null +++ b/internal/panel/perf_frontend_test.go @@ -0,0 +1,141 @@ +package panel + +import ( + "os" + "os/exec" + "path/filepath" + "strings" + "testing" +) + +// TestAppJSSetHTMLSkipsUnchanged 钉住 setHTML 的「内容相同就不碰 DOM」语义 +// (perf:面板每 5 秒重建整张表,即使内容没变也在白烧 CPU/内存)。 +// +// 断言的是**行为**而非实现:同一个元素连续两次写相同内容 → 第二次不得触发 +// innerHTML 赋值;写不同内容 → 必须赋(否则页面会停在旧数据上)。 +func TestAppJSSetHTMLSkipsUnchanged(t *testing.T) { + node, err := exec.LookPath("node") + if err != nil { + t.Skip("node not installed; setHTML test skipped") + } + script := `const fs = require('fs'); +const vm = require('vm'); +const src = fs.readFileSync(process.argv[2], 'utf8'); +// 取出 setHTML 及其依赖(lastHTML 声明)那一段。 +const start = src.indexOf('let lastHTML = new WeakMap();'); +const end = src.indexOf('function ago('); +if (start < 0 || end < 0) throw new Error('setHTML block not found'); +let assigns = 0; +const el = { set innerHTML(v) { assigns++; this._h = v; }, get innerHTML() { return this._h; } }; +const ctx = { WeakMap, Map }; +vm.createContext(ctx); +vm.runInContext('\'use strict\';' + src.slice(start, end) + '\nthis.setHTML=setHTML;', ctx); +ctx.setHTML(el, 'x'); +const afterFirst = assigns; +ctx.setHTML(el, 'x'); +const afterSame = assigns; +ctx.setHTML(el, 'y'); +const afterDiff = assigns; +process.stdout.write(JSON.stringify({ afterFirst, afterSame, afterDiff })); +` + f, err := os.CreateTemp(t.TempDir(), "sethtml-*.cjs") + if err != nil { + t.Fatal(err) + } + if _, err := f.WriteString(script); err != nil { + t.Fatal(err) + } + f.Close() + out, err := exec.Command(node, f.Name(), appJSPath(t)).CombinedOutput() + if err != nil { + t.Fatalf("setHTML node test failed: %v\n%s", err, out) + } + s := strings.TrimSpace(string(out)) + if s != `{"afterFirst":1,"afterSame":1,"afterDiff":2}` { + t.Fatalf("setHTML 行为不对: %s(首次赋值=1、相同内容不再赋值=1、不同内容再赋值=2)", s) + } +} + +// TestAppJSLogIncrementalWiring 钉住运行日志的增量拉取接线:前端必须带 since +// 参数(否则每次都拉全量 500 行,~90KB),且服务端支持该参数。 +// +// 这条是「省掉 logs 页 130× 流量」的接线闸门——哪天有人把 since 参数删了、 +// 或增量合并逻辑去掉,这条测试会失败。 +func TestAppJSLogIncrementalWiring(t *testing.T) { + raw, err := os.ReadFile(appJSPath(t)) + if err != nil { + t.Fatal(err) + } + s := string(raw) + // 增量请求:真正拼进 URL 的那行(不能只匹配注释里的字样——注释里也写了 + // "since_seq=",删掉代码它照样能匹配上,这条断言就废了)。 + if !strings.Contains(s, "const lq = logSeq ? '?since_seq='") { + t.Error("运行日志未使用 ?since_seq= 增量参数(每轮会重拉全量 500 行)") + } + // 增量合并:把新行追加到本地窗口 + if !strings.Contains(s, "logRows = logRows.concat(incoming)") { + t.Error("运行日志增量行未并入本地窗口(logRows.concat)") + } + // 游标推进 + if !strings.Contains(s, "logSeq") { + t.Error("运行日志缺增量游标(logSeq)") + } + // 游标过期回落全量:长时间切走后服务端环形缓冲会淘汰中间行 + if !strings.Contains(s, "LOG_CURSOR_MAX_AGE_MS") { + t.Error("运行日志缺游标过期回落(LOG_CURSOR_MAX_AGE_MS)") + } +} + +// TestAppJSLogCursorUsesSeq 钉住「游标是服务端单调序号 seq,不是时间戳」。 +// +// 回归位(用户实测):游标曾按 ts 推进。入环 TS 来自 time.Now(),同一时钟刻度 +// 内的多次写入**完全相同**(Windows 实测 ~15.6ms 粒度),于是「最后一条」自己 +// 仍然满足 `TS > since`,每轮轮询都被重发、游标再也不前进——「运行日志」底部 +// 那行反复刷出来。曾经用 Date.toISOString() 取游标,毫秒截断让重复更严重。 +// +// 断言的是**实际赋值的代码形态**,不是注释里的字样。 +func TestAppJSLogCursorUsesSeq(t *testing.T) { + raw, err := os.ReadFile(appJSPath(t)) + if err != nil { + t.Fatal(err) + } + s := string(raw) + if !strings.Contains(s, "e.seq > logSeq) logSeq = e.seq") { + t.Error("运行日志游标未按服务端 seq 推进(按 ts 推进会在同一时钟刻度内卡死)") + } + if strings.Contains(s, "logSinceTs") { + t.Error("运行日志又退回 ts 游标(logSinceTs):同一刻度内多条时间戳相同,必然重复或漏行") + } +} + +// TestAppJSPollPausedWhenHidden 钉住「页面隐藏时暂停轮询」——切到后台的标签页 +// 仍在每 5 秒打接口 + 重建整表,是「面板很占资源」的一大来源。 +func TestAppJSPollPausedWhenHidden(t *testing.T) { + raw, err := os.ReadFile(appJSPath(t)) + if err != nil { + t.Fatal(err) + } + s := string(raw) + if !strings.Contains(s, "visibilitychange") { + t.Error("面板未监听 visibilitychange(页面隐藏后仍持续轮询)") + } + if !strings.Contains(s, "pageHidden") { + t.Error("面板缺 pageHidden 状态(无法按可见性停表)") + } + if !strings.Contains(s, "if (pageHidden) return;") { + t.Error("refreshVisible 未按 pageHidden 早退") + } +} + +// appJSPath 返回 app.js 的路径(测试工作目录是 internal/panel)。 +func appJSPath(t *testing.T) string { + t.Helper() + p, err := filepath.Abs("app.js") + if err != nil { + t.Fatal(err) + } + if _, err := os.Stat(p); err != nil { + t.Fatalf("app.js 不存在: %v", err) + } + return p +} diff --git a/internal/panel/poll_skip_test.go b/internal/panel/poll_skip_test.go new file mode 100644 index 0000000000000000000000000000000000000000..0dc6b15116e9253852d5a0cb5976d8f95512835a --- /dev/null +++ b/internal/panel/poll_skip_test.go @@ -0,0 +1,75 @@ +package panel + +import ( + "os" + "os/exec" + "strings" + "testing" +) + +// TestAppJSPollSkipsUnchangedRender 轮询载荷没变时不重建账号表。 +// +// 面板每 5 秒轮询 overview,此前无条件 renderAccounts:重建 innerHTML 会打断行内 +// 焦点与悬停(29 个号就是每 5 秒抖一次)。借鉴 workbuddy2api-hub 的「轮询指纹跳过」。 +// 断言打在两处可观测契约上:同载荷连轮两次只渲染一次,载荷变了必须再渲染。 +func TestAppJSPollSkipsUnchangedRender(t *testing.T) { + node, err := exec.LookPath("node") + if err != nil { + t.Skip("node not installed; poll skip test skipped") + } + script := `const fs = require('fs'), vm = require('vm'), assert = require('assert'); +const src = fs.readFileSync(process.argv[2], 'utf8'); +const s = src.indexOf("let overviewSig = ''"); +const e = src.indexOf("$('accBody').addEventListener", s); +assert.ok(s >= 0 && e > s, 'overviewSig slice anchors not found: s=' + s + ' e=' + e); +assert.ok(src.slice(s, e).includes('async function loadOverview('), 'slice missed loadOverview'); + +const dom = new Proxy(function () {}, { get: (t, k) => (k === Symbol.toPrimitive ? () => '' : dom), set: () => true, apply: () => dom }); +const store = { payload: null }; +const calls = { accounts: 0, locks: 0 }; +const ctx = { + $: () => dom, document: dom, window: dom, localStorage: dom, location: dom, + String, Number, Math, Date, Object, Array, Set, JSON, RegExp, console, encodeURIComponent, + api: async () => store.payload, + esc: x => String(x == null ? '' : x), + setHTML: () => {}, toast: () => {}, + renderUpdateStatus: () => {}, renderExpirySnapshot: () => {}, + renderAccounts: () => { calls.accounts++; }, + renderModelLocks: () => { calls.locks++; }, + startPolling: () => {}, + pollAutoRefresh: true, pollIntervalMs: 5000, updateData: null, +}; +vm.createContext(ctx); +vm.runInContext(src.slice(s, e), ctx); + +(async () => { + const base = { total: 1, healthy: 1, cooling: 0, disabled: 0, paused: 0, sticky_sessions: 0, + in_flight_full: 0, uptime_sec: 10, redis_mode: 'memory', version: 't', + accounts: [{ uid: 'u1', credits: 5 }], model_locks: [] }; + store.payload = base; + await ctx.loadOverview(true); + await ctx.loadOverview(true); + assert.strictEqual(calls.accounts, 1, '同载荷重复轮询不该重建账号表,实际 ' + calls.accounts + ' 次'); + store.payload = Object.assign({}, base, { accounts: [{ uid: 'u1', credits: 6 }] }); + await ctx.loadOverview(true); + assert.strictEqual(calls.accounts, 2, '载荷变化后必须重渲染'); + console.log(JSON.stringify({ accounts: calls.accounts, locks: calls.locks })); +})().catch(err => { console.error(err); process.exit(1); });` + + f, err := os.CreateTemp(t.TempDir(), "pollskip-*.cjs") + if err != nil { + t.Fatalf("temp file: %v", err) + } + if _, err := f.WriteString(script); err != nil { + t.Fatalf("write script: %v", err) + } + f.Close() + + out, err := exec.Command(node, f.Name(), "app.js").CombinedOutput() + if err != nil { + t.Fatalf("node failed: %v\n%s", err, out) + } + if !strings.Contains(string(out), `"accounts":2`) { + t.Fatalf("unexpected output: %s", out) + } +} diff --git a/internal/panel/proxies.go b/internal/panel/proxies.go new file mode 100644 index 0000000000000000000000000000000000000000..438484a2b36a98789b6ffc2e7f5cc42db8dfa324 --- /dev/null +++ b/internal/panel/proxies.go @@ -0,0 +1,183 @@ +package panel + +import ( + "encoding/json" + "errors" + "io" + "net/http" + + "github.com/misakano7545/workbuddy2api-panel/internal/proxypool" +) + +func (p *Panel) proxySnapshot() any { + if p.cfg.ProxyPool == nil { + return nil + } + return p.cfg.ProxyPool.Snapshot() +} + +func (p *Panel) proxyRoutes() { + p.mux.HandleFunc("GET /panel/api/proxies", p.proxies) + p.mux.HandleFunc("POST /panel/api/proxies", p.proxyImport) + p.mux.HandleFunc("PATCH /panel/api/proxies/{id}", p.proxyUpdate) + p.mux.HandleFunc("DELETE /panel/api/proxies/{id}", p.proxyDelete) + p.mux.HandleFunc("POST /panel/api/proxies/check", p.proxyCheck) + p.mux.HandleFunc("POST /panel/api/proxies/{id}/check", p.proxyCheck) + p.mux.HandleFunc("PUT /panel/api/proxies/health", p.proxyHealth) + p.mux.HandleFunc("PUT /panel/api/accounts/{uid}/proxy", p.accountProxy) + p.mux.HandleFunc("PUT /panel/api/proxies/realm/{realm}", p.realmProxy) +} + +func (p *Panel) proxyReady(w http.ResponseWriter) bool { + if p.cfg.ProxyPool == nil { + writeErr(w, http.StatusNotImplemented, "proxy pool not available") + return false + } + return true +} + +func proxyBody(w http.ResponseWriter, r *http.Request, dst any) bool { + r.Body = http.MaxBytesReader(w, r.Body, 1<<20) + dec := json.NewDecoder(r.Body) + dec.DisallowUnknownFields() + if err := dec.Decode(dst); err != nil { + writeErr(w, http.StatusBadRequest, "invalid proxy request body") + return false + } + if err := dec.Decode(new(any)); err != io.EOF { + writeErr(w, http.StatusBadRequest, "proxy request body must contain one JSON value") + return false + } + return true +} + +func proxyError(w http.ResponseWriter, err error) { + status := http.StatusBadRequest + if errors.Is(err, proxypool.ErrNotFound) { + status = http.StatusNotFound + } else if errors.Is(err, proxypool.ErrBound) { + status = http.StatusConflict + } + writeErr(w, status, err.Error()) +} + +func (p *Panel) proxies(w http.ResponseWriter, r *http.Request) { + if p.proxyReady(w) { + writeJSON(w, http.StatusOK, p.proxySnapshot()) + } +} + +func (p *Panel) proxyImport(w http.ResponseWriter, r *http.Request) { + if !p.proxyReady(w) { + return + } + var body struct { + Lines string `json:"lines"` + } + if !proxyBody(w, r, &body) { + return + } + results, err := p.cfg.ProxyPool.Import(body.Lines) + if err != nil { + proxyError(w, err) + return + } + writeJSON(w, http.StatusOK, map[string]any{"ok": true, "results": results}) +} + +func (p *Panel) proxyUpdate(w http.ResponseWriter, r *http.Request) { + if !p.proxyReady(w) { + return + } + var body proxypool.Input + if !proxyBody(w, r, &body) { + return + } + if err := p.cfg.ProxyPool.Update(r.PathValue("id"), body); err != nil { + proxyError(w, err) + return + } + writeJSON(w, http.StatusOK, map[string]any{"ok": true}) +} + +func (p *Panel) proxyDelete(w http.ResponseWriter, r *http.Request) { + if !p.proxyReady(w) { + return + } + if err := p.cfg.ProxyPool.Delete(r.PathValue("id")); err != nil { + proxyError(w, err) + return + } + writeJSON(w, http.StatusOK, map[string]any{"ok": true}) +} + +func (p *Panel) proxyCheck(w http.ResponseWriter, r *http.Request) { + if !p.proxyReady(w) { + return + } + if err := p.cfg.ProxyPool.RequestCheck(r.PathValue("id")); err != nil { + proxyError(w, err) + return + } + writeJSON(w, http.StatusAccepted, map[string]any{"ok": true, "queued": true}) +} + +func (p *Panel) proxyHealth(w http.ResponseWriter, r *http.Request) { + if !p.proxyReady(w) { + return + } + var body proxypool.Settings + if !proxyBody(w, r, &body) { + return + } + if err := p.cfg.ProxyPool.Configure(body); err != nil { + proxyError(w, err) + return + } + writeJSON(w, http.StatusOK, map[string]any{"ok": true}) +} + +// realmProxy 设置 realm 级默认出口(issue #39 P3):账号未显式绑定时取它。 +func (p *Panel) realmProxy(w http.ResponseWriter, r *http.Request) { + if !p.proxyReady(w) { + return + } + p.proxyAccountMu.Lock() + defer p.proxyAccountMu.Unlock() + realm := r.PathValue("realm") + if realm != "cn" && realm != "global" { + writeErr(w, http.StatusBadRequest, "realm must be cn or global") + return + } + var body proxypool.Binding + if !proxyBody(w, r, &body) { + return + } + if err := p.cfg.ProxyPool.BindRealm(realm, body); err != nil { + proxyError(w, err) + return + } + writeJSON(w, http.StatusOK, map[string]any{"ok": true}) +} + +func (p *Panel) accountProxy(w http.ResponseWriter, r *http.Request) { + if !p.proxyReady(w) { + return + } + p.proxyAccountMu.Lock() + defer p.proxyAccountMu.Unlock() + uid := r.PathValue("uid") + if p.cfg.Pool.AuthByUID(uid) == nil { + writeErr(w, http.StatusNotFound, "account not found") + return + } + var body proxypool.Binding + if !proxyBody(w, r, &body) { + return + } + if err := p.cfg.ProxyPool.Bind(uid, body); err != nil { + proxyError(w, err) + return + } + writeJSON(w, http.StatusOK, map[string]any{"ok": true}) +} diff --git a/internal/panel/proxies_test.go b/internal/panel/proxies_test.go new file mode 100644 index 0000000000000000000000000000000000000000..b58cd7250897196f968e3fe74aeddc9ad4d96e64 --- /dev/null +++ b/internal/panel/proxies_test.go @@ -0,0 +1,103 @@ +package panel + +import ( + "encoding/json" + "net/http" + "net/http/httptest" + "path/filepath" + "strings" + "testing" + + "github.com/misakano7545/workbuddy2api-panel/internal/auth" + "github.com/misakano7545/workbuddy2api-panel/internal/pool" + "github.com/misakano7545/workbuddy2api-panel/internal/proxypool" +) + +func TestProxyAPIAuthenticationBindingAndRemoval(t *testing.T) { + manager, err := proxypool.New(filepath.Join(t.TempDir(), "proxy-pool.json"), nil, nil) + if err != nil { + t.Fatal(err) + } + defer manager.Close() + accounts := pool.New("") + accounts.Add(&auth.Auth{UID: "u1", AccessToken: "token"}) + p := New(Config{Pool: accounts, ProxyPool: manager, APIKey: "panel-key"}) + call := func(method, path, body, key string) *httptest.ResponseRecorder { + t.Helper() + req := httptest.NewRequest(method, "/panel/api/"+path, strings.NewReader(body)) + req.Header.Set("Authorization", "Bearer "+key) + rec := httptest.NewRecorder() + p.ServeHTTP(rec, req) + return rec + } + for _, route := range []struct{ method, path string }{ + {"GET", "proxies"}, {"POST", "proxies"}, {"PATCH", "proxies/missing"}, + {"DELETE", "proxies/missing"}, {"POST", "proxies/check"}, {"POST", "proxies/missing/check"}, + {"PUT", "proxies/health"}, {"PUT", "accounts/u1/proxy"}, {"PUT", "proxies/realm/cn"}, + } { + if got := call(route.method, route.path, "{}", "wrong"); got.Code != http.StatusUnauthorized { + t.Fatalf("unauthorized %s %s: %d", route.method, route.path, got.Code) + } + } + imported := call("POST", "proxies", `{"lines":"http://user:TOPSECRET@localhost:8080\nbad://host\nhttp://user:TOPSECRET@localhost:8080"}`, "panel-key") + if imported.Code != 200 || strings.Contains(imported.Body.String(), "TOPSECRET") { + t.Fatalf("import: %d %s", imported.Code, imported.Body.String()) + } + var data struct { + Results []proxypool.ImportResult `json:"results"` + } + if err := json.Unmarshal(imported.Body.Bytes(), &data); err != nil || len(data.Results) != 3 { + t.Fatalf("results=%+v err=%v", data, err) + } + id := data.Results[0].ID + for _, route := range []struct { + method, path, body string + want int + }{ + {"GET", "proxies", "", 200}, + {"PATCH", "proxies/" + id, `{"name":"Office","password":""}`, 200}, + {"PUT", "accounts/u1/proxy", `{"mode":"fixed","proxy_id":"` + id + `"}`, 200}, + {"DELETE", "proxies/" + id, "", 409}, + {"POST", "proxies/" + id + "/check", "", 202}, + {"POST", "proxies/check", "", 202}, + {"POST", "proxies/missing/check", "", 404}, + {"POST", "proxies", `{"lines":"http://localhost:1234"} {}`, 400}, + {"PUT", "accounts/missing/proxy", `{"mode":"direct"}`, 404}, + {"PUT", "accounts/u1/proxy", `{"mode":"fixed","proxy_id":"missing"}`, 404}, + {"PUT", "accounts/u1/proxy", `{"mode":"bogus"}`, 400}, + {"PUT", "proxies/health", `{"url":"file:///tmp/check","interval_seconds":60}`, 400}, + // realm 默认出口(issue #39 P3):只认 cn/global,绑不存在的代理 404。 + {"PUT", "proxies/realm/cn", `{"mode":"fixed","proxy_id":"` + id + `"}`, 200}, + {"PUT", "proxies/realm/global", `{"mode":"direct"}`, 200}, + {"PUT", "proxies/realm/us", `{"mode":"direct"}`, 400}, + {"PUT", "proxies/realm/global", `{"mode":"fixed","proxy_id":"missing"}`, 404}, + // 绑了 realm 默认的代理不许直接删(删掉等于整域静默掉回随机池)。 + {"DELETE", "proxies/" + id, "", 409}, + {"PUT", "proxies/realm/cn", `{"mode":"random"}`, 200}, + {"POST", "accounts/u1/remove", "", 200}, + {"DELETE", "proxies/" + id, "", 200}, + } { + got := call(route.method, route.path, route.body, "panel-key") + if got.Code != route.want || strings.Contains(got.Body.String(), "TOPSECRET") { + t.Fatalf("%s %s: %d %s; want %d", route.method, route.path, got.Code, got.Body.String(), route.want) + } + } + if len(manager.Snapshot().Bindings) != 0 { + t.Fatal("account removal retained binding") + } +} + +func TestProxyAPIRejectsOversizedBody(t *testing.T) { + m, err := proxypool.New("", nil, nil) + if err != nil { + t.Fatal(err) + } + defer m.Close() + p := New(Config{Pool: pool.New(""), ProxyPool: m}) + body := `{"lines":"` + strings.Repeat("x", 1<<20) + `"}` + rec := httptest.NewRecorder() + p.ServeHTTP(rec, httptest.NewRequest("POST", "/panel/api/proxies", strings.NewReader(body))) + if rec.Code != http.StatusBadRequest || len(m.Snapshot().Proxies) != 0 { + t.Fatalf("oversized request: %d", rec.Code) + } +} diff --git a/internal/panel/qr_matrix_test.go b/internal/panel/qr_matrix_test.go new file mode 100644 index 0000000000000000000000000000000000000000..513a3ce2c084d6727502c178b5a3e22b9ae12a84 --- /dev/null +++ b/internal/panel/qr_matrix_test.go @@ -0,0 +1,105 @@ +package panel + +import ( + "crypto/sha256" + "encoding/json" + "fmt" + "os" + "os/exec" + "path/filepath" + "strings" + "testing" +) + +// TestAppJSQRMatrix 授权链接二维码的编码器必须与规范逐像素一致。 +// +// 为什么钉死 sha:面板 CSP 只允许 self(不能引外链 QR 服务),也不引前端依赖, +// 所以 QR 是手写实现 —— 分段、纠错、交织、掩码任一处错都只表现为「扫不出来」, +// 浏览器里没有任何断言能发现。下面的 golden 已由 python qrcode 库逐像素交叉验证 +// (byte 模式 + ECC L + mask 0,v1-v6 共 30 组输入全部 diff=0)。 +// +// v6 是 issue #94 新增的:workbuddy 站的授权链接 108 字节超过 v5 单块上限 106, +// 需要两块交织;CN 站 105 字节仍走 v5。两条路径都要钉。 +func TestAppJSQRMatrix(t *testing.T) { + node, err := exec.LookPath("node") + if err != nil { + t.Skip("node not installed; QR matrix test skipped") + } + script := `const fs = require('fs'), vm = require('vm'); +const src = fs.readFileSync(process.argv[2], 'utf8'); +const start = src.indexOf('/* ── 精简 QR 编码器'); +const end = src.indexOf('/* ── 开学季券码查询'); +if (start < 0 || end < start) throw new Error('QR block not found'); +const ctx = { TextEncoder, Math, Array, Error }; +vm.createContext(ctx); +vm.runInContext(src.slice(start, end) + '\nthis.qrMatrix = qrMatrix;', ctx); +const out = {}; +for (const [k, v] of Object.entries(JSON.parse(process.argv[3]))) { + try { + const M = ctx.qrMatrix(v); + out[k] = { n: M.length, rows: M.map(r => r.map(b => b ? '1' : '0').join('')).join('\n') }; + } catch (e) { out[k] = { err: String(e.message) }; } +} +fs.writeFileSync(process.argv[4], JSON.stringify(out));` + f, err := os.CreateTemp(t.TempDir(), "qr-*.cjs") + if err != nil { + t.Fatalf("temp file: %v", err) + } + if _, err := f.WriteString(script); err != nil { + t.Fatalf("write script: %v", err) + } + f.Close() + + const st = "12345678-1234-1234-1234-123456789abc" + inputs := map[string]string{ + // CN 站真实形态:105 字节 → v5(37×37,单块) + "cn": "https://copilot.tencent.com/login?platform=CLI&state=" + st + "&version=2.176.0", + // workbuddy 站:108 字节 → v6(41×41,两块交织) + "wb": "https://www.workbuddy.ai/login?platform=workbuddy&state=" + st + "&version=2.176.0", + // 容量上界 134 字节;135 必须报错(前端据此退回只显示链接) + "over": strings.Repeat("a", 135), + } + in, _ := json.Marshal(inputs) + outPath := filepath.Join(t.TempDir(), "out.json") + if b, err := exec.Command(node, f.Name(), "app.js", string(in), outPath).CombinedOutput(); err != nil { + t.Fatalf("node failed: %v\n%s", err, b) + } + raw, err := os.ReadFile(outPath) + if err != nil { + t.Fatalf("read output: %v", err) + } + var got map[string]struct { + N int `json:"n"` + Rows string `json:"rows"` + Err string `json:"err"` + } + if err := json.Unmarshal(raw, &got); err != nil { + t.Fatalf("bad output: %v\n%s", err, raw) + } + + for _, c := range []struct { + key string + name string + modules int + sha string + }{ + {"cn", "CN 站 105 字节 / v5", 37, "2ccaa4c9502d84f197a54ec1d4a174a8312e1db42b3d8a05f306c97477a0a3cd"}, + {"wb", "workbuddy 站 108 字节 / v6 两块交织", 41, "c5818c46fe1cdb1bc829a2249d3fc790f5a0f2c7b141bd196e722bbe5c6ed1ef"}, + } { + r := got[c.key] + if r.Err != "" { + t.Errorf("%s:编码失败 %s", c.name, r.Err) + continue + } + if r.N != c.modules { + t.Errorf("%s:模块边长 %d,期望 %d(版本选错)", c.name, r.N, c.modules) + continue + } + if h := fmt.Sprintf("%x", sha256.Sum256([]byte(r.Rows))); h != c.sha { + t.Errorf("%s:矩阵与已验证实现不一致\n got %s\nwant %s", c.name, h, c.sha) + } + } + if r := got["over"]; r.Err == "" { + t.Errorf("135 字节超出 v6 容量应报错(前端靠它退回链接),实际编码成功 n=%d", r.N) + } +} diff --git a/internal/panel/reload.go b/internal/panel/reload.go new file mode 100644 index 0000000000000000000000000000000000000000..69901579050635ea737f7ad4f43ab92fdaeb9b50 --- /dev/null +++ b/internal/panel/reload.go @@ -0,0 +1,402 @@ +// reload.go 账号目录热重载(issue #199):auths/ 增删改不必重启进程。 +// +// 触发源两条,都走同一个 ReloadAccounts: +// - 手动:POST /panel/api/accounts/reload(脚本/编排服务的确定性入口); +// - 自动:ReloadLoop 按 accounts.reload_interval 轮询(默认 10s,"0s" 关闭)。 +// +// 为什么不只用 inotify:群晖/CIFS/NFS 挂载上 inotify 普遍不可靠,轮询必须兜底; +// 反过来只用轮询又不能实时,所以两条都留。 +// +// 四条防「踢号」的护栏(issue #199 里点名的风险,逐条对应): +// +// 1. 有任何文件解析失败 → 本轮**只增不删**。半写文件(登录落盘/SaveAtomic 瞬间) +// 会被当成「文件已删」,把在池账号剔除,而剔除结果会持久化,下次启动也不复活。 +// 2. 删除要连续 N 次扫描(默认 2)都确认该 uid 不在,第一次只挂账不删。 +// 3. 重载前后各取一次目录指纹(名字+大小+mtime),扫描期间集合变动就放弃本轮 +// ——正写到一半的时刻不该做判断。 +// 4. 剔除前再 stat 一次该账号的文件;文件在就跳过。这一条同时堵住「面板刚导入、 +// 重载还没看到」的竞争:那条路径刚写出的文件一定在盘上。 +// +// 另外还有一条与「自激」有关:auth.LoadDir 对空 realm 会 SaveAtomic 回填,自己 +// 就会改 mtime。所以轮询判据用**内容指纹**(uid|expiresAt|realm 的有序哈希)而不是 +// mtime —— 回填只改文件不改语义,指纹不变就不会反复重载。 +package panel + +import ( + "crypto/sha256" + "encoding/hex" + "errors" + "fmt" + "log" + "net/http" + "os" + "path/filepath" + "sort" + "strings" + "time" + + "github.com/misakano7545/workbuddy2api-panel/internal/auth" +) + +// ReloadResult 一次重载的结果(直接作为接口响应体)。 +type ReloadResult struct { + Added int `json:"added"` + Updated int `json:"updated"` + Removed int `json:"removed"` + ParseErrors int `json:"parse_errors"` + Files int `json:"files"` + Skipped bool `json:"skipped"` // 本轮放弃(目录在扫描期间变动 / 无变化) + Reason string `json:"reason,omitempty"` // 放弃原因 + Errors []string `json:"errors,omitempty"` // 解析失败明细 + RemovedUIDs []string `json:"removed_uids,omitempty"` // 便于脚本核对删的是哪些 +} + +// errReloadNotConfigured 面板未配置 AuthDir(理论上不会发生)。 +var errReloadNotConfigured = errors.New("auth dir 未配置,无法重载") + +// ReloadAccounts 扫描 AuthDir 并让池与目录对齐。 +// +// 与启动路径的差别只有护栏,加载逻辑完全复用 auth.LoadDirReport(同一套「扫描 + +// 解析 + 坏文件回退 .bak + 空 realm 回填」),避免第二份实现漂移。 +func (p *Panel) ReloadAccounts() (ReloadResult, error) { + return p.ReloadAccountsReason("manual") +} + +// ReloadAccountsReason 同 ReloadAccounts,reason 只用于日志(manual / poll)。 +func (p *Panel) ReloadAccountsReason(reason string) (ReloadResult, error) { + if p.cfg.AuthDir == "" { + return ReloadResult{}, errReloadNotConfigured + } + p.reloadMu.Lock() + defer p.reloadMu.Unlock() + + before := dirSignature(p.cfg.AuthDir) + report, err := auth.LoadDirReport(p.cfg.AuthDir) + if err != nil { + return ReloadResult{}, err + } + after := dirSignature(p.cfg.AuthDir) + // 护栏 3 的自纠:LoadDirReport 本身会写盘(空 realm 回填 SaveAtomic、坏文件另存 + // .bad),首轮扫描几乎必然让指纹变一次。这类「自己改的」不算并发写入,重扫一遍 + // 就会稳定——所以给一次重试,而不是当场放弃(否则每次新增文件后首轮都白跑)。 + if before != after { + before = after + report, err = auth.LoadDirReport(p.cfg.AuthDir) + if err != nil { + return ReloadResult{}, err + } + after = dirSignature(p.cfg.AuthDir) + } + res := ReloadResult{Files: report.Files, ParseErrors: len(report.ParseError), Errors: report.ParseError} + + // 护栏 3:扫描期间目录集合变了 → 放弃本轮(下一轮再来,代价只有几毫秒)。 + if before != after { + res.Skipped = true + res.Reason = "目录在扫描期间发生变化,本轮放弃(下一轮重试)" + log.Printf("[reload] 放弃(%s):目录在扫描期间变动", reason) + return res, nil + } + + seen := make(map[string]bool, len(report.Auths)) + for _, a := range report.Auths { + seen[a.UID] = true + if p.cfg.Pool.AuthByUID(a.UID) == nil { + res.Added++ + } else { + res.Updated++ + } + p.cfg.Pool.Add(a) // upsert:已存在只换凭证,保留 credits/cooling 状态 + } + + // 护栏 1:本轮有解析失败 → 只增不删。此时「不在扫描结果里」可能只是「文件读不动」。 + if res.ParseErrors > 0 { + res.Skipped = res.Added == 0 && res.Updated == 0 + res.Reason = fmt.Sprintf("%d 个文件解析失败,本轮只增不删", res.ParseErrors) + p.noteReload(res) + log.Printf("[reload] %s added=%d updated=%d removed=0 parse_errors=%d(解析失败时禁止删除)", + reason, res.Added, res.Updated, res.ParseErrors) + return res, nil + } + + // 护栏 2:缺席计数满 N 次才删;期间有在途请求也往后推。 + confirm := p.reloadDeleteConfirm + if confirm < 1 { + confirm = 1 + } + var toRemove []string + for _, st := range p.cfg.Pool.List() { + if seen[st.UID] { + delete(p.reloadMissing, st.UID) + continue + } + // 护栏 4:文件其实在盘上(可能是面板刚写入、或扫描竞态)→ 视为在场,不计缺席。 + if a := p.cfg.Pool.AuthByUID(st.UID); a != nil && a.FilePath != "" { + if _, statErr := os.Stat(a.FilePath); statErr == nil { + delete(p.reloadMissing, st.UID) + continue + } + } + p.reloadMissing[st.UID]++ + if p.reloadMissing[st.UID] < confirm { + continue + } + if p.cfg.Pool.InFlight(st.UID) > 0 { + log.Printf("[reload] uid=%s 文件已不存在,但在途请求未结束 → 下一轮再删", st.UID) + continue + } + toRemove = append(toRemove, st.UID) + } + if removed := p.cfg.Pool.RemoveMany(toRemove); len(removed) > 0 { + res.Removed = len(removed) + res.RemovedUIDs = removed + for _, uid := range removed { + delete(p.reloadMissing, uid) + } + } + // 已不在池里的 uid 不再占着缺席计数表。 + for uid := range p.reloadMissing { + if p.cfg.Pool.AuthByUID(uid) == nil { + delete(p.reloadMissing, uid) + } + } + + p.noteReload(res) + if res.Added > 0 || res.Updated > 0 || res.Removed > 0 { + // 一行审计日志:内容变动的重载才打(10s 轮询下没变化时不能刷屏)。 + log.Printf("[reload] added=%d updated=%d removed=%d parse_errors=0 files=%d", + res.Added, res.Updated, res.Removed, res.Files) + if len(res.RemovedUIDs) > 0 { + log.Printf("[reload] 已移除(auth 文件不存在,连续 %d 次扫描确认): %s", + confirm, strings.Join(res.RemovedUIDs, ", ")) + } + } + return res, nil +} + +// noteReload 记录「上次重载时间/结果」供面板展示。 +// 调用方必须已持有 reloadMu(ReloadAccountsReason 全程持锁);这里再加锁就是 +// 自己锁自己——sync.Mutex 不可重入,会当场死锁。 +func (p *Panel) noteReload(res ReloadResult) { + p.reloadLastAt = time.Now() + p.reloadLast = res +} + +// ReloadStatus 面板展示用的最近一次重载快照。 +func (p *Panel) ReloadStatus() (time.Time, ReloadResult) { + p.reloadMu.Lock() + defer p.reloadMu.Unlock() + return p.reloadLastAt, p.reloadLast +} + +// SetReloadConfig 设置轮询间隔与删除确认次数(cmd/server 按 config 注入)。 +func (p *Panel) SetReloadConfig(interval time.Duration, confirm int) { + p.reloadMu.Lock() + p.reloadInterval = interval + if confirm > 0 { + p.reloadDeleteConfirm = confirm + } + p.reloadMu.Unlock() +} + +// ReloadLoop 按间隔轮询目录;指纹没变就完全不动池(不扫、不解析、不写日志)。 +// +// 指纹只在「可能变了」时才做完整扫描:先取目录指纹(名字+大小+mtime),与上次 +// 成功重载后的指纹比对,相同即跳过。这一步不解析文件内容,10s 一次的开销就是 +// 一次 ReadDir——几十个账号的目录是小几百微秒级。 +func (p *Panel) ReloadLoop(stop <-chan struct{}) { + p.reloadMu.Lock() + interval := p.reloadInterval + p.reloadMu.Unlock() + if interval <= 0 { + log.Printf("[reload] 目录轮询未启用(accounts.reload_interval=0);手动接口 %s 仍可用", + relooadEndpointPath) + return + } + log.Printf("[reload] 目录轮询已启用:每 %s 检查一次 %s(删除需连续 %d 次确认)", + interval, p.cfg.AuthDir, p.reloadDeleteConfirm) + ticker := time.NewTicker(interval) + defer ticker.Stop() + // 启动后立刻对齐一次:进程启动到面板起来之间外部可能已经丢了文件进来。 + if res, err := p.reloadIfChanged("poll"); err != nil { + log.Printf("[reload] 启动首轮重载失败:%v", err) + } else if res.Added+res.Updated+res.Removed > 0 { + log.Printf("[reload] 启动首轮:added=%d updated=%d removed=%d", res.Added, res.Updated, res.Removed) + } + for { + select { + case <-stop: + return + case <-ticker.C: + if _, err := p.reloadIfChanged("poll"); err != nil { + log.Printf("WARN: [reload] 轮询重载失败:%v", err) + } + } + } +} + +// relooadEndpointPath 手动重载接口路径(日志文案用;路由注册在 panel.go)。 +const relooadEndpointPath = "POST /panel/api/accounts/reload" + +// reloadIfChanged 目录指纹变了才真正完整重载。 +// +// 用内容指纹而不是 mtime:auth.LoadDirReport 对空 realm 会 SaveAtomic 回填,自己 +// 就会改 mtime;按 mtime 判断会自激(backfill → mtime 变 → 再 reload → ...)。 +// +// 但指纹没变时不能一走了之。删除要「连续 N 次扫描确认」,而删掉一个文件只让指纹 +// 变一次:缺勤计到 1 之后,每个 tick 都会被指纹门挡回去,reload_delete_confirm +// 只要 >1 就永远到不了——删除语义静默失效(issue #199)。所以指纹没变、但缺席 +// 计数表里还有待确认的账号时,走一次只做 stat 的轻量确认:不重解析目录、不刷审计 +// 日志,代价是池大小量级的 stat。 +func (p *Panel) reloadIfChanged(reason string) (ReloadResult, error) { + fp := dirContentFingerprint(p.cfg.AuthDir) + p.reloadMu.Lock() + last := p.reloadFingerprint + pending := len(p.reloadMissing) > 0 + p.reloadMu.Unlock() + if fp != "" && fp == last { + if pending { + return p.confirmMissing(reason) + } + return ReloadResult{Skipped: true, Reason: "目录未变化"}, nil + } + res, err := p.ReloadAccountsReason(reason) + if err != nil { + return res, err + } + if !res.Skipped { + p.reloadMu.Lock() + p.reloadFingerprint = fp + p.reloadMu.Unlock() + } + return res, nil +} + +// confirmMissing 指纹没变时推进缺席计数,让删除确认能在多个 tick 里走完。 +// +// 只在 reloadMissing 非空(上一轮完整重载发现账号不在目录里)时被调用。判据与 +// ReloadAccountsReason 的护栏 2/4 完全一致:文件其实还在盘上就清账(面板刚写入、 +// 扫描竞态),连续 confirm 次缺席且在途请求归零才真删。 +func (p *Panel) confirmMissing(reason string) (ReloadResult, error) { + p.reloadMu.Lock() + defer p.reloadMu.Unlock() + + confirm := p.reloadDeleteConfirm + if confirm < 1 { + confirm = 1 + } + res := ReloadResult{Skipped: true} + var toRemove []string + pending := 0 + for _, st := range p.cfg.Pool.List() { + a := p.cfg.Pool.AuthByUID(st.UID) + // 护栏 4:文件在盘上 → 视为在场,清掉缺席计数。 + if a != nil && a.FilePath != "" { + if _, statErr := os.Stat(a.FilePath); statErr == nil { + delete(p.reloadMissing, st.UID) + continue + } + } + p.reloadMissing[st.UID]++ + if p.reloadMissing[st.UID] < confirm || p.cfg.Pool.InFlight(st.UID) > 0 { + pending++ + continue + } + toRemove = append(toRemove, st.UID) + } + if removed := p.cfg.Pool.RemoveMany(toRemove); len(removed) > 0 { + res.Skipped = false + res.Removed = len(removed) + res.RemovedUIDs = removed + log.Printf("[reload] %s 已移除(auth 文件不存在,连续 %d 次扫描确认): %s", + reason, confirm, strings.Join(removed, ", ")) + } else if pending > 0 { + res.Reason = fmt.Sprintf("%d 个账号文件不存在,删除确认中(需连续 %d 次)", pending, confirm) + } + // 已不在池里的 uid 不再占着缺席计数表。 + for uid := range p.reloadMissing { + if p.cfg.Pool.AuthByUID(uid) == nil { + delete(p.reloadMissing, uid) + } + } + p.noteReload(res) + return res, nil +} + +// dirSignature 目录「集合指纹」:文件名+大小+mtime 的有序哈希。 +// +// 只用来判「扫描期间目录有没有被别人动过」——比内容指纹便宜,且能看见尚未写完的 +// 文件(大小/mtime 已变但内容还不完整)。 +func dirSignature(dir string) string { + entries, err := os.ReadDir(dir) + if err != nil { + return "" + } + names := make([]string, 0, len(entries)) + for _, e := range entries { + if e.IsDir() || !strings.HasPrefix(e.Name(), "workbuddy") || !strings.HasSuffix(e.Name(), ".json") { + continue + } + info, ierr := e.Info() + if ierr != nil { + continue + } + names = append(names, fmt.Sprintf("%s|%d|%d", e.Name(), info.Size(), info.ModTime().UnixNano())) + } + sort.Strings(names) + sum := sha256.Sum256([]byte(strings.Join(names, "\n"))) + return hex.EncodeToString(sum[:8]) +} + +// dirContentFingerprint 目录「内容指纹」:uid|expiresAt|realm 的有序哈希。 +// +// 比 dirSignature 贵(要解析每个文件),但只在 dirSignature 可能变化时才算—— +// 见 reloadIfChanged。它回答的是「账号语义变了吗」,backfill 回填 realm 属于 +// 「文件变了但账号没变」的情形,指纹不变,因此不会自激。 +func dirContentFingerprint(dir string) string { + entries, err := os.ReadDir(dir) + if err != nil { + return "" + } + lines := make([]string, 0, len(entries)) + for _, e := range entries { + if e.IsDir() || !strings.HasPrefix(e.Name(), "workbuddy") || !strings.HasSuffix(e.Name(), ".json") { + continue + } + path := filepath.Join(dir, e.Name()) + raw, rerr := os.ReadFile(path) + if rerr != nil { + lines = append(lines, e.Name()+"|unreadable") + continue + } + a, perr := auth.Parse(raw) + if perr != nil { + // 解析失败也进指纹:文件被写坏了要算「变了」,否则永远不会重试。 + lines = append(lines, e.Name()+"|invalid") + continue + } + lines = append(lines, fmt.Sprintf("%s|%s|%d|%s", e.Name(), a.UID, a.ExpiresAt, a.Realm())) + } + sort.Strings(lines) + sum := sha256.Sum256([]byte(strings.Join(lines, "\n"))) + return hex.EncodeToString(sum[:8]) +} + +// reloadAccounts POST /panel/api/accounts/reload —— 手动重载账号目录。 +// +// 返回 ReloadResult;目录不可读/未配置时 500。跳过(Skipped=true)也是 200: +// 「本轮没动」是正常结果,脚本不该因为目录正在变动就当失败。 +func (p *Panel) reloadAccounts(w http.ResponseWriter, r *http.Request) { + res, err := p.ReloadAccountsReason("manual") + if err != nil { + writeErr(w, http.StatusInternalServerError, "重载失败: "+err.Error()) + return + } + at, _ := p.ReloadStatus() + writeJSON(w, http.StatusOK, map[string]any{ + "ok": true, + "result": res, + "at": at, + "auth_dir": p.cfg.AuthDir, + "pool": len(p.cfg.Pool.List()), + }) +} diff --git a/internal/panel/reload_poll_delete_test.go b/internal/panel/reload_poll_delete_test.go new file mode 100644 index 0000000000000000000000000000000000000000..2a656260aa558dea0ad3277f0ff3927351d26a39 --- /dev/null +++ b/internal/panel/reload_poll_delete_test.go @@ -0,0 +1,235 @@ +package panel + +import ( + "os" + "path/filepath" + "testing" + "time" +) + +// 轮询路径必须能把删掉的账号移出去(issue #199 的删除语义在轮询下要真的生效)。 +// +// 缺陷现场:reloadIfChanged 用内容指纹做门控,指纹没变就直接 Skipped 返回;而 +// 缺席计数 reloadMissing[uid]++ 在 ReloadAccountsReason 内部。删掉一个 auth 文件 +// 只让指纹变一次,计到 1 之后每个 tick 都被指纹门挡在外面 —— reload_delete_confirm +// 只要 >1 就永远到不了,删号静默失效。 +// +// 变异判据:把 reloadIfChanged 里的「指纹没变就返回」放回无条件早退,本用例红。 +func TestReloadPollRemovesDeletedAccountWithConfirmTwo(t *testing.T) { + e := newReloadEnv(t) + e.panel.SetReloadConfig(0, 2) // 与生产默认一致:删除需连续 2 次确认 + now := time.Now().Add(24 * time.Hour).Unix() + + e.writeAuth("u1", "at1", now) + e.writeAuth("u2", "at2", now) + if res, err := e.panel.reloadIfChanged("poll"); err != nil { + t.Fatal(err) + } else if res.Added != 2 { + t.Fatalf("准备阶段 added=%d want 2", res.Added) + } + + // 删掉 u2 的文件,之后再没有人动目录。 + if err := os.Remove(filepath.Join(e.dir, "workbuddy-u2.json")); err != nil { + t.Fatal(err) + } + + // 连续 5 个轮询 tick(远超 confirm=2)。 + var last ReloadResult + for i := 0; i < 5; i++ { + res, err := e.panel.reloadIfChanged("poll") + if err != nil { + t.Fatalf("第 %d 轮: %v", i+1, err) + } + last = res + } + if got := e.poolUIDs(); got["u2"] { + t.Fatalf("删文件后 5 个 tick 仍未移出池(confirm=2);最后一轮 %+v", last) + } + if got := e.poolUIDs(); !got["u1"] { + t.Fatal("未删的 u1 被误删") + } +} + +// 删除必须在**恰好** confirm 次缺席后发生,早一次不行、晚一次也不行。 +// 这一条同时钉住两件事:不在第 1 次就删(护栏 2 的本意),以及不会拖到第 3 次 +// (拖太久会让运维以为功能坏了,正是 issue 报的现象)。 +// +// 变异判据:把 `<` 改成 `<=`(变成要 N+1 次)时本用例红。 +func TestReloadPollRemovesExactlyAtConfirmCount(t *testing.T) { + e := newReloadEnv(t) + e.panel.SetReloadConfig(0, 3) // 用 3 才能区分「第 2 次」「第 3 次」 + now := time.Now().Add(24 * time.Hour).Unix() + + e.writeAuth("solo", "at", now) + if _, err := e.panel.reloadIfChanged("poll"); err != nil { + t.Fatal(err) + } + if err := os.Remove(filepath.Join(e.dir, "workbuddy-solo.json")); err != nil { + t.Fatal(err) + } + + // tick1:完整重载发现缺席,计到 1,不删。 + if _, err := e.panel.reloadIfChanged("poll"); err != nil { + t.Fatal(err) + } + if !e.poolUIDs()["solo"] { + t.Fatal("第 1 次缺席就删了,护栏 2 失效") + } + // tick2:计到 2 < 3,仍不删。 + if _, err := e.panel.reloadIfChanged("poll"); err != nil { + t.Fatal(err) + } + if !e.poolUIDs()["solo"] { + t.Fatal("第 2 次缺席就删了,confirm=3 没被遵守") + } + // tick3:计到 3,必须删。 + res3, err := e.panel.reloadIfChanged("poll") + if err != nil { + t.Fatal(err) + } + if e.poolUIDs()["solo"] { + t.Fatal("第 3 次缺席(confirm=3)仍未删,删除被推迟") + } + // 删除必须被记账:脚本/面板靠 removed/removed_uids 判断「删的是谁」。 + if res3.Removed != 1 { + t.Fatalf("删了但 removed=%d,运维看不见", res3.Removed) + } + if len(res3.RemovedUIDs) != 1 || res3.RemovedUIDs[0] != "solo" { + t.Fatalf("removed_uids=%v want [solo]", res3.RemovedUIDs) + } + if res3.Skipped { + t.Fatal("真删了却仍标 Skipped") + } +} + +// 单账号(池里只有被删的那个)同样要能删掉:确认不是「因为还有别的账号在动才触发」。 +func TestReloadPollRemovesLastAccount(t *testing.T) { + e := newReloadEnv(t) + e.panel.SetReloadConfig(0, 2) + now := time.Now().Add(24 * time.Hour).Unix() + + e.writeAuth("solo", "at", now) + if res, err := e.panel.reloadIfChanged("poll"); err != nil { + t.Fatal(err) + } else if res.Added != 1 { + t.Fatalf("准备阶段 added=%d want 1", res.Added) + } + if err := os.Remove(filepath.Join(e.dir, "workbuddy-solo.json")); err != nil { + t.Fatal(err) + } + for i := 0; i < 4; i++ { + if _, err := e.panel.reloadIfChanged("poll"); err != nil { + t.Fatalf("第 %d 轮: %v", i+1, err) + } + } + if e.poolUIDs()["solo"] { + t.Fatal("唯一账号删文件后仍未移出池") + } +} + +// 在途请求未结束时,轮询路径也不能删——护栏 2 的后半条必须在新路径里同样生效。 +// +// 变异判据:confirmMissing 里去掉 `InFlight(st.UID) > 0` 判断时本用例红。 +func TestReloadPollSkipsRemovalWhileInFlight(t *testing.T) { + e := newReloadEnv(t) + e.panel.SetReloadConfig(0, 2) + now := time.Now().Add(24 * time.Hour).Unix() + + e.writeAuth("u1", "at1", now) + if _, err := e.panel.reloadIfChanged("poll"); err != nil { + t.Fatal(err) + } + if !e.pool.Acquire("u1") { + t.Fatal("获取在途名额失败") + } + if err := os.Remove(filepath.Join(e.dir, "workbuddy-u1.json")); err != nil { + t.Fatal(err) + } + for i := 0; i < 6; i++ { + if _, err := e.panel.reloadIfChanged("poll"); err != nil { + t.Fatalf("第 %d 轮: %v", i+1, err) + } + } + if !e.poolUIDs()["u1"] { + t.Fatal("在途请求未结束时账号被删了") + } + e.pool.Release("u1") + if _, err := e.panel.reloadIfChanged("poll"); err != nil { + t.Fatal(err) + } + if e.poolUIDs()["u1"] { + t.Fatal("在途结束后应立刻删掉(缺席计数已累计到 confirm)") + } +} + +// 删完之后缺席计数表必须清干净:残留的 uid 会让下一轮误判「还有待确认」, +// 把空闲轮询永久拖进 stat 路径。 +// +// 变异判据:confirmMissing 里去掉 `delete(p.reloadMissing, uid)` 时本用例红。 +func TestReloadPollClearsMissingTableAfterRemoval(t *testing.T) { + e := newReloadEnv(t) + e.panel.SetReloadConfig(0, 2) + now := time.Now().Add(24 * time.Hour).Unix() + + e.writeAuth("u1", "at1", now) + if _, err := e.panel.reloadIfChanged("poll"); err != nil { + t.Fatal(err) + } + if err := os.Remove(filepath.Join(e.dir, "workbuddy-u1.json")); err != nil { + t.Fatal(err) + } + for i := 0; i < 3; i++ { + if _, err := e.panel.reloadIfChanged("poll"); err != nil { + t.Fatalf("第 %d 轮: %v", i+1, err) + } + } + if e.poolUIDs()["u1"] { + t.Fatal("前提失败:u1 没被删掉") + } + e.panel.reloadMu.Lock() + left := len(e.panel.reloadMissing) + e.panel.reloadMu.Unlock() + if left != 0 { + t.Fatalf("删完后缺席计数表还剩 %d 条(应为 0)", left) + } + // 残留的缺席计数会让空闲轮询永远走进 stat 路径:真实判据是「下一轮必须干净地跳过」。 + res, err := e.panel.reloadIfChanged("poll") + if err != nil { + t.Fatal(err) + } + if res.Removed != 0 || res.Added != 0 || res.Updated != 0 { + t.Fatalf("删完后空闲轮询仍有动作:%+v", res) + } + if !res.Skipped { + t.Fatalf("删完后空闲轮询应 Skipped,实际 %+v", res) + } +} + +// 指纹门控仍然要挡自激:没人动目录时轮询不能真的重复扫描/重载。 +// 这条与上面几条是同一个改动的两侧约束——放宽删除不能把「无变化就跳过」弄丢。 +// 同时钉住「没有待确认项时绝不去走 stat 路径」。 +func TestReloadPollStaysIdleWhenNothingChanges(t *testing.T) { + e := newReloadEnv(t) + e.panel.SetReloadConfig(0, 2) + now := time.Now().Add(24 * time.Hour).Unix() + + e.writeAuth("u1", "at1", now) + e.writeAuth("u2", "at2", now) + if res, err := e.panel.reloadIfChanged("poll"); err != nil { + t.Fatal(err) + } else if res.Added != 2 { + t.Fatalf("准备阶段 added=%d want 2", res.Added) + } + for i := 0; i < 5; i++ { + res, err := e.panel.reloadIfChanged("poll") + if err != nil { + t.Fatalf("第 %d 轮: %v", i+1, err) + } + if !res.Skipped { + t.Fatalf("第 %d 轮目录没变却做了完整重载:%+v", i+1, res) + } + if res.Removed != 0 || res.Added != 0 || res.Updated != 0 { + t.Fatalf("第 %d 轮空闲却动了池:%+v", i+1, res) + } + } +} diff --git a/internal/panel/reload_test.go b/internal/panel/reload_test.go new file mode 100644 index 0000000000000000000000000000000000000000..c8250cf274ed406e3f14a40d582f15a9c1909632 --- /dev/null +++ b/internal/panel/reload_test.go @@ -0,0 +1,376 @@ +package panel + +import ( + "encoding/json" + "net/http" + "net/http/httptest" + "os" + "path/filepath" + "sync" + "testing" + "time" + + "github.com/misakano7545/workbuddy2api-panel/internal/auth" + "github.com/misakano7545/workbuddy2api-panel/internal/pool" +) + +// reloadEnv 热重载测试环境:真实 auths 目录 + 真实池,不碰上游。 +type reloadEnv struct { + t *testing.T + dir string + panel *Panel + pool *pool.Pool +} + +func newReloadEnv(t *testing.T) *reloadEnv { + t.Helper() + dir := t.TempDir() + pl := pool.New("") + pn := New(Config{Pool: pl, AuthDir: dir}) + pn.SetReloadConfig(0, 2) + return &reloadEnv{t: t, dir: dir, panel: pn, pool: pl} +} + +// writeAuth 落一个合法凭据文件(uid 决定文件名,与生产一致)。 +func (e *reloadEnv) writeAuth(uid, at string, expiresAt int64) string { + e.t.Helper() + a := &auth.Auth{ + UID: uid, AccessToken: at, RefreshToken: "rt-" + uid, + ExpiresAt: expiresAt, FilePath: filepath.Join(e.dir, "workbuddy-"+uid+".json"), + } + if err := a.SaveAtomic(); err != nil { + e.t.Fatalf("write auth %s: %v", uid, err) + } + return a.FilePath +} + +func (e *reloadEnv) reload() ReloadResult { + e.t.Helper() + res, err := e.panel.ReloadAccountsReason("test") + if err != nil { + e.t.Fatalf("reload: %v", err) + } + return res +} + +func (e *reloadEnv) poolUIDs() map[string]bool { + out := map[string]bool{} + for _, st := range e.pool.List() { + out[st.UID] = true + } + return out +} + +// 新增文件 → 入池;改 expires_at → updated 但保留状态;删文件 → 连续 N 次才出池。 +func TestReloadAddsUpdatesAndRemoves(t *testing.T) { + e := newReloadEnv(t) + now := time.Now().Add(24 * time.Hour).Unix() + + e.writeAuth("u1", "at1", now) + res := e.reload() + if res.Added != 1 || res.Updated != 0 || res.Removed != 0 || res.ParseErrors != 0 { + t.Fatalf("首轮 added=%d updated=%d removed=%d parse_errors=%d want 1/0/0/0", + res.Added, res.Updated, res.Removed, res.ParseErrors) + } + if !e.poolUIDs()["u1"] { + t.Fatal("u1 没有入池") + } + + // 记账一个状态,改 expires_at 后必须保留(upsert 只换凭证)。 + a := e.pool.AuthByUID("u1") + if a == nil { + t.Fatal("池里没有 u1") + } + e.writeAuth("u1", "at1-new", now+3600) + res = e.reload() + if res.Updated != 1 || res.Added != 0 || res.Removed != 0 { + t.Fatalf("第二轮 added=%d updated=%d removed=%d want 0/1/0", res.Added, res.Updated, res.Removed) + } + if got := e.pool.AuthByUID("u1").AccessTokenValue(); got != "at1-new" { + t.Fatalf("凭证没更新:%q", got) + } + + // 删文件:第 1 次只挂账,第 2 次才删(连续确认)。 + if err := os.Remove(filepath.Join(e.dir, "workbuddy-u1.json")); err != nil { + t.Fatal(err) + } + res = e.reload() + if res.Removed != 0 { + t.Fatalf("第 1 次扫描就删了(应等连续 2 次确认):removed=%d", res.Removed) + } + if !e.poolUIDs()["u1"] { + t.Fatal("第 1 次扫描后 u1 不该出池") + } + res = e.reload() + if res.Removed != 1 { + t.Fatalf("第 2 次扫描应删掉 u1:removed=%d", res.Removed) + } + if e.poolUIDs()["u1"] { + t.Fatal("连续 2 次确认后 u1 应在池外") + } +} + +// 回归(issue #199 风险 1):目录里有坏文件时,**不得**删除任何账号。 +// +// 场景就是最危险的那条:登录落盘/SaveAtomic 的瞬间被读到半截文件 —— 该账号在 +// 本次扫描结果里消失,若按「扫描结果里没有 = 文件已删」处理,它会被踢出池且 +// 剔除结果持久化,下次启动也不复活。 +// +// 变异判据:去掉 ReloadAccountsReason 里 res.ParseErrors > 0 的早退,本用例红。 +func TestReloadNeverRemovesWhileAnyFileUnparsable(t *testing.T) { + e := newReloadEnv(t) + now := time.Now().Add(24 * time.Hour).Unix() + e.writeAuth("u1", "at1", now) + e.writeAuth("u2", "at2", now) + if res := e.reload(); res.Added != 2 { + t.Fatalf("准备阶段 added=%d want 2", res.Added) + } + + // u1 的文件被删,同时 u2 的文件被写坏(半截 JSON)。 + if err := os.Remove(filepath.Join(e.dir, "workbuddy-u1.json")); err != nil { + t.Fatal(err) + } + broken := filepath.Join(e.dir, "workbuddy-u2.json") + for _, f := range []string{broken, broken + ".bak"} { + if err := os.WriteFile(f, []byte(`{"auth":{"accessToken":"at2"`), 0o600); err != nil { + t.Fatal(err) + } + } + + for round := 1; round <= 3; round++ { + res := e.reload() + if res.ParseErrors == 0 { + t.Fatalf("第 %d 轮应报告解析失败", round) + } + if res.Removed != 0 { + t.Fatalf("第 %d 轮在有坏文件时删了账号:removed=%d %v", round, res.Removed, res.RemovedUIDs) + } + } + got := e.poolUIDs() + if !got["u1"] || !got["u2"] { + t.Fatalf("有坏文件时两个账号都应留在池里,实际 %v", got) + } +} + +// 半写文件恢复后可继续正常工作:修好文件,下一轮照常。 +func TestReloadResumesAfterFileRepaired(t *testing.T) { + e := newReloadEnv(t) + now := time.Now().Add(24 * time.Hour).Unix() + e.writeAuth("u1", "at1", now) + e.reload() + + // 正文与 .bak 一起写坏:只坏正文时 safefile 会从 .bak 回退救回来(也正确, + // 但那样测不到「解析失败」这条路径)。 + broken := filepath.Join(e.dir, "workbuddy-u1.json") + for _, f := range []string{broken, broken + ".bak"} { + if err := os.WriteFile(f, []byte(`{"auth":`), 0o600); err != nil { + t.Fatal(err) + } + } + if res := e.reload(); res.ParseErrors != 1 || res.Removed != 0 { + t.Fatalf("坏文件轮 parse_errors=%d removed=%d want 1/0", res.ParseErrors, res.Removed) + } + // 修好(换一份新凭证) + e.writeAuth("u1", "at1-fixed", now) + res := e.reload() + if res.ParseErrors != 0 || res.Removed != 0 || res.Updated != 1 { + t.Fatalf("修复轮 parse_errors=%d removed=%d updated=%d want 0/0/1", res.ParseErrors, res.Removed, res.Updated) + } + if got := e.pool.AuthByUID("u1").AccessTokenValue(); got != "at1-fixed" { + t.Fatalf("修好后凭证没更新:%q", got) + } +} + +// 在途请求未结束的账号不删(护栏 4)。 +func TestReloadSkipsRemovalWhileInFlight(t *testing.T) { + e := newReloadEnv(t) + now := time.Now().Add(24 * time.Hour).Unix() + e.writeAuth("u1", "at1", now) + e.reload() + + if !e.pool.Acquire("u1") { + t.Fatal("获取在途名额失败") + } + defer e.pool.Release("u1") + + if err := os.Remove(filepath.Join(e.dir, "workbuddy-u1.json")); err != nil { + t.Fatal(err) + } + for i := 0; i < 3; i++ { + if res := e.reload(); res.Removed != 0 { + t.Fatalf("第 %d 轮:在途账号被删了", i+1) + } + } + if !e.poolUIDs()["u1"] { + t.Fatal("在途期间 u1 必须留在池里") + } + e.pool.Release("u1") + // 释放后再走两轮(缺席计数从 0 开始重算,因为前几轮每次都被跳过但仍计数)。 + for i := 0; i < 2; i++ { + e.reload() + } + if e.poolUIDs()["u1"] { + t.Fatal("在途结束后连续确认应删掉 u1") + } +} + +// 目录里有文件盘上还在时不算缺席(护栏 4 的另一半:面板刚写入、扫描竞态)。 +func TestReloadKeepsAccountWhoseFileStillExists(t *testing.T) { + e := newReloadEnv(t) + now := time.Now().Add(24 * time.Hour).Unix() + e.writeAuth("u1", "at1", now) + e.reload() + + // 模拟「面板路径刚把账号加进池,但文件名不匹配扫描 glob」——文件还在盘上。 + a := &auth.Auth{UID: "u1", AccessToken: "at1", RefreshToken: "rt-u1", + ExpiresAt: now, FilePath: filepath.Join(e.dir, "workbuddy-u1.json")} + e.pool.Add(a) + for i := 0; i < 3; i++ { + if res := e.reload(); res.Removed != 0 { + t.Fatalf("第 %d 轮:文件仍在盘上却删了账号", i+1) + } + } +} + +// 手动接口:返回结果摘要,且目录不可读时给出明确错误。 +func TestReloadEndpoint(t *testing.T) { + e := newReloadEnv(t) + now := time.Now().Add(24 * time.Hour).Unix() + e.writeAuth("u1", "at1", now) + + rec := httptest.NewRecorder() + e.panel.ServeHTTP(rec, httptest.NewRequest("POST", "/panel/api/accounts/reload", nil)) + if rec.Code != http.StatusOK { + t.Fatalf("code=%d body=%s", rec.Code, rec.Body) + } + var got struct { + OK bool `json:"ok"` + Result struct { + Added int `json:"added"` + ParseErrors int `json:"parse_errors"` + } `json:"result"` + Pool int `json:"pool"` + } + if err := json.Unmarshal(rec.Body.Bytes(), &got); err != nil { + t.Fatalf("decode: %v (%s)", err, rec.Body) + } + if !got.OK || got.Result.Added != 1 || got.Pool != 1 { + t.Fatalf("ok=%v added=%d pool=%d want true/1/1(%s)", got.OK, got.Result.Added, got.Pool, rec.Body) + } + + // 目录被移走 → 500 且带原因(脚本据此判断「配置错了」而不是「没变化」)。 + e.panel.cfg.AuthDir = filepath.Join(e.dir, "nope") // 不存在的目录:ReadDir 失败但 Glob 返回空 + if res, err := e.panel.ReloadAccountsReason("test"); err != nil { + t.Fatalf("目录不存在不该报错(应视为空目录): %v", err) + } else if res.Files != 0 { + t.Fatalf("空目录 files=%d want 0", res.Files) + } +} + +// 轮询只在目录内容变化时才重载(自激防护):LoadDirReport 会回填空 realm 并写盘, +// 若按 mtime 判断会永远在重载。 +func TestReloadPollOnlyWhenContentChanges(t *testing.T) { + e := newReloadEnv(t) + now := time.Now().Add(24 * time.Hour).Unix() + e.writeAuth("u1", "at1", now) + + res, err := e.panel.reloadIfChanged("poll") + if err != nil { + t.Fatal(err) + } + if res.Added != 1 { + t.Fatalf("首轮 added=%d want 1", res.Added) + } + // 第二轮:内容没变 → 跳过,不再扫。 + res, err = e.panel.reloadIfChanged("poll") + if err != nil { + t.Fatal(err) + } + if !res.Skipped || res.Added != 0 { + t.Fatalf("目录未变时应跳过:skipped=%v added=%d", res.Skipped, res.Added) + } + // 换一个账号文件 → 应当重载。 + e.writeAuth("u2", "at2", now) + res, err = e.panel.reloadIfChanged("poll") + if err != nil { + t.Fatal(err) + } + if res.Skipped || res.Added != 1 { + t.Fatalf("新增文件后应重载:skipped=%v added=%d", res.Skipped, res.Added) + } +} + +// 并发重载不会互相拆台(reloadMu 串行化)。 +func TestReloadConcurrentSafe(t *testing.T) { + e := newReloadEnv(t) + now := time.Now().Add(24 * time.Hour).Unix() + e.writeAuth("u1", "at1", now) + + var wg sync.WaitGroup + for i := 0; i < 8; i++ { + wg.Add(1) + go func() { + defer wg.Done() + _, _ = e.panel.ReloadAccountsReason("test") + }() + } + wg.Wait() + if n := len(e.pool.List()); n != 1 { + t.Fatalf("并发重载后 pool=%d want 1", n) + } +} + +// 面板增删与热重载并发时不互相拆台、也不死锁(issue #199 风险 3)。 +// +// 覆盖三条会同时动池的路径:目录重载、账号移除、API Key 新增账号。断言只要求 +// 「跑完不炸、池子与目录一致」;配 -race 跑能抓数据竞争,死锁则会让测试超时。 +func TestReloadSerialisesWithPanelMutations(t *testing.T) { + e := newReloadEnv(t) + now := time.Now().Add(24 * time.Hour).Unix() + e.writeAuth("u1", "at1", now) + e.writeAuth("u2", "at2", now) + if res := e.reload(); res.Added != 2 { + t.Fatalf("准备阶段 added=%d want 2", res.Added) + } + + var wg sync.WaitGroup + stop := make(chan struct{}) + // 持续重载 + wg.Add(1) + go func() { + defer wg.Done() + for { + select { + case <-stop: + return + default: + _, _ = e.panel.ReloadAccountsReason("test") + } + } + }() + // 并发增删 + wg.Add(1) + go func() { + defer wg.Done() + for i := 0; i < 20; i++ { + rec := httptest.NewRecorder() + req := httptest.NewRequest("POST", "/panel/api/accounts/u1/remove", nil) + e.panel.ServeHTTP(rec, req) + e.writeAuth("u1", "at1-"+time.Now().Format("150405.000000000"), now) + _, _ = e.panel.ReloadAccountsReason("test") + } + }() + time.Sleep(150 * time.Millisecond) + close(stop) + wg.Wait() + + // 收尾:目录里两份文件都在,池里也应当有两号(最后一轮重载以目录为准)。 + for _, uid := range []string{"u1", "u2"} { + e.writeAuth(uid, "at-final-"+uid, now) + } + e.reload() + got := e.poolUIDs() + if !got["u1"] || !got["u2"] { + t.Fatalf("并发结束后池应与目录一致,实际 %v", got) + } +} diff --git a/internal/panel/remarks_store_test.go b/internal/panel/remarks_store_test.go new file mode 100644 index 0000000000000000000000000000000000000000..79141d5d949e5d5253fd416c676b07cafe251b61 --- /dev/null +++ b/internal/panel/remarks_store_test.go @@ -0,0 +1,77 @@ +package panel + +import ( + "encoding/json" + "os" + "os/exec" + "testing" +) + +// TestAppJSStoreRemarksReportsFailure 备注写不进浏览器存储时必须返回 false。 +// +// 原来 storeRemarks 用空 catch 吞掉 localStorage 的异常,而 saveRemarkForm 无条件 +// toast「备注已保存」—— 隐私模式或配额满时界面说保存成功、刷新后全丢,是静默的 +// 数据丢失。契约改为返回 bool,调用方据此报错,这里钉住这个返回值。 +func TestAppJSStoreRemarksReportsFailure(t *testing.T) { + node, err := exec.LookPath("node") + if err != nil { + t.Skip("node not installed; remarks store test skipped") + } + script := `const fs = require('fs'), vm = require('vm'); +const src = fs.readFileSync(process.argv[2], 'utf8'); +const s = src.indexOf('function storeRemarks(map) {'); +const e = src.indexOf('\n}\n', s); +if (s < 0 || e < 0) throw new Error('storeRemarks not found'); +const code = "const LS_REMARKS = 'k';\nlet remarksCache = null;\n" + src.slice(s, e + 3) + + '\nthis.storeRemarks = storeRemarks; this.cache = () => remarksCache;'; +function run(setItem) { + const ctx = { JSON, localStorage: { setItem }, }; + vm.createContext(ctx); + vm.runInContext(code, ctx); + return ctx; +} +const out = {}; +const ok = run(() => {}); +out.okReturn = ok.storeRemarks({ u1: 'A' }); +out.okCache = JSON.stringify(ok.cache()); +out.okPayload = ok.storeRemarks({ u2: 'B' }) && JSON.stringify(ok.cache()); +const bad = run(() => { throw new Error('QuotaExceededError'); }); +out.badReturn = bad.storeRemarks({ u1: 'A' }); +out.badCache = JSON.stringify(bad.cache()); +process.stdout.write(JSON.stringify(out));` + f, err := os.CreateTemp(t.TempDir(), "remarks-*.cjs") + if err != nil { + t.Fatalf("temp file: %v", err) + } + if _, err := f.WriteString(script); err != nil { + t.Fatalf("write script: %v", err) + } + f.Close() + + out, err := exec.Command(node, f.Name(), "app.js").CombinedOutput() + if err != nil { + t.Fatalf("node failed: %v\n%s", err, out) + } + var got struct { + OkReturn bool `json:"okReturn"` + OkCache string `json:"okCache"` + OkPayload string `json:"okPayload"` + BadReturn bool `json:"badReturn"` + BadCache string `json:"badCache"` + } + if err := json.Unmarshal(out, &got); err != nil { + t.Fatalf("bad output: %v\n%s", err, out) + } + if !got.OkReturn { + t.Error("写入成功时必须返回 true(否则调用方会误报失败)") + } + if got.OkCache != `{"u1":"A"}` { + t.Errorf("写入成功后缓存应为本值,得到 %q", got.OkCache) + } + if got.BadReturn { + t.Error("localStorage 抛异常时必须返回 false —— 否则界面谎报「已保存」、刷新后丢失") + } + if got.BadCache != `{"u1":"A"}` { + t.Errorf("写盘失败时内存缓存仍应更新(本次会话内还能看到),得到 %s", got.BadCache) + } +} diff --git a/internal/panel/ring.go b/internal/panel/ring.go index 52b88bf2a28606f1beaecffdb9195e91b98392b8..2f871db879c88f898283b0f36c1d3a947130b266 100644 --- a/internal/panel/ring.go +++ b/internal/panel/ring.go @@ -1,94 +1,264 @@ -// ring.go 固定容量的结构化日志环形缓冲(并发安全,实现 io.Writer)。 -// main 把 log 包输出与 chat 表格日志经 MultiWriter 镜像进来,面板 -// /panel/api/logs 读取快照;超出容量的旧行按 FIFO 淘汰。 -// -// 每行入环时按前缀规则归类频道(chat=对话请求表格行 / task=任务动作 / -// sys=系统与其它),面板日志视图按频道筛选——对话流量大时任务结果不被冲掉。 -package panel - -import ( - "regexp" - "strings" - "sync" - "time" -) - -// 日志频道。 -const ( - ChChat = "chat" - ChTask = "task" - ChSys = "sys" -) - -// LogEntry 单条日志(时间戳取写入时刻;log 包行的行首日期时间已被剥离)。 -type LogEntry struct { - TS time.Time `json:"ts"` - Ch string `json:"ch"` - Text string `json:"text"` -} - -// taskPrefixes 任务动作日志的行首标识(scheduler 与 panel 的既有口径)。 -var taskPrefixes = []string{ - "school ", "streak-bonus ", "travel ", "blackcat ", "lottery ", - "checkin ", "activity ", "keepalive ", "balance ", "user-resource ", - "panel: 任务", "panel: 一键", "panel: checkin", "panel: 手动", - "panel: 队列", "panel: 券码", -} - -// tsPrefixRe log 包默认 flags(日期 时间)产生的行首时间戳。 -var tsPrefixRe = regexp.MustCompile(`^\d{4}/\d{2}/\d{2} \d{2}:\d{2}:\d{2} `) - -// classifyLine 按行首特征归类频道。 -func classifyLine(line string) string { - if strings.HasPrefix(line, "| #") { // chat 表格日志(server/logging.go logChatRow) - return ChChat - } - for _, p := range taskPrefixes { - if strings.HasPrefix(line, p) { - return ChTask - } - } - return ChSys -} - -// Ring 日志环形缓冲。 -type Ring struct { - mu sync.Mutex - entries []LogEntry - cap int -} - -// NewRing 构建容量为 capacity 的日志环(非正值回退 500)。 -func NewRing(capacity int) *Ring { - if capacity <= 0 { - capacity = 500 - } - return &Ring{cap: capacity} -} - -// Write 按 \n 切分入环(实现 io.Writer)。空行丢弃;超容量淘汰最旧行。 -func (r *Ring) Write(p []byte) (int, error) { - now := time.Now() - r.mu.Lock() - defer r.mu.Unlock() - for _, line := range strings.Split(strings.TrimRight(string(p), "\r\n"), "\n") { - if line == "" { - continue - } - text := tsPrefixRe.ReplaceAllString(line, "") - r.entries = append(r.entries, LogEntry{TS: now, Ch: classifyLine(text), Text: text}) - if overflow := len(r.entries) - r.cap; overflow > 0 { - r.entries = r.entries[overflow:] - } - } - return len(p), nil -} - -// Snapshot 按写入顺序返回缓冲内全部条目(拷贝,调用方可安全持有)。 -func (r *Ring) Snapshot() []LogEntry { - r.mu.Lock() - defer r.mu.Unlock() - out := make([]LogEntry, len(r.entries)) - copy(out, r.entries) - return out -} +// ring.go 固定容量的结构化日志环形缓冲(并发安全,实现 io.Writer)。 +// main 把 log 包输出与 chat 表格日志经 MultiWriter 镜像进来,面板 +// /panel/api/logs 读取快照;每个频道独立限额,任务日志可原子落盘。 +// +// 每行入环时按前缀规则归类频道(chat=对话请求表格行 / task=任务动作 / +// sys=系统与其它),面板日志视图按频道筛选——对话流量大时任务结果不被冲掉。 +package panel + +import ( + "encoding/json" + "errors" + "fmt" + "io" + "os" + "path/filepath" + "regexp" + "sort" + "strings" + "sync" + "time" +) + +// 日志频道。 +const ( + ChChat = "chat" + ChTask = "task" + ChSys = "sys" +) + +// LogEntry 单条日志(时间戳取写入时刻;log 包行的行首日期时间已被剥离)。 +// +// Seq 是环形缓冲内的**单调序号**(随写入递增,淘汰不回退;初值取启动时刻的 +// 毫秒数,使跨进程重启也保持单调)。增量拉取 +// 必须用它做游标,不能用 TS: +// - time.Now() 的精度不足以保证唯一。Windows 上实测相邻 Write 落在同一 +// ~15.6ms 时钟刻度内,TS 完全相同(一次 Write 的多行、以及背靠背的多次 +// Write 都是);Linux 上纳秒精度好些但同样不保证。 +// - 用 TS 做游标时,客户端只能拿到毫秒(JS Date)或全精度(原始串)两种形态; +// 无论哪种,「同一 TS 的多条」都无法部分推进——要么重复返回,要么整批漏掉。 +// +// 序号没有这个问题:`Seq > since_seq` 精确表达「这一批里的哪些还没给你」。 +type LogEntry struct { + TS time.Time `json:"ts"` + Seq uint64 `json:"seq"` + Ch string `json:"ch"` + Text string `json:"text"` +} + +// taskPrefixes 任务动作日志的行首标识(scheduler 与 panel 的既有口径)。 +var taskPrefixes = []string{ + "streak-bonus ", "travel ", "lottery ", + "checkin ", "activity ", "keepalive ", "balance ", "user-resource ", + "panel: 任务", "panel: 一键", "panel: checkin", "panel: 手动", + "panel: 队列", "panel: task ", "panel: 接受任务", "panel: 定时成长", +} + +// tsPrefixRe log 包默认 flags(日期 时间)产生的行首时间戳。 +var tsPrefixRe = regexp.MustCompile(`^\d{4}/\d{2}/\d{2} \d{2}:\d{2}:\d{2} `) + +// classifyLine 按行首特征归类频道。 +func classifyLine(line string) string { + if strings.HasPrefix(line, "| #") { // chat 表格日志(server/logging.go logChatRow) + return ChChat + } + for _, p := range taskPrefixes { + if strings.HasPrefix(line, p) { + return ChTask + } + } + return ChSys +} + +// Ring 日志环形缓冲。 +type Ring struct { + mu sync.Mutex + entries []LogEntry + seq uint64 + cap int + taskArchive string + archiveError string + // store 全频道按天落盘(见 logstore.go)。nil = 未启用(纯内存)。 + store *LogStore +} + +// SetLogStore 挂上按天落盘存储,并用它回填最近日志。 +// +// 回填来源特意取 store 而不是 taskArchive:那份 JSON 只有任务频道、只留 500 条、 +// 跨天即丢,重启后「昨天的 chat 行」它给不了。store 可用即由它接管,taskArchive +// 退化为落盘目录建不出来时的兜底(见 main 的装配)。 +func (r *Ring) SetLogStore(store *LogStore) error { + r.mu.Lock() + r.store = store + // 回填期间不能持锁调用 store 的读(store 内部也有锁,且要 Flush),先取数据。 + r.mu.Unlock() + if store == nil { + return nil + } + back := store.Backfill(0) + r.mu.Lock() + defer r.mu.Unlock() + for _, entry := range back { + entry.Text = boundedLogText(entry.Text) + r.appendLocked(entry) + } + sort.SliceStable(r.entries, func(i, j int) bool { return r.entries[i].TS.Before(r.entries[j].TS) }) + return nil +} + +// NewRing 构建每频道容量为 capacity 的日志环(非正值回退 500)。 +// +// seq 的起点取**当前时间戳的毫秒数**,不是 0:序号要在进程重启后仍然单调, +// 否则浏览器里残留的旧游标(重启前 seq 可能已到几万)会大于新进程的序号, +// `?since_seq=` 一直返回空,「运行日志」页空白最长要到游标老化(5 分钟)才恢复。 +// 用时间做纪元后,重启前的游标必然小于重启后写入的任何序号。 +func NewRing(capacity int) *Ring { + if capacity <= 0 { + capacity = 500 + } + return &Ring{cap: capacity, seq: uint64(time.Now().UnixMilli())} +} + +// SetTaskArchive 恢复并持久化任务频道的最近日志。不存在的文件是正常首启。 +// 在连接 log 输出之前调用;路径与 state_file 同目录,由入口负责注入。 +// 移植上游 PR #104。 +func (r *Ring) SetTaskArchive(path string) error { + r.mu.Lock() + defer r.mu.Unlock() + r.taskArchive = path + if path == "" { + return nil + } + f, err := os.Open(path) + if errors.Is(err, os.ErrNotExist) { + return nil + } + if err != nil { + r.archiveError = err.Error() + return err + } + defer f.Close() + var entries []LogEntry + if err := json.NewDecoder(io.LimitReader(f, 16<<20)).Decode(&entries); err != nil { + r.archiveError = err.Error() + return fmt.Errorf("read task log archive: %w", err) + } + for _, entry := range entries { + if entry.Ch != ChTask || entry.Text == "" { + continue + } + entry.Text = boundedLogText(entry.Text) + r.appendLocked(entry) + } + sort.SliceStable(r.entries, func(i, j int) bool { return r.entries[i].TS.Before(r.entries[j].TS) }) + r.archiveError = "" + return nil +} + +// ArchiveError 供面板反馈写盘故障,日志写失败不阻塞/破坏模型请求。 +func (r *Ring) ArchiveError() string { + r.mu.Lock() + defer r.mu.Unlock() + return r.archiveError +} + +// boundedLogText 超长行截断到 4096 个字符(含恢复路径:防历史文件拖垮面板)。 +func boundedLogText(text string) string { + const maxRunes = 4096 + if len(text) <= maxRunes { + return text + } + runes := []rune(text) + if len(runes) > maxRunes { + return string(runes[:maxRunes]) + "…" + } + return text +} + +// appendLocked 入环并按**同频道**计数淘汰最旧行(频道互不挤占)。 +func (r *Ring) appendLocked(entry LogEntry) { + // 序号在锁内递增:即使 TS 相同(同一时钟刻度内的多次写入),每行也唯一。 + r.seq++ + entry.Seq = r.seq + r.entries = append(r.entries, entry) + count, first := 0, -1 + for i, e := range r.entries { + if e.Ch != entry.Ch { + continue + } + count++ + if first == -1 { + first = i + } + } + if count > r.cap { + r.entries = append(r.entries[:first], r.entries[first+1:]...) + } +} + +// persistTasksLocked 把任务频道整体原子落盘(tmp+rename;失败只记 archiveError)。 +func (r *Ring) persistTasksLocked() { + if r.taskArchive == "" { + return + } + tasks := make([]LogEntry, 0, r.cap) + for _, entry := range r.entries { + if entry.Ch == ChTask { + tasks = append(tasks, entry) + } + } + raw, err := json.Marshal(tasks) + if err == nil { + err = os.MkdirAll(filepath.Dir(r.taskArchive), 0700) + } + tmp := r.taskArchive + ".tmp" + if err == nil { + err = os.WriteFile(tmp, raw, 0600) + } + if err == nil { + err = os.Rename(tmp, r.taskArchive) + } + if err != nil { + r.archiveError = err.Error() + _ = os.Remove(tmp) + } else { + r.archiveError = "" + } +} + +// Write 按 \n 切分入环(实现 io.Writer)。频道互不淘汰,任务结果独立保存。 +func (r *Ring) Write(p []byte) (int, error) { + now := time.Now() + r.mu.Lock() + defer r.mu.Unlock() + taskChanged := false + for _, line := range strings.Split(strings.TrimRight(string(p), "\r\n"), "\n") { + if line == "" { + continue + } + text := boundedLogText(tsPrefixRe.ReplaceAllString(line, "")) + channel := classifyLine(text) + entry := LogEntry{TS: now, Ch: channel, Text: text} + r.appendLocked(entry) + // 落盘在**锁内**做:与既有 persistTasksLocked 同款取舍——同一把锁保证 + // 「入环顺序 = 文件顺序」,swap 出去写会让两条并发日志在文件里倒序, + // 事故复盘时按时间读就错位了。 + if r.store != nil { + r.store.Append(entry) + } + taskChanged = taskChanged || channel == ChTask + } + if taskChanged { + r.persistTasksLocked() + } + return len(p), nil +} + +// Snapshot 按写入顺序返回缓冲内全部条目(拷贝,调用方可安全持有)。 +func (r *Ring) Snapshot() []LogEntry { + r.mu.Lock() + defer r.mu.Unlock() + out := make([]LogEntry, len(r.entries)) + copy(out, r.entries) + return out +} diff --git a/internal/panel/ring_test.go b/internal/panel/ring_test.go index b3f71cf14c7a565afab592a892146f32d73a05a5..a3fee48a0e83d77e935029878e71c928f4f3ae9b 100644 --- a/internal/panel/ring_test.go +++ b/internal/panel/ring_test.go @@ -1,50 +1,127 @@ -package panel - -import ( - "strings" - "testing" - "time" -) - -func TestClassifyLine(t *testing.T) { - cases := map[string]string{ - "| #001 | glm-5.2 | stream | 200 | uid=c8a3e793 | TTFB=120ms |": ChChat, - "school c8a3e793: ★ 分享任务完成": ChTask, - "streak-bonus 5c162cc9: 🎊 新手礼包 +100c": ChTask, - "blackcat c8a3e793: 完成 3 次夜间对话": ChTask, - "checkin 5c162cc9: 已签到": ChTask, - "panel: 任务动作 uid=x code=chat_5": ChTask, - "panel: 队列启动:6 项(并发 2)": ChTask, - "panel: revive uid=x": ChSys, - "workbuddy2api listening on :7863": ChSys, - "scheduler: 余额后台刷新每 5m0s": ChSys, - } - for line, want := range cases { - if got := classifyLine(line); got != want { - t.Errorf("classifyLine(%q)=%q want %q", line, got, want) - } - } -} - -func TestRingWriteStripsTimestamp(t *testing.T) { - r := NewRing(4) - if _, err := r.Write([]byte("2026/09/14 00:12:34 school x: done\n")); err != nil { - t.Fatal(err) - } - if _, err := r.Write([]byte("| #002 | glm | stream | 200 | ok |")); err != nil { - t.Fatal(err) - } - es := r.Snapshot() - if len(es) != 2 { - t.Fatalf("entries=%d want 2", len(es)) - } - if strings.HasPrefix(es[0].Text, "2026/") { - t.Errorf("timestamp not stripped: %q", es[0].Text) - } - if es[0].Ch != ChTask || es[1].Ch != ChChat { - t.Errorf("channels: %q %q", es[0].Ch, es[1].Ch) - } - if time.Since(es[0].TS) > 5*time.Second { - t.Errorf("stale ts: %v", es[0].TS) - } -} +package panel + +import ( + "encoding/json" + "fmt" + "net/http/httptest" + "os" + "path/filepath" + "strings" + "testing" + "time" +) + +func TestClassifyLine(t *testing.T) { + cases := map[string]string{ + "| #001 | glm-5.2 | stream | 200 | uid=c8a3e793 | TTFB=120ms |": ChChat, + "checkin c8a3e793: 已签到(幂等)": ChTask, + "streak-bonus 5c162cc9: 🎊 新手礼包 +100c": ChTask, + "checkin 5c162cc9: 已签到": ChTask, + "panel: 任务动作 uid=x code=chat_5": ChTask, + "panel: task auto uid=x code=chat_5 status=claim_pending": ChTask, + "panel: 接受任务 uid=x: 3 项": ChTask, + "panel: 定时成长 uid=x: 进入后台任务": ChTask, + "panel: 队列启动:6 项(并发 2)": ChTask, + "panel: revive uid=x": ChSys, + "workbuddy2api listening on :7863": ChSys, + "scheduler: 余额后台刷新每 5m0s": ChSys, + } + for line, want := range cases { + if got := classifyLine(line); got != want { + t.Errorf("classifyLine(%q)=%q want %q", line, got, want) + } + } +} + +func TestRingWriteStripsTimestamp(t *testing.T) { + r := NewRing(4) + if _, err := r.Write([]byte("2026/09/14 00:12:34 checkin x: done\n")); err != nil { + t.Fatal(err) + } + if _, err := r.Write([]byte("| #002 | glm | stream | 200 | ok |")); err != nil { + t.Fatal(err) + } + es := r.Snapshot() + if len(es) != 2 { + t.Fatalf("entries=%d want 2", len(es)) + } + if strings.HasPrefix(es[0].Text, "2026/") { + t.Errorf("timestamp not stripped: %q", es[0].Text) + } + if es[0].Ch != ChTask || es[1].Ch != ChChat { + t.Errorf("channels: %q %q", es[0].Ch, es[1].Ch) + } + if time.Since(es[0].TS) > 5*time.Second { + t.Errorf("stale ts: %v", es[0].TS) + } +} + +// TestRingRetainsTaskDuringChatFloodAndRestores 频道独立限额:chat 洪峰不冲掉 task; +// 任务频道原子落盘并在重启后恢复(上限照旧约束)。移植上游 PR #104。 +func TestRingRetainsTaskDuringChatFloodAndRestores(t *testing.T) { + archive := filepath.Join(t.TempDir(), "task-logs.json") + r := NewRing(5) + if err := r.SetTaskArchive(archive); err != nil { + t.Fatal(err) + } + r.Write([]byte("panel: task auto uid=test code=chat_5 status=done claimed=true\n")) + for i := 0; i < 50; i++ { + r.Write([]byte(fmt.Sprintf("| #%d | chat\n", i))) + } + counts := map[string]int{} + for _, e := range r.Snapshot() { + counts[e.Ch]++ + } + if counts[ChTask] != 1 || counts[ChChat] != 5 { + t.Fatalf("channels=%v", counts) + } + restored := NewRing(5) + if err := restored.SetTaskArchive(archive); err != nil { + t.Fatal(err) + } + entries := restored.Snapshot() + if len(entries) != 1 || !strings.Contains(entries[0].Text, "claimed=true") { + t.Fatalf("restored=%v", entries) + } + for i := 0; i < 12; i++ { + restored.Write([]byte(fmt.Sprintf("panel: 任务 result %d\n", i))) + } + restarted := NewRing(5) + if err := restarted.SetTaskArchive(archive); err != nil { + t.Fatal(err) + } + if len(restarted.Snapshot()) != 5 { + t.Fatal("task archive is not bounded") + } +} + +// TestRingPersistenceFailureStillRetainsLogs 写盘故障不阻塞日志入环,且经面板 +// /panel/api/logs 的 archive_error 暴露(失败仅提示,不影响请求路径)。 +func TestRingPersistenceFailureStillRetainsLogs(t *testing.T) { + r := NewRing(3) + archive := filepath.Join(t.TempDir(), "task-logs.json") + if err := r.SetTaskArchive(archive); err != nil { + t.Fatal(err) + } + // 文件位置存在同名目录 → 原子替换失败。 + if err := os.Mkdir(archive, 0700); err != nil { + t.Fatal(err) + } + n, err := r.Write([]byte("panel: 任务 result\n")) + if err != nil || n == 0 || len(r.Snapshot()) != 1 || r.ArchiveError() == "" { + t.Fatalf("n=%d err=%v archive=%q", n, err, r.ArchiveError()) + } + p := New(Config{}) + p.logs = r + rec := httptest.NewRecorder() + p.ServeHTTP(rec, httptest.NewRequest("GET", "/panel/api/logs", nil)) + var data struct { + ArchiveError string `json:"archive_error"` + } + if err := json.Unmarshal(rec.Body.Bytes(), &data); err != nil { + t.Fatal(err) + } + if data.ArchiveError == "" { + t.Fatal("archive error was hidden from the panel API") + } +} diff --git a/internal/panel/security_test.go b/internal/panel/security_test.go index 2505644868fab4fb7bb020a163eb50c7bd8c12ce..6bdc30d660113842a0de50716ec47e29116eb670 100644 --- a/internal/panel/security_test.go +++ b/internal/panel/security_test.go @@ -1,146 +1,248 @@ -package panel - -import ( - "net/http" - "net/http/httptest" - "strings" - "testing" -) - -func newTestPanel() *Panel { - // 启用鉴权:未带 key 的请求一律 401,不进入依赖 Pool/Upstream 的 handler。 - return New(Config{Version: "test", APIKey: "test-key"}) -} - -// 面板安全响应头必须覆盖:页面、静态脚本、鉴权失败响应。 -func TestSecurityHeadersOnAllPanelResponses(t *testing.T) { - p := newTestPanel() - paths := []struct{ method, path string }{ - {"GET", "/panel/"}, - {"GET", "/panel/app.js"}, - {"GET", "/panel/api/overview"}, // 401(未提供 key) - {"POST", "/panel/api/config"}, // 401 - {"GET", "/panel/api/nonexistent"}, - } - for _, c := range paths { - rec := httptest.NewRecorder() - p.ServeHTTP(rec, httptest.NewRequest(c.method, c.path, nil)) - h := rec.Header() - if got := h.Get("Content-Security-Policy"); got == "" { - t.Errorf("%s %s: missing CSP", c.method, c.path) - } - if h.Get("X-Content-Type-Options") != "nosniff" { - t.Errorf("%s %s: X-Content-Type-Options=%q", c.method, c.path, h.Get("X-Content-Type-Options")) - } - if h.Get("X-Frame-Options") != "DENY" { - t.Errorf("%s %s: X-Frame-Options=%q", c.method, c.path, h.Get("X-Frame-Options")) - } - if h.Get("Referrer-Policy") != "no-referrer" { - t.Errorf("%s %s: Referrer-Policy=%q", c.method, c.path, h.Get("Referrer-Policy")) - } - } -} - -// CSP 必须禁止内联脚本与 iframe 嵌套(严格策略的核心约束)。 -func TestCSPDisallowsInlineScriptAndFraming(t *testing.T) { - p := newTestPanel() - rec := httptest.NewRecorder() - p.ServeHTTP(rec, httptest.NewRequest("GET", "/panel/", nil)) - csp := rec.Header().Get("Content-Security-Policy") - - for _, must := range []string{ - "script-src 'self'", - "frame-ancestors 'none'", - "base-uri 'none'", - "default-src 'none'", - } { - if !strings.Contains(csp, must) { - t.Errorf("CSP missing %q; got: %s", must, csp) - } - } - if strings.Contains(csp, "script-src 'self' 'unsafe-inline'") || strings.Contains(csp, "script-src 'unsafe-inline'") { - t.Errorf("CSP must not allow unsafe-inline scripts; got: %s", csp) - } -} - -// 页面必须引用外部脚本(内联脚本会被上面的 CSP 拦掉,页面将完全不可用)。 -func TestIndexReferencesExternalScript(t *testing.T) { - p := newTestPanel() - rec := httptest.NewRecorder() - p.ServeHTTP(rec, httptest.NewRequest("GET", "/panel/", nil)) - body := rec.Body.String() - - if !strings.Contains(body, ``) { - t.Error("index.html must load app.js externally (inline script is blocked by CSP)") - } - // 反例保护:出现内联 内容块即为回归 - if strings.Contains(body, " 内容块即为回归 + if strings.Contains(body, "blocked`, ErrWafBlock}, - // 403 带业务信封的仍走既有分类(P0-1 约束:不劫持业务 403)。 - {403, `{"code":11128,"msg":"blocked by security policy"}`, ErrContentBlocked}, - {403, `{"code":60001,"msg":"quota exceeded"}`, ErrHardCredit}, - {403, `{"code":1,"msg":"unknown business error"}`, ErrClient}, - // 非 403 的无信封错误体不进 WAF 分类(WAF 判定绑定 403 形态)。 - {400, `bad request`, ErrClient}, - {429, ``, ErrSoftRate}, - } - for _, c := range cases { - if got := Classify(c.status, c.body); got != c.want { - t.Errorf("Classify(%d,%q)=%v want %v", c.status, c.body, got, c.want) - } - } -} - -// TestIsModelRateLimit 判断 429 body 是否明确指向模型级限流(code 6004)。 -func TestIsModelRateLimit(t *testing.T) { - cases := []struct { - body string - want bool - }{ - // 6004:模型级限流(issue #31 的核心场景)。 - {`{"code":6004,"msg":"将在 2026-09-11 18:33:27 UTC+8 重置"}`, true}, - {`{"code": 6004,"msg":"x"}`, true}, - // 其他 code(非模型级限流)→ 不算。 - {`{"code":11140,"msg":"The model provider is rate-limiting requests."}`, false}, - {`{"code":1,"msg":"429 rate limit"}`, false}, - } - for _, c := range cases { - if got := IsModelRateLimit(c.body); got != c.want { - t.Errorf("IsModelRateLimit(%q)=%v want %v", c.body, got, c.want) - } - } -} - -// TestParseSoftRateReset 解析上游 429 6004 msg 里的「将在 … 重置」时间(## UTC+8)。 -func TestParseSoftRateReset(t *testing.T) { - future := time.Now().Add(35 * time.Minute) - ts := future.In(softRateResetLoc).Format("2006-01-02 15:04:05") - cases := []struct { - name string - body string - ok bool - }{ - {"6004 带时间+UTC+8 后缀", `{"code":6004,"msg":"将在 ` + ts + ` UTC+8 重置"}`, true}, - {"6004 带时间无后缀", `{"code":6004,"msg":"将在 ` + ts + ` 重置"}`, true}, - {"6004 无时间文案", `{"code":6004,"msg":"model usage limit exceeded"}`, false}, - {"非 6004 但带时间(ParseRateReset 统一解析;模型级豁免由调用侧按 6004 判定)", `{"code":11140,"msg":"将在 ` + ts + ` UTC+8 重置"}`, true}, - {"非法时间格式", `{"code":6004,"msg":"将在 明天 重置"}`, false}, - {"空 body", ``, false}, - } - for _, c := range cases { - t.Run(c.name, func(t *testing.T) { - got, ok := ParseRateReset(c.body) - if ok != c.ok { - t.Fatalf("ok=%v want %v (body=%s)", ok, c.ok, c.body) - } - if ok { - // 解析结果 = ts 在 UTC+8 解释下的墙钟(截断到分钟),应与 future 相差 ±2 分钟。 - if d := got.Sub(future); d < -2*time.Minute || d > 2*time.Minute { - t.Errorf("parsed=%v want ~%v (diff %v)", got, future, d) - } - if got.Location() != time.UTC { - // 不同指针的 FixedZone 实例相等性按 offset 判,这里只断言 offset。 - if _, off := got.Zone(); off != 8*60*60 { - t.Errorf("zone offset=%d want +08:00", off) - } - } - } - }) - } -} - -type rtFunc func(*http.Request) (*http.Response, error) - -func (f rtFunc) RoundTrip(r *http.Request) (*http.Response, error) { return f(r) } - -func jsonResp(status int, body string) *http.Response { - return &http.Response{ - StatusCode: status, - Header: http.Header{"Content-Type": []string{"application/json"}}, - Body: io.NopCloser(strings.NewReader(body)), - } -} - -func testClient(fn rtFunc) *Client { - return &Client{ - HTTP: &http.Client{Transport: fn}, - ChatBaseCN: "https://chat.example", - BillingBaseCN: "https://billing.example", - } -} - -func TestRefreshSuccess(t *testing.T) { - c := testClient(func(r *http.Request) (*http.Response, error) { - if !strings.HasSuffix(r.URL.Path, "/v2/plugin/auth/token/refresh") { - return nil, errors.New("wrong path: " + r.URL.Path) - } - if r.Header.Get("X-Refresh-Token") != "oldrt" { - return nil, errors.New("missing X-Refresh-Token") - } - return jsonResp(200, `{"code":0,"msg":"ok","data":{"accessToken":"newat","refreshToken":"newrt","expiresIn":3600}}`), nil - }) - a := &auth.Auth{AccessToken: "at", RefreshToken: "oldrt", ExpiresAt: 1} - if err := c.RefreshToken(a); err != nil { - t.Fatalf("refresh: %v", err) - } - if a.AccessToken != "newat" || a.RefreshToken != "newrt" { - t.Errorf("tokens not updated: %+v", a) - } - if a.ExpiresAt <= 1 { - t.Errorf("expiresAt not advanced: %d", a.ExpiresAt) - } -} - -func TestRefreshPreservesExpiryWhenOmitted(t *testing.T) { - c := testClient(func(r *http.Request) (*http.Response, error) { - return jsonResp(200, `{"code":0,"data":{"accessToken":"newat"}}`), nil - }) - a := &auth.Auth{AccessToken: "at", RefreshToken: "rt", ExpiresAt: 1753600000} - if err := c.RefreshToken(a); err != nil { - t.Fatalf("refresh: %v", err) - } - if a.ExpiresAt != 1753600000 { - t.Errorf("expiresAt should be preserved, got %d", a.ExpiresAt) - } - if a.RefreshToken != "rt" { - t.Errorf("refreshToken should be preserved, got %s", a.RefreshToken) - } -} - -func TestRefreshSessionDead(t *testing.T) { - c := testClient(func(r *http.Request) (*http.Response, error) { - return &http.Response{ - StatusCode: 401, - Header: http.Header{"Content-Type": []string{"application/json"}}, - Body: io.NopCloser(strings.NewReader(`{"code":12153,"msg":"Offline user session not found"}`)), - }, nil - }) - a := &auth.Auth{AccessToken: "at", RefreshToken: "rt", ExpiresAt: 1} - err := c.RefreshToken(a) - if err == nil { - t.Fatal("want error") - } - var ue *Error - if !errors.As(err, &ue) { - t.Fatalf("want *Error, got %T %v", err, err) - } - if ue.Kind != ErrSessionDead { - t.Errorf("kind=%v want ErrSessionDead", ue.Kind) - } -} - -func TestChatStreamSendsHeadersAndStreamTrue(t *testing.T) { - var gotAuth, gotUID, gotProduct string - var gotBody []byte - c := testClient(func(r *http.Request) (*http.Response, error) { - gotAuth = r.Header.Get("Authorization") - gotUID = r.Header.Get("X-User-Id") - gotProduct = r.Header.Get("X-Product") - gotBody, _ = io.ReadAll(r.Body) - return &http.Response{ - StatusCode: 200, - Header: http.Header{"Content-Type": []string{"text/event-stream"}}, - Body: io.NopCloser(strings.NewReader("data: [DONE]\n\n")), - }, nil - }) - a := &auth.Auth{AccessToken: "at", UID: "u1", EnterpriseID: "e1"} - rc, status, respBody, err := c.ChatStream(a, []byte(`{"model":"glm-5.2","messages":[]}`), "", ChatMeta{}) - if err != nil || status != 200 { - t.Fatalf("chat: status=%d err=%v", status, err) - } - if respBody != nil { - t.Errorf("200 response should carry nil body, got %q", respBody) - } - rc.Close() - if gotAuth != "Bearer at" || gotUID != "u1" || gotProduct != "WorkBuddy" { - t.Errorf("headers: auth=%q uid=%q product=%q", gotAuth, gotUID, gotProduct) - } - if !bytes.Contains(gotBody, []byte(`"stream":true`)) { - t.Errorf("stream not forced: %s", gotBody) - } -} - -func TestFetchModelsEffortsDriveBodyDowngrade(t *testing.T) { - var outbound []byte - c := testClient(func(r *http.Request) (*http.Response, error) { - switch { - case strings.HasSuffix(r.URL.Path, "/console/enterprises/personal/models"): - return jsonResp(200, `{"code":0,"data":{"models":[ - {"id":"glm-5.2","name":"GLM-5.2","maxInputTokens":131072,"maxOutputTokens":8192,"reasoning":{"effort":"high","supportedEfforts":["low","high"]}} - ],"agents":[{"name":"cli","models":["glm-5.2"]}]}}`), nil - case strings.HasSuffix(r.URL.Path, "/v3/config"): - return jsonResp(200, `{"code":0,"data":{"models":[]}}`), nil - default: - outbound, _ = io.ReadAll(r.Body) - return &http.Response{ - StatusCode: 200, - Header: http.Header{"Content-Type": []string{"text/event-stream"}}, - Body: io.NopCloser(strings.NewReader("data: [DONE]\n\n")), - }, nil - } - }) - a := &auth.Auth{AccessToken: "at", UID: "u1"} - infos, err := c.FetchModels(a) - if err != nil { - t.Fatalf("fetch models: %v", err) - } - if len(infos) != 1 { - t.Fatalf("infos=%+v", infos) - } - // ModelInfo.Efforts 应携带 supportedEfforts,DefaultEffort 应携带 reasoning.effort - if len(infos[0].Efforts) != 2 || infos[0].Efforts[0] != "low" { - t.Errorf("infos[0].Efforts=%v", infos[0].Efforts) - } - if infos[0].DefaultEffort != "high" { - t.Errorf("infos[0].DefaultEffort=%q want high", infos[0].DefaultEffort) - } - // glm-5.2 只支持 low/high,请求 max → 降级为 high - rc, status, _, err := c.ChatStream(a, []byte(`{"model":"glm-5.2","reasoning_effort":"max","messages":[]}`), "", ChatMeta{}) - if err != nil || status != 200 { - t.Fatalf("chat: status=%d err=%v", status, err) - } - rc.Close() - var m map[string]any - if err := json.Unmarshal(outbound, &m); err != nil { - t.Fatalf("outbound unmarshal: %v (%s)", err, outbound) - } - if got, _ := m["reasoning_effort"].(string); got != "high" { - t.Errorf("reasoning_effort=%v want high (outbound=%s)", m["reasoning_effort"], outbound) - } -} - -func TestChatStreamHardCreditError(t *testing.T) { - c := testClient(func(r *http.Request) (*http.Response, error) { - return jsonResp(402, `{"code":1,"msg":"余额不足"}`), nil - }) - a := &auth.Auth{AccessToken: "at", UID: "u1"} - _, status, respBody, err := c.ChatStream(a, []byte(`{}`), "", ChatMeta{}) - if status != 402 { - t.Errorf("status=%d", status) - } - // 错误信封一次成型:≥400 返回已分类的 *Error(Kind + body 全量仍经 respBody 透出) - var ue *Error - if !errors.As(err, &ue) || ue.Kind != ErrHardCredit { - t.Fatalf("hard credit should return classified *Error envelope, got %v", err) - } - if len(respBody) == 0 { - t.Errorf("body should still be returned for passthrough") - } -} - -// TestChatStreamReadsMultipleChunksOverRealTransport 走真实 net/http 传输层, -// 回归 defer cancel() 导致第二块起 body Read 返回 context canceled 的断流 bug。 -func TestChatStreamReadsMultipleChunksOverRealTransport(t *testing.T) { - const frames = 6 - srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { - w.Header().Set("Content-Type", "text/event-stream") - flusher, ok := w.(http.Flusher) - if !ok { - t.Error("http.ResponseWriter does not implement http.Flusher") - return - } - for i := 1; i <= frames; i++ { - if _, err := fmt.Fprintf(w, "data: chunk-%d\n\n", i); err != nil { - return - } - flusher.Flush() - time.Sleep(20 * time.Millisecond) - } - })) - defer srv.Close() - - c := New() - c.ChatBaseCN = srv.URL - c.IdleTimeout = 5 * time.Second - - a := &auth.Auth{AccessToken: "at", UID: "u1"} - rc, status, _, err := c.ChatStream(a, []byte(`{"model":"glm-5.2","messages":[]}`), "", ChatMeta{}) - if err != nil || status != 200 { - t.Fatalf("chat: status=%d err=%v", status, err) - } - defer rc.Close() - - buf := make([]byte, 1) - var got string - for i := 0; i < frames; i++ { - if _, err := io.ReadFull(rc, buf); err != nil { - t.Fatalf("read %d: %v (real transport body must not be cut)", i, err) - } - got += string(buf) - } - if strings.Contains(got, "context canceled") { - t.Fatalf("body read hit context canceled, got %q", got) - } -} - -func TestUserResourceAggregation(t *testing.T) { - c := testClient(func(r *http.Request) (*http.Response, error) { - if !strings.HasSuffix(r.URL.Path, "/v2/billing/meter/get-user-resource") { - return nil, errors.New("wrong path: " + r.URL.Path) - } - if r.Method != http.MethodPost { - return nil, errors.New("want POST") - } - body, _ := io.ReadAll(r.Body) - if !bytes.Contains(body, []byte(`"ProductCode":"p_tcaca"`)) { - return nil, errors.New("missing ProductCode: " + string(body)) - } - return jsonResp(200, `{"code":0,"data":{"Response":{"Data":{"TotalCount":2,"TotalDosage":3000,"Accounts":[ - {"PackageName":"签到包","CapacitySize":2000,"CapacityRemain":1200,"CapacityUsed":800,"CycleCapacitySize":2000,"CycleCapacityRemain":1200,"CycleCapacityUsed":800}, - {"PackageName":"体验包","CapacitySize":1000,"CapacityRemain":300,"CapacityUsed":700,"CycleCapacitySize":1000,"CycleCapacityRemain":300,"CycleCapacityUsed":700} - ]}}}}`), nil - }) - a := &auth.Auth{AccessToken: "at", UID: "u1"} - remain, total, err := c.UserResource(a) - if err != nil { - t.Fatalf("resource: %v", err) - } - if remain != 1500 { - t.Errorf("remain=%d want 1500", remain) - } - if total != 3000 { - t.Errorf("total=%d want 3000", total) - } -} - -func TestUserResourceNegativeClamped(t *testing.T) { - c := testClient(func(r *http.Request) (*http.Response, error) { - return jsonResp(200, `{"code":0,"data":{"Response":{"Data":{"Accounts":[ - {"PackageName":"p","CycleCapacitySize":100,"CycleCapacityRemain":-50,"CycleCapacityUsed":150} - ]}}}}`), nil - }) - remain, total, err := c.UserResource(&auth.Auth{AccessToken: "at"}) - if err != nil || remain != 0 { - t.Errorf("remain=%d err=%v, want 0 (clamped)", remain, err) - } - if total != 100 { - t.Errorf("total=%d want 100", total) - } -} - -func TestDailyCheckinAlready(t *testing.T) { - c := testClient(func(r *http.Request) (*http.Response, error) { - if !strings.HasSuffix(r.URL.Path, "/v2/billing/meter/daily-checkin") { - return nil, errors.New("wrong path") - } - return jsonResp(200, `{"code":14001,"msg":"今日已签到"}`), nil - }) - err := c.DailyCheckin(&auth.Auth{AccessToken: "at"}) - if err == nil || !strings.Contains(err.Error(), "已签到") { - t.Errorf("err=%v", err) - } -} - -func TestBasesAlwaysCN(t *testing.T) { - c := testClient(nil) - cn := &auth.Auth{Domain: ""} - other := &auth.Auth{Domain: "example.com"} - if c.chatBase(cn) != "https://chat.example" || c.billingBase(cn) != "https://billing.example" { - t.Error("cn bases wrong") - } - // 恒 CN:domain 不同不改变上游 host。 - if c.chatBase(other) != c.chatBase(cn) || c.billingBase(other) != c.billingBase(cn) { - t.Error("bases must be CN regardless of domain") - } -} - -func TestNewChatClientNoTotalTimeoutAndSharedTransport(t *testing.T) { - c := New() - if c.ChatHTTP == nil { - t.Fatal("ChatHTTP should be initialized") - } - if c.ChatHTTP.Timeout != 0 { - t.Errorf("ChatHTTP.Timeout=%v want 0 (no total cap)", c.ChatHTTP.Timeout) - } - // 共享同一个 Transport 实例,连接池不重复。 - if c.ChatHTTP.Transport != c.HTTP.Transport { - t.Errorf("ChatHTTP and HTTP must share the same *http.Transport") - } - htr, ok := c.ChatHTTP.Transport.(*http.Transport) - if !ok { - t.Fatalf("Transport type=%T", c.ChatHTTP.Transport) - } - if htr.ResponseHeaderTimeout != 60*time.Second { // 连接层加固:响应头上限从 120s 收到 60s(慢冷启动留 3.75× 余量) - t.Errorf("ResponseHeaderTimeout=%v want 60s", htr.ResponseHeaderTimeout) - } -} - -func TestChatStreamRoutesToChatHTTP(t *testing.T) { - // 显式注入 ChatHTTP(可辨识标记),验证 ChatStream 走它而非 HTTP。 - chatHit, httpHit := false, false - c := testClient(func(*http.Request) (*http.Response, error) { - httpHit = true - return jsonResp(200, `{}`), nil - }) - c.ChatHTTP = &http.Client{Transport: rtFunc(func(*http.Request) (*http.Response, error) { - chatHit = true - return &http.Response{ - StatusCode: 200, - Header: http.Header{"Content-Type": []string{"text/event-stream"}}, - Body: io.NopCloser(strings.NewReader("data: [DONE]\n\n")), - }, nil - })} - a := &auth.Auth{AccessToken: "at", UID: "u1"} - rc, status, _, err := c.ChatStream(a, []byte(`{}`), "", ChatMeta{}) - if err != nil || status != 200 { - t.Fatalf("chat: status=%d err=%v", status, err) - } - rc.Close() - if !chatHit { - t.Error("ChatStream should use ChatHTTP") - } - if httpHit { - t.Error("ChatStream must not use HTTP") - } -} - -func TestChatHTTPNilFallsBackToHTTP(t *testing.T) { - c := testClient(func(*http.Request) (*http.Response, error) { - return &http.Response{ - StatusCode: 200, - Header: http.Header{"Content-Type": []string{"text/event-stream"}}, - Body: io.NopCloser(strings.NewReader("data: [DONE]\n\n")), - }, nil - }) - if c.chatHTTP() != c.HTTP { - t.Error("chatHTTP() should fall back to HTTP when ChatHTTP is nil") - } -} - -func TestFetchModelsDefaultEffortDualKeyAndSizes(t *testing.T) { - // 上游双键:老模型 reasoning.effort(auto),新模型(glm-5.3 系)只有 reasoning.defaultEffort; - // credits/maxAllowedSize/canDisableThinking/supportsReasoning 等尺寸与能力字段应一并透出。 - c := testClient(func(r *http.Request) (*http.Response, error) { - return jsonResp(200, `{"code":0,"data":{"models":[ - {"id":"glm-5.3","maxInputTokens":1000000,"maxOutputTokens":48000,"maxAllowedSize":1000000,"credits":"x0.79","supportsReasoning":true,"reasoning":{"defaultEffort":"high","canDisableThinking":true,"supportedEfforts":["low","high","max"]}}, - {"id":"auto","maxInputTokens":168000,"maxOutputTokens":32000,"supportsReasoning":true,"reasoning":{"effort":"high"}} - ],"agents":[{"name":"cli","models":["glm-5.3","auto"]}]}}`), nil - }) - a := &auth.Auth{AccessToken: "at", UID: "u1"} - infos, err := c.FetchModels(a) - if err != nil { - t.Fatalf("fetch models: %v", err) - } - byID := map[string]ModelInfo{} - for _, mi := range infos { - byID[mi.ID] = mi - } - g := byID["glm-5.3"] - if g.DefaultEffort != "high" { - t.Errorf("glm-5.3 DefaultEffort=%q want high (from defaultEffort key)", g.DefaultEffort) - } - if !g.CanDisableThinking || !g.SupportsReasoning { - t.Errorf("glm-5.3 capability flags: canDisable=%v supportsReasoning=%v want true/true", g.CanDisableThinking, g.SupportsReasoning) - } - if g.MaxAllowedSize != 1000000 || g.MaxTokens != 48000 || g.Credits != "x0.79" { - t.Errorf("glm-5.3 sizes: maxAllowed=%d maxOut=%d credits=%q", g.MaxAllowedSize, g.MaxTokens, g.Credits) - } - if got := c.ModelRate("cn", "glm-5.3"); got != "0.79" { - t.Errorf("glm-5.3 ModelRate=%q want 0.79", got) - } - if au := byID["auto"]; au.DefaultEffort != "high" { - t.Errorf("auto DefaultEffort=%q want high (from legacy effort key)", au.DefaultEffort) - } -} - -func TestModelRateCacheEffectiveAndNormalized(t *testing.T) { - c := New() - factor := 0.5 - c.storeModelRates("cn", []ModelInfo{ - {ID: "base", Credits: "x0.50 credits"}, - {ID: "promo", Credits: "x0.80", PromoFactor: &factor, PromoCredits: "0.50x"}, - }) - if got := c.ModelRate("cn", "base"); got != "0.5" { - t.Fatalf("base rate=%q want 0.5", got) - } - if got := c.ModelRate("cn", "promo"); got != "0.5" { - t.Fatalf("promo rate=%q want 0.5", got) - } - if got := normalizeModelRate("x0.05 credits"); got != "0.05" { - t.Fatalf("normalizeModelRate=%q want 0.05", got) - } - c.storeModelRates("cn", []ModelInfo{{ID: "base", Credits: "x0.79"}}) - if got := c.ModelRate("cn", "base"); got != "0.79" { - t.Fatalf("refreshed base rate=%q want 0.79", got) - } - if got := c.ModelRate("cn", "promo"); got != "" { - t.Fatalf("stale promo rate=%q want empty after full refresh", got) - } -} - -func TestFetchModelsOverlaysV3ConfigCapabilities(t *testing.T) { - // CLI 目录给 flash 精简字段(128K / 固定 high);IDE /v3/config 给完整能力。 - var sawIDE bool - c := testClient(func(r *http.Request) (*http.Response, error) { - switch { - case strings.HasSuffix(r.URL.Path, "/console/enterprises/personal/models"): - return jsonResp(200, `{"code":0,"data":{"models":[ - {"id":"deepseek-v4.1-flash","name":"Deepseek-V4.1-Flash","maxInputTokens":1000000,"maxOutputTokens":128000,"credits":"x0.03 credits","supportsReasoning":true,"onlyReasoning":true,"reasoning":{"effort":"high","summary":"auto"}} - ],"agents":[{"name":"cli","models":["deepseek-v4.1-flash"]}]}}`), nil - case strings.HasSuffix(r.URL.Path, "/v3/config"): - sawIDE = true - if r.Header.Get("User-Agent") != codeBuddyIDEUA { - t.Errorf("v3/config UA=%q want %s", r.Header.Get("User-Agent"), codeBuddyIDEUA) - } - if r.Header.Get("X-Product") != "SaaS" { - t.Errorf("X-Product=%q want SaaS", r.Header.Get("X-Product")) - } - if r.Header.Get("X-User-Id") != "u1" { - t.Errorf("X-User-Id=%q want u1", r.Header.Get("X-User-Id")) - } - return jsonResp(200, `{"code":0,"data":{"models":[ - {"id":"deepseek-v4.1-flash","name":"Deepseek-V4.1-Flash","maxInputTokens":1000000,"maxOutputTokens":393216,"credits":"x0.03","supportsReasoning":true,"onlyReasoning":true,"reasoning":{"canDisableThinking":true,"defaultEffort":"high","summary":"auto","supportedEfforts":["low","high","max"]}} - ]}}`), nil - default: - t.Errorf("unexpected path %s", r.URL.Path) - return jsonResp(404, `{}`), nil - } - }) - a := &auth.Auth{AccessToken: "at", UID: "u1", Domain: "copilot.tencent.com"} - infos, err := c.FetchModels(a) - if err != nil { - t.Fatalf("fetch models: %v", err) - } - if !sawIDE { - t.Fatal("expected /v3/config request") - } - if len(infos) != 1 { - t.Fatalf("infos=%+v", infos) - } - mi := infos[0] - if mi.MaxTokens != 393216 { - t.Errorf("MaxTokens=%d want 393216", mi.MaxTokens) - } - if mi.ContextWindow != 1000000 { - t.Errorf("ContextWindow=%d want 1000000", mi.ContextWindow) - } - if !mi.CanDisableThinking || !mi.SupportsReasoning { - t.Errorf("flags canDisable=%v supportsReasoning=%v", mi.CanDisableThinking, mi.SupportsReasoning) - } - if mi.DefaultEffort != "high" { - t.Errorf("DefaultEffort=%q want high", mi.DefaultEffort) - } - if got := strings.Join(mi.Efforts, ","); got != "low,high,max" { - t.Errorf("Efforts=%v want low,high,max", mi.Efforts) - } -} +package upstream + +import ( + "bytes" + "encoding/json" + "errors" + "fmt" + "io" + "net/http" + "net/http/httptest" + "strings" + "testing" + "time" + + "github.com/misakano7545/workbuddy2api-panel/internal/auth" +) + +func TestClassify(t *testing.T) { + cases := []struct { + status int + body string + want ErrKind + }{ + {402, ``, ErrHardCredit}, + {400, `{"code":1,"msg":"余额不足"}`, ErrHardCredit}, + {403, `insufficient credits`, ErrHardCredit}, + {200, `{"code":10001,"msg":"积分不足,请充值"}`, ErrHardCredit}, + {400, `{"code":1,"msg":"额度用尽"}`, ErrHardCredit}, + {429, ``, ErrSoftRate}, + // 限流文案(issue #28):状态码不是 429 时也必须识别为软限流, + // 否则账号不会被冷却,下次请求仍会被选中。 + {200, `{"code":11140,"msg":"The model provider is rate-limiting requests. Please wait a moment and try again."}`, ErrSoftRate}, + {400, `rate limit`, ErrSoftRate}, + {403, `usage limit reached`, ErrSoftRate}, + // "model usage limit exceeded" 不是余额语义(无 credit/quota/积分/额度 等计费词), + // 属于模型侧用量节流 → 短冷却(误判为硬冷却会把有余量的号停到次日 04:00)。 + {200, `{"code":1,"msg":"model usage limit exceeded"}`, ErrSoftRate}, + {200, `{"code":1,"msg":"too many requests"}`, ErrSoftRate}, + {500, `rate-limited upstream`, ErrSoftRate}, // 限流文案优先于 5xx 分类 + // 内容策略拦截(HTTP 400 + 审核文案):误报信号,不罚账号,走降级重试。 + {400, `Illegal API invocation from an unapproved channel`, ErrContentBlocked}, + {400, `{"code":11128,"msg":"blocked by security policy"}`, ErrContentBlocked}, + {400, `unapproved channel`, ErrContentBlocked}, + // 11140 的第二种形态:内容安全审核(官方会打断会话的那条文案)。 + // 未收录时落 ErrClient:只换号不罚号、也不走降级重试,客户端拿到必然失败的答复。 + {400, `{"code":11140,"msg":"Content failed safety review. Please revise it"}`, ErrContentBlocked}, + // 14003 RateLimitError:模型忙(官方文案「当前模型请求繁忙,请切换模型」), + // 不是额度耗尽;200 信封形态也必须归软限流(否则账号不会被停车)。 + {429, `{"code":14003,"msg":"too many requests","displayMsg":{"zh":"请求过于频繁,请稍后重试。"}}`, ErrSoftRate}, + {200, `{"code":14003,"msg":"too many requests","displayMsg":{"zh":"请求过于频繁,请稍后重试。"}}`, ErrSoftRate}, + // 通用 4xx(非审核文案):仍判 ErrClient,只换号不罚。 + {400, `bad request`, ErrClient}, + // ErrBadParams:请求体解析失败(HTTP 400 + Unmarshal chat params failed / code 11101)。 + // 这是"发给上游的 body 有问题"(网关截断已由 413 消灭,剩余为客户端畸形 JSON), + // 换了账号也一样 400,不罚号。具体词优先于通用 4xx。 + {400, `{"code":11101,"msg":"Unmarshal chat params failed with error: unexpected EOF"}`, ErrBadParams}, + {400, `Unmarshal chat params failed`, ErrBadParams}, + {400, `{"code":11101,"msg":"x"}`, ErrBadParams}, + // 图片格式/数据错误是确定性请求错误,分类后不轮转、不罚号。 + {400, `{"code":11101,"msg":"Parse message failed: invalid image_url content at index 2: json: cannot unmarshal string into Go value of type v2.ImageContent"}`, ErrImageInvalid}, + {400, `{"code":11135,"msg":"invalid_image_data"}`, ErrImageInvalid}, + {400, `invalid_image_data`, ErrImageInvalid}, + // 11135 业务码须容忍 JSON 空白(5d5223d:字面量 marker 只覆盖紧凑形态)。 + {400, `{"code": 11135, "msg":"image data invalid"}`, ErrImageInvalid}, + {400, `{"error":{"code": "11135", "message":"image invalid"}}`, ErrImageInvalid}, + // 防过宽:11133(模型不支持图片)不进 image_invalid——它自成一类确定性请求级 + // 错误(ErrModelParamInvalid),与 11135/11115 同待遇:不轮转、不罚号、末端 400 透传。 + {400, `{"code": 11133, "msg":"model does not support image"}`, ErrModelParamInvalid}, + // 11133 家族实测形态(缺/空 messages):extError.param=messages + StatusCode 400。 + {400, `{"code":11133,"msg":"the request parameters were rejected by the model provider","extError":{"code":"400002","param":"messages","type":"invalid_request_error","StatusCode":400}}`, ErrModelParamInvalid}, + {400, `{"code":"11133","msg":"model_param_invalid"}`, ErrModelParamInvalid}, + {400, `invalid request parameters`, ErrModelParamInvalid}, + {400, `the request parameters do not meet the current model requirements`, ErrModelParamInvalid}, + // 状态码先于业务码:429/5xx 上的 11133 不得抢走限流/服务端语义。 + {429, `{"code":11133,"msg":"the request parameters were rejected"}`, ErrSoftRate}, + {503, `{"code":11133,"msg":"the request parameters were rejected"}`, ErrServer}, + {200, `quota exceeded`, ErrHardCredit}, + // session 死亡优先于限流文案(401+12153 需人工重登,短冷却无意义)。 + {401, `{"code":12153,"msg":"Offline user session not found, rate limit"}`, ErrSessionDead}, + {401, `Offline user session not found`, ErrSessionDead}, + {401, `{"code":12153,"msg":"Offline user session not found"}`, ErrSessionDead}, + {401, `{"code":9999,"msg":"bad token"}`, ErrClient}, + {500, `boom`, ErrServer}, + {503, `unavailable`, ErrServer}, + {200, ``, ErrNone}, + // 11102「该后端无此模型」:确定性答复,归 ErrModelBlocked((账号,模型) 负缓存避让)。 + {404, `{"code":11102,"msg":"model [deepseek-v3-2-volc] service info not found"}`, ErrModelBlocked}, + {400, `{"error":{"code":"11102","message":"model service info not found"}}`, ErrModelBlocked}, + {400, `{"msg":"service info not found"}`, ErrModelBlocked}, + // 11158 是账号类型级模型权限拒绝:同一模型换有权限的账号仍可能成功, + // 按 (账号, 模型) 避让;不能落入 ErrClient 轮转后误报 503。 + {400, `{"code":11158,"msg":"model [gpt-5.6-sol] is not allowed for user type [personal_free_user]"}`, ErrModelBlocked}, + {400, `{"error":{"code":"11158","message":"model is not allowed for user type"}}`, ErrModelBlocked}, + {429, `{"code":11158,"msg":"model is not allowed for user type"}`, ErrSoftRate}, + // 11102 撞在 requestId 上不算(不得误避让可用模型)。 + {404, `{"requestId":"11102","msg":"ok"}`, ErrNotFound}, + // 429 + 11102 → 限流语义(ErrSoftRate),不是模型不存在。 + {429, `{"code":11102,"msg":"service info not found"}`, ErrSoftRate}, + // 429 + 余额措辞 → 限流语义(fork-scan-absorb T-3,本次修复点):限流响应 + // body 高频携带 "quota exceeded"/"额度不足" 等跨计费/限流两界的措辞, + // hardRule 在 429 之前会误判 ErrHardCredit 硬冷却到次日 04:00,白扔号约 12h。 + // 状态码是比关键词更权威的信号:真余额耗尽走 402,非 429 的 quota 措辞 + // 仍归 hardRule(上方 {200,"quota exceeded"} 语义不变)。 + {429, `quota exceeded`, ErrSoftRate}, + {429, `{"code":1,"msg":"quota exceeded, please wait"}`, ErrSoftRate}, + {429, `insufficient credits`, ErrSoftRate}, + {429, `{"code":1,"msg":"额度不足"}`, ErrSoftRate}, + {429, `积分不足,请充值`, ErrSoftRate}, + // 429 + 账号级故障码防回归(accountFault 仍先于 429 判定):429+14017 若 + // 落到 status==429 兜底会误归 soft_rate,账号级故障等不来自愈。 + {429, `{"code":14017,"msg":"trial not activated"}`, ErrAccountFault}, + {429, `{"error":{"data":{"code":11140,"msg":"request illegal"}}}`, ErrAccountFault}, + // Issue #175:14018 明确表示账号积分耗尽,即使 HTTP 状态是 429 也必须 + // 走硬积分冷却;仅有相同文案而无该业务码的普通 429 仍保持软限流。 + {429, `{"code":14018,"msg":"Credits exhausted"}`, ErrHardCredit}, + {429, `{"error":{"data":{"code":"14018","msg":"Credits exhausted"}}}`, ErrHardCredit}, + {429, `{"requestId":"14018","msg":"Credits exhausted"}`, ErrSoftRate}, + {429, `{"code":1,"msg":"Credits exhausted"}`, ErrSoftRate}, + // WAF 403(P0-1):403 + 无业务信封(无 "code":/"msg": 字段)→ ErrWafBlock。 + // 空体 / HTML 拦截页 / 纯文本 / 非信封 JSON 均命中。 + {403, ``, ErrWafBlock}, + {403, `403 Forbidden`, ErrWafBlock}, + {403, `Forbidden`, ErrWafBlock}, + {403, `{"message":"blocked by waf"}`, ErrWafBlock}, + {403, `blocked`, ErrWafBlock}, + // 403 带业务信封的仍走既有分类(P0-1 约束:不劫持业务 403)。 + {403, `{"code":11128,"msg":"blocked by security policy"}`, ErrContentBlocked}, + {403, `{"code":60001,"msg":"quota exceeded"}`, ErrHardCredit}, + {403, `{"code":1,"msg":"unknown business error"}`, ErrClient}, + // 非 403 的无信封错误体不进 WAF 分类(WAF 判定绑定 403 形态)。 + {400, `bad request`, ErrClient}, + {429, ``, ErrSoftRate}, + // 网关 401(APISIX `invalid_token` 页,无业务信封)→ session 死亡,需重登。 + // 夹具是 2026-10-17 实测原文(CN 站 /v2/chat/completions,token 被上游作废)。 + // 旧行为落 ErrClient(只换号不罚)⇒ 死号永久留在池里,每请求刷一排 401。 + {401, "401 Authorization Required

401 Authorization Required


openresty

Powered by APISIX.

", ErrSessionDead}, + {401, ``, ErrSessionDead}, + {401, `Unauthorized`, ErrSessionDead}, + // 业务层 401 带信封的维持既有语义:12153 仍是 session 死亡; + // 其他业务码不劫持(不许把网关 401 的判定扩张到带信封的响应)。 + {401, `{"code":12153,"msg":"12153:refresh token is invalid"}`, ErrSessionDead}, + {401, `{"code":1,"msg":"unknown business error"}`, ErrClient}, + // 6020「queue.waiting.title」/ 6021「queue.full.title」渠道级排队/队列满: + // 任意状态码都判 upstream_busy(防上游换状态码),结构化 code 主判、 + // requestId 含 "6020"/"6021" 不误伤。 + {429, `{"code":6020,"msg":"queue.waiting.title","requestId":"01a16e3d95b4a000e3385c807c"}`, ErrUpstreamBusy}, + {429, `{"code":6021,"msg":"queue.full.title","requestId":"341738971737c911985e5b9e67a4eceb"}`, ErrUpstreamBusy}, + {500, `{"code":6021,"msg":"queue.full.title"}`, ErrUpstreamBusy}, + // 防过宽:普通 429(无 queue 语义)仍是账号级软限流。 + {429, `{"code":1,"msg":"too many requests"}`, ErrSoftRate}, + {429, `{"requestId":"6021","msg":"rate limit"}`, ErrSoftRate}, + {429, `{"requestId":"6020","msg":"rate limit"}`, ErrSoftRate}, + // 11134「model provider is temporarily unavailable」:供应商过载,与账号无关。 + // 落 ErrServer 会按 5xx 罚号 + 换号,而换号撞同一 provider 且打断账号级前缀缓存 + // (issue #188)。认结构化 code;只有文案、没有 code 的仍是普通 5xx。 + {500, `{"code":11134,"msg":"the model provider is temporarily unavailable, please retry later or switch to another model","requestId":"01a1b4d1b3f45f4b99c406eb04d68909","retry_policy":{"retry":true,"retry_after":8}}`, ErrUpstreamBusy}, + {503, `{"code":11134,"msg":"the model provider is temporarily unavailable"}`, ErrUpstreamBusy}, + {500, `{"msg":"the model provider is temporarily unavailable"}`, ErrServer}, + // 11148 工具配对断裂:请求内容级(上游「直接重试无效,请新建任务」), + // 换号/重试必然同样失败——不得落 ErrClient 白轮转全池。 + {400, `{"code":11148,"msg":"tool calls and tool results do not match"}`, ErrToolMismatch}, + // 5xx 外壳同样认(上游对同因有时换状态码)。 + {500, `{"code": 11148,"msg":"tool calls and tool results do not match"}`, ErrToolMismatch}, + // 防过宽:相邻错误码不误伤(11140 账号级风控、11115 超长各有归属)。 + {400, `{"code":11140,"msg":"request illegal"}`, ErrAccountFault}, + {400, `{"code":11115,"msg":"prompt is too long"}`, ErrPromptTooLong}, + // 11151 空 text 段(a message has empty content):请求内容级,出站前由 + // empty_text_part.go 补位;真打到这里说明补位没覆盖,也不能轮转全池。 + {400, `{"code":11151,"msg":"a message has empty content"}`, ErrEmptyContent}, + {400, `{"code": 11151 , "msg":"a message has empty content"}`, ErrEmptyContent}, + // 只认结构化 code:文案单独出现不算(用户自己的消息里可能就有这句)。 + {400, `{"msg":"a message has empty content"}`, ErrClient}, + // 非 400 不认(上游目前只用 400,放宽会让别的状态码误入不轮转通道)。 + {500, `{"code":11151,"msg":"a message has empty content"}`, ErrServer}, + } + for _, c := range cases { + if got := Classify(c.status, c.body); got != c.want { + t.Errorf("Classify(%d,%q)=%v want %v", c.status, c.body, got, c.want) + } + } +} + +// TestIsModelRateLimit 判断 429 body 是否明确指向模型级限流(code 6004)。 +func TestIsModelRateLimit(t *testing.T) { + cases := []struct { + body string + want bool + }{ + // 6004:模型级限流(issue #31 的核心场景)。 + {`{"code":6004,"msg":"将在 2026-09-11 18:33:27 UTC+8 重置"}`, true}, + {`{"code": 6004,"msg":"x"}`, true}, + // 6000:上游新码,文案带「切换其他模型」才按模型级(2026-10-24 kimi 实测)。 + {`{"code":6000,"msg":"您的使用量已超出频率限制,将在 2026-10-24 19:25:18 UTC+8 重置,您也可以切换其他模型继续使用。"}`, true}, + {`{"code": 6000, "msg":"您也可以切换其他模型继续使用"}`, true}, + // 6000 但无换模型提示:账号级,不能放宽成模型级。 + {`{"code":6000,"msg":"账号并发超限"}`, false}, + // 其他 code(非模型级限流)→ 不算。 + {`{"code":11140,"msg":"The model provider is rate-limiting requests."}`, false}, + {`{"code":1,"msg":"429 rate limit"}`, false}, + } + for _, c := range cases { + if got := IsModelRateLimit(c.body); got != c.want { + t.Errorf("IsModelRateLimit(%q)=%v want %v", c.body, got, c.want) + } + } +} + +// TestParseSoftRateReset 解析上游 429 6004 msg 里的「将在 … 重置」时间(## UTC+8)。 +func TestParseSoftRateReset(t *testing.T) { + future := time.Now().Add(35 * time.Minute) + ts := future.In(softRateResetLoc).Format("2006-01-02 15:04:05") + cases := []struct { + name string + body string + ok bool + }{ + {"6004 带时间+UTC+8 后缀", `{"code":6004,"msg":"将在 ` + ts + ` UTC+8 重置"}`, true}, + {"6004 带时间无后缀", `{"code":6004,"msg":"将在 ` + ts + ` 重置"}`, true}, + {"6004 无时间文案", `{"code":6004,"msg":"model usage limit exceeded"}`, false}, + {"非 6004 但带时间(ParseRateReset 统一解析;模型级豁免由调用侧按 6004 判定)", `{"code":11140,"msg":"将在 ` + ts + ` UTC+8 重置"}`, true}, + {"非法时间格式", `{"code":6004,"msg":"将在 明天 重置"}`, false}, + {"空 body", ``, false}, + } + for _, c := range cases { + t.Run(c.name, func(t *testing.T) { + got, ok := ParseRateReset(c.body) + if ok != c.ok { + t.Fatalf("ok=%v want %v (body=%s)", ok, c.ok, c.body) + } + if ok { + // 解析结果 = ts 在 UTC+8 解释下的墙钟(截断到分钟),应与 future 相差 ±2 分钟。 + if d := got.Sub(future); d < -2*time.Minute || d > 2*time.Minute { + t.Errorf("parsed=%v want ~%v (diff %v)", got, future, d) + } + if got.Location() != time.UTC { + // 不同指针的 FixedZone 实例相等性按 offset 判,这里只断言 offset。 + if _, off := got.Zone(); off != 8*60*60 { + t.Errorf("zone offset=%d want +08:00", off) + } + } + } + }) + } +} + +// TestParseQueueRetryAfter 6020 排队信封的重试口径在 body(data.retry_after, +// 实测真机:429 + code 6020,data 含 queue_position/retry_after/estimated_wait, +// 头侧无 Retry-After)。ParseRetryAfter 只认头,拿不到这个口径—— +// parseQueueRetryAfter 补上 body 侧,供末端 429 的 Retry-After 上报使用。 +func TestParseQueueRetryAfter(t *testing.T) { + cases := []struct { + name string + body string + want time.Duration + ok bool + }{ + {"6020 真机形态", `{"code":6020,"msg":"queue.waiting.title","requestId":"01a181ca3b67934d01c3f64599c8490c","data":{"queue_position":2502,"queue_size":"999+","retry_after":40,"estimated_wait":12510}}`, 40 * time.Second, true}, + {"retry_after=0(不该出现的边界)", `{"code":6020,"data":{"retry_after":0}}`, 0, false}, + {"6021 无 data(queue.full 无等待口径)", `{"code":6021,"msg":"queue.full.title","requestId":"b1bc87ea"}`, 0, false}, + // 11134 供应商过载:口径在 retry_policy.retry_after(issue #188 生产实测形态)。 + {"11134 retry_policy 形态", `{"code":11134,"msg":"the model provider is temporarily unavailable, please retry later or switch to another model","requestId":"01a1b4d1b3f45f4b99c406eb04d68909","retry_policy":{"retry":true,"retry_after":8}}`, 8 * time.Second, true}, + {"11134 retry_policy 无 retry_after", `{"code":11134,"msg":"model unavailable","retry_policy":{"retry":true}}`, 0, false}, + {"非 JSON", `upstream unavailable`, 0, false}, + {"空 body", ``, 0, false}, + } + for _, c := range cases { + t.Run(c.name, func(t *testing.T) { + got, ok := parseQueueRetryAfter([]byte(c.body)) + if ok != c.ok { + t.Fatalf("ok=%v want %v (body=%s)", ok, c.ok, c.body) + } + if ok && got != c.want { + t.Errorf("got=%v want %v", got, c.want) + } + }) + } + // 上限封顶:异常大的 retry_after 按 retryAfterSanity 截断,不把天文数字带回 + //(estimated_wait 是另一个字段不会误入;防上游口径漂移)。 + if d, ok := parseQueueRetryAfter([]byte(`{"code":6020,"data":{"retry_after":999999}}`)); !ok || d != retryAfterSanity { + t.Errorf("cap: got=%v,%v want %v,true", d, ok, retryAfterSanity) + } +} + +type rtFunc func(*http.Request) (*http.Response, error) + +func (f rtFunc) RoundTrip(r *http.Request) (*http.Response, error) { return f(r) } + +func jsonResp(status int, body string) *http.Response { + return &http.Response{ + StatusCode: status, + Header: http.Header{"Content-Type": []string{"application/json"}}, + Body: io.NopCloser(strings.NewReader(body)), + } +} + +func testClient(fn rtFunc) *Client { + return &Client{ + HTTP: &http.Client{Transport: fn}, + ChatBaseCN: "https://chat.example", + BillingBaseCN: "https://billing.example", + } +} + +func TestRefreshSuccess(t *testing.T) { + c := testClient(func(r *http.Request) (*http.Response, error) { + if !strings.HasSuffix(r.URL.Path, "/v2/plugin/auth/token/refresh") { + return nil, errors.New("wrong path: " + r.URL.Path) + } + if r.Header.Get("X-Refresh-Token") != "oldrt" { + return nil, errors.New("missing X-Refresh-Token") + } + return jsonResp(200, `{"code":0,"msg":"ok","data":{"accessToken":"newat","refreshToken":"newrt","expiresIn":3600}}`), nil + }) + a := &auth.Auth{AccessToken: "at", RefreshToken: "oldrt", ExpiresAt: 1} + if err := c.RefreshToken(a); err != nil { + t.Fatalf("refresh: %v", err) + } + if a.AccessToken != "newat" || a.RefreshToken != "newrt" { + t.Errorf("tokens not updated: %+v", a) + } + if a.ExpiresAt <= 1 { + t.Errorf("expiresAt not advanced: %d", a.ExpiresAt) + } +} + +func TestRefreshPreservesExpiryWhenOmitted(t *testing.T) { + c := testClient(func(r *http.Request) (*http.Response, error) { + return jsonResp(200, `{"code":0,"data":{"accessToken":"newat"}}`), nil + }) + a := &auth.Auth{AccessToken: "at", RefreshToken: "rt", ExpiresAt: 1753600000} + if err := c.RefreshToken(a); err != nil { + t.Fatalf("refresh: %v", err) + } + if a.ExpiresAt != 1753600000 { + t.Errorf("expiresAt should be preserved, got %d", a.ExpiresAt) + } + if a.RefreshToken != "rt" { + t.Errorf("refreshToken should be preserved, got %s", a.RefreshToken) + } +} + +func TestRefreshSessionDead(t *testing.T) { + c := testClient(func(r *http.Request) (*http.Response, error) { + return &http.Response{ + StatusCode: 401, + Header: http.Header{"Content-Type": []string{"application/json"}}, + Body: io.NopCloser(strings.NewReader(`{"code":12153,"msg":"Offline user session not found"}`)), + }, nil + }) + a := &auth.Auth{AccessToken: "at", RefreshToken: "rt", ExpiresAt: 1} + err := c.RefreshToken(a) + if err == nil { + t.Fatal("want error") + } + var ue *Error + if !errors.As(err, &ue) { + t.Fatalf("want *Error, got %T %v", err, err) + } + if ue.Kind != ErrSessionDead { + t.Errorf("kind=%v want ErrSessionDead", ue.Kind) + } +} + +func TestChatStreamSendsHeadersAndStreamTrue(t *testing.T) { + var gotAuth, gotUID, gotProduct string + var gotBody []byte + c := testClient(func(r *http.Request) (*http.Response, error) { + gotAuth = r.Header.Get("Authorization") + gotUID = r.Header.Get("X-User-Id") + gotProduct = r.Header.Get("X-Product") + gotBody, _ = io.ReadAll(r.Body) + return &http.Response{ + StatusCode: 200, + Header: http.Header{"Content-Type": []string{"text/event-stream"}}, + Body: io.NopCloser(strings.NewReader("data: [DONE]\n\n")), + }, nil + }) + a := &auth.Auth{AccessToken: "at", UID: "u1", EnterpriseID: "e1"} + rc, status, respBody, err := c.ChatStream(a, []byte(`{"model":"glm-5.2","messages":[]}`), "", ChatMeta{}) + if err != nil || status != 200 { + t.Fatalf("chat: status=%d err=%v", status, err) + } + if respBody != nil { + t.Errorf("200 response should carry nil body, got %q", respBody) + } + rc.Close() + if gotAuth != "Bearer at" || gotUID != "u1" || gotProduct != "SaaS" { + t.Errorf("headers: auth=%q uid=%q product=%q", gotAuth, gotUID, gotProduct) + } + if !bytes.Contains(gotBody, []byte(`"stream":true`)) { + t.Errorf("stream not forced: %s", gotBody) + } +} + +func TestFetchModelsEffortsDriveBodyDowngrade(t *testing.T) { + var outbound []byte + c := testClient(func(r *http.Request) (*http.Response, error) { + switch { + case strings.HasSuffix(r.URL.Path, "/console/enterprises/personal/models"): + return jsonResp(200, `{"code":0,"data":{"models":[ + {"id":"glm-5.2","name":"GLM-5.2","maxInputTokens":131072,"maxOutputTokens":8192,"reasoning":{"effort":"high","supportedEfforts":["low","high"]}} + ],"agents":[{"name":"cli","models":["glm-5.2"]}]}}`), nil + case strings.HasSuffix(r.URL.Path, "/v3/config"): + return jsonResp(200, `{"code":0,"data":{"models":[]}}`), nil + default: + outbound, _ = io.ReadAll(r.Body) + return &http.Response{ + StatusCode: 200, + Header: http.Header{"Content-Type": []string{"text/event-stream"}}, + Body: io.NopCloser(strings.NewReader("data: [DONE]\n\n")), + }, nil + } + }) + a := &auth.Auth{AccessToken: "at", UID: "u1"} + infos, err := c.FetchModels(a) + if err != nil { + t.Fatalf("fetch models: %v", err) + } + if len(infos) != 1 { + t.Fatalf("infos=%+v", infos) + } + // ModelInfo.Efforts 应携带 supportedEfforts,DefaultEffort 应携带 reasoning.effort + if len(infos[0].Efforts) != 2 || infos[0].Efforts[0] != "low" { + t.Errorf("infos[0].Efforts=%v", infos[0].Efforts) + } + if infos[0].DefaultEffort != "high" { + t.Errorf("infos[0].DefaultEffort=%q want high", infos[0].DefaultEffort) + } + // glm-5.2 只支持 low/high,请求 max → 降级为 high + rc, status, _, err := c.ChatStream(a, []byte(`{"model":"glm-5.2","reasoning_effort":"max","messages":[]}`), "", ChatMeta{}) + if err != nil || status != 200 { + t.Fatalf("chat: status=%d err=%v", status, err) + } + rc.Close() + var m map[string]any + if err := json.Unmarshal(outbound, &m); err != nil { + t.Fatalf("outbound unmarshal: %v (%s)", err, outbound) + } + if got, _ := m["reasoning_effort"].(string); got != "high" { + t.Errorf("reasoning_effort=%v want high (outbound=%s)", m["reasoning_effort"], outbound) + } +} + +func TestEffortPolicyWiredThroughChatStream(t *testing.T) { + // 策略接线测试:SetEffortPolicy → prepareBody → 出站 JSON。单元测试直接调 + // applyEffortPolicy,这条补上「客户端实例真的把策略带进请求」的缺口。 + var outbound []byte + c := testClient(func(r *http.Request) (*http.Response, error) { + switch { + case strings.HasSuffix(r.URL.Path, "/console/enterprises/personal/models"): + return jsonResp(200, `{"code":0,"data":{"models":[ + {"id":"glm-5.2","name":"GLM-5.2","maxInputTokens":131072,"maxOutputTokens":8192,"reasoning":{"effort":"high","supportedEfforts":["low","high"]}} + ],"agents":[{"name":"cli","models":["glm-5.2"]}]}}`), nil + case strings.HasSuffix(r.URL.Path, "/v3/config"): + return jsonResp(200, `{"code":0,"data":{"models":[]}}`), nil + default: + outbound, _ = io.ReadAll(r.Body) + return &http.Response{ + StatusCode: 200, + Header: http.Header{"Content-Type": []string{"text/event-stream"}}, + Body: io.NopCloser(strings.NewReader("data: [DONE]\n\n")), + }, nil + } + }) + a := &auth.Auth{AccessToken: "at", UID: "u1"} + if _, err := c.FetchModels(a); err != nil { + t.Fatalf("fetch models: %v", err) + } + send := func(body string) map[string]any { + t.Helper() + rc, status, _, err := c.ChatStream(a, []byte(body), "", ChatMeta{}) + if err != nil || status != 200 { + t.Fatalf("chat: status=%d err=%v", status, err) + } + rc.Close() + var m map[string]any + if err := json.Unmarshal(outbound, &m); err != nil { + t.Fatalf("outbound unmarshal: %v (%s)", err, outbound) + } + return m + } + + c.SetEffortPolicy(&EffortPolicy{Enabled: true, DefaultEffort: "max", OverrideScope: OverrideScopeLevel}) + // 客户端没发档位 → 网关补 max 解析后的最高档 high + if got := send(`{"model":"glm-5.2","messages":[]}`)["reasoning_effort"]; got != "high" { + t.Errorf("filled effort=%v want high", got) + } + // 网关优先 → 客户端 low 被改写 high + if got := send(`{"model":"glm-5.2","reasoning_effort":"low","messages":[]}`)["reasoning_effort"]; got != "high" { + t.Errorf("gateway-priority effort=%v want high", got) + } + // 客户端优先 → 保留 low + c.SetEffortPolicy(&EffortPolicy{Enabled: true, ClientPriority: true, DefaultEffort: "max"}) + if got := send(`{"model":"glm-5.2","reasoning_effort":"low","messages":[]}`)["reasoning_effort"]; got != "low" { + t.Errorf("client-priority effort=%v want low", got) + } + // 策略关闭 → 逐字节透传(只剩既有的支持档钳制,low 本身合规) + c.SetEffortPolicy(&EffortPolicy{Enabled: false, DefaultEffort: "max"}) + if got := send(`{"model":"glm-5.2","messages":[]}`)["reasoning_effort"]; got != nil { + t.Errorf("policy off should not inject, got %v", got) + } +} + +func TestChatStreamHardCreditError(t *testing.T) { + c := testClient(func(r *http.Request) (*http.Response, error) { + return jsonResp(402, `{"code":1,"msg":"余额不足"}`), nil + }) + a := &auth.Auth{AccessToken: "at", UID: "u1"} + _, status, respBody, err := c.ChatStream(a, []byte(`{}`), "", ChatMeta{}) + if status != 402 { + t.Errorf("status=%d", status) + } + // 错误信封一次成型:≥400 返回已分类的 *Error(Kind + body 全量仍经 respBody 透出) + var ue *Error + if !errors.As(err, &ue) || ue.Kind != ErrHardCredit { + t.Fatalf("hard credit should return classified *Error envelope, got %v", err) + } + if len(respBody) == 0 { + t.Errorf("body should still be returned for passthrough") + } +} + +// TestChatStreamReadsMultipleChunksOverRealTransport 走真实 net/http 传输层, +// 回归 defer cancel() 导致第二块起 body Read 返回 context canceled 的断流 bug。 +func TestChatStreamReadsMultipleChunksOverRealTransport(t *testing.T) { + const frames = 6 + srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { + w.Header().Set("Content-Type", "text/event-stream") + flusher, ok := w.(http.Flusher) + if !ok { + t.Error("http.ResponseWriter does not implement http.Flusher") + return + } + for i := 1; i <= frames; i++ { + if _, err := fmt.Fprintf(w, "data: chunk-%d\n\n", i); err != nil { + return + } + flusher.Flush() + time.Sleep(20 * time.Millisecond) + } + })) + defer srv.Close() + + c := New() + c.ChatBaseCN = srv.URL + c.IdleTimeout = 5 * time.Second + + a := &auth.Auth{AccessToken: "at", UID: "u1"} + rc, status, _, err := c.ChatStream(a, []byte(`{"model":"glm-5.2","messages":[]}`), "", ChatMeta{}) + if err != nil || status != 200 { + t.Fatalf("chat: status=%d err=%v", status, err) + } + defer rc.Close() + + buf := make([]byte, 1) + var got string + for i := 0; i < frames; i++ { + if _, err := io.ReadFull(rc, buf); err != nil { + t.Fatalf("read %d: %v (real transport body must not be cut)", i, err) + } + got += string(buf) + } + if strings.Contains(got, "context canceled") { + t.Fatalf("body read hit context canceled, got %q", got) + } +} + +func TestUserResourceAggregation(t *testing.T) { + c := testClient(func(r *http.Request) (*http.Response, error) { + if !strings.HasSuffix(r.URL.Path, "/v2/billing/meter/get-user-resource") { + return nil, errors.New("wrong path: " + r.URL.Path) + } + if r.Method != http.MethodPost { + return nil, errors.New("want POST") + } + body, _ := io.ReadAll(r.Body) + if !bytes.Contains(body, []byte(`"ProductCode":"p_tcaca"`)) { + return nil, errors.New("missing ProductCode: " + string(body)) + } + return jsonResp(200, `{"code":0,"data":{"Response":{"Data":{"TotalCount":2,"TotalDosage":3000,"Accounts":[ + {"PackageName":"签到包","CapacitySize":2000,"CapacityRemain":1200,"CapacityUsed":800,"CycleCapacitySize":2000,"CycleCapacityRemain":1200,"CycleCapacityUsed":800}, + {"PackageName":"体验包","CapacitySize":1000,"CapacityRemain":300,"CapacityUsed":700,"CycleCapacitySize":1000,"CycleCapacityRemain":300,"CycleCapacityUsed":700} + ]}}}}`), nil + }) + a := &auth.Auth{AccessToken: "at", UID: "u1"} + remain, total, err := c.UserResource(a) + if err != nil { + t.Fatalf("resource: %v", err) + } + if remain != 1500 { + t.Errorf("remain=%d want 1500", remain) + } + if total != 3000 { + t.Errorf("total=%d want 3000", total) + } +} + +func TestUserResourceNegativeClamped(t *testing.T) { + c := testClient(func(r *http.Request) (*http.Response, error) { + return jsonResp(200, `{"code":0,"data":{"Response":{"Data":{"Accounts":[ + {"PackageName":"p","CycleCapacitySize":100,"CycleCapacityRemain":-50,"CycleCapacityUsed":150} + ]}}}}`), nil + }) + remain, total, err := c.UserResource(&auth.Auth{AccessToken: "at"}) + if err != nil || remain != 0 { + t.Errorf("remain=%d err=%v, want 0 (clamped)", remain, err) + } + if total != 100 { + t.Errorf("total=%d want 100", total) + } +} + +func TestDailyCheckinAlready(t *testing.T) { + c := testClient(func(r *http.Request) (*http.Response, error) { + if !strings.HasSuffix(r.URL.Path, "/v2/billing/meter/daily-checkin") { + return nil, errors.New("wrong path") + } + return jsonResp(200, `{"code":14001,"msg":"今日已签到"}`), nil + }) + err := c.DailyCheckin(&auth.Auth{AccessToken: "at"}) + if err == nil || !strings.Contains(err.Error(), "已签到") { + t.Errorf("err=%v", err) + } +} + +func TestBasesAlwaysCN(t *testing.T) { + c := testClient(nil) + cn := &auth.Auth{Domain: ""} + other := &auth.Auth{Domain: "example.com"} + if c.chatBase(cn) != "https://chat.example" || c.billingBase(cn) != "https://billing.example" { + t.Error("cn bases wrong") + } + // 恒 CN:domain 不同不改变上游 host。 + if c.chatBase(other) != c.chatBase(cn) || c.billingBase(other) != c.billingBase(cn) { + t.Error("bases must be CN regardless of domain") + } +} + +// TestGlobalBaseByDomain 覆盖 global 域按 auth 文件 domain 选上游主机: +// codebuddy.ai → 官方国际站,workbuddy.ai → 旧桌面端,其它/空 → 默认(官方国际站)。 +// +// 为什么必须按 domain:国际域两套主机名并存(老账号 workbuddy.ai、官方 CLI 新登录 +// codebuddy.ai),只按 realm 选主机必然把一半账号打到非其签发域。 +func TestGlobalBaseByDomain(t *testing.T) { + c := New() + c.ChatBaseGlobal = "" + c.BillingBaseGlobal = "" + + cases := []struct { + name string + domain string + realm string + wantChat string + wantBilling string + wantWeb string + }{ + {name: "官方国际站", domain: "www.codebuddy.ai", + wantChat: "https://www.codebuddy.ai", wantBilling: "https://www.codebuddy.ai", wantWeb: "https://www.codebuddy.ai"}, + {name: "官方国际站裸域", domain: "codebuddy.ai", + wantChat: "https://www.codebuddy.ai", wantBilling: "https://www.codebuddy.ai", wantWeb: "https://www.codebuddy.ai"}, + {name: "旧桌面端", domain: "www.workbuddy.ai", + wantChat: "https://www.workbuddy.ai", wantBilling: "https://www.workbuddy.ai", wantWeb: "https://www.workbuddy.ai"}, + {name: "旧桌面端裸域", domain: "workbuddy.ai", + wantChat: "https://www.workbuddy.ai", wantBilling: "https://www.workbuddy.ai", wantWeb: "https://www.workbuddy.ai"}, + // 显式 realm=global 但 domain 缺失/非国际域(手写扁平 auth)→ 回落官方国际站默认, + // 不按 domain 猜。 + {name: "global 无 domain 回落默认", realm: "global", domain: "", + wantChat: "https://www.codebuddy.ai", wantBilling: "https://www.codebuddy.ai", wantWeb: "https://www.codebuddy.ai"}, + {name: "global 非国际域回落默认", realm: "global", domain: "example.com", + wantChat: "https://www.codebuddy.ai", wantBilling: "https://www.codebuddy.ai", wantWeb: "https://www.codebuddy.ai"}, + // 非 global 账号恒走 CN 三域(realm 决定域,domain 只在 global 内选主机)。 + // CN 三个 base 同源(2026-10-28 起):客户端把 chat / billing / web 全打到 + // www.workbuddy.cn(5.9.3 真机 23 条 checkin + 12 条 resource + 13 条 growth 全在此域)。 + {name: "空 domain 非 global 走 CN", domain: "", + wantChat: "https://www.workbuddy.cn", wantBilling: "https://www.workbuddy.cn", wantWeb: "https://www.workbuddy.cn"}, + {name: "非国际域非 global 走 CN", domain: "example.com", + wantChat: "https://www.workbuddy.cn", wantBilling: "https://www.workbuddy.cn", wantWeb: "https://www.workbuddy.cn"}, + } + for _, tc := range cases { + t.Run(tc.name, func(t *testing.T) { + a := &auth.Auth{Domain: tc.domain, AccessToken: "at"} + if tc.realm != "" { + if _, err := auth.BackfillRealmFor(a, tc.realm); err != nil { + t.Fatalf("set realm: %v", err) + } + } + if got := c.chatBase(a); got != tc.wantChat { + t.Errorf("chatBase(realm=%q domain=%q)=%q want %q", a.Realm(), tc.domain, got, tc.wantChat) + } + if got := c.billingBase(a); got != tc.wantBilling { + t.Errorf("billingBase(realm=%q domain=%q)=%q want %q", a.Realm(), tc.domain, got, tc.wantBilling) + } + if got := c.webBase(a); got != tc.wantWeb { + t.Errorf("webBase(realm=%q domain=%q)=%q want %q", a.Realm(), tc.domain, got, tc.wantWeb) + } + }) + } + + // 显式配置优先于 domain 推断(部署侧要指到自建反代时不能被 domain 覆盖)。 + c.ChatBaseGlobal = "https://chat.global.example" + c.BillingBaseGlobal = "https://billing.global.example" + a := &auth.Auth{Domain: "www.codebuddy.ai", AccessToken: "at"} + if got := c.chatBase(a); got != "https://chat.global.example" { + t.Errorf("显式 ChatBaseGlobal 被 domain 覆盖:%q", got) + } + if got := c.billingBase(a); got != "https://billing.global.example" { + t.Errorf("显式 BillingBaseGlobal 被 domain 覆盖:%q", got) + } +} + +func TestNewChatClientNoTotalTimeoutAndSharedTransport(t *testing.T) { + c := New() + if c.ChatHTTP == nil { + t.Fatal("ChatHTTP should be initialized") + } + if c.ChatHTTP.Timeout != 0 { + t.Errorf("ChatHTTP.Timeout=%v want 0 (no total cap)", c.ChatHTTP.Timeout) + } + // 共享同一个 Transport 实例,连接池不重复。 + if c.ChatHTTP.Transport != c.HTTP.Transport { + t.Errorf("ChatHTTP and HTTP must share the same *http.Transport") + } + htr, ok := c.ChatHTTP.Transport.(*http.Transport) + if !ok { + t.Fatalf("Transport type=%T", c.ChatHTTP.Transport) + } + if htr.ResponseHeaderTimeout != 60*time.Second { // 连接层加固:响应头上限从 120s 收到 60s(慢冷启动留 3.75× 余量) + t.Errorf("ResponseHeaderTimeout=%v want 60s", htr.ResponseHeaderTimeout) + } +} + +func TestChatStreamRoutesToChatHTTP(t *testing.T) { + // 显式注入 ChatHTTP(可辨识标记),验证 ChatStream 走它而非 HTTP。 + chatHit, httpHit := false, false + c := testClient(func(*http.Request) (*http.Response, error) { + httpHit = true + return jsonResp(200, `{}`), nil + }) + c.ChatHTTP = &http.Client{Transport: rtFunc(func(*http.Request) (*http.Response, error) { + chatHit = true + return &http.Response{ + StatusCode: 200, + Header: http.Header{"Content-Type": []string{"text/event-stream"}}, + Body: io.NopCloser(strings.NewReader("data: [DONE]\n\n")), + }, nil + })} + a := &auth.Auth{AccessToken: "at", UID: "u1"} + rc, status, _, err := c.ChatStream(a, []byte(`{}`), "", ChatMeta{}) + if err != nil || status != 200 { + t.Fatalf("chat: status=%d err=%v", status, err) + } + rc.Close() + if !chatHit { + t.Error("ChatStream should use ChatHTTP") + } + if httpHit { + t.Error("ChatStream must not use HTTP") + } +} + +func TestChatHTTPNilFallsBackToHTTP(t *testing.T) { + c := testClient(func(*http.Request) (*http.Response, error) { + return &http.Response{ + StatusCode: 200, + Header: http.Header{"Content-Type": []string{"text/event-stream"}}, + Body: io.NopCloser(strings.NewReader("data: [DONE]\n\n")), + }, nil + }) + if c.chatHTTP() != c.HTTP { + t.Error("chatHTTP() should fall back to HTTP when ChatHTTP is nil") + } +} + +func TestFetchModelsDefaultEffortDualKeyAndSizes(t *testing.T) { + // 上游双键:老模型 reasoning.effort(hy3),新模型(glm-5.3 系)只有 reasoning.defaultEffort; + // credits/maxAllowedSize/canDisableThinking/supportsReasoning 等尺寸与能力字段应一并透出。 + // + // 注:这条用例原先拿 auto 当「老键模型」,但 auto 是客户端自动模式开关、已从 + // 名单里剔掉(见 clientpick.go 的 autoModeIDs),故换 hy3——它同样只带老键。 + c := testClient(func(r *http.Request) (*http.Response, error) { + return jsonResp(200, `{"code":0,"data":{"models":[ + {"id":"glm-5.3","maxInputTokens":1000000,"maxOutputTokens":48000,"maxAllowedSize":1000000,"credits":"x0.79","supportsReasoning":true,"reasoning":{"defaultEffort":"high","canDisableThinking":true,"supportedEfforts":["low","high","max"]}}, + {"id":"hy3","maxInputTokens":192000,"maxOutputTokens":64000,"supportsReasoning":true,"reasoning":{"effort":"high"}} + ],"agents":[{"name":"cli","models":["glm-5.3","hy3"]}]}}`), nil + }) + a := &auth.Auth{AccessToken: "at", UID: "u1"} + infos, err := c.FetchModels(a) + if err != nil { + t.Fatalf("fetch models: %v", err) + } + byID := map[string]ModelInfo{} + for _, mi := range infos { + byID[mi.ID] = mi + } + g := byID["glm-5.3"] + if g.DefaultEffort != "high" { + t.Errorf("glm-5.3 DefaultEffort=%q want high (from defaultEffort key)", g.DefaultEffort) + } + if !g.CanDisableThinking || !g.SupportsReasoning { + t.Errorf("glm-5.3 capability flags: canDisable=%v supportsReasoning=%v want true/true", g.CanDisableThinking, g.SupportsReasoning) + } + if g.MaxAllowedSize != 1000000 || g.MaxTokens != 48000 || g.Credits != "x0.79" { + t.Errorf("glm-5.3 sizes: maxAllowed=%d maxOut=%d credits=%q", g.MaxAllowedSize, g.MaxTokens, g.Credits) + } + if got := c.ModelRate("cn", "glm-5.3"); got != "0.79" { + t.Errorf("glm-5.3 ModelRate=%q want 0.79", got) + } + if au := byID["hy3"]; au.DefaultEffort != "high" { + t.Errorf("hy3 DefaultEffort=%q want high (from legacy effort key)", au.DefaultEffort) + } +} + +func TestModelRateCacheEffectiveAndNormalized(t *testing.T) { + c := New() + factor := 0.5 + c.storeModelRates("cn", []ModelInfo{ + {ID: "base", Credits: "x0.50 credits"}, + {ID: "promo", Credits: "x0.80", PromoFactor: &factor, PromoCredits: "0.50x"}, + }) + if got := c.ModelRate("cn", "base"); got != "0.5" { + t.Fatalf("base rate=%q want 0.5", got) + } + if got := c.ModelRate("cn", "promo"); got != "0.5" { + t.Fatalf("promo rate=%q want 0.5", got) + } + if got := normalizeModelRate("x0.05 credits"); got != "0.05" { + t.Fatalf("normalizeModelRate=%q want 0.05", got) + } + c.storeModelRates("cn", []ModelInfo{{ID: "base", Credits: "x0.79"}}) + if got := c.ModelRate("cn", "base"); got != "0.79" { + t.Fatalf("refreshed base rate=%q want 0.79", got) + } + if got := c.ModelRate("cn", "promo"); got != "" { + t.Fatalf("stale promo rate=%q want empty after full refresh", got) + } +} + +func TestFetchModelsOverlaysV3ConfigCapabilities(t *testing.T) { + // CLI 目录给 flash 精简字段(128K / 固定 high);IDE /v3/config 给完整能力。 + var sawIDE bool + c := testClient(func(r *http.Request) (*http.Response, error) { + switch { + case strings.HasSuffix(r.URL.Path, "/console/enterprises/personal/models"): + return jsonResp(200, `{"code":0,"data":{"models":[ + {"id":"deepseek-v4.1-flash","name":"Deepseek-V4.1-Flash","maxInputTokens":1000000,"maxOutputTokens":128000,"credits":"x0.03 credits","supportsReasoning":true,"onlyReasoning":true,"reasoning":{"effort":"high","summary":"auto"}} + ],"agents":[{"name":"cli","models":["deepseek-v4.1-flash"]}]}}`), nil + case strings.HasSuffix(r.URL.Path, "/v3/config"): + sawIDE = true + if r.Header.Get("User-Agent") != v3ProbeUACNForTest { + t.Errorf("v3/config UA=%q want %s", r.Header.Get("User-Agent"), v3ProbeUACNForTest) + } + if r.Header.Get("X-Product") != "SaaS" { + t.Errorf("X-Product=%q want SaaS", r.Header.Get("X-Product")) + } + if r.Header.Get("X-User-Id") != "u1" { + t.Errorf("X-User-Id=%q want u1", r.Header.Get("X-User-Id")) + } + return jsonResp(200, `{"code":0,"data":{"models":[ + {"id":"deepseek-v4.1-flash","name":"Deepseek-V4.1-Flash","maxInputTokens":1000000,"maxOutputTokens":393216,"credits":"x0.03","supportsReasoning":true,"onlyReasoning":true,"reasoning":{"canDisableThinking":true,"defaultEffort":"high","summary":"auto","supportedEfforts":["low","high","max"]}} + ]}}`), nil + default: + t.Errorf("unexpected path %s", r.URL.Path) + return jsonResp(404, `{}`), nil + } + }) + a := &auth.Auth{AccessToken: "at", UID: "u1", Domain: "copilot.tencent.com"} + infos, err := c.FetchModels(a) + if err != nil { + t.Fatalf("fetch models: %v", err) + } + if !sawIDE { + t.Fatal("expected /v3/config request") + } + if len(infos) != 1 { + t.Fatalf("infos=%+v", infos) + } + mi := infos[0] + if mi.MaxTokens != 393216 { + t.Errorf("MaxTokens=%d want 393216", mi.MaxTokens) + } + if mi.ContextWindow != 1000000 { + t.Errorf("ContextWindow=%d want 1000000", mi.ContextWindow) + } + if !mi.CanDisableThinking || !mi.SupportsReasoning { + t.Errorf("flags canDisable=%v supportsReasoning=%v", mi.CanDisableThinking, mi.SupportsReasoning) + } + if mi.DefaultEffort != "high" { + t.Errorf("DefaultEffort=%q want high", mi.DefaultEffort) + } + if got := strings.Join(mi.Efforts, ","); got != "low,high,max" { + t.Errorf("Efforts=%v want low,high,max", mi.Efforts) + } +} + +// TestV3PromotionsEmbedImageModel 出图模型只出现在 modelPromotions 里时也要进目录。 +// +// 实测(2026-10-22,global 个人号):/v3/config 的 data.models 里**没有任何**图片模型, +// 可用的 hy-image-3.5 只以纯模型定义形态夹在 modelPromotions 中 +// ({"id":"hy-image-3.5","name":...,"tags":["text-to-image","image-to-image"]}, +// 没有 kind/discount)。只解析 models 会得出「国际版没有出图模型」的假结论, +// 而它实际可调(200 + usage{output_image_tokens:15000, credit:0.27})。 +func TestV3PromotionsEmbedImageModel(t *testing.T) { + c := testClient(func(r *http.Request) (*http.Response, error) { + if strings.HasSuffix(r.URL.Path, "/v3/config") { + return jsonResp(200, `{"code":0,"data":{"models":[ + {"id":"glm-5.2","name":"GLM-5.2","maxInputTokens":1000000,"maxOutputTokens":65536} + ],"modelPromotions":[ + {"id":"hy3-free","kind":"discount","modelIds":["glm-5.2"],"priority":200,"discount":{"discountedCredits":"0x","factor":0}}, + {"id":"hy-image-3.5","name":"HY-Image-3.5","tags":["text-to-image","image-to-image"]}, + {"id":"kling-video-v3","name":"Kling-Video-V3","tags":["text-to-video","image-to-video"]} + ]}}`), nil + } + return jsonResp(200, `{"code":0,"data":{"models":[]}}`), nil + }) + a := &auth.Auth{AccessToken: "at", UID: "u1", Domain: "www.workbuddy.ai"} + if _, err := c.FetchModels(a); err != nil { + t.Fatalf("fetch models: %v", err) + } + kinds := map[string]string{} + for _, m := range c.GenerationModels("cn") { + kinds[m.ID] = m.GenerationKind + } + if kinds["kling-video-v3"] != "video" { + t.Errorf("modelPromotions 里的出视频模型应进留存,实际 %+v", kinds) + } + // 注意:GenerationModels 还会按 imageRouteRealm 做域过滤(hy-image-3.5 是 global + // 模型),所以这里直接看留存本体,验证的是「解析有没有把它收进目录」。 + stashed := map[string]bool{} + for _, m := range c.imageModels["cn"] { + stashed[m.ID] = true + } + if !stashed["hy-image-3.5"] { + t.Errorf("modelPromotions 里的出图模型未进留存:%v", c.imageModels["cn"]) + } + // 折扣条目(id 是优惠名而非模型名)不得被当成模型塞进目录。 + if stashed["hy3-free"] { + t.Errorf("折扣条目不应被当作模型:%v", c.imageModels["cn"]) + } +} + +// TestIsModelRateLimitCodes 模型级限流的 code 集合:6004(已有)与 14003(模型忙)。 +// 14003 若漏收,槽位会落到账号级冷却——一个模型抖动就能冷掉整池(同类实现的线上事故形态)。 +func TestIsModelRateLimitCodes(t *testing.T) { + cases := []struct { + name string + body string + want bool + }{ + {"6004 完整形态", `{"code":6004,"msg":"将在 2026-10-05 20:00:00 重置"}`, true}, + {"6004 带空格", `{"code": 6004}`, true}, + {"14003 模型忙", `{"code":14003,"msg":"too many requests"}`, true}, + {"14003 字符串码", `{"code":"14003"}`, true}, + {"14018 额度耗尽不算模型级", `{"code":14018,"msg":"credits exhausted"}`, false}, + {"11140 账号风控不算模型级", `{"code":11140,"msg":"request illegal"}`, false}, + {"无 code", `{"msg":"too many requests"}`, false}, + } + for _, c := range cases { + if got := IsModelRateLimit(c.body); got != c.want { + t.Errorf("%s: IsModelRateLimit=%v want %v", c.name, got, c.want) + } + } +} + +// TestIsModelBusy 区分「模型繁忙」14003 与「额度窗口用满」6004:前者没有恢复 +// 时刻,只能短窗口退避;后者带「将在 … 重置」的权威墙钟。两者混用会让一次 +// 瞬时抖动被停成十分钟(线上国际版就是这样整池冷 10 分钟)。 +func TestIsModelBusy(t *testing.T) { + cases := []struct { + name string + body string + want bool + }{ + {"14003 完整形态", `{"code":14003,"msg":"too many requests","displayMsg":{"zh":"模型繁忙,请换模型或稍后重试"}}`, true}, + {"14003 带空格", `{"code": 14003}`, true}, + {"14003 字符串码", `{"code":"14003"}`, true}, + {"6004 不是繁忙", `{"code":6004,"msg":"将在 2026-10-20 16:37:47 UTC+8 重置"}`, false}, + {"requestId 里出现 14003 不误判", `{"code":1,"requestId":"14003abc"}`, false}, + } + for _, c := range cases { + if got := IsModelBusy(c.body); got != c.want { + t.Errorf("%s: IsModelBusy=%v want %v", c.name, got, c.want) + } + } +} diff --git a/internal/upstream/clientpick.go b/internal/upstream/clientpick.go new file mode 100644 index 0000000000000000000000000000000000000000..2730310e4d80f172e2198d7c438cf30860b5c1f4 --- /dev/null +++ b/internal/upstream/clientpick.go @@ -0,0 +1,188 @@ +// clientpick.go 「客户端 picker 口径」:/v3/config 的 data.agents 里那个默认 agent +// 的 models 数组,就是官方桌面客户端模型菜单的数据源。 +// +// 为什么必须按它裁剪(2026-10-29 真机实测,5.9.3 两域): +// +// CN www.workbuddy.cn data.models 58 条,data.agents[cli].models 16 条 +// INTL www.workbuddy.ai data.models 25 条,data.agents[cli].models 23 条 +// +// data.models 是**平台全量目录**(含 codewise-* 补全模型、hy3-b/hy3-c/hy3-x 这类 +// 路由变体、default-1.1/1.2 这类历史别名、以及已被 disabled 的 wb-lite)。客户端 +// 从不把它们全画出来:菜单项只取 agents[].models,再叠三条客户端自己的规则。 +// 按 data.models 照单全列(本网关此前的行为)等于把一堆客户端根本不显示、点了还会 +// 11102 的内部 id 暴露给下游——用户侧表现为「模型列表和官方客户端对不上」。 +// +// 客户端侧的三条规则(渲染层源码实测,见下): +// +// 1. 只列默认 agent 的 models(resolveConversationAgent:tags 含 default → name==cli +// → 首个非空 models)。CN 实测菜单 17 项 = agents[cli].models 16 条 − auto − +// hy3-x + 快速/均衡/极致 三个预设,逐项对得上。 +// 2. ModelRateLimitCap.lines[].paidId 不单列:客户端把它并进 freeId 那一行,免费额度 +// 撞顶后再切过去(filterVisiblePaidLineModels)。CN 是 hy3 → hy3-x; +// INTL 是 deepseek-v4.1-flash → deepseek-v4.1-flash-sg。 +// 3. 快速/均衡/极致(fast-model / balanced-model / deep-model)是客户端的三个速度 +// 预设,即使不在 agents[].models 里也照样出现在菜单顶部;而 auto / auto-chat +// 是「自动模式」开关本身(isAutoModelId 集合),不是菜单行。 +// +// 口径缺失即不裁剪(保留上游全量):上游没下发 agents 时(老版本、企业端点、 +// 私有化部署)我们无从得知客户端会显示什么,此时宁可照旧全列也不臆造白名单。 +package upstream + +import "strings" + +// autoModeIDs 客户端当作「自动模式」开关、不画成菜单行的 id +// (渲染层 isAutoModelId 集合去掉三个速度预设后的余集)。 +// +// CN 的 agents[cli].models 里带着 auto,但它不是菜单项:点了「自动」是切路由模式, +// 由 isAutoModelId 单独处理。企业端点探测(fetchEnterpriseModels)与 picker 口径 +// 共用这一份判据——两边各写一个字符串常量,将来上游加 auto-lite 之类必然漏一处。 +var autoModeIDs = map[string]bool{ + "auto": true, + "auto-chat": true, +} + +// isAutoModeID 报告 id 是否是客户端的自动模式开关(不是可选模型)。 +func isAutoModeID(id string) bool { return autoModeIDs[id] } + +// pickPresetIDs 客户端的三个速度预设(菜单顶部「快速 / 均衡 / 极致」)。 +// 顺序即客户端顺序;不在目录里的跳过(INTL 无 deep-model)。 +var pickPresetIDs = []string{"fast-model", "balanced-model", "deep-model"} + +// v3ConfigAgent /v3/config data.agents 单条。只有 name/models/tags 参与可见性判定。 +type v3ConfigAgent struct { + Name string `json:"name"` + Models []string `json:"models"` + Tags []string `json:"tags"` +} + +// v3RateLimitLine productFeaturesConfig.ModelRateLimitCap.lines 单条: +// 免费额度撞顶后客户端从 freeId 切到 paidId,两个 id 在菜单里只占一行。 +type v3RateLimitLine struct { + FreeID string `json:"freeId"` + PaidID string `json:"paidId"` +} + +// clientPick 一次 /v3/config 响应推导出的「客户端菜单可见集合」。 +// nil 表示上游没给 agents(无从判定),调用方按既有全量口径处理。 +type clientPick struct { + order []string // 默认 agent 的 models 原序 + paid map[string]bool // ModelRateLimitCap 的 paidId 集合(不单列) +} + +// newClientPick 从 agents + rate-limit lines 推导可见性;没有可用 agents 时返回 nil。 +func newClientPick(agents []v3ConfigAgent, lines []v3RateLimitLine) *clientPick { + ag := defaultPickerAgent(agents) + if ag == nil || len(ag.Models) == 0 { + return nil + } + p := &clientPick{order: make([]string, 0, len(ag.Models)), paid: map[string]bool{}} + for _, id := range ag.Models { + if s := strings.TrimSpace(id); s != "" { + p.order = append(p.order, s) + } + } + for _, ln := range lines { + if s := strings.TrimSpace(ln.PaidID); s != "" { + p.paid[s] = true + } + } + if len(p.order) == 0 { + return nil + } + return p +} + +// defaultPickerAgent 客户端选默认 agent 的同一条优先级:tags 含 default → name==cli +// → 第一个 models 非空的。三者都没有时返回 nil(口径缺失,调用方不裁剪)。 +func defaultPickerAgent(agents []v3ConfigAgent) *v3ConfigAgent { + for i := range agents { + for _, t := range agents[i].Tags { + if strings.EqualFold(strings.TrimSpace(t), "default") { + return &agents[i] + } + } + } + for i := range agents { + if strings.EqualFold(strings.TrimSpace(agents[i].Name), "cli") { + return &agents[i] + } + } + for i := range agents { + if len(agents[i].Models) > 0 { + return &agents[i] + } + } + return nil +} + +// allows 报告 id 是否属于客户端菜单会显示的那一批。p 为 nil → 恒 true +// (口径缺失不裁剪)。 +func (p *clientPick) allows(id string) bool { + if p == nil { + return true + } + id = strings.TrimSpace(id) + if id == "" { + return false + } + if isAutoModeID(id) || p.paid[id] { + return false + } + for _, o := range p.order { + if o == id { + return true + } + } + // 速度预设不在 agent 名单里也可能被菜单列出(CN 的 快速/均衡/极致 即如此)。 + for _, o := range pickPresetIDs { + if o == id { + return true + } + } + return false +} + +// ordered 按客户端菜单顺序返回可见 id,只保留 byID 里真实存在的条目 +// ——目录缺条的 id 不臆造。p 为 nil → 返回 nil(调用方走既有全量分支)。 +// +// 顺序规则(两域真机菜单实测,2026-10-29): +// +// 菜单 = [不在 agent 名单里的速度预设,按 快速/均衡/极致] + [agent 原序过滤后] +// +// CN:agents 里没有 fast/balanced/deep,故三个预设被前置,得 快速/均衡/极致/… +// INTL:agents 本身就含 fast-model/balanced-model(default-model 打头), +// +// 预设已在名单内不再前置,结果 = 纯 agent 原序。两条真机菜单都逐条对上。 +// +// 曾经写成「预设一律前置」:INTL 菜单首项是 default-model(Auto),前置会把 +// Fast/Balanced 顶到 Auto 前面,顺序与客户端不符(id 集合对、顺序错)。 +func (p *clientPick) ordered(byID map[string]ModelInfo) []string { + if p == nil { + return nil + } + inOrder := make(map[string]bool, len(p.order)) + for _, id := range p.order { + inOrder[id] = true + } + seen := make(map[string]bool, len(p.order)+len(pickPresetIDs)) + out := make([]string, 0, len(p.order)+len(pickPresetIDs)) + add := func(id string) { + if seen[id] || !p.allows(id) { + return + } + if _, ok := byID[id]; !ok { + return + } + seen[id] = true + out = append(out, id) + } + for _, id := range pickPresetIDs { + if !inOrder[id] { + add(id) + } + } + for _, id := range p.order { + add(id) + } + return out +} diff --git a/internal/upstream/clientpick_test.go b/internal/upstream/clientpick_test.go new file mode 100644 index 0000000000000000000000000000000000000000..85bed7aeed08e841b72b7a04ea0b77621cfdbaa9 --- /dev/null +++ b/internal/upstream/clientpick_test.go @@ -0,0 +1,192 @@ +// clientpick_test.go 「/v1/models 与官方客户端菜单一致」的回归钉。 +// +// 上游形状(2026-10-29 真机 5.9.3 两域 /v3/config 实测): +// +// CN data.models 58 条 / data.agents[cli].models 16 条 / 客户端菜单 17 项 +// INTL data.models 25 条 / data.agents[cli].models 23 条 / 客户端菜单 22 项 +// +// 差距的来源就是本文件钉住的三条规则(详见 clientpick.go 头部):paidId 不单列、 +// auto 是开关不是菜单行、速度预设即使不在 agent 名单里也显示。写反任何一条, +// 用户侧都会看到「模型列表和官方客户端对不上」——而这正是本次改动的动因。 +package upstream + +import ( + "net/http" + "strings" + "testing" + + "github.com/misakano7545/workbuddy2api-panel/internal/auth" +) + +// cnV3ConfigFixture 按 5.9.3 CN 真机响应裁剪出的最小样本,保留每个关键形态: +// 速度预设(不在 agents 里)、auto(在 agents 里但不是菜单行)、paidId(hy3-x)、 +// 路由变体(hy3-b)、已 disabled(wb-lite)、补全模型(codewise-*)。 +const cnV3ConfigFixture = `{"code":0,"data":{ + "models":[ + {"id":"fast-model","name":"快速","maxInputTokens":200000,"maxOutputTokens":48000}, + {"id":"balanced-model","name":"均衡","maxInputTokens":256000,"maxOutputTokens":48000}, + {"id":"deep-model","name":"极致","maxInputTokens":272000,"maxOutputTokens":48000}, + {"id":"auto","name":"Auto","maxInputTokens":200000,"maxOutputTokens":32000}, + {"id":"hy3","name":"Hy3","maxInputTokens":192000,"maxOutputTokens":64000,"reasoning":{"defaultEffort":"high","supportedEfforts":["low","high"]}}, + {"id":"hy3-b","name":"Hy3","maxInputTokens":192000,"maxOutputTokens":64000}, + {"id":"hy3-x","name":"Hy3","maxInputTokens":192000,"maxOutputTokens":64000}, + {"id":"deepseek-v4.1-flash","name":"DeepSeek-V4.1-Flash","maxInputTokens":1000000,"maxOutputTokens":128000}, + {"id":"glm-5.3-flash","name":"GLM-5.3-Flash","maxInputTokens":1000000,"maxOutputTokens":131072}, + {"id":"codewise-jump","name":"codewise-jump","maxInputTokens":8000,"maxOutputTokens":128}, + {"id":"wb-lite","name":"wb-lite","disabled":true} + ], + "agents":[{"name":"cli","tags":["cli","default","model:craft"], + "models":["auto","hy3","hy3-x","deepseek-v4.1-flash","glm-5.3-flash"]}], + "productFeaturesConfig":{"ModelRateLimitCap":{"lines":[ + {"displayName":"Hy3","freeId":"hy3","paidId":"hy3-x","allowPaidSwitch":true}]}} +}}` + +// cnMenuWant 客户端模型菜单的真实内容与顺序(真机 DOM 抓的 17 项里的这一段): +// 三个速度预设永远在最前,其余按 agents.models 原序;auto 与 hy3-x 不出现。 +var cnMenuWant = []string{"fast-model", "balanced-model", "deep-model", + "hy3", "deepseek-v4.1-flash", "glm-5.3-flash"} + +// TestFetchV3ModelsMatchesClientMenu CN 域:目录里多出来的 hy3-b(变体)、auto(开关)、 +// hy3-x(paidId)、codewise-jump(补全)、wb-lite(disabled)都不许进对话列表。 +// +// 反向代价:这条断言松掉,就等于允许「上游目录有就列」——那正是本次修掉的 bug, +// 下游客户端会选到 11102 或客户端根本不显示的 id。 +func TestFetchV3ModelsMatchesClientMenu(t *testing.T) { + c := testClient(func(r *http.Request) (*http.Response, error) { + if !strings.HasSuffix(r.URL.Path, "/v3/config") { + t.Errorf("unexpected path %s", r.URL.Path) + return jsonResp(404, `{}`), nil + } + return jsonResp(200, cnV3ConfigFixture), nil + }) + a := &auth.Auth{AccessToken: "at", UID: "u1", Domain: "copilot.tencent.com"} + infos, err := c.fetchV3Models(a) + if err != nil { + t.Fatalf("fetchV3Models: %v", err) + } + got := make([]string, 0, len(infos)) + for _, mi := range infos { + got = append(got, mi.ID) + } + if strings.Join(got, ",") != strings.Join(cnMenuWant, ",") { + t.Fatalf("menu order/ids = %v want %v", got, cnMenuWant) + } +} + +// TestClientPickDropsPaidRateLimitVariant INTL 域:deepseek-v4.1-flash-sg 是 +// deepseek-v4.1-flash 的付费变体(ModelRateLimitCap.paidId),客户端把它并进免费那一行, +// 不单独列。若把它当独立模型列给下游,用户会以为有两个不同模型。 +func TestClientPickDropsPaidRateLimitVariant(t *testing.T) { + byID := map[string]ModelInfo{ + "deepseek-v4.1-flash": {ID: "deepseek-v4.1-flash"}, + "deepseek-v4.1-flash-sg": {ID: "deepseek-v4.1-flash-sg"}, + "kimi-k3": {ID: "kimi-k3"}, + } + pick := newClientPick( + []v3ConfigAgent{{Name: "cli", Tags: []string{"default"}, + Models: []string{"deepseek-v4.1-flash", "deepseek-v4.1-flash-sg", "kimi-k3"}}}, + []v3RateLimitLine{{FreeID: "deepseek-v4.1-flash", PaidID: "deepseek-v4.1-flash-sg"}}, + ) + got := pick.ordered(byID) + want := []string{"deepseek-v4.1-flash", "kimi-k3"} + if strings.Join(got, ",") != strings.Join(want, ",") { + t.Fatalf("ordered = %v want %v", got, want) + } +} + +// TestClientPickWithoutAgentsKeepsFullCatalog 口径缺失不裁剪:企业端点 / 私有化 / 老版本 +// 不下发 agents 时无从得知客户端菜单,此时必须照旧全量列出,而不是返回空列表。 +// 反向代价:这里若改成「无 agents 就全隐藏」,所有非 SaaS 部署的 /v1/models 会直接空掉。 +func TestClientPickWithoutAgentsKeepsFullCatalog(t *testing.T) { + c := testClient(func(r *http.Request) (*http.Response, error) { + return jsonResp(200, `{"code":0,"data":{"models":[ + {"id":"glm-5.2","name":"GLM-5.2","maxOutputTokens":64000}, + {"id":"hy3-b","name":"Hy3","maxOutputTokens":64000} + ]}}`), nil + }) + a := &auth.Auth{AccessToken: "at", UID: "u1", Domain: "copilot.tencent.com"} + infos, err := c.fetchV3Models(a) + if err != nil { + t.Fatalf("fetchV3Models: %v", err) + } + if len(infos) != 2 { + t.Fatalf("infos=%v want 2 entries (no agents → keep full catalog)", idsOf(infos)) + } +} + +// TestClientPickPrefersDefaultTaggedAgent 客户端选默认 agent 的优先级是 +// tags 含 default → name==cli。若先按 name 选,企业部署里 cli agent 的名单会 +// 覆盖掉真正给菜单用的那个 agent。 +func TestClientPickPrefersDefaultTaggedAgent(t *testing.T) { + pick := newClientPick([]v3ConfigAgent{ + {Name: "cli", Models: []string{"m-cli-only"}}, + {Name: "desktop", Tags: []string{"default"}, Models: []string{"m-default"}}, + }, nil) + byID := map[string]ModelInfo{"m-cli-only": {ID: "m-cli-only"}, "m-default": {ID: "m-default"}} + // 三个速度预设不在目录里,按 ordered 的规则跳过,只留下 default agent 的那条。 + got := pick.ordered(byID) + if strings.Join(got, ",") != "m-default" { + t.Fatalf("ordered = %v want [m-default]", got) + } +} + +// TestGenerationModelsSurviveVisibilityFilter 媒体模型不在 agent 菜单里,但仍要进 +// GenerationModels 单列(/v1/models 按 image_generation 标记列出)。 +// 若把 stash 挪到可见性过滤之后,出图模型会凭空消失。 +func TestGenerationModelsSurviveVisibilityFilter(t *testing.T) { + c := testClient(func(r *http.Request) (*http.Response, error) { + return jsonResp(200, `{"code":0,"data":{ + "models":[ + {"id":"glm-5.3","name":"GLM-5.3","maxOutputTokens":64000}, + {"id":"hunyuan-image-alpha","name":"Hunyuan-Image-Alpha","tags":["text-to-image","image-to-image"]} + ], + "agents":[{"name":"cli","tags":["default"],"models":["glm-5.3"]}] + }}`), nil + }) + a := &auth.Auth{AccessToken: "at", UID: "u1", Domain: "copilot.tencent.com"} + infos, err := c.fetchV3Models(a) + if err != nil { + t.Fatalf("fetchV3Models: %v", err) + } + if len(infos) != 1 || infos[0].ID != "glm-5.3" { + t.Fatalf("chat list = %v want [glm-5.3]", idsOf(infos)) + } + gen := c.GenerationModels("cn") + found := false + for _, mi := range gen { + if mi.ID == "hunyuan-image-alpha" { + found = true + } + } + if !found { + t.Fatalf("GenerationModels=%v want hunyuan-image-alpha kept", idsOf(gen)) + } +} + +func idsOf(infos []ModelInfo) []string { + out := make([]string, 0, len(infos)) + for _, mi := range infos { + out = append(out, mi.ID) + } + return out +} + +// TestClientPickIntlMenuOrder INTL 域顺序钉:客户端菜单首项是 default-model(Auto), +// 而 fast-model / balanced-model 这段**在 agents 名单里**,不能像 CN 那样前置。 +// +// 这两条真机菜单顺序不同(CN 预设在前、INTL 纯 agent 序),故 ordered 的规则是 +// 「只前置不在 agent 名单里的预设」。曾写成「预设一律前置」:id 集合仍对、首项变成 +// Fast,与客户端菜单不符。 +func TestClientPickIntlMenuOrder(t *testing.T) { + byID := map[string]ModelInfo{} + for _, id := range []string{"default-model", "fast-model", "balanced-model", "primary-model", "hy3"} { + byID[id] = ModelInfo{ID: id} + } + pick := newClientPick([]v3ConfigAgent{{Name: "cli", Tags: []string{"default"}, + Models: []string{"default-model", "fast-model", "balanced-model", "primary-model", "hy3"}}}, nil) + got := pick.ordered(byID) + want := []string{"default-model", "fast-model", "balanced-model", "primary-model", "hy3"} + if strings.Join(got, ",") != strings.Join(want, ",") { + t.Fatalf("ordered = %v want %v", got, want) + } +} diff --git a/internal/upstream/cn_contract_test.go b/internal/upstream/cn_contract_test.go new file mode 100644 index 0000000000000000000000000000000000000000..133ad4233b705ded88b4eaf5600b34cda9364460 --- /dev/null +++ b/internal/upstream/cn_contract_test.go @@ -0,0 +1,298 @@ +// cn_contract_test.go CN 客户端请求契约回归(黄金头集来自 WorkBuddy 5.9.3 真机抓包)。 +// +// 这不是「按文档推的」测试,是把 2026-10-28 真机 mitmproxy 抓到的每个路径的**出站头 +// 键集**固化成黄金值,再用生产代码真实构造请求逐条比对。任何一头多发/漏发都会红。 +// +// 抓包环境:国内版 WorkBuddy 5.9.3(CLI 2.165.0),CN 账号,www.workbuddy.cn。 +// 每个路径取的是该路径全部样本的**交集**(排除客户端按场景才加的偶发头,如 auxiliary +// 链才有的差异),再剔除三类与网关环境相关、不该进黄金集的键: +// +// host / connection / content-length ← 连接层,由 http.Client 决定 +// accept-encoding ← 传输层协商 +// x-device-token ← 账号是否配了设备令牌(配置项,非契约) +// +// 值断言只做「形态/关键常量」级(版本段、布尔值、枚举),动态 ID 只校验形态。 +package upstream + +import ( + "bytes" + "compress/gzip" + "io" + "net/http" + "net/http/httptest" + "regexp" + "sort" + "strings" + "testing" + + "github.com/misakano7545/workbuddy2api-panel/internal/auth" +) + +// cnGolden 单条路径的黄金契约。 +type cnGolden struct { + path string + // headers 期望出现的出站头(全部小写)。必须**精确**等于实际集合(忽略上表三类)。 + headers []string + // values 关键头的期望值(小写键)。 + values map[string]string + // absent 明确断言**不能**出现的头(防回归:这些是旧实现多发的)。 + absent []string +} + +var cnGoldenCases = []cnGolden{ + { + // 真机 idx 438(另 6 条 /v2/chat/completions 同构)。 + path: "/v2/chat/completions", + headers: []string{ + "accept", "authorization", "acp-connection-id", "b3", "baggage", + "content-type", "traceparent", "user-agent", + "x-agent-intent", "x-agent-purpose", "x-agent-runtime", "x-agent-type", + "x-b3-parentspanid", "x-b3-sampled", "x-b3-spanid", "x-b3-traceid", + "x-codebuddy-request", "x-conversation-id", "x-conversation-message-id", + "x-conversation-request-id", "x-domain", "x-ide-name", "x-ide-type", + "x-ide-version", "x-private-data", "x-product", "x-request-id", + "x-requested-with", "x-root-request-id", "x-trace-id", "x-user-id", + "x-stainless-arch", "x-stainless-lang", "x-stainless-os", + "x-stainless-package-version", "x-stainless-retry-count", + "x-stainless-runtime", "x-stainless-runtime-version", + }, + values: map[string]string{ + "accept": "application/json", + "x-private-data": "false", // 真机 false(模型优化开),不是 true + "x-agent-runtime": "local-agent", + "x-agent-type": "main", + "x-codebuddy-request": "1", + "x-ide-version": "5.9.3", + "x-product": "SaaS", + "user-agent": "WorkBuddy/5.9.3 WorkBuddy/5.9.3 CLI/2.165.0", + }, + // 客户端 chat 从不上浏览器语义头(node fetch,无同源概念)。 + absent: []string{"origin", "referer", "accept-language", "x-machine-id", "x-session-id"}, + }, + { + // 真机 idx 443。走 chat 域,UA 三段式(不是 billing 的 axios)。 + path: "/v2/report", + headers: []string{ + "accept", "authorization", "content-type", "user-agent", "x-domain", + "x-product", "x-request-id", "x-user-id", + }, + values: map[string]string{ + "accept": "application/json, text/plain, */*", + "content-type": "application/json;charset=UTF-8", + "x-product": "SaaS", + "user-agent": "WorkBuddy/5.9.3 WorkBuddy/5.9.3 CLI/2.165.0", + }, + // 2026-10-30 复核:CN 5.9.3 全部 26 条 /v2/report(含登录前 2 条)**都没有** + // X-Requested-With。国际版那 10 条带它的样本属于 UA 首段驼峰的渲染器侧另一族, + // 与本函数发的三段式不是同一个上报通道。 + absent: []string{"origin", "referer", "accept-language", "x-codebuddy-request", "x-device-token", "x-requested-with"}, + }, + { + // 真机 idx 307/531/380…(19 条):轻头族,不是 chat 重头族。 + path: "/v2/chat/busy", + headers: []string{ + "accept", "authorization", "content-type", "user-agent", "x-domain", + "x-product", "x-request-id", "x-user-id", + }, + values: map[string]string{ + "accept": "application/json, text/plain, */*", + "content-type": "application/json", + "x-product": "SaaS", + "user-agent": "WorkBuddy/5.9.3 WorkBuddy/5.9.3 CLI/2.165.0", + }, + absent: []string{ + "x-codebuddy-request", "x-conversation-id", "x-conversation-request-id", + "acp-connection-id", "baggage", "b3", "x-requested-with", + "x-stainless-lang", "origin", "referer", "accept-language", + }, + }, + { + // 真机 idx 556。XRW:refresh 的 RPC 族样本(本函数发的这一族)**无**此头, + // 只有渲染器族 `WorkBuddy/ / CLI/…` 那条镜像请求才带 + // (2026-10-30 三条 refresh 逐条核对:RPC 两条无、渲染器一条有)。 + path: "/v2/plugin/auth/token/refresh", + headers: []string{ + "accept", "authorization", "content-type", "user-agent", + "x-auth-refresh-source", "x-domain", "x-product", "x-refresh-token", + "x-request-id", "x-user-id", + }, + values: map[string]string{ + "accept": "application/json, text/plain, */*", + "x-auth-refresh-source": "plugin", + "x-product": "SaaS", + "user-agent": "WorkBuddy/5.9.3 WorkBuddy/5.9.3 CLI/2.165.0", + }, + absent: []string{"origin", "referer", "accept-language", "x-codebuddy-request", "x-requested-with"}, + }, + { + // 真机 idx 314(23 条 billing 同构)。 + path: "/v2/billing/meter/checkin-activity-status", + headers: []string{ + "accept", "authorization", "content-type", "user-agent", "x-domain", + "x-request-id", "x-user-id", + }, + values: map[string]string{ + "accept": "application/json", + "content-type": "application/json", + "user-agent": "axios/1.16.1", // billing 层是 axios 实例,与客户端 UA 不同 + }, + absent: []string{"origin", "referer", "accept-language", "x-codebuddy-request"}, + }, + { + // 真机 idx 558(9 条 /v3/config 同构)。 + // XRW:该路径由 RPC 层打,主流样本(CLI 两段式 UA)**无**此头;带 XRW 的那几条 + // 是渲染器族的镜像请求(UA 为三段 `WorkBuddy/ / CLI/…`), + // 不是本函数这条链。 + path: "/v3/config", + headers: []string{ + "accept", "authorization", "user-agent", "x-domain", "x-product", + "x-request-id", "x-user-id", + }, + values: map[string]string{ + "accept": "application/json, text/plain, */*", + "x-product": "SaaS", + // 2026-10-30 复核:真机 /v3/config 是两段单品牌(同 token 三段/两段返回相同)。 + "user-agent": "WorkBuddy/5.9.3 CLI/2.165.0", + }, + absent: []string{"origin", "referer", "accept-language", "x-codebuddy-request", "x-requested-with"}, + }, +} + +// transportOnly 与网关环境相关、不进契约比对的头。 +var transportOnly = map[string]bool{ + "host": true, "connection": true, "content-length": true, + "accept-encoding": true, "x-device-token": true, + // 客户端按 body 大小才加的压缩头(本测试 body 小,故允许缺省)。 + "content-encoding": true, +} + +// TestCNContractGolden 用生产代码真实构造 CN 六条关键路径,逐条比对黄金头集。 +func TestCNContractGolden(t *testing.T) { + captured := map[string]http.Header{} + var order []string + srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { + raw, _ := io.ReadAll(r.Body) + if r.Header.Get("Content-Encoding") == "gzip" && len(raw) > 2 && raw[0] == 0x1f { + if zr, err := gzip.NewReader(bytes.NewReader(raw)); err == nil { + raw, _ = io.ReadAll(zr) + } + } + if _, seen := captured[r.URL.Path]; !seen { + captured[r.URL.Path] = r.Header.Clone() + order = append(order, r.URL.Path) + } + w.Write([]byte(`{"code":0,"msg":"OK","data":{}}`)) + })) + defer srv.Close() + + a := &auth.Auth{ + UID: "00000000-0000-4000-8000-000000000002", AccessToken: "AT", + RefreshToken: "RT", Nickname: "MisakaNo", + } + c := &Client{ + HTTP: srv.Client(), ChatHTTP: srv.Client(), + ChatBaseCN: srv.URL, BillingBaseCN: srv.URL, WebBaseCN: srv.URL, + GlobalEnabled: true, + } + c.SanitizeFingerprints.Store(true) + c.SanitizeBrandScope.Store("all") + + body := []byte(`{"model":"deepseek-v4.1-flash","messages":[{"role":"system","content":"s"},{"role":"user","content":"hi"}]}`) + meta := ChatMeta{ + ConversationID: "a896735e-cc8a-41ae-9a0f-068f43089056", + ConversationRequestID: "01a1815dc89177bd961af0245527ef7e", + } + if rc, _, _, err := c.ChatStream(a, body, "", meta); err == nil && rc != nil { + io.Copy(io.Discard, rc) + rc.Close() + } + _ = c.ReportChatActivity(a, "e5f5037d-10a2-4889-87ed-1b7539718a64", "01a1815eb602737a9f30ab51740d0ff7") + _, _ = c.ModelBusy(a, []string{"hy3"}) + _ = c.RefreshToken(a) + _, _ = c.GetCheckinActivityStatus(a) + _, _, _ = c.fetchV3ConfigModelMap(a, "") + + for _, g := range cnGoldenCases { + t.Run(strings.TrimPrefix(g.path, "/"), func(t *testing.T) { + hdr, ok := captured[g.path] + if !ok { + t.Fatalf("未捕获到 %s 的出站请求", g.path) + } + got := map[string]bool{} + for k := range hdr { + lk := strings.ToLower(k) + if !transportOnly[lk] { + got[lk] = true + } + } + want := map[string]bool{} + for _, k := range g.headers { + want[k] = true + } + // 集合必须精确相等:多一个(旧实现多发)或少一个(漏发)都是偏差。 + var extra, missing []string + for k := range got { + if !want[k] { + extra = append(extra, k) + } + } + for k := range want { + if !got[k] { + missing = append(missing, k) + } + } + sort.Strings(extra) + sort.Strings(missing) + if len(extra) > 0 { + t.Errorf("多发了客户端没有的头: %v", extra) + } + if len(missing) > 0 { + t.Errorf("漏发了真机必带的头: %v", missing) + } + for k, v := range g.values { + if got := hdr.Get(k); got != v { + t.Errorf("%s=%q want %q", k, got, v) + } + } + for _, k := range g.absent { + if got := hdr.Get(k); got != "" { + t.Errorf("%s 不应出现(真机无),实际=%q", k, got) + } + } + }) + } + _ = order +} + +var ( + hex32 = regexp.MustCompile(`^[0-9a-f]{32}$`) + uuidV7Re = regexp.MustCompile(`^[0-9a-f]{8}-[0-9a-f]{4}-7[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$`) +) + +// TestCNIDShapes 会话头族 ID 形态对齐真机:32 hex 时间前缀 / UUIDv7。 +func TestCNIDShapes(t *testing.T) { + hdr := http.Header{} + req := httptest.NewRequest("POST", "https://www.workbuddy.cn/v2/chat/completions", nil) + req.Header = hdr + c := New() + a := &auth.Auth{UID: "u1", AccessToken: "at"} + // 零值 meta:走「现造」分支,检验兜底形态。 + c.ChatHeaders(req, a, "", ChatMeta{}) + + if got := req.Header.Get("X-Conversation-ID"); !uuidV7Re.MatchString(got) { + t.Errorf("零值 X-Conversation-ID=%q 不是 UUIDv7(真机 01a1815d-dacf-75f1-…)", got) + } + if got := req.Header.Get("acp-connection-id"); !uuidV7Re.MatchString(got) { + t.Errorf("零值 acp-connection-id=%q 不是 UUIDv7", got) + } + if got := req.Header.Get("X-Request-ID"); !hex32.MatchString(got) { + t.Errorf("X-Request-ID=%q 不是 32 hex", got) + } + if got := req.Header.Get("X-Conversation-Message-ID"); got != req.Header.Get("X-Request-ID") { + t.Errorf("消息级两头应同值: %q vs %q", got, req.Header.Get("X-Request-ID")) + } + // 真机:X-Trace-ID 与 request id 从不相等(旧实现空则回落 convReqID 是错的)。 + if req.Header.Get("X-Trace-ID") == req.Header.Get("X-Conversation-Request-ID") { + t.Error("X-Trace-ID 不应等于 X-Conversation-Request-ID") + } +} diff --git a/internal/upstream/connection_reuse_e2e_test.go b/internal/upstream/connection_reuse_e2e_test.go new file mode 100644 index 0000000000000000000000000000000000000000..c7d6bd568e997764570e834ee924c43ebdd44bae --- /dev/null +++ b/internal/upstream/connection_reuse_e2e_test.go @@ -0,0 +1,149 @@ +// connection_reuse_e2e_test.go 验证 Connection 头补发没有破坏连接复用。 +// +// 补 Connection 头时最危险的副作用不是「多一个头」,而是: +// - keep-alive 若被误写成 req.Close,Transport 会每次新建连接(性能回退 + 握手放大) +// - close 若不生效,/v3/config 会占着一条本该释放的连接 +// 两者都不会让任何断言失败,只会让线上慢下来,所以必须用真实 TLS 连接钉死。 +package upstream + +import ( + "bufio" + "crypto/tls" + "io" + "net" + "net/http" + "strings" + "sync/atomic" + "testing" + "time" + + "github.com/misakano7545/workbuddy2api-panel/internal/auth" +) + +// reuseTestServer 起一个支持 keep-alive 多请求的自签 TLS 服务器, +// 返回地址、接受连接的累计次数、以及「读到 Connection: close 的请求数」。 +func reuseTestServer(t *testing.T) (addr string, accepts, closeReqs *int64) { + t.Helper() + srvTLS := selfSignedServerTLS(t) + ln, err := net.Listen("tcp", "127.0.0.1:0") + if err != nil { + t.Fatalf("listen: %v", err) + } + t.Cleanup(func() { ln.Close() }) + tlsLn := tls.NewListener(ln, srvTLS) + + var n, cn int64 + accepts, closeReqs = &n, &cn + go func() { + for { + conn, aerr := tlsLn.Accept() + if aerr != nil { + return + } + atomic.AddInt64(&n, 1) + go func(c net.Conn) { + defer c.Close() + br := bufio.NewReader(c) + for { + // 读到空行为止(请求头结束) + closed := false + var closeSeen bool + for { + ln, rerr := br.ReadBytes('\n') + if rerr != nil { + closed = true + break + } + if strings.HasPrefix(strings.ToLower(string(ln)), "connection:") && + strings.Contains(strings.ToLower(string(ln)), "close") { + closeSeen = true + } + if string(ln) == "\r\n" { + break + } + } + if closed { + return + } + if closeSeen { + atomic.AddInt64(&cn, 1) + } + // Content-Length 明确,客户端才能判定响应边界并复用连接 + if _, werr := c.Write([]byte("HTTP/1.1 200 OK\r\nContent-Length: 2\r\nContent-Type: application/json\r\n\r\n{}")); werr != nil { + return + } + if closeSeen { + return // 客户端要求 close:服务端配合断开 + } + } + }(conn) + } + }() + return ln.Addr().String(), accepts, closeReqs +} + +// TestConnectionHeaderKeepsConnReuse 验证 Connection 头的两种语义都落到了线上: +// +// /report ×2 → keep-alive,同一条连接处理两个请求(复用没被破坏) +// /v3/config → close,占用现有连接但在响应后被关闭(不是另开一条) +// /report → 上一条已关,必须新建 +// +// 断言「close 之后必然新建连接」而不是「close 时新建连接」:HTTP 语义里 +// Connection: close 标记的是本条连接用完即弃,Transport 仍可先用空闲连接。 +func TestConnectionHeaderKeepsConnReuse(t *testing.T) { + addr, accepts, closeReqs := reuseTestServer(t) + + tr := newTransport() + // newTransport 走生产 TLS 指纹(node 档),自签证书需要跳过校验; + // 这里用 go 档避开 SNI 与自签的纠缠,测的是连接复用不是指纹。 + tr.DialTLSContext = newTLSDialer(newDialer(), &tls.Config{InsecureSkipVerify: true}, TLSFingerprintGo) + tr.DisableKeepAlives = false + tr.MaxIdleConnsPerHost = 4 + defer tr.CloseIdleConnections() + + httpClient := &http.Client{Transport: tr} + c := &Client{HTTP: httpClient, ChatHTTP: httpClient} + a := &auth.Auth{UID: "uid-reuse", AccessToken: "AT", Nickname: "reuse"} + + fire := func(path string) { + t.Helper() + req, err := http.NewRequest(http.MethodPost, "https://"+addr+path, strings.NewReader(`{}`)) + if err != nil { + t.Fatalf("new request %s: %v", path, err) + } + req.Header.Set("Accept", "application/json") + resp, derr := c.do(req, a, false) + if derr != nil { + t.Fatalf("do %s: %v", path, derr) + } + // 必须把 body 读干净再 Close:net/http 对未读完的响应体不复用连接, + // 那会让「连接没复用」的诊断失真(测的就不是 Connection 头了)。 + io.Copy(io.Discard, resp.Body) + resp.Body.Close() + } + + fire("/v2/report") + fire("/v2/report") + // keep-alive 语义下 Transport 会把连接放回空闲池,但它是异步的; + // 给一个极短的窗口,避免把「还没来得及复用」误判成「复用坏了」。 + time.Sleep(50 * time.Millisecond) + if got := atomic.LoadInt64(accepts); got != 1 { + t.Fatalf("两个 keep-alive 请求应复用同一条连接,实际建立 %d 条", got) + } + + fire("/v3/config") + time.Sleep(50 * time.Millisecond) + if got := atomic.LoadInt64(closeReqs); got != 1 { + t.Fatalf("/v3/config 必须在线上发出 Connection: close,服务端实际收到 %d 条", got) + } + if got := atomic.LoadInt64(accepts); got != 1 { + t.Fatalf("close 请求应先复用空闲连接(语义是「用完即弃」而非「另开一条」),实际累计 %d 条", got) + } + + // 上一条已被 close,这次必须重新建连 + fire("/v2/report") + time.Sleep(50 * time.Millisecond) + if got := atomic.LoadInt64(accepts); got != 2 { + t.Fatalf("close 之后的下一个请求必须新建连接,累计应为 2,实际 %d", got) + } +} diff --git a/internal/upstream/console_system_test.go b/internal/upstream/console_system_test.go new file mode 100644 index 0000000000000000000000000000000000000000..50e079a171bfcb07e88a9b694170eda5e2ccf129 --- /dev/null +++ b/internal/upstream/console_system_test.go @@ -0,0 +1,52 @@ +// console_system_test.go global 兜底 system 的两条钉:形态(首条必须是 system)与 +// 内容(不声明身份)。 +// +// 为什么要钉内容(issue #187):模型会把「被代理插入的身份声明」当成提示注入而拒绝 +// 执行。兜底只需要满足上游「首条是 system」的渠道校验,正文写成身份句是自找冲突。 +package upstream + +import ( + "encoding/json" + "strings" + "testing" +) + +func firstMessage(t *testing.T, body []byte) map[string]any { + t.Helper() + var o struct { + Messages []map[string]any `json:"messages"` + } + if err := json.Unmarshal(body, &o); err != nil { + t.Fatalf("unmarshal: %v", err) + } + if len(o.Messages) == 0 { + t.Fatal("messages 为空") + } + return o.Messages[0] +} + +// TestEnsureConsoleSystemPrefersBehaviorOverIdentity 首条是 user → 前置一条只讲行为 +// 约定的 system,且不出现任何身份声明。 +func TestEnsureConsoleSystemPrefersBehaviorOverIdentity(t *testing.T) { + in := []byte(`{"model":"deepseek-v4.1-flash","messages":[{"role":"user","content":"hi"}]}`) + first := firstMessage(t, ensureConsoleSystem(in)) + + if role, _ := first["role"].(string); role != "system" { + t.Fatalf("首条 role=%q want system(上游渠道校验要求)", role) + } + content, _ := first["content"].(string) + if content != consoleSystemFallback { + t.Errorf("content=%q want %q", content, consoleSystemFallback) + } + if strings.Contains(strings.ToLower(content), "you are") { + t.Errorf("兜底 system 不该声明身份(会被模型当成注入): %q", content) + } +} + +// TestEnsureConsoleSystemLeavesSystemAlone 首条已是 system → 一个字节都不动。 +func TestEnsureConsoleSystemLeavesSystemAlone(t *testing.T) { + in := []byte(`{"model":"m","messages":[{"role":"system","content":"You are Buddy."},{"role":"user","content":"hi"}]}`) + if got := string(ensureConsoleSystem(in)); got != string(in) { + t.Errorf("首条已是 system 却被改写:\n got %s\nwant %s", got, in) + } +} diff --git a/internal/upstream/context_catalog.go b/internal/upstream/context_catalog.go index d928897fc55dc340c37549916950e16ef8786f81..0985bfb8323871aad95d42674cd8e11d4f17c3b1 100644 --- a/internal/upstream/context_catalog.go +++ b/internal/upstream/context_catalog.go @@ -1,106 +1,106 @@ -// context_catalog.go context_length / max_output_tokens 字段级静态兜底知识表。 -// -// 数据来源四级(model-json-dynamic 任务书;查找链入口在 model_catalog.go 的 -// ContextWindowListingV4 / MaxOutputTokensListingV4,本文件是第 2 级): -// - 上游动态值(ModelInfo.ContextWindow/MaxTokens,即 maxInputTokens/maxOutputTokens)权威,优先; -// - 本文件静态知识表(远端零值时补齐;model.json 缺失/损坏时的编译期兜底); -// - model.json 本地缓存(数据目录,含运行时 models.dev 按需补值,见 model_catalog.go); -// - models.dev 按需拉取(异步不阻塞;仍未知 → context_length 1M 兜底——宁可高估 -// 不低估:高估代价是客户端不截断、上游报错可重试;低估代价是下游客户端 -// (Codex/ZCode/Claude Code 按 context_length 提前截断)白白丢上下文; -// max_output_tokens 未知 → 省略字段(输出上限无合估算据,不编造))。 -// -// 知识表**一处定义、CN/global 两域共用**:context_length 是模型固有属性——fork -// 706412584 实测结论「两区是同一套 API 的两次部署」,同 id 上下文一致,无按 realm -// 分表必要(与 effort 档位的 realm 分表刻意不同)。 -// -// 值来源两类,逐条注释标注: -// - fork 实测:706412584 直连上游 /console/enterprises/personal/models 的 -// maxInputTokens(/tmp/fork_diffs/70_927f57f9.diff,2026-09-13 实测; -// global 侧无法直测、按同 id 外推); -// - models.dev:https://models.dev/ 收录值(2026-09-16 查询,取多 provider 共识值; -// 官方源如 moonshotai/zai 优先)。未收录或歧义大者不编造。 -package upstream - -// DefaultContextWindow 知识表也未收录的模型的 context_length 兜底:1M。 -// 上游多数大窗口模型的实际量级;高估优于低估(见文件头)。 -const DefaultContextWindow int64 = 1000000 - -// contextCap 一个模型的上下文能力(字段级兜底条目)。 -// context 必为正(否则条目无意义,直接走 1M 兜底); -// maxOutput 为 0 表示输出上限未知 → max_output_tokens 字段省略(不编造)。 -type contextCap struct { - context int64 - maxOutput int64 -} - -// contextCapFallback context_length / max_output_tokens 知识表(CN/global 共用)。 -// 每条注释标注来源:实测 = fork 706412584 直连 CN /console 实测 maxInputTokens -// (global 侧为同 id 外推);models.dev = 2026-09-16 收录共识值;估算 = 同族外推。 -var contextCapFallback = map[string]contextCap{ - // ---- GLM 家族(z-ai)---- - "glm-5.2": {context: 1000000, maxOutput: 131072}, // 实测(CN 1M;models.dev 共识 1M/131072) - "glm-5.1": {context: 200000, maxOutput: 131072}, // 实测(CN 200K;models.dev 共识 200K/131072) - "glm-5.3": {context: 1000000, maxOutput: 131072}, // 实测外推 + models.dev 共识 1M/131072 - "glm-5.3-flash": {context: 1000000, maxOutput: 131072}, // models.dev 共识 1M/131072 - "glm-5v-turbo": {context: 200000, maxOutput: 131072}, // 实测(CN 200K;models.dev 共识 200K/131072) - - // ---- Kimi 家族(moonshot)---- - "kimi-k2.7": {context: 256000, maxOutput: 65536}, // 实测(CN 256K);输出 65536 为 models.dev kimi-k2.7-code 同族估算 - "kimi-k2.6": {context: 256000, maxOutput: 262144}, // 实测(CN 256K);输出 models.dev 官方 262144 - "kimi-k2.5": {context: 164000, maxOutput: 262144}, // 实测(global 侧同 id 外推 164K);输出 models.dev 共识 262144 - "kimi-k3": {context: 1048576, maxOutput: 131072}, // models.dev 官方(moonshotai 1M/128K) - "kimi-k2.8-preview": {context: 1048576, maxOutput: 0}, // models.dev(Kimi K2.8 Preview 1M;输出上限未收录,省略) - - // ---- MiniMax / 混元(tencent)---- - "minimax-m3": {context: 512000, maxOutput: 512000}, // 实测(CN 512K);输出 models.dev 共识 512000 - "hy3": {context: 192000, maxOutput: 64000}, // 实测(CN 192K/64K,repo hy3 抓取样本同值) - "hy3-preview": {context: 262144, maxOutput: 64000}, // models.dev(共识 262144/64000) - "hy4-preview": {context: 1000000, maxOutput: 64000}, // 实测外推 + models.dev(~1M/64000) - "hy4-preview-x": {context: 1000000, maxOutput: 64000}, // 实测外推(1M);输出同族 hy4-preview 估算 - - // ---- DeepSeek 家族 ---- - "deepseek-v4-pro": {context: 1000000, maxOutput: 384000}, // 实测(CN 1M;models.dev 共识 1M/384000) - "deepseek-v4-flash": {context: 1000000, maxOutput: 384000}, // 实测(CN 1M;models.dev 共识 1M/384000) - "deepseek-v4.1-flash": {context: 1000000, maxOutput: 384000}, // 实测外推 + models.dev 共识 1M/384000 - - // ---- OpenAI / Google(global 域家族)---- - "gpt-6-astra": {context: 1050000, maxOutput: 128000}, // models.dev(全 provider 一致 1050000/128000) - "gpt-5.6-sol": {context: 1050000, maxOutput: 128000}, // models.dev 共识 - "gpt-5.6-terra": {context: 1050000, maxOutput: 128000}, // models.dev 共识 - "gpt-5.6-luna": {context: 1050000, maxOutput: 128000}, // models.dev 共识 - "gpt-5.5": {context: 1050000, maxOutput: 128000}, // models.dev 共识 - "gpt-5.4": {context: 1050000, maxOutput: 128000}, // models.dev 共识 - "gpt-5.3-codex": {context: 400000, maxOutput: 128000}, // models.dev(全 provider 一致 400000/128000) - "gemini-3.5-flash": {context: 1048576, maxOutput: 65536}, // models.dev 共识 - - // ---- global 域路由别名/别名模型 ---- - "auto": {context: 168000, maxOutput: 0}, // 实测外推(fork global 静态表 168K);输出上限未知,省略 -} - -// ContextWindowListing 模型在 /v1/models 的 context_length(三级查找): -// remote(上游 maxInputTokens)>0 时权威;否则查知识表;仍未收录 → DefaultContextWindow -// (1M,宁可高估不低估)。绝不再透出假 131072。 -func ContextWindowListing(model string, remote int64) int64 { - if remote > 0 { - return remote - } - if cap, ok := contextCapFallback[model]; ok && cap.context > 0 { - return cap.context - } - return DefaultContextWindow -} - -// MaxOutputTokensListing 模型在 /v1/models 的 max_output_tokens(三级查找): -// remote(上游 maxOutputTokens)>0 时权威;否则查知识表;仍未收录 → ok=false -// (调用方省略字段,不编造输出上限)。与 ContextWindowListing 的 1M 兜底刻意不同: -// 输出上限无「宁可高估」的安全侧,未知即省略。 -func MaxOutputTokensListing(model string, remote int64) (int64, bool) { - if remote > 0 { - return remote, true - } - if cap, ok := contextCapFallback[model]; ok && cap.maxOutput > 0 { - return cap.maxOutput, true - } - return 0, false -} +// context_catalog.go context_length / max_output_tokens 字段级静态兜底知识表。 +// +// 数据来源四级(model-json-dynamic 任务书;查找链入口在 model_catalog.go 的 +// ContextWindowListingV4 / MaxOutputTokensListingV4,本文件是第 2 级): +// - 上游动态值(ModelInfo.ContextWindow/MaxTokens,即 maxInputTokens/maxOutputTokens)权威,优先; +// - 本文件静态知识表(远端零值时补齐;model.json 缺失/损坏时的编译期兜底); +// - model.json 本地缓存(数据目录,含运行时 models.dev 按需补值,见 model_catalog.go); +// - models.dev 按需拉取(异步不阻塞;仍未知 → context_length 1M 兜底——宁可高估 +// 不低估:高估代价是客户端不截断、上游报错可重试;低估代价是下游客户端 +// (Codex/ZCode/Claude Code 按 context_length 提前截断)白白丢上下文; +// max_output_tokens 未知 → 省略字段(输出上限无合估算据,不编造))。 +// +// 知识表**一处定义、CN/global 两域共用**:context_length 是模型固有属性——fork +// 706412584 实测结论「两区是同一套 API 的两次部署」,同 id 上下文一致,无按 realm +// 分表必要(与 effort 档位的 realm 分表刻意不同)。 +// +// 值来源两类,逐条注释标注: +// - fork 实测:706412584 直连上游 /console/enterprises/personal/models 的 +// maxInputTokens(/tmp/fork_diffs/70_927f57f9.diff,2026-09-13 实测; +// global 侧无法直测、按同 id 外推); +// - models.dev:https://models.dev/ 收录值(2026-09-16 查询,取多 provider 共识值; +// 官方源如 moonshotai/zai 优先)。未收录或歧义大者不编造。 +package upstream + +// DefaultContextWindow 知识表也未收录的模型的 context_length 兜底:1M。 +// 上游多数大窗口模型的实际量级;高估优于低估(见文件头)。 +const DefaultContextWindow int64 = 1000000 + +// contextCap 一个模型的上下文能力(字段级兜底条目)。 +// context 必为正(否则条目无意义,直接走 1M 兜底); +// maxOutput 为 0 表示输出上限未知 → max_output_tokens 字段省略(不编造)。 +type contextCap struct { + context int64 + maxOutput int64 +} + +// contextCapFallback context_length / max_output_tokens 知识表(CN/global 共用)。 +// 每条注释标注来源:实测 = fork 706412584 直连 CN /console 实测 maxInputTokens +// (global 侧为同 id 外推);models.dev = 2026-09-16 收录共识值;估算 = 同族外推。 +var contextCapFallback = map[string]contextCap{ + // ---- GLM 家族(z-ai)---- + "glm-5.2": {context: 1000000, maxOutput: 131072}, // 实测(CN 1M;models.dev 共识 1M/131072) + "glm-5.1": {context: 200000, maxOutput: 131072}, // 实测(CN 200K;models.dev 共识 200K/131072) + "glm-5.3": {context: 1000000, maxOutput: 131072}, // 实测外推 + models.dev 共识 1M/131072 + "glm-5.3-flash": {context: 1000000, maxOutput: 131072}, // models.dev 共识 1M/131072 + "glm-5v-turbo": {context: 200000, maxOutput: 131072}, // 实测(CN 200K;models.dev 共识 200K/131072) + + // ---- Kimi 家族(moonshot)---- + "kimi-k2.7": {context: 256000, maxOutput: 65536}, // 实测(CN 256K);输出 65536 为 models.dev kimi-k2.7-code 同族估算 + "kimi-k2.6": {context: 256000, maxOutput: 262144}, // 实测(CN 256K);输出 models.dev 官方 262144 + "kimi-k2.5": {context: 164000, maxOutput: 262144}, // 实测(global 侧同 id 外推 164K);输出 models.dev 共识 262144 + "kimi-k3": {context: 1048576, maxOutput: 131072}, // models.dev 官方(moonshotai 1M/128K) + "kimi-k2.8-preview": {context: 1048576, maxOutput: 0}, // models.dev(Kimi K2.8 Preview 1M;输出上限未收录,省略) + + // ---- MiniMax / 混元(tencent)---- + "minimax-m3": {context: 512000, maxOutput: 512000}, // 实测(CN 512K);输出 models.dev 共识 512000 + "hy3": {context: 192000, maxOutput: 64000}, // 实测(CN 192K/64K,repo hy3 抓取样本同值) + "hy3-preview": {context: 262144, maxOutput: 64000}, // models.dev(共识 262144/64000) + "hy4-preview": {context: 1000000, maxOutput: 64000}, // 实测外推 + models.dev(~1M/64000) + "hy4-preview-x": {context: 1000000, maxOutput: 64000}, // 实测外推(1M);输出同族 hy4-preview 估算 + + // ---- DeepSeek 家族 ---- + "deepseek-v4-pro": {context: 1000000, maxOutput: 384000}, // 实测(CN 1M;models.dev 共识 1M/384000) + "deepseek-v4-flash": {context: 1000000, maxOutput: 384000}, // 实测(CN 1M;models.dev 共识 1M/384000) + "deepseek-v4.1-flash": {context: 1000000, maxOutput: 384000}, // 实测外推 + models.dev 共识 1M/384000 + + // ---- OpenAI / Google(global 域家族)---- + "gpt-6-astra": {context: 1050000, maxOutput: 128000}, // models.dev(全 provider 一致 1050000/128000) + "gpt-5.6-sol": {context: 1050000, maxOutput: 128000}, // models.dev 共识 + "gpt-5.6-terra": {context: 1050000, maxOutput: 128000}, // models.dev 共识 + "gpt-5.6-luna": {context: 1050000, maxOutput: 128000}, // models.dev 共识 + "gpt-5.5": {context: 1050000, maxOutput: 128000}, // models.dev 共识 + "gpt-5.4": {context: 1050000, maxOutput: 128000}, // models.dev 共识 + "gpt-5.3-codex": {context: 400000, maxOutput: 128000}, // models.dev(全 provider 一致 400000/128000) + "gemini-3.5-flash": {context: 1048576, maxOutput: 65536}, // models.dev 共识 + + // ---- global 域路由别名/别名模型 ---- + "auto": {context: 168000, maxOutput: 0}, // 实测外推(fork global 静态表 168K);输出上限未知,省略 +} + +// ContextWindowListing 模型在 /v1/models 的 context_length(三级查找): +// remote(上游 maxInputTokens)>0 时权威;否则查知识表;仍未收录 → DefaultContextWindow +// (1M,宁可高估不低估)。绝不再透出假 131072。 +func ContextWindowListing(model string, remote int64) int64 { + if remote > 0 { + return remote + } + if cap, ok := contextCapFallback[model]; ok && cap.context > 0 { + return cap.context + } + return DefaultContextWindow +} + +// MaxOutputTokensListing 模型在 /v1/models 的 max_output_tokens(三级查找): +// remote(上游 maxOutputTokens)>0 时权威;否则查知识表;仍未收录 → ok=false +// (调用方省略字段,不编造输出上限)。与 ContextWindowListing 的 1M 兜底刻意不同: +// 输出上限无「宁可高估」的安全侧,未知即省略。 +func MaxOutputTokensListing(model string, remote int64) (int64, bool) { + if remote > 0 { + return remote, true + } + if cap, ok := contextCapFallback[model]; ok && cap.maxOutput > 0 { + return cap.maxOutput, true + } + return 0, false +} diff --git a/internal/upstream/contextwindow_test.go b/internal/upstream/contextwindow_test.go new file mode 100644 index 0000000000000000000000000000000000000000..29069ffd4766a8d64b1404cd10d4c39c2f028509 --- /dev/null +++ b/internal/upstream/contextwindow_test.go @@ -0,0 +1,147 @@ +// contextwindow_test.go 5.9.3 新增的 contextWindow 段解析(上下文档位可选项)。 +// +// 上游形状(2026-10-29 真机 /v3/config 实测): +// +// "contextWindow": {"defaultLength": 400000, "supportedLengths": [400000, 1000000]} +// +// CN 17 个模型 / global 3 个模型带该段。它与 maxInputTokens 不是同一口径: +// maxInputTokens 是当前生效上限,supportedLengths 是客户端**可切换**的档位。 +package upstream + +import ( + "encoding/json" + "net/http" + "net/http/httptest" + "strings" + "testing" + + "github.com/misakano7545/workbuddy2api-panel/internal/auth" +) + +// TestContextWindowParsedFromConfig contextWindow 段必须落进 ModelInfo 的两个新字段。 +func TestContextWindowParsedFromConfig(t *testing.T) { + prev := auth.GlobalEnabled() + auth.SetGlobalEnabled(true) + defer auth.SetGlobalEnabled(prev) + + srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { + if !strings.HasSuffix(r.URL.Path, "/v3/config") { + w.WriteHeader(http.StatusInternalServerError) + return + } + _ = json.NewEncoder(w).Encode(map[string]any{"code": 0, "data": map[string]any{ + "models": []map[string]any{ + { + "id": "gpt-6-astra", "maxInputTokens": 1000000, "maxOutputTokens": 128000, + "contextWindow": map[string]any{ + "defaultLength": 400000, + "supportedLengths": []int{400000, 1000000}, + }, + }, + // 没有 contextWindow 段:两个新字段必须留零值,不得编造档位。 + {"id": "hy3", "maxInputTokens": 192000, "maxOutputTokens": 64000}, + }, + }}) + })) + defer srv.Close() + + c := New() + c.HTTP = srv.Client() + c.ChatBaseGlobal = srv.URL + c.GlobalEnabled = true + + infos := c.FetchGlobalModelInfos(&auth.Auth{UID: "g1", AccessToken: "at", Domain: "www.workbuddy.ai"}) + byID := map[string]ModelInfo{} + for _, mi := range infos { + byID[mi.ID] = mi + } + astra, ok := byID["gpt-6-astra"] + if !ok { + t.Fatalf("目录里没有 gpt-6-astra(拿到 %v)", byID) + } + if astra.ContextWindowDefault != 400000 { + t.Errorf("ContextWindowDefault=%d want 400000", astra.ContextWindowDefault) + } + if len(astra.ContextWindowSupported) != 2 || + astra.ContextWindowSupported[0] != 400000 || astra.ContextWindowSupported[1] != 1000000 { + t.Errorf("ContextWindowSupported=%v want [400000 1000000]", astra.ContextWindowSupported) + } + hy3 := byID["hy3"] + if hy3.ContextWindowDefault != 0 || len(hy3.ContextWindowSupported) != 0 { + t.Errorf("无 contextWindow 段时不得编造档位: default=%d supported=%v", + hy3.ContextWindowDefault, hy3.ContextWindowSupported) + } +} + +// TestContextWindowIgnoresZeroLengths 全 0 / 空数组等于「上游没声明档位」: +// 必须当作没有,而不是输出 {"default":0,"supported":[]}(下游会读成"只有 0 token")。 +func TestContextWindowIgnoresZeroLengths(t *testing.T) { + e := dynModelEntry{ID: "m"} + e.ContextWindow = &struct { + DefaultLength int64 `json:"defaultLength"` + SupportedLengths []int64 `json:"supportedLengths"` + }{DefaultLength: 0, SupportedLengths: []int64{0, 0}} + mi := e.modelInfo() + if mi.ContextWindowDefault != 0 || len(mi.ContextWindowSupported) != 0 { + t.Fatalf("零值档位不得透出: %+v", mi) + } +} + +// TestGlobalEffortFallbackMatches59Catalog 国际版静态兜底表必须与 5.9.3 实测目录一致: +// 新上架模型有档位可报,已下架模型不再占位。 +// +// 静态表只在「远端 effort 桶取不到」时生效;错了的代价是按不存在的档位降级 +// (把请求打到上游 400 非法参数)。 +func TestGlobalEffortFallbackMatches59Catalog(t *testing.T) { + want := map[string][]string{ + "fast-model": {"medium"}, + "balanced-model": {"medium"}, + "primary-model": {"high"}, + "glm-5.3-flash": {"low", "high", "max"}, + "kimi-k3.1-pro": {"low", "high", "max"}, + "kimi-k3.1-pro-highspeed": {"low", "high", "max"}, + "minimax-m3.1-flash": {"low", "medium", "high", "xhigh", "max"}, + "gpt-6-sol": {"low", "medium", "high", "xhigh"}, + "gpt-6.1-sol": {"low", "medium", "high", "xhigh"}, + "gemini-3.8-flash": {"low", "medium", "high"}, + "grok-4.7": {"low", "medium", "high", "xhigh"}, + "hy4-preview": {"high"}, + "deepseek-v4.1-flash-sg": {"low", "high", "max"}, + } + for id, efforts := range want { + cap := staticEffortCap("global", id) + if strings.Join(cap.efforts, ",") != strings.Join(efforts, ",") { + t.Errorf("%s efforts=%v want %v", id, cap.efforts, efforts) + } + } + // 2026-10-29 目录里已经没有这些 id:留着静态档位等于给不存在的模型发档位。 + for _, gone := range []string{"gpt-5.5", "gpt-5.4", "gpt-5.3-codex", "gemini-3.5-flash", "kimi-k2.6", "glm-5.2", "hy4-preview-f"} { + if cap := staticEffortCap("global", gone); len(cap.efforts) != 0 { + t.Errorf("%s 已下架,静态兜底表不该再给它档位 %v", gone, cap.efforts) + } + } +} + +// TestGlobalModelNamesMatches59Catalog 历史名单必须与实际目录同代, +// 否则拿它做差集参照会得出一半假差异。 +func TestGlobalModelNamesMatches59Catalog(t *testing.T) { + want := map[string]bool{ + "default-model": true, "fast-model": true, "balanced-model": true, "primary-model": true, + "deepseek-v4.1-flash": true, "deepseek-v4.1-flash-sg": true, + "glm-5.3": true, "glm-5.3-flash": true, "hy4-preview": true, "hy3": true, + "kimi-k3": true, "kimi-k3.1-pro": true, "kimi-k3.1-pro-highspeed": true, + "minimax-m3.1-flash": true, + "gpt-5.6-sol": true, "gpt-5.6-terra": true, "gpt-5.6-luna": true, + "gpt-6-astra": true, "gpt-6-sol": true, "gpt-6-luna": true, "gpt-6.1-sol": true, + "gemini-3.8-flash": true, "grok-4.7": true, + "hy-image-3.5": true, "kling-video-v3": true, + } + if len(GlobalModelNames) != len(want) { + t.Fatalf("GlobalModelNames 有 %d 条 want %d(5.9.3 实测)", len(GlobalModelNames), len(want)) + } + for _, id := range GlobalModelNames { + if !want[id] { + t.Errorf("GlobalModelNames 含 5.9.3 目录里没有的 %q", id) + } + } +} diff --git a/internal/upstream/conv_fields.go b/internal/upstream/conv_fields.go new file mode 100644 index 0000000000000000000000000000000000000000..a21502d2f6990370b8bd1f629b23bf97d116a9c7 --- /dev/null +++ b/internal/upstream/conv_fields.go @@ -0,0 +1,100 @@ +// conv_fields.go 把会话轮级字段写进出站消息体,对齐官方桌面端的 chat body 形态 +// (issue #51 body 侧)。 +// +// 官方实测(国际版 5.8.4 / 国内版 5.8.3 同构,见 capture/raw3、capture/raw8): +// +// messages[i] = { +// "role": "user", +// "content": [{"type":"text","text":"..."}], +// "agent": "cli", +// "conversationRequestId": "<该轮的 X-Conversation-Request-ID>", ← 轮级 +// "startsNewUserRequest": true, +// } +// messages[i] = { // assistant +// "role": "assistant", ..., "conversationRequestId": "<产出它的那一轮>", +// "messageId": "<那条消息的 X-Request-ID>", "traceId": ..., +// "model"/"requestModelId"/"requestModelName"/"usage"/"rawUsage"/"reasoning"/"stepSeq" +// } +// +// 也就是说:客户端把「这一轮属于哪个 request-id」同时写在**头**和**体**里。 +// 网关之前只写了头,body 里一条都没有——头体不一致本身就是可判别的形态。 +// +// 边界(不伪造): +// - 只给「当前轮」的最后一条 user 消息写 conversationRequestId; +// - 历史消息的轮级 ID 客户端没给(OpenAI 协议无此字段),网关无从得知,**不编造**—— +// 宁可少写,也不写一个对不上的值(对不上的 ID 比缺失更容易被关联分析抓出来); +// - assistant 消息的 messageId / usage / model 等由真实调用产出,历史部分同样不补。 +package upstream + +import ( + "encoding/json" + "strings" +) + +// agentCLI 官方 chat 出站每条消息都带的 agent 段(两版实测均为 `cli`)。 +const agentCLI = "cli" + +// injectConversationFields 在已改写的出站 body 上补会话轮级字段(字节入口)。 +// +// 热路径不走这里:prepareBodyOpt 已经持有解析好的 obj,注入与它的序列化合并成 +// 一次(见 injectConversationFieldsObj)。本函数保留给测试与独立调用方。 +func injectConversationFields(body []byte, convReqID string) []byte { + if len(body) == 0 || convReqID == "" { + return body + } + var obj map[string]any + if err := json.Unmarshal(body, &obj); err != nil { + return body + } + if !injectConversationFieldsObj(obj, convReqID) { + return body + } + out, err := json.Marshal(obj) + if err != nil { + return body + } + return out +} + +// injectConversationFieldsObj 在已解析的 obj 上补会话轮级字段,返回是否改动。 +// convReqID 为空或没有可写的当前轮时不改动(不写空值、不凭空造消息)。 +func injectConversationFieldsObj(obj map[string]any, convReqID string) bool { + if obj == nil || convReqID == "" { + return false + } + msgs, ok := obj["messages"].([]any) + if !ok || len(msgs) == 0 { + return false + } + // 找最后一条 user 消息:它就是「当前轮」的起点(官方 startsNewUserRequest 语义)。 + idx := -1 + for i := len(msgs) - 1; i >= 0; i-- { + m, ok := msgs[i].(map[string]any) + if !ok { + continue + } + if role, _ := m["role"].(string); strings.EqualFold(role, "user") { + idx = i + break + } + } + if idx < 0 { + return false + } + cur, ok := msgs[idx].(map[string]any) + if !ok { + return false + } + // 客户端若已自带(OpenAI 兼容网关转发官方 body 的场景)→ 原值优先,不覆盖。 + if v, _ := cur["conversationRequestId"].(string); v != "" { + return false + } + cur["conversationRequestId"] = convReqID + cur["startsNewUserRequest"] = true + if v, _ := cur["agent"].(string); v == "" { + cur["agent"] = agentCLI + } + msgs[idx] = cur + obj["messages"] = msgs + return true +} diff --git a/internal/upstream/conv_fields_test.go b/internal/upstream/conv_fields_test.go new file mode 100644 index 0000000000000000000000000000000000000000..0413b4f286f0a79a3a29b085e334e7f3cdfe56bf --- /dev/null +++ b/internal/upstream/conv_fields_test.go @@ -0,0 +1,112 @@ +package upstream + +import ( + "encoding/json" + "regexp" + "strings" + "testing" +) + +// TestInjectConversationFields_LastUserMessage 钉住 body 侧会话字段的放置规则: +// 只给「当前轮」的最后一条 user 消息写 conversationRequestId / startsNewUserRequest / +// agent,历史消息不编造(官方历史消息的轮级 ID 网关无从得知)。 +func TestInjectConversationFields_LastUserMessage(t *testing.T) { + in := `{"model":"glm-5.2","messages":[ + {"role":"system","content":"s"}, + {"role":"user","content":"第一轮"}, + {"role":"assistant","content":"答"}, + {"role":"user","content":"第二轮"} + ]}` + out := injectConversationFields([]byte(in), "01a160ff00007fff8000000000000001") + + var obj struct { + Messages []map[string]any `json:"messages"` + } + if err := json.Unmarshal(out, &obj); err != nil { + t.Fatalf("unmarshal: %v", err) + } + if got := obj.Messages[3]["conversationRequestId"]; got != "01a160ff00007fff8000000000000001" { + t.Fatalf("最后一条 user 必须带本轮 ID,got=%v", got) + } + if got := obj.Messages[3]["startsNewUserRequest"]; got != true { + t.Fatalf("startsNewUserRequest 必须为 true,got=%v", got) + } + if got := obj.Messages[3]["agent"]; got != "cli" { + t.Fatalf("agent 必须为 cli,got=%v", got) + } + // 历史 user 消息不补(不编造对不上的 ID) + if _, ok := obj.Messages[1]["conversationRequestId"]; ok { + t.Fatal("历史 user 消息不应被写入 conversationRequestId") + } + // system / assistant 不动 + if _, ok := obj.Messages[0]["agent"]; ok { + t.Fatal("system 消息不应被写入 agent") + } +} + +// TestInjectConversationFields_PreservesClientValue 客户端自带轮级 ID 时原值优先。 +func TestInjectConversationFields_PreservesClientValue(t *testing.T) { + in := `{"messages":[{"role":"user","content":"x","conversationRequestId":"client-turn-id"}]}` + out := injectConversationFields([]byte(in), "gateway-turn-id") + if !strings.Contains(string(out), "client-turn-id") { + t.Fatalf("客户端原值被覆盖: %s", out) + } +} + +// TestInjectConversationFields_NoConversationRequestID 空 ID 时原样返回(不写空值)。 +func TestInjectConversationFields_NoConversationRequestID(t *testing.T) { + in := `{"messages":[{"role":"user","content":"x"}]}` + out := injectConversationFields([]byte(in), "") + if string(out) != in { + t.Fatalf("空 ID 不应改 body:\n in=%s\nout=%s", in, out) + } +} + +// TestInjectConversationFields_BadJSON 坏 body 原样返回(不二次错误化)。 +func TestInjectConversationFields_BadJSON(t *testing.T) { + in := `not json` + if out := injectConversationFields([]byte(in), "id"); string(out) != in { + t.Fatalf("坏 body 被改动: %s", out) + } +} + +// TestACPConnectionIDShape acp-connection-id 必须与会话 ID 同形但不同值: +// 官方在 applyGatewayHeaders 里把它与 X-Conversation-ID 并列设置,值来自会话注册表 +// (每 session 一个,同会话稳定、跨会话不同)。 +// +// 2026-10-28 修正形态:此前断言的是 UUID v4(`xxxx-4xxx`),而真机两者都是 +// **UUIDv7**(`01a1815d-dacf-75f1-…`,第 13 位恒 7、前 48 bit 是操作时刻)—— +// 派生值摆 v4 位是与真机相反的形态特征,故改走 buildTimeOrderedUUID。 +func TestACPConnectionIDShape(t *testing.T) { + uid, conv := "85329a86-a3e7-448a-9666-ec34e0bdfb67", "conv-1" + sess := buildCacheKey(uid, conv) // prompt_cache_key 槽(v4,历史值零漂移) + convHdr := buildTimeOrderedUUID(uid, conv, "") // X-Conversation-ID 派生形态 + acp := buildTimeOrderedUUID(uid, conv, "acp") // acp-connection-id + uuid4 := regexp.MustCompile(`^[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$`) + for name, got := range map[string]string{"X-Conversation-ID": convHdr, "acp-connection-id": acp} { + if !uuid7.MatchString(got) { + t.Fatalf("%s 必须 UUIDv7 形态(真机恒 01a1815d-…): %q", name, got) + } + } + if !uuid4.MatchString(sess) { + t.Fatalf("buildCacheKey 应保持 v4 形态(prompt_cache_key 槽位不漂移): %q", sess) + } + if acp == convHdr { + t.Fatal("acp-connection-id 不能与会话 ID 同值(官方是两个独立值)") + } + // 同 (账号, 会话) 稳定 + if again := buildTimeOrderedUUID(uid, conv, "acp"); again != acp { + t.Fatalf("acp-connection-id 不稳定: %q vs %q", acp, again) + } + // 跨会话不同 + if other := buildTimeOrderedUUID(uid, "conv-2", "acp"); other == acp { + t.Fatal("不同会话不该共用 acp-connection-id") + } + // purpose 为空时与 buildCacheKey 的**输入**一致(同签名,只是位布局不同 → 值不同是预期的) + if buildStableUUID(uid, conv, "") != sess { + t.Fatal("buildStableUUID(purpose=\"\") 必须等于 buildCacheKey") + } +} + +// uuid7 v7 形态正则(与 cn_contract_test.go 的 uuidV7Re 同义,此处独立便于单测引用)。 +var uuid7 = regexp.MustCompile(`^[0-9a-f]{8}-[0-9a-f]{4}-7[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$`) diff --git a/internal/upstream/conversation_headers_test.go b/internal/upstream/conversation_headers_test.go new file mode 100644 index 0000000000000000000000000000000000000000..0bb385f1ebab5704160ecad99f8abe754f1dc38d --- /dev/null +++ b/internal/upstream/conversation_headers_test.go @@ -0,0 +1,51 @@ +// conversation_headers_test.go chat 出站渠道校验三件套的不变量。 +// +// 上游按 X-Conversation-ID / Request-ID / Message-ID 是否**齐全**做渠道校验,缺任一头 +// 即 400 code=11-128 "conversation id missing"(官方客户端 chat 与 speech 都带)。 +// 零值 ChatMeta 的调用方(夜猫子对话、面板模型任务)与手搓头的桌面指纹路径是历史缺口, +// 这里钉住「chat 出站必发三件套」,防止将来某条路径又悄悄留空。 +package upstream + +import ( + "net/http" + "testing" + + "github.com/misakano7545/workbuddy2api-panel/internal/auth" +) + +func TestChatHeadersAlwaysSendConversationTrio(t *testing.T) { + c := &Client{} + trio := []string{"X-Conversation-ID", "X-Conversation-Request-ID", "X-Conversation-Message-ID"} + cases := []struct { + name string + meta ChatMeta + }{ + {"零值 ChatMeta", ChatMeta{}}, + {"只有轮级主键", ChatMeta{ConversationRequestID: "req-1"}}, + {"客户端声明会话", ChatMeta{ConversationID: "conv-client"}}, + {"只有缓存键来源", ChatMeta{CacheKeyID: "sess-1"}}, + } + for _, tc := range cases { + req, err := http.NewRequest(http.MethodPost, "https://example.invalid/v2/chat/completions", nil) + if err != nil { + t.Fatal(err) + } + c.ChatHeaders(req, &auth.Auth{UID: "uid-abcdef123", AccessToken: "at"}, "", tc.meta) + for _, h := range trio { + if req.Header.Get(h) == "" { + t.Errorf("%s: 缺 %s(上游渠道校验要求三件套齐全)", tc.name, h) + } + } + } +} + +// TestChatHeadersConversationIDPrefersClientValue 透传优先:客户端声明的会话值不得被改写 +// (该头同时是前缀缓存槽来源,issue #169)。 +func TestChatHeadersConversationIDPrefersClientValue(t *testing.T) { + c := &Client{} + req, _ := http.NewRequest(http.MethodPost, "https://example.invalid/v2/chat/completions", nil) + c.ChatHeaders(req, &auth.Auth{UID: "uid-abcdef123", AccessToken: "at"}, "", ChatMeta{ConversationID: "conv-from-client"}) + if got := req.Header.Get("X-Conversation-ID"); got != "conv-from-client" { + t.Errorf("X-Conversation-ID=%q want 原值透传", got) + } +} diff --git a/internal/upstream/credit_observer_test.go b/internal/upstream/credit_observer_test.go new file mode 100644 index 0000000000000000000000000000000000000000..6e32da2cfcf1ce3896b281e3a5211d937af790b1 --- /dev/null +++ b/internal/upstream/credit_observer_test.go @@ -0,0 +1,109 @@ +package upstream + +import ( + "errors" + "net/http" + "strings" + "testing" + + "github.com/misakano7545/workbuddy2api-panel/internal/auth" +) + +// 余额查询成功必须通知观察者一次(uid + 余额):这是积分历史留痕的唯一数据入口。 +func TestCreditObserverNotifiedOncePerQuery(t *testing.T) { + payload := `{"code":0,"data":{"Response":{"Data":{"Accounts":[` + + `{"PackageName":"p","CycleCapacitySize":30,"CycleCapacityRemain":30,"CycleCapacityUsed":0}` + + `]}}}}` + c := testClient(func(r *http.Request) (*http.Response, error) { + if !strings.HasSuffix(r.URL.Path, "/v2/billing/meter/get-user-resource") { + return nil, errors.New("wrong path: " + r.URL.Path) + } + return jsonResp(200, payload), nil + }) + type call struct { + uid string + credits int64 + } + var calls []call + c.SetCreditObserver(func(uid string, credits int64) { calls = append(calls, call{uid, credits}) }) + + remain, _, _, _, _, err := c.UserResourceDetailedWithExpiry(&auth.Auth{AccessToken: "at", UID: "u1"}, 0) + if err != nil { + t.Fatalf("resource: %v", err) + } + if remain != 30 { + t.Fatalf("remain=%d want 30", remain) + } + if len(calls) != 1 || calls[0].uid != "u1" || calls[0].credits != 30 { + t.Fatalf("观察者应被回调一次 (u1,30),得到 %+v", calls) + } + + // UserResource / UserResourceDetailed 都是委托调用:每次查询只回调一次,不重复。 + if _, _, err := c.UserResource(&auth.Auth{AccessToken: "at", UID: "u2"}); err != nil { + t.Fatalf("resource: %v", err) + } + if len(calls) != 2 || calls[1].uid != "u2" || calls[1].credits != 30 { + t.Fatalf("委托路径应恰好再回调一次,得到 %+v", calls) + } +} + +// 查询失败不通知:错误路径返回的 0 余额若被留痕,会在下一次成功时造出一条假变动。 +// 用业务错误(code!=0)注入而不是非法 JSON:后者会被重试策略当成瞬时错误, +// 白白等满 6s 退避(见 retryBillingTransient)。 +func TestCreditObserverSilentOnBusinessError(t *testing.T) { + c := testClient(func(r *http.Request) (*http.Response, error) { + return jsonResp(200, `{"code":400,"msg":"bad request"}`), nil + }) + n := 0 + c.SetCreditObserver(func(string, int64) { n++ }) + if _, _, _, _, _, err := c.UserResourceDetailedWithExpiry(&auth.Auth{AccessToken: "at", UID: "u1"}, 0); err == nil { + t.Fatal("业务错误应返回错误") + } + if n != 0 { + t.Fatalf("失败不应通知观察者,得到 %d 次", n) + } +} + +// 未挂载 / 注销观察者时必须零开销且不 panic(观察者是可选旁路,不得改变既有行为)。 +func TestCreditObserverOptionalAndDetachable(t *testing.T) { + payload := `{"code":0,"data":{"Response":{"Data":{"Accounts":[]}}}}` + c := testClient(func(r *http.Request) (*http.Response, error) { + return jsonResp(200, payload), nil + }) + if _, _, _, _, _, err := c.UserResourceDetailedWithExpiry(&auth.Auth{AccessToken: "at", UID: "u1"}, 0); err != nil { + t.Fatalf("未挂载观察者时查询应正常: %v", err) + } + n := 0 + c.SetCreditObserver(func(string, int64) { n++ }) + if _, _, _, _, _, err := c.UserResourceDetailedWithExpiry(&auth.Auth{AccessToken: "at", UID: "u1"}, 0); err != nil { + t.Fatal(err) + } + if n != 1 { + t.Fatalf("挂载后应通知 1 次,得到 %d", n) + } + c.SetCreditObserver(nil) + if _, _, _, _, _, err := c.UserResourceDetailedWithExpiry(&auth.Auth{AccessToken: "at", UID: "u1"}, 0); err != nil { + t.Fatal(err) + } + if n != 1 { + t.Fatalf("注销后不应再通知,得到 %d", n) + } +} + +// 观察者是纯旁路:它 panic 绝不能打断余额查询主流程——调度器 goroutine 里未恢复的 +// panic 会直接带走整个进程。recover 之后查询结果必须照常返回。 +func TestCreditObserverPanicIsContained(t *testing.T) { + payload := `{"code":0,"data":{"Response":{"Data":{"Accounts":[{"PackageName":"p","CycleCapacitySize":30,"CycleCapacityRemain":30,"CycleCapacityUsed":0}]}}}}` + c := testClient(func(r *http.Request) (*http.Response, error) { + return jsonResp(200, payload), nil + }) + c.SetCreditObserver(func(string, int64) { panic("observer boom") }) + + remain, _, _, _, _, err := c.UserResourceDetailedWithExpiry(&auth.Auth{AccessToken: "at", UID: "u1"}, 0) + if err != nil { + t.Fatalf("观察者 panic 不应影响查询: %v", err) + } + if remain != 30 { + t.Fatalf("remain=%d want 30", remain) + } +} diff --git a/internal/upstream/decode_body_test.go b/internal/upstream/decode_body_test.go new file mode 100644 index 0000000000000000000000000000000000000000..1e74a99aa6cda29c7bc6549a40d3a7383f49b07d --- /dev/null +++ b/internal/upstream/decode_body_test.go @@ -0,0 +1,135 @@ +// decode_body_test.go 响应体解压的回归(Accept-Encoding 显式声明后的必需配套)。 +// +// 触发条件:CommonHeaders 现在显式声明 `gzip, compress, deflate, br`, +// net/http 因此**不再透明解压**。若 decodeResponseBody 有洞,所有走 doJSON +// 的接口全部解析失败——这不是「一个头的优化」,是链路级前提。 +package upstream + +import ( + "bytes" + "compress/flate" + "compress/gzip" + "compress/zlib" + "encoding/json" + "net/http" + "net/http/httptest" + "testing" + + "github.com/andybalholm/brotli" + "github.com/misakano7545/workbuddy2api-panel/internal/auth" +) + +const decodeTestJSON = `{"code":0,"msg":"OK","data":{"hello":"world"}}` + +// encodeWith 按 (header 声明的编码, 实际压缩方式) 造响应体。 +// +// 注意 deflate 的坑:RFC 7230 说 `deflate` = zlib 包装,但相当多的服务端 +// 直接发裸 flate。两种都必须能解,而 Header 里写的都是 `deflate`。 +func encodeWith(t *testing.T, mode string) (headerEnc string, body []byte) { + t.Helper() + var buf bytes.Buffer + switch mode { + case "gzip": + w := gzip.NewWriter(&buf) + w.Write([]byte(decodeTestJSON)) + w.Close() + return "gzip", buf.Bytes() + case "br": + w := brotli.NewWriter(&buf) + w.Write([]byte(decodeTestJSON)) + w.Close() + return "br", buf.Bytes() + case "deflate": // zlib 包装 + w := zlib.NewWriter(&buf) + w.Write([]byte(decodeTestJSON)) + w.Close() + return "deflate", buf.Bytes() + case "deflate-raw": // 裸 flate,Header 仍写 deflate + w, _ := flate.NewWriter(&buf, flate.DefaultCompression) + w.Write([]byte(decodeTestJSON)) + w.Close() + return "deflate", buf.Bytes() + default: + return "", []byte(decodeTestJSON) + } +} + +// TestDoJSONDecodesAllEncodings 各种编码都必须解回同一个 JSON。 +func TestDoJSONDecodesAllEncodings(t *testing.T) { + for _, mode := range []string{"", "gzip", "br", "deflate", "deflate-raw"} { + t.Run(mode, func(t *testing.T) { + headerEnc, body := encodeWith(t, mode) + srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { + // 断言请求确实带上了我们声明的 Accept-Encoding + if got := r.Header.Get("Accept-Encoding"); got != "gzip, compress, deflate, br" { + t.Errorf("Accept-Encoding=%q want gzip, compress, deflate, br", got) + } + if headerEnc != "" { + w.Header().Set("Content-Encoding", headerEnc) + } + w.Header().Set("Content-Type", "application/json") + w.Write(body) + })) + defer srv.Close() + + c := New() + c.ChatBaseCN = srv.URL + req, _ := http.NewRequest(http.MethodPost, srv.URL+"/v2/test", bytes.NewReader([]byte(`{}`))) + c.CommonHeaders(req, &auth.Auth{UID: "u1", AccessToken: "at"}) + + data, err := c.doJSON(req, &auth.Auth{UID: "u1", AccessToken: "at"}) + if err != nil { + t.Fatalf("doJSON(%s) 失败: %v", mode, err) + } + var got map[string]any + if err := json.Unmarshal(data, &got); err != nil { + t.Fatalf("解出的 data 不是 JSON: %v (%q)", err, string(data)) + } + if got["hello"] != "world" { + t.Fatalf("data=%v want hello=world", got) + } + }) + } +} + +// TestDoJSONClassifiesDecodedErrorBody 400 分支必须看到**解压后**的文本, +// 否则 Classify 会按压缩字节分类,罚号策略全错。 +func TestDoJSONClassifiesDecodedErrorBody(t *testing.T) { + var buf bytes.Buffer + w := brotli.NewWriter(&buf) + w.Write([]byte(`{"code":402,"msg":"insufficient credit"}`)) + w.Close() + + srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { + w.Header().Set("Content-Encoding", "br") + w.WriteHeader(http.StatusPaymentRequired) + w.Write(buf.Bytes()) + })) + defer srv.Close() + + c := New() + req, _ := http.NewRequest(http.MethodPost, srv.URL+"/v2/test", bytes.NewReader([]byte(`{}`))) + c.CommonHeaders(req, &auth.Auth{UID: "u1", AccessToken: "at"}) + + _, err := c.doJSON(req, &auth.Auth{UID: "u1", AccessToken: "at"}) + if err == nil { + t.Fatal("402 应返回错误") + } + ue, ok := err.(*Error) + if !ok { + t.Fatalf("错误类型 = %T want *Error", err) + } + if ue.Kind != ErrHardCredit { + t.Fatalf("分类 = %v want hard_credit(说明 Classify 没看到解压后的文本)", ue.Kind) + } +} + +// TestDecodeBodyRejectsUnknownEncoding 未知编码必须明确报错,不能把压缩 +// 字节当 JSON 往下传(那会变成"解析失败"这种误导性错误)。 +func TestDecodeBodyRejectsUnknownEncoding(t *testing.T) { + resp := &http.Response{Header: http.Header{}} + resp.Header.Set("Content-Encoding", "compress") // LZW,官方声明但服务端不回 + if _, err := decodeResponseBody(resp, []byte("xx")); err == nil { + t.Fatal("未知编码应报错") + } +} diff --git a/internal/upstream/desktop.go b/internal/upstream/desktop.go index e63418b332119f33a32896ddf89f40e6096646ac..8a4232eaab5051a8546e6b4f56b876cd9f36a6cf 100644 --- a/internal/upstream/desktop.go +++ b/internal/upstream/desktop.go @@ -1,588 +1,702 @@ -// desktop.go 桌面客户端(WorkBuddy Desktop 5.5.6)行为指纹上报。 -// -// 来源:2026-09-12 Sunny 抓包实测(data/desktop-task-protocol.md)。桌面端点亮 -// 「需电脑端」类任务的关键不是独立端点,而是同一 POST /v2/report 通道上 -// **不同的客户端指纹**: -// -// POST https://copilot.tencent.com/v2/report ← chatBase(CLI 上报走 billingBase) -// User-Agent: WorkBuddy/5.5.6 WorkBuddy/5.5.6 CLI/2.137.1 -// X-Domain: copilot.tencent.com, X-Product: SaaS, X-User-Id: -// Body: [ {...event...} ] ← 数组 -// -// 每个事件除业务字段外必带桌面指纹(ideName/ideType=WorkBuddy、 -// extName=workbuddy-desktop 等)。实测点亮记录: -// - RichMeow_Chat(桌面端对话1次):agent_task_created + 成功的 -// chat_message_response(isSuccessful=true) → 1/1 + UR Buddy。 -// - Hp_Appearance(主题任务):独立 API -// POST /v2/user-asset/appearance/set {kind:"theme",resource_key} → SetAppearanceTheme。 -// -// 注意:service 端对事件链有一定真实性校验倾向(RichMeow 需要消息成功回执), -// 本模块按实测事件形状发送,不保证所有任务都能 API 侧点亮——autotask 侧 -// 仍按 attempt 语义处理结果。 -package upstream - -import ( - "bytes" - "crypto/sha256" - "encoding/hex" - "encoding/json" - "fmt" - "io" - "net/http" - "os" - "regexp" - "time" - - "github.com/linguo2625469/workbuddy2api-panel/internal/auth" -) - -const ( - desktopReportPath = "/v2/report" - desktopAppearanceSet = "/v2/user-asset/appearance/set" - // desktopUA 实测桌面客户端 UA(5.5.6 内嵌 CLI 2.137.1)。 - desktopUA = "WorkBuddy/5.5.6 WorkBuddy/5.5.6 CLI/2.137.1" -) - -// desktopBase 桌面端 /v2/report 与 user-asset 走 chatBase(copilot.tencent.com)。 -func (c *Client) desktopBase(a *auth.Auth) string { return c.chatBase(a) } - -// deriveID 由 uid 稳定派生一个 36 位 hex 设备标识(machineId/qimei36 复用), -// 幂等:同一账号每次生成相同值,模拟固定设备。 -func deriveID(a *auth.Auth, salt string) string { - sum := sha256.Sum256([]byte(salt + ":" + a.UID)) - return hex.EncodeToString(sum[:18]) // 36 hex chars -} - -// DesktopEvent 桌面端事件:业务字段任意(map),公共指纹由 ReportDesktopEvent 注入。 -type DesktopEvent map[string]any - -// desktopFingerprint 公共桌面指纹字段(注入每个事件,覆盖同名业务键)。 -func desktopFingerprint(a *auth.Auth) map[string]any { - now := time.Now().UnixMilli() - return map[string]any{ - "timezone": "Asia/Shanghai", - "reportDelay": 2000, - "userId": a.UID, - "username": a.Nickname, - "userNickname": a.Nickname, - "product": "SaaS", - "releaseDate": int64(1789036585355), - "commit": "5f9692923c93033111c51ad7b003eb80204a9b75", - "ideName": "WorkBuddy", - "ideType": "WorkBuddy", - "ideVersion": "5.5.6", - "machineId": deriveID(a, "machine"), - "sessionId": deriveID(a, "session"), - "extName": "workbuddy-desktop", - "extVersion": "5.5.6", - "os": "win32", - "arch": "x64", - "osVersion": "10.0.26220", - "cpuCores": 20, - "memorySize": 24, - "timestamp": now, - "presentAt": now, - } -} - -// ReportDesktopEvent 以桌面客户端指纹向 copilot.tencent.com/v2/report 批量上报事件。 -// events 为业务载荷(eventCode 等字段由调用方给出);公共指纹自动注入, -// 业务字段优先(可用于覆盖 qimei36/machineId 等设备标识做真实设备对齐)。 -func (c *Client) ReportDesktopEvent(a *auth.Auth, events ...DesktopEvent) error { - if len(events) == 0 { - return fmt.Errorf("desktop report: no events") - } - fp := desktopFingerprint(a) - arr := make([]map[string]any, 0, len(events)) - for _, ev := range events { - m := map[string]any{} - for k, v := range fp { - m[k] = v - } - for k, v := range ev { - m[k] = v - } - arr = append(arr, m) - } - raw, err := json.Marshal(arr) - if err != nil { - return err - } - req, err := http.NewRequest(http.MethodPost, c.desktopBase(a)+desktopReportPath, bytes.NewReader(raw)) - if err != nil { - return err - } - req.Header.Set("Authorization", "Bearer "+a.AccessTokenValue()) - req.Header.Set("Accept", "application/json, text/plain, */*") - req.Header.Set("Content-Type", "application/json;charset=UTF-8") - req.Header.Set("User-Agent", desktopUA) - req.Header.Set("X-Domain", c.desktopBase(a)) - req.Header.Set("X-Product", "SaaS") - req.Header.Set("X-Request-ID", deriveID(a, "req")+fmt.Sprintf("%d", time.Now().UnixNano()%1e6)) - if a.UID != "" { - req.Header.Set("X-User-Id", a.UID) - } - _, err = c.doJSON(req) - return err -} - -// DesktopChatSequence 构造一次「桌面端成功对话」的完整事件链 -// (agent_task_created → chat_message_send → chat_request_send → -// chat_message_response(isSuccessful) → chat_message_status → chat_request_response)。 -// 实测该链点亮 RichMeow_Chat。conversationID/requestID/messageID 由调用方生成。 -func DesktopChatSequence(conversationID, requestID, messageID, modelID, modelName string) []DesktopEvent { - uuid := func() string { return requestID } - mk := func(code string, extra map[string]any) DesktopEvent { - ev := DesktopEvent{"eventCode": code} - for k, v := range extra { - ev[k] = v - } - return ev - } - return []DesktopEvent{ - mk("agent_task_created", map[string]any{ - "source": "LOCAL", "name": "working", "task_target": "local", "mode": "craft", - "requestModelId": modelID, "requestModelName": modelName, - "has_repo": false, "repo_type": "none", "workspace_type": "empty", - "has_connector": false, "connector_types": []any{}, - "has_mention": false, "mention_types": []any{}, - "has_template": false, "action": "", "template_name": "", - "has_expert": false, "expert_id": "", "expert_name": "", "expert_industry_id": "", - "has_skill": false, "skill_names": []any{}, - "conversationId": conversationID, "messageId": messageID, - "buddyId": "", "buddyName": "", - }), - mk("chat_message_send", map[string]any{ - "messageId": messageID + "-assistant", "historyCount": 0, - "isContextTruncated": false, "currentStepCount": 1, - "traceId": uuid(), "rootRequestId": requestID, - "parentConversationId": conversationID, - "agentName": "cli", "agentType": "main", - }), - mk("chat_request_send", map[string]any{ - "inputLength": 24, "isPlan": false, "isAutoExecuteTerminal": false, - "isAutoModify": false, "codebaseEnable": false, "maxToken": 0, - "maxSteps": 500, "temperature": 0, "maxRetries": 0, - "mentionContexts": []any{}, "knowledgeId": []any{}, "knowledgeName": []any{}, - "codebaseId": "", "mentionContextCount": 0, "command": "", - "recommendId": "", "skillId": "", "skillCount": 0, "totalCount": 0, - "traceId": uuid(), "rootRequestId": requestID, - "parentConversationId": conversationID, - "agentName": "cli", "agentType": "main", - "codebuddy.session_id": conversationID, - "codebuddy.conversation_request_id": requestID, - }), - mk("chat_message_response", map[string]any{ - "messageId": messageID + "-assistant", "responseModelId": modelID, - "inputToken": 120, "outputToken": 80, "totalToken": 200, - "cachedTokens": 0, "cachedWriteTokens": 0, "cachedMissTokens": 0, - "isSuccessful": true, "messageErrorCode": "", "finishReason": "stop", - "firstTokenAt": time.Now().UnixMilli(), "traceId": uuid(), - "conversationId": conversationID, - "rootRequestId": requestID, "parentConversationId": conversationID, - "agentName": "cli", "agentType": "main", - "codebuddy.session_id": conversationID, - "codebuddy.conversation_request_id": requestID, - }), - mk("chat_message_status", map[string]any{ - "messageId": messageID + "-assistant", "messageErrorCode": "0", - "traceId": uuid(), "rootRequestId": requestID, - "parentConversationId": conversationID, - "agentName": "cli", "agentType": "main", - }), - mk("chat_request_response", map[string]any{ - "mode": "craft", "toolCallCount": 0, - "inputToken": 120, "outputToken": 80, "totalToken": 200, - "cachedTokens": 0, "cachedWriteTokens": 0, "cachedMissTokens": 0, - "isSuccessful": true, "messageErrorCode": "", "finishReason": "stop", - "rootRequestId": requestID, "parentConversationId": conversationID, - }), - } -} - -// SetAppearanceTheme 应用外观主题(实测:POST copilot.tencent.com/v2/user-asset/appearance/set, -// 和品主题 resource_key 为 "theme-tkmw7j",浅色 "light"、深色 "dark")。纯 API set 不计 -// Hp_Appearance 分(需客户端切主题后真实活跃),保留供调色/还原与后续验证用。 -func (c *Client) SetAppearanceTheme(a *auth.Auth, resourceKey string) error { - body := map[string]string{"kind": "theme", "resource_key": resourceKey} - raw, err := json.Marshal(body) - if err != nil { - return err - } - req, err := http.NewRequest(http.MethodPost, c.desktopBase(a)+desktopAppearanceSet, bytes.NewReader(raw)) - if err != nil { - return err - } - req.Header.Set("Authorization", "Bearer "+a.AccessTokenValue()) - req.Header.Set("Accept", "application/json, text/plain, */*") - req.Header.Set("Content-Type", "application/json;charset=UTF-8") - req.Header.Set("User-Agent", desktopUA) - req.Header.Set("X-Product", "SaaS") - if a.UID != "" { - req.Header.Set("X-User-Id", a.UID) - } - _, err = c.doJSON(req) - return err -} - -// DesktopBuddyAppSequence 构造「进入 Buddy 应用」五连事件(实测两账号纯 API 点亮 -// Buddy_App 与 Buddy_App_QQ):discover → show → enter_click → auth_confirm → -// bindaccount_skip。buddyID 固定用企鹅教师助手 cb_y5Dy46tPQGGWtueMxXbe -// (Buddy_App_QQ 的判据应用),同时满足 Buddy_App「进入任一应用」。 -func DesktopBuddyAppSequence(buddyID, buddyName string) []DesktopEvent { - mk := func(code string, extra map[string]any) DesktopEvent { - ev := DesktopEvent{ - "eventCode": code, "mode": "LOCAL", - "buddyId": buddyID, "buddyName": buddyName, - } - for k, v := range extra { - ev[k] = v - } - return ev - } - return []DesktopEvent{ - mk("buddyapp_discover_click", nil), - mk("buddyapp_show", map[string]any{"elementId": buddyID, "elementName": buddyName, "position": 2}), - mk("buddyapp_enter_click", map[string]any{"elementId": buddyID, "elementName": buddyName, "position": 2, "isFirstPage": "1"}), - mk("buddyapp_auth_confirm_click", map[string]any{"elementId": buddyID, "elementName": buddyName}), - mk("buddyapp_bindaccount_skip_click", map[string]any{"elementId": buddyID, "elementName": buddyName}), - } -} - -// DesktopAutomationCreateEvent 构造「定时任务创建成功」事件(实测两账号纯 API -// 点亮 automation_1)。name 为任务名,可与真实创建语义对齐。 -func DesktopAutomationCreateEvent(name string) DesktopEvent { - return DesktopEvent{ - "eventCode": "automated_task_create_suc", "name": name, - "source": "manually", "modelId": "fast-model", "modelIsThinking": true, - "connectorCount": 0, "skills": "", "skillCount": 0, - "scheduleType": "once", "mode": "LOCAL", - } -} - -// ReportWebEvent 以 Web 端指纹向 www.workbuddy.cn/v2/report 上报单事件。 -// 与桌面指纹(copilot 域)不同:web 域事件是浏览器形状(os/machineId/userAgent), -// 用于 Library_read 等页面行为类任务(实测 library_doc_intro_click 4 秒点亮)。 -func (c *Client) ReportWebEvent(a *auth.Auth, eventCode, pageURL, elementID, elementName string) error { - ua := "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/152.0.0.0 Safari/537.36" - ev := map[string]any{ - "eventCode": eventCode, "timestamp": time.Now().UnixMilli(), "reportDelay": 0, - "pageURL": pageURL, "elementId": elementID, "elementName": elementName, - "os": "Win32", "arch": "", "osVersion": "10.0", "userAgent": ua, - "machineId": deriveID(a, "webmachine"), "userId": a.UID, - "userNickname": a.Nickname, "enterpriseId": a.EnterpriseID, - } - raw, err := json.Marshal([]map[string]any{ev}) - if err != nil { - return err - } - req, err := http.NewRequest(http.MethodPost, c.webBase(a)+"/v2/report", bytes.NewReader(raw)) - if err != nil { - return err - } - req.Header.Set("Authorization", "Bearer "+a.AccessTokenValue()) - req.Header.Set("Content-Type", "application/json") - req.Header.Set("Accept", "application/json") - req.Header.Set("x-client-platform", "web") - req.Header.Set("Origin", c.webBase(a)) - req.Header.Set("Referer", pageURL) - req.Header.Set("User-Agent", ua) - if a.UID != "" { - req.Header.Set("X-User-Id", a.UID) - } - _, err = c.doJSON(req) - return err -} - -// --------------------------------------------------------------------------- -// 2026-09-12 第五轮:客户端 asar 逆向 + Sunny 真实样本驱动的新判据(三账号实测点亮)。 -// 来源:WorkBuddy.exe 5.5.6 app.asar 渲染层事件枚举/载荷 + 抓包真实专家召唤样本 -// (data/desktop-task-protocol.md §7.3)。 -// --------------------------------------------------------------------------- - -// DesktopTemplateUseSequence 构造「使用模板创建任务」事件组(实测 template_5 计数): -// agent_task_created_with_template {mode,isCustomModel,id,name,requestId} + -// template_used {template_id,task_mode},JOIN 一条完整 chat 链。 -// 三账号实测:5 组(不同模板)一次上报 → 5/5 点亮。 -func DesktopTemplateUseSequence(conversationID, requestID, templateID, templateName string) []DesktopEvent { - events := DesktopChatSequence(conversationID, requestID, "msg-"+templateID, "fast-model", "fast-model") - events = append(events, - DesktopEvent{ - "eventCode": "agent_task_created_with_template", "mode": "working", - "isCustomModel": false, "id": templateID, "name": templateName, "requestId": requestID, - }, - DesktopEvent{"eventCode": "template_used", "template_id": templateID, "task_mode": "working"}, - ) - return events -} - -// DesktopPlaybookPromptSequence 构造「灵感案例做同款」事件组(实测 playbook_prompt 计数): -// web_element_click(playbook_ctaClick) + playbook_cta_click + playbook_prompt_send -// (Dialog 发送 Prompt,带 conversationId/requestId JOIN chat 链)。三账号实测 1/1 点亮。 -func DesktopPlaybookPromptSequence(conversationID, requestID, caseID, caseName string) []DesktopEvent { - events := DesktopChatSequence(conversationID, requestID, "msg-pb", "fast-model", "fast-model") - payload := map[string]any{ - "id": caseID, "name": caseName, "type": "document", - "categoryId": "", "categoryName": "", - } - events = append(events, - DesktopEvent{ - "eventCode": "web_element_click", "pageName": "playbook_detail", - "elementId": "playbook_ctaClick", "elementName": caseName, "source": "discover", - }, - DesktopEvent(func() map[string]any { - m := map[string]any{"eventCode": "playbook_cta_click", "source": "discover", "position": 0} - for k, v := range payload { - m[k] = v - } - return m - }()), - DesktopEvent(func() map[string]any { - m := map[string]any{"eventCode": "playbook_prompt_send", "conversationId": conversationID, "requestId": requestID} - for k, v := range payload { - m[k] = v - } - return m - }()), - ) - return events -} - -// DesktopDesignCanvasSequence 构造「设计创意画布」事件组(实测 create_canvas 计数): -// wbx_design_canvas_task_create + wbx_design_canvas_open(Ardot create_design 工具 -// 完成时客户端经 metrics 通道上报,同一 /v2/report 端点)。三账号实测 1/1 点亮。 -func DesktopDesignCanvasSequence(conversationID, requestID string) []DesktopEvent { - events := DesktopChatSequence(conversationID, requestID, "msg-canvas", "fast-model", "fast-model") - return append(events, - DesktopEvent{ - "eventCode": "wbx_design_canvas_task_create", "conversationId": conversationID, - "requestId": requestID, "source": "summon_keyword", "cost": 12000, "isSuccessful": true, - }, - DesktopEvent{ - "eventCode": "wbx_design_canvas_open", "conversationId": conversationID, - "requestId": requestID, "id": "ardot-file-" + requestID[len(requestID)-8:], - "source": "summon_keyword", "type": "page", "cost": 13000, "isSuccessful": true, - }, - ) -} - -// MarketExpert 专家市场的单个专家(/portal/operation-platform/market/expert/list 响应子集)。 -type MarketExpert struct { - ExpertID string `json:"expert_id"` - ExpertType string `json:"expert_type"` - DisplayNameZH string `json:"display_name_zh"` - ProfessionZH string `json:"profession_zh"` - Version string `json:"version"` - Categories []any `json:"categories"` -} - -// MarketExpertList 拉取专家市场真实专家列表(expertType: "agent" 单专家 / "team" 专家团)。 -// expert_actual_use 的判据校验要求 id 是平台上真实存在的专家(编造 id 不计数)。 -func (c *Client) MarketExpertList(a *auth.Auth, expertType string) ([]MarketExpert, error) { - body := map[string]any{"page": 1, "page_size": 20, "sort_by": "reco_rank", "sort_order": "desc"} - if expertType != "" { - body["expert_type"] = expertType - } - raw, err := json.Marshal(body) - if err != nil { - return nil, err - } - req, err := http.NewRequest(http.MethodPost, c.chatBase(a)+"/portal/operation-platform/market/expert/list", bytes.NewReader(raw)) - if err != nil { - return nil, err - } - req.Header.Set("Authorization", "Bearer "+a.AccessTokenValue()) - req.Header.Set("Content-Type", "application/json") - req.Header.Set("User-Agent", desktopUA) - req.Header.Set("X-Domain", c.chatBase(a)) - req.Header.Set("X-Product", "SaaS") - if a.UID != "" { - req.Header.Set("X-User-Id", a.UID) - } - var out struct { - Experts []MarketExpert `json:"experts"` - } - data, err := c.doJSON(req) - if err != nil { - return nil, err - } - if err := json.Unmarshal(data, &out); err != nil { - return nil, fmt.Errorf("expert list parse: %w", err) - } - return out.Experts, nil -} - -// DesktopChatWithExpert 发一条真实桌面指纹 chat 请求(可带 X-Expert-Id),从 SSE 流 -// 解析**服务端返回的 requestId**(data.id,如 cmb-xxxx / 32hex)并返回。 -// expert_actual_use 等 JOIN 事件的 requestId 必须是该服务端 id——自造 UUID 不计数 -// (客户端 resolveRealRequestId 同款语义,Sunny row 2113 实证)。 -func (c *Client) DesktopChatWithExpert(a *auth.Auth, expertID string) (conversationID, requestID string, err error) { - conversationID = fmt.Sprintf("wb2api-conv-%d", time.Now().UnixNano()) - body := map[string]any{ - "model": "fast-model", - "messages": []any{ - map[string]any{"role": "system", "content": "You are a helpful assistant. 当前处于中文环境,使用简体中文回答。"}, - map[string]any{"role": "user", "content": "1+1等于几?直接回答。"}, - }, - "agent": "cli", - "temperature": 1, - "stream": true, - "stream_options": map[string]any{"include_usage": true}, - } - raw, err := json.Marshal(body) - if err != nil { - return "", "", err - } - req, err := http.NewRequest(http.MethodPost, c.chatBase(a)+"/v2/chat/completions", bytes.NewReader(raw)) - if err != nil { - return "", "", err - } - h := req.Header - h.Set("Authorization", "Bearer "+a.AccessTokenValue()) - h.Set("Content-Type", "application/json") - h.Set("Accept", "text/event-stream") - h.Set("User-Agent", desktopUA) - h.Set("X-Domain", c.chatBase(a)) - h.Set("X-Product", "SaaS") - h.Set("X-User-Id", a.UID) - h.Set("X-Conversation-ID", conversationID) - h.Set("X-Request-ID", fmt.Sprintf("%d", time.Now().UnixNano())) - h.Set("X-Agent-Intent", "craft") - h.Set("X-Agent-Type", "main") - h.Set("X-IDE-Name", "WorkBuddy") - h.Set("X-IDE-Type", "WorkBuddy") - h.Set("X-IDE-Version", "5.5.6") - h.Set("x-codebuddy-request", "1") - if expertID != "" { - h.Set("X-Expert-Id", expertID) - } - if os.Getenv("WB2A_DEBUG_CHAT") != "" { - fmt.Printf("[dbg] URL=%s\n", req.URL) - for k := range req.Header { - fmt.Printf("[dbg] %s: %s\n", k, req.Header.Get(k)) - } - } - resp, err := c.HTTP.Do(req) - if err != nil { - return "", "", err - } - defer resp.Body.Close() - if os.Getenv("WB2A_DEBUG_CHAT") != "" { - fmt.Printf("[dbg] status=%d enc=%q\n", resp.StatusCode, resp.Header.Get("Content-Encoding")) - } - if resp.StatusCode != 200 { - b, _ := io.ReadAll(io.LimitReader(resp.Body, 200)) - return "", "", fmt.Errorf("chat http %d: %s", resp.StatusCode, b) - } - // 从 SSE 流抓第一个 data.id 作为服务端 requestId(读干流避免残留连接)。 - buf := make([]byte, 0, 1<<20) - tmp := make([]byte, 8192) - searchFrom := 0 - for { - n, rerr := resp.Body.Read(tmp) - if n > 0 { - buf = append(buf, tmp[:n]...) - if os.Getenv("WB2A_DEBUG_CHAT") != "" { - dbg := string(tmp[:n]) - if len(dbg) > 120 { - dbg = dbg[:120] - } - fmt.Printf("[dbg-rd %d] %q\n", n, dbg) - } - // 从上次搜索位置继续:SSE 里 `"id":"` 可能先出现在消息 id 等字段, - // 若不推进偏移,首个不匹配的 id 会让循环永远重复命中同一位置, - // 读满 1MB 后误报"未找到 requestId"。 - if i := bytes.Index(buf[searchFrom:], []byte(`"id":"`)); i >= 0 { - abs := searchFrom + i - rest := buf[abs+6:] - if end := bytes.IndexByte(rest, '"'); end > 0 { - id := string(rest[:end]) - if os.Getenv("WB2A_DEBUG_CHAT") != "" { - fmt.Printf("[dbg-id] %q match=%v\n", id, idRegex.MatchString(id)) - } - if idRegex.MatchString(id) { - return conversationID, id, nil - } - searchFrom = abs + 1 - } - } - } - if rerr != nil || len(buf) > 1<<20 { - break - } - } - return "", "", fmt.Errorf("SSE 中未找到服务端 requestId") -} - -// idRegex 服务端 requestId 形状(cmb- 前缀 32hex 或裸 32hex)。 -var idRegex = regexp.MustCompile(`^(cmb-)?[0-9a-f]{32}$`) - -// DesktopExpertSummonSequence 构造「召唤平台专家」事件组(expert_summon_click 等), -// 载荷对齐真实抓包样本(Sunny row 2644)。需配合 DesktopChatWithExpert + -// DesktopExpertActualUseEvent 完成一次完整「召唤+使用」。 -func DesktopExpertSummonSequence(e MarketExpert) []DesktopEvent { - cat := "expert-all" - if len(e.Categories) > 0 { - if s, ok := e.Categories[0].(string); ok { - cat = s - } - } - ver := e.Version - if ver == "" { - ver = "1.0.0" - } - return []DesktopEvent{ - { - "eventCode": "web_element_click", "source": e.ExpertID, "type": cat, "version": ver, - "elementId": "expert_summon_click", "elementName": "立即召唤", - "pageURL": "/C:/Program%20Files/WorkBuddy/resources/app.asar/renderer/index.html", - }, - { - "eventCode": "expert_summon_click", "id": e.ExpertID, "name": e.DisplayNameZH, - "expertTitle": e.ProfessionZH, "type": "expert-all", "position": 0, - "expertType": e.ExpertType, "version": ver, "mode": "LOCAL", - }, - { - "eventCode": "expert_summoned", "id": e.ExpertID, "name": e.DisplayNameZH, - "expertTitle": e.ProfessionZH, "type": "expert-all", - }, - } -} - -// DesktopExpertActualUseEvent 构造「专家真实使用」事件(expert_5/Expert_team_use_3 计数)。 -// requestID 必须是 DesktopChatWithExpert 返回的服务端 requestId。 -func DesktopExpertActualUseEvent(e MarketExpert, conversationID, requestID string) DesktopEvent { - ev := desktopExpertActualUse(e, conversationID, requestID) - ev["mode"] = "craft" - return ev -} - -// DesktopExpertActualUseLocal mode:"LOCAL" 变体(Expert_lighthouse 判据要求 LOCAL, -// 对齐真实样本 Sunny row 868:轻量云专家使用时 mode=LOCAL、type 为空、cost=0)。 -func DesktopExpertActualUseLocal(e MarketExpert, conversationID, requestID string) DesktopEvent { - ev := desktopExpertActualUse(e, conversationID, requestID) - ev["mode"] = "LOCAL" - return ev -} - -// desktopExpertActualUse expert_actual_use 公共载荷。 -func desktopExpertActualUse(e MarketExpert, conversationID, requestID string) DesktopEvent { - cat := "expert-all" - if len(e.Categories) > 0 { - if s, ok := e.Categories[0].(string); ok { - cat = s - } - } - ver := e.Version - if ver == "" { - ver = "1.0.0" - } - return DesktopEvent{ - "eventCode": "expert_actual_use", - "id": e.ExpertID, "name": e.DisplayNameZH, "expertTitle": e.ProfessionZH, - "type": cat, "expertType": e.ExpertType, "source": "builtin", "version": ver, - "cost": 9000, "characterCount": 14, - "conversationId": conversationID, "requestId": requestID, "messageId": "msg-" + requestID[len(requestID)-8:], - "requestModelId": "fast-model", "requestModelName": "fast-model", - } -} +// desktop.go 桌面客户端(WorkBuddy Desktop 5.5.6)行为指纹上报。 +// +// 来源:2026-09-12 Sunny 抓包实测(data/desktop-task-protocol.md)。桌面端点亮 +// 「需电脑端」类任务的关键不是独立端点,而是同一 POST /v2/report 通道上 +// **不同的客户端指纹**: +// +// POST https://copilot.tencent.com/v2/report ← chatBase(CLI 上报走 billingBase) +// User-Agent: WorkBuddy/5.5.6 WorkBuddy/5.5.6 CLI/2.137.1 +// X-Domain: copilot.tencent.com, X-Product: SaaS, X-User-Id: +// Body: [ {...event...} ] ← 数组 +// +// 每个事件除业务字段外必带桌面指纹(ideName/ideType=WorkBuddy、 +// extName=workbuddy-desktop 等)。实测点亮记录: +// - RichMeow_Chat(桌面端对话1次):agent_task_created + 成功的 +// chat_message_response(isSuccessful=true) → 1/1 + UR Buddy。 +// - Hp_Appearance(主题任务):独立 API +// POST /v2/user-asset/appearance/set {kind:"theme",resource_key} → SetAppearanceTheme。 +// +// 注意:service 端对事件链有一定真实性校验倾向(RichMeow 需要消息成功回执), +// 本模块按实测事件形状发送,不保证所有任务都能 API 侧点亮——autotask 侧 +// 仍按 attempt 语义处理结果。 +package upstream + +import ( + "bytes" + "crypto/sha256" + "encoding/hex" + "encoding/json" + "fmt" + "io" + "net/http" + "net/url" + "os" + "regexp" + "strings" + "time" + + "github.com/misakano7545/workbuddy2api-panel/internal/auth" + "github.com/misakano7545/workbuddy2api-panel/internal/session" +) + +const ( + desktopReportPath = "/v2/report" + desktopAppearanceSet = "/v2/user-asset/appearance/set" + // desktopVersion / desktopCommit / desktopReleaseDate 官方分发包实测值 + // (install-manifest.json 的 appVersion + /v2/report body 的 commit/releaseDate)。 + // 与面板自身 client_version 分开:/v2/report 是「桌面端行为」指纹,应恒为桌面端版本。 + // + // **按 realm 分开**(2026-10-30 双版本抓包实测):两版上报的版本三元组不同, + // 且 commit/releaseDate 是打包期常量、无法从版本号推导: + // + // CN 5.9.3 ideVersion 5.9.3 commit d4692421… releaseDate 1793093056315 + // global 5.9.4 ideVersion 5.9.4 commit fa0a0901… releaseDate 1793288804029 + // + // CN 三元组在 2026-10-28 按 5.9.3 真机 /v2/report 重新采集(commit / releaseDate / + // ideVersion / extVersion 逐字取自 7 条上报事件,与分发包 cli/product.json 的 + // commit + date 交叉一致): + // commit = d46924219e79332f49c37ccebf27292f87001b19 + // releaseDate = 1793093056315 + // + // 此前不分档、恒用 global 的三元组,等于给每个国内号都盖了国际版的包指纹 + // (版本号与安装清单自相矛盾),是最容易被设备侧写识破的一处。 + desktopVersionCN = "5.9.3" + desktopCommitCN = "d46924219e79332f49c37ccebf27292f87001b19" + desktopReleaseDateCN = int64(1793093056315) + // global 三元组按 5.9.4 国际分发包重采(2026-10-30 拆包): + // cli/product.json commit = fa0a0901906addaa1a4259f6df347388a5563ded + // cli/product.json date = 2026-10-29T15:46:44.029Z → 1793288804029 + // 真机 /v2/update?platform=workbuddy-win32-x64-user&version=5.9.4 与 UA 段一致。 + desktopVersionGlobal = "5.9.4" + desktopCommitGlobal = "fa0a0901906addaa1a4259f6df347388a5563ded" + desktopReleaseDateGlobal = int64(1793288804029) +) + +// desktopBase 桌面端 /v2/report 与 user-asset 走 chatBase(copilot.tencent.com)。 +func (c *Client) desktopBase(a *auth.Auth) string { return c.chatBase(a) } + +// desktopUAFor 桌面端 UA:两段品牌一致(与业务链路同源,都是 SDK 的 buildUserAgent)。 +// CN 5.9.3 → `WorkBuddy/5.9.3 WorkBuddy/5.9.3 CLI/2.165.0`(真机实测); +// global 5.9.4 → `workbuddy-ai/5.9.4 workbuddy-ai/5.9.4 CLI/2.165.0`(真机实测)。 +func desktopUAFor(a *auth.Auth) string { + ver, _, _ := desktopTriple(a) + brand := uaBrandFor(a) + cli := defaultCliVersion + return brand + "/" + ver + " " + brand + "/" + ver + " CLI/" + cli +} + +// desktopTriple 返回该账号域的桌面端 (ideVersion, commit, releaseDate) 三元组。 +// 两版分发包不同 → 三元组不同;nil(默认 CN 形态)走 CN 值。 +func desktopTriple(a *auth.Auth) (ver, commit string, release int64) { + if a != nil && a.IsGlobal() { + return desktopVersionGlobal, desktopCommitGlobal, desktopReleaseDateGlobal + } + return desktopVersionCN, desktopCommitCN, desktopReleaseDateCN +} + +// desktopHost 返回 X-Domain 用的裸主机名(与真机一致:www.workbuddy.ai / +// copilot.tencent.com)。从 base 里剥 scheme 与路径;解析失败时退回 base 原串, +// 保证不会因为 URL 畸形而把该头发成空串(头缺失同样会触发渠道校验)。 +func (c *Client) desktopHost(a *auth.Auth) string { + base := c.desktopBase(a) + if u, err := url.Parse(base); err == nil && u.Hostname() != "" { + return u.Hostname() + } + return strings.TrimSuffix(strings.TrimPrefix(strings.TrimPrefix(base, "https://"), "http://"), "/") +} + +// deriveID 由 uid 稳定派生一个 36 位 hex 设备标识(machineId/qimei36 复用), +// 幂等:同一账号每次生成相同值,模拟固定设备。 +func deriveID(a *auth.Auth, salt string) string { + sum := sha256.Sum256([]byte(salt + ":" + a.UID)) + return hex.EncodeToString(sum[:18]) // 36 hex chars +} + +// DesktopEvent 桌面端事件:业务字段任意(map),公共指纹由 ReportDesktopEvent 注入。 +type DesktopEvent map[string]any + +// desktopFingerprint 公共桌面指纹字段(注入每个事件,覆盖同名业务键)。 +// 版本三元组按 realm 取(见 desktopTriple);qimei36 仅国内版有(见下)。 +func desktopFingerprint(a *auth.Auth) map[string]any { + now := time.Now().UnixMilli() + ver, commit, release := desktopTriple(a) + fp := map[string]any{ + "timezone": "Asia/Shanghai", + "reportDelay": 2000, + "userId": a.UID, + "username": a.Nickname, + "userNickname": a.Nickname, + "product": "SaaS", + "releaseDate": release, + "commit": commit, + "ideName": "WorkBuddy", + "ideType": "WorkBuddy", + "ideVersion": ver, + "machineId": deriveID(a, "machine"), + "sessionId": deriveID(a, "session"), + "extName": "workbuddy-desktop", + "extVersion": ver, + "os": "win32", + "arch": "x64", + // osVersion / cpuModel / cpuCores / memorySize 是真机上报名(5.8.4 实测): + // 这些字段上游侧用于设备侧写,缺 cpuModel 是最明显的「非桌面端」特征。 + "osVersion": "10.0.28000", + "cpuModel": "11th Gen Intel(R) Core(TM) i5-11320H @ 3.20GHz", + "cpuCores": 8, + "memorySize": 16, + "timestamp": now, + "presentAt": now, + } + // qimei36:腾讯设备标识(36 位小写十六进制)。2026-10-20 双版本抓包实测—— + // 国内版每个 report 事件都带,国际版**一条都不带**(CN 28 键 vs GL 27 键, + // 差集恰好只有 qimei36)。故按 realm 条件注入:给国际版补这个键反而是伪造。 + // 取值按 uid 稳定派生(同 deriveID 口径),保证同号跨重启恒同值。 + if a != nil && !a.IsGlobal() { + fp["qimei36"] = deriveID(a, "qimei") + } + return fp +} + +// ReportDesktopEvent 以桌面客户端指纹向 copilot.tencent.com/v2/report 批量上报事件。 +// events 为业务载荷(eventCode 等字段由调用方给出);公共指纹自动注入, +// 业务字段优先(可用于覆盖 qimei36/machineId 等设备标识做真实设备对齐)。 +func (c *Client) ReportDesktopEvent(a *auth.Auth, events ...DesktopEvent) error { + if len(events) == 0 { + return fmt.Errorf("desktop report: no events") + } + fp := desktopFingerprint(a) + arr := make([]map[string]any, 0, len(events)) + for _, ev := range events { + m := map[string]any{} + for k, v := range fp { + m[k] = v + } + for k, v := range ev { + m[k] = v + } + arr = append(arr, m) + } + raw, err := json.Marshal(arr) + if err != nil { + return err + } + req, err := http.NewRequest(http.MethodPost, c.desktopBase(a)+desktopReportPath, bytes.NewReader(raw)) + if err != nil { + return err + } + req.Header.Set("Authorization", "Bearer "+a.AccessTokenValue()) + req.Header.Set("Accept", "application/json, text/plain, */*") + req.Header.Set("Content-Type", "application/json;charset=UTF-8") + // X-Requested-With:**不发**。 + // + // 2026-10-30 双版本真机复核(国际 5.9.4 37 条 + 国内 5.9.3 多条 /v2/report, + // 按 UA 分成两族): + // + // workbuddy-ai/5.9.4 workbuddy-ai/5.9.4 CLI/… ← 本函数发的就是这一族,**无** X-Requested-With + // WorkBuddy/5.9.4 workbuddy-ai/5.9.4 CLI/… ← 渲染器侧另一条上报,带 X-Requested-With + // + // 旧实现在 UA 取「RPC 族」的同时又补了 X-Requested-With,等于把两族的头各取一半 + // 拼成第三族——两族都不像,比少一个头更显眼。 + req.Header.Set("User-Agent", desktopUAFor(a)) + // Accept-Encoding:真机 /v2/report 与 chat / billing 同族,四段全声明 + // (夹具 official_report_cn_head.txt,cn 抓包 report 族 1/1 命中该值)。 + // 显式声明会关闭 net/http 透明解压,响应由 doJSON→decodeResponseBody 解。 + req.Header.Set("Accept-Encoding", "gzip, compress, deflate, br") + // X-Domain 是**主机名**不是 URL:真机实测 `X-Domain: www.workbuddy.ai`, + // 而 desktopBase 返回的是带 scheme 的 base,直接塞进去会发成 + // `https://www.workbuddy.ai`——与本仓其它头(chat/billing 用 DomainValue 的裸域) + // 也不自洽,是最容易被上游按「非客户端形态」识别出来的一处。 + req.Header.Set("X-Domain", c.desktopHost(a)) + req.Header.Set("X-Product", "SaaS") + req.Header.Set("X-Request-ID", session.NewMessageID()) + if a.UID != "" { + req.Header.Set("X-User-Id", a.UID) + } + _, err = c.doJSON(req, a) + return err +} + +// DesktopChatSequence 构造一次「桌面端成功对话」的完整事件链 +// (agent_task_created → chat_message_send → chat_request_send → +// chat_message_response(isSuccessful) → chat_message_status → chat_request_response)。 +// 实测该链点亮 RichMeow_Chat。conversationID/requestID/messageID 由调用方生成。 +func DesktopChatSequence(conversationID, requestID, messageID, modelID, modelName string) []DesktopEvent { + uuid := func() string { return requestID } + mk := func(code string, extra map[string]any) DesktopEvent { + ev := DesktopEvent{"eventCode": code} + for k, v := range extra { + ev[k] = v + } + return ev + } + return []DesktopEvent{ + mk("agent_task_created", map[string]any{ + "source": "LOCAL", "name": "working", "task_target": "local", "mode": "craft", + "requestModelId": modelID, "requestModelName": modelName, + "has_repo": false, "repo_type": "none", "workspace_type": "empty", + "has_connector": false, "connector_types": []any{}, + "has_mention": false, "mention_types": []any{}, + "has_template": false, "action": "", "template_name": "", + "has_expert": false, "expert_id": "", "expert_name": "", "expert_industry_id": "", + "has_skill": false, "skill_names": []any{}, + "conversationId": conversationID, "messageId": messageID, + "buddyId": "", "buddyName": "", + }), + mk("chat_message_send", map[string]any{ + "messageId": messageID + "-assistant", "historyCount": 0, + "isContextTruncated": false, "currentStepCount": 1, + "traceId": uuid(), "rootRequestId": requestID, + "parentConversationId": conversationID, + "agentName": "cli", "agentType": "main", + }), + mk("chat_request_send", map[string]any{ + "inputLength": 24, "isPlan": false, "isAutoExecuteTerminal": false, + "isAutoModify": false, "codebaseEnable": false, "maxToken": 0, + "maxSteps": 500, "temperature": 0, "maxRetries": 0, + "mentionContexts": []any{}, "knowledgeId": []any{}, "knowledgeName": []any{}, + "codebaseId": "", "mentionContextCount": 0, "command": "", + "recommendId": "", "skillId": "", "skillCount": 0, "totalCount": 0, + "traceId": uuid(), "rootRequestId": requestID, + "parentConversationId": conversationID, + "agentName": "cli", "agentType": "main", + "codebuddy.session_id": conversationID, + "codebuddy.conversation_request_id": requestID, + }), + mk("chat_message_response", map[string]any{ + "messageId": messageID + "-assistant", "responseModelId": modelID, + "inputToken": 120, "outputToken": 80, "totalToken": 200, + "cachedTokens": 0, "cachedWriteTokens": 0, "cachedMissTokens": 0, + "isSuccessful": true, "messageErrorCode": "", "finishReason": "stop", + "firstTokenAt": time.Now().UnixMilli(), "traceId": uuid(), + "conversationId": conversationID, + "rootRequestId": requestID, "parentConversationId": conversationID, + "agentName": "cli", "agentType": "main", + "codebuddy.session_id": conversationID, + "codebuddy.conversation_request_id": requestID, + }), + mk("chat_message_status", map[string]any{ + "messageId": messageID + "-assistant", "messageErrorCode": "0", + "traceId": uuid(), "rootRequestId": requestID, + "parentConversationId": conversationID, + "agentName": "cli", "agentType": "main", + }), + mk("chat_request_response", map[string]any{ + "mode": "craft", "toolCallCount": 0, + "inputToken": 120, "outputToken": 80, "totalToken": 200, + "cachedTokens": 0, "cachedWriteTokens": 0, "cachedMissTokens": 0, + "isSuccessful": true, "messageErrorCode": "", "finishReason": "stop", + "rootRequestId": requestID, "parentConversationId": conversationID, + }), + } +} + +// SetAppearanceTheme 应用外观主题(实测:POST copilot.tencent.com/v2/user-asset/appearance/set, +// 和品主题 resource_key 为 "theme-tkmw7j",浅色 "light"、深色 "dark")。纯 API set 不计 +// Hp_Appearance 分(需客户端切主题后真实活跃),保留供调色/还原与后续验证用。 +func (c *Client) SetAppearanceTheme(a *auth.Auth, resourceKey string) error { + body := map[string]string{"kind": "theme", "resource_key": resourceKey} + raw, err := json.Marshal(body) + if err != nil { + return err + } + req, err := http.NewRequest(http.MethodPost, c.desktopBase(a)+desktopAppearanceSet, bytes.NewReader(raw)) + if err != nil { + return err + } + req.Header.Set("Authorization", "Bearer "+a.AccessTokenValue()) + req.Header.Set("Accept", "application/json, text/plain, */*") + req.Header.Set("Content-Type", "application/json;charset=UTF-8") + req.Header.Set("User-Agent", desktopUAFor(a)) + req.Header.Set("X-Product", "SaaS") + if a.UID != "" { + req.Header.Set("X-User-Id", a.UID) + } + _, err = c.doJSON(req, a) + return err +} + +// DesktopBuddyAppSequence 构造「进入 Buddy 应用」五连事件(实测两账号纯 API 点亮 +// Buddy_App 与 Buddy_App_QQ):discover → show → enter_click → auth_confirm → +// bindaccount_skip。buddyID 固定用企鹅教师助手 cb_y5Dy46tPQGGWtueMxXbe +// (Buddy_App_QQ 的判据应用),同时满足 Buddy_App「进入任一应用」。 +func DesktopBuddyAppSequence(buddyID, buddyName string) []DesktopEvent { + mk := func(code string, extra map[string]any) DesktopEvent { + ev := DesktopEvent{ + "eventCode": code, "mode": "LOCAL", + "buddyId": buddyID, "buddyName": buddyName, + } + for k, v := range extra { + ev[k] = v + } + return ev + } + return []DesktopEvent{ + mk("buddyapp_discover_click", nil), + mk("buddyapp_show", map[string]any{"elementId": buddyID, "elementName": buddyName, "position": 2}), + mk("buddyapp_enter_click", map[string]any{"elementId": buddyID, "elementName": buddyName, "position": 2, "isFirstPage": true}), + mk("buddyapp_auth_confirm_click", map[string]any{"elementId": buddyID, "elementName": buddyName}), + mk("buddyapp_bindaccount_skip_click", map[string]any{"elementId": buddyID, "elementName": buddyName}), + } +} + +// DesktopAutomationCreateEvent 构造「定时任务创建成功」事件(实测两账号纯 API +// 点亮 automation_1)。name 为任务名,可与真实创建语义对齐。 +func DesktopAutomationCreateEvent(name string) DesktopEvent { + return DesktopEvent{ + "eventCode": "automated_task_create_suc", "name": name, + "source": "manually", "modelId": "fast-model", "modelIsThinking": true, + "connectorCount": 0, "skills": "", "skillCount": 0, + "scheduleType": "once", "mode": "LOCAL", + } +} + +// ReportWebEvent 以 **官方桌面端等价形态** 向 /v2/report 上报单事件。 +// +// 2026-11-01 真机抓包修正(夹具 testdata/official_report_cn_head.txt): +// 官方 /v2/report 在 CN 侧 **只有一种形态**——Node/SDK 发的,11 个头: +// +// Accept: application/json, text/plain, */* +// Content-Type: application/json;charset=UTF-8 +// X-Request-ID / X-Product: SaaS +// User-Agent: WorkBuddy/5.9.3 WorkBuddy/5.9.3 CLI/2.165.0 +// Authorization / X-User-Id / X-Domain: www.workbuddy.cn +// +// **没有** sec-ch-ua / Sec-Fetch-* / Origin / Referer / x-client-platform。 +// 旧实现造的是一条「浏览器 UA + Origin + Referer」的第三族请求,官方客户端 +// 从不发这种包——而且 UA 里的 `Chrome/152.0.0.0` 是不可能的值(Electron 37 +// 内置 Chromium 138,真机实测 `WorkBuddy/5.9.3 Chrome/138.0.7204.251 +// Electron/37.10.3`)。头与体各自自洽、彼此矛盾,是最容易被单条规则命中的形态。 +// +// body 仍保留 web 事件形状(os/machineId/userAgent 等):那条路径的业务载荷 +// 没有真机样本可比对,改头不动体是本轮能拿证据支撑的最小改动。 +func (c *Client) ReportWebEvent(a *auth.Auth, eventCode, pageURL, elementID, elementName string) error { + ua := c.userAgent(a) + ev := map[string]any{ + "eventCode": eventCode, "timestamp": time.Now().UnixMilli(), "reportDelay": 0, + "pageURL": pageURL, "elementId": elementID, "elementName": elementName, + "os": "Win32", "arch": "", "osVersion": "10.0", "userAgent": ua, + "machineId": deriveID(a, "webmachine"), "userId": a.UID, + "userNickname": a.Nickname, "enterpriseId": a.EnterpriseID, + } + raw, err := json.Marshal([]map[string]any{ev}) + if err != nil { + return err + } + base := c.webBase(a) + req, err := http.NewRequest(http.MethodPost, base+"/v2/report", bytes.NewReader(raw)) + if err != nil { + return err + } + // 以下逐项照抄真机夹具,顺序与取值都不自己发挥。 + req.Header.Set("Accept", "application/json, text/plain, */*") + req.Header.Set("Content-Type", "application/json;charset=UTF-8") + req.Header.Set("User-Agent", ua) + // X-Request-ID 用**纯随机 32 hex**(NewTraceID),不是 UUIDv7: + // 真机 report 样本 `4891f0b179cc4959be94b2c867c16e3c` 解不出时间位, + // 而同一客户端的 chat 请求才带毫秒前缀。两条链的 ID 规则不同。 + req.Header.Set("X-Request-ID", session.NewTraceID()) + req.Header.Set("X-Product", "SaaS") + req.Header.Set("Authorization", "Bearer "+a.AccessTokenValue()) + // Accept-Encoding:同 /v2/report 真机族(四段全声明)。 + req.Header.Set("Accept-Encoding", "gzip, compress, deflate, br") + if a.UID != "" { + req.Header.Set("X-User-Id", a.UID) + } + // X-Domain 是**裸主机名**(真机 `X-Domain: www.workbuddy.cn`),不是 URL。 + host := strings.TrimSuffix(strings.TrimPrefix(strings.TrimPrefix(base, "https://"), "http://"), "/") + if u, perr := url.Parse(base); perr == nil && u.Hostname() != "" { + host = u.Hostname() + } + req.Header.Set("X-Domain", host) + _, err = c.doJSON(req, a) + return err +} + +// --------------------------------------------------------------------------- +// 2026-09-12 第五轮:客户端 asar 逆向 + Sunny 真实样本驱动的新判据(三账号实测点亮)。 +// 来源:WorkBuddy.exe 5.5.6 app.asar 渲染层事件枚举/载荷 + 抓包真实专家召唤样本 +// (data/desktop-task-protocol.md §7.3)。 +// --------------------------------------------------------------------------- + +// DesktopTemplateUseSequence 构造「使用模板创建任务」事件组(实测 template_5 计数): +// agent_task_created_with_template {mode,isCustomModel,id,name,requestId} + +// template_used {template_id,task_mode},JOIN 一条完整 chat 链。 +// 三账号实测:5 组(不同模板)一次上报 → 5/5 点亮。 +func DesktopTemplateUseSequence(conversationID, requestID, templateID, templateName string) []DesktopEvent { + events := DesktopChatSequence(conversationID, requestID, "msg-"+templateID, "fast-model", "fast-model") + events = append(events, + DesktopEvent{ + "eventCode": "agent_task_created_with_template", "mode": "working", + "isCustomModel": false, "id": templateID, "name": templateName, "requestId": requestID, + }, + DesktopEvent{"eventCode": "template_used", "template_id": templateID, "task_mode": "working"}, + ) + return events +} + +// DesktopPlaybookPromptSequence 构造「灵感案例做同款」事件组(实测 playbook_prompt 计数): +// web_element_click(playbook_ctaClick) + playbook_cta_click + playbook_prompt_send +// (Dialog 发送 Prompt,带 conversationId/requestId JOIN chat 链)。三账号实测 1/1 点亮。 +func DesktopPlaybookPromptSequence(conversationID, requestID, caseID, caseName string) []DesktopEvent { + events := DesktopChatSequence(conversationID, requestID, "msg-pb", "fast-model", "fast-model") + payload := map[string]any{ + "id": caseID, "name": caseName, "type": "document", + "categoryId": "", "categoryName": "", + } + events = append(events, + DesktopEvent{ + "eventCode": "web_element_click", "pageName": "playbook_detail", + "elementId": "playbook_ctaClick", "elementName": caseName, "source": "discover", + }, + DesktopEvent(func() map[string]any { + m := map[string]any{"eventCode": "playbook_cta_click", "source": "discover", "position": 0} + for k, v := range payload { + m[k] = v + } + return m + }()), + DesktopEvent(func() map[string]any { + m := map[string]any{"eventCode": "playbook_prompt_send", "conversationId": conversationID, "requestId": requestID} + for k, v := range payload { + m[k] = v + } + return m + }()), + ) + return events +} + +// MarketExpert 专家市场的单个专家(/portal/operation-platform/market/expert/list 响应子集)。 +type MarketExpert struct { + ExpertID string `json:"expert_id"` + ExpertType string `json:"expert_type"` + DisplayNameZH string `json:"display_name_zh"` + ProfessionZH string `json:"profession_zh"` + Version string `json:"version"` + Categories []any `json:"categories"` +} + +// MarketExpertList 拉取专家市场真实专家列表(expertType: "agent" 单专家 / "team" 专家团)。 +// expert_actual_use 的判据校验要求 id 是平台上真实存在的专家(编造 id 不计数)。 +func (c *Client) MarketExpertList(a *auth.Auth, expertType string) ([]MarketExpert, error) { + body := map[string]any{"page": 1, "page_size": 20, "sort_by": "reco_rank", "sort_order": "desc"} + if expertType != "" { + body["expert_type"] = expertType + } + return c.marketExpertList(a, body) +} + +// MarketExpertSearch 按关键词检索专家市场(等价于客户端「专家页搜索框」)。 +// +// 请求体里的关键词字段名是 keyword(实测:keyword 生效时 total_count 收窄到 220, +// search_keyword / query / search 均被忽略返回全量 25318)。同一关键词可能命中多个 +// 同名专家(display_name_zh 与 profession_zh 都会参与匹配),调用方必须按 expert_id +// 二次筛选,不能取首条。 +func (c *Client) MarketExpertSearch(a *auth.Auth, keyword string) ([]MarketExpert, error) { + if strings.TrimSpace(keyword) == "" { + return nil, fmt.Errorf("market expert search: keyword required") + } + return c.marketExpertList(a, map[string]any{"page": 1, "page_size": 20, "keyword": keyword}) +} + +// marketExpertList 专家市场列表/搜索的公共请求(POST .../market/expert/list)。 +func (c *Client) marketExpertList(a *auth.Auth, body map[string]any) ([]MarketExpert, error) { + raw, err := json.Marshal(body) + if err != nil { + return nil, err + } + req, err := http.NewRequest(http.MethodPost, c.chatBase(a)+"/portal/operation-platform/market/expert/list", bytes.NewReader(raw)) + if err != nil { + return nil, err + } + req.Header.Set("Authorization", "Bearer "+a.AccessTokenValue()) + req.Header.Set("Content-Type", "application/json") + req.Header.Set("User-Agent", desktopUAFor(a)) + req.Header.Set("X-Domain", c.chatBase(a)) + req.Header.Set("X-Product", "SaaS") + if a.UID != "" { + req.Header.Set("X-User-Id", a.UID) + } + var out struct { + Experts []MarketExpert `json:"experts"` + } + data, err := c.doJSON(req, a) + if err != nil { + return nil, err + } + if err := json.Unmarshal(data, &out); err != nil { + return nil, fmt.Errorf("expert list parse: %w", err) + } + return out.Experts, nil +} + +// DesktopChatWithExpert 发一条真实桌面指纹 chat 请求(可带 X-Expert-Id),从 SSE 流 +// 解析**服务端返回的 requestId**(data.id,如 cmb-xxxx / 32hex)并返回。 +// expert_actual_use 等 JOIN 事件的 requestId 必须是该服务端 id——自造 UUID 不计数 +// (客户端 resolveRealRequestId 同款语义,Sunny row 2113 实证)。 +func (c *Client) DesktopChatWithExpert(a *auth.Auth, expertID string) (conversationID, requestID string, err error) { + // 会话 ID 用官方形态(v4 UUID)。旧实现是 `wb2api-conv-`——项目缩写 + + // 纳秒时间戳直接当 X-Conversation-ID 打给上游,是 issue #51 里最直白的一处自证。 + conversationID = session.NewConversationID() + body := map[string]any{ + "model": "fast-model", + "messages": []any{ + map[string]any{"role": "system", "content": "You are a helpful assistant. 当前处于中文环境,使用简体中文回答。"}, + map[string]any{"role": "user", "content": "1+1等于几?直接回答。"}, + }, + "agent": "cli", + "temperature": 1, + "stream": true, + "stream_options": map[string]any{"include_usage": true}, + } + raw, err := json.Marshal(body) + if err != nil { + return "", "", err + } + req, err := http.NewRequest(http.MethodPost, c.chatBase(a)+"/v2/chat/completions", bytes.NewReader(raw)) + if err != nil { + return "", "", err + } + // 头族一律走 ChatHeaders:这条路径原先手搓了 20 多行头,结果与主 chat 路径长期漂移 + // (缺 X-Trace-ID / X-B3-* / x-stainless-* / acp-connection-id,X-IDE-Version 写死 + // 5.5.6,X-Request-ID 还是十进制纳秒)。手搓头本身就是漂移的根因——统一出口后 + // 主路径改一次这里自动跟随。 + meta := ChatMeta{ + ConversationID: conversationID, + CacheKeyID: conversationID, + ConversationRequestID: session.NewMessageID(), + } + c.ChatHeaders(req, a, "", meta) + if expertID != "" { + req.Header.Set("X-Expert-Id", expertID) + } + if os.Getenv("WB2A_DEBUG_CHAT") != "" { + fmt.Printf("[dbg] URL=%s\n", req.URL) + for k := range req.Header { + fmt.Printf("[dbg] %s: %s\n", k, req.Header.Get(k)) + } + } + resp, err := c.do(req, a, false) + if err != nil { + return "", "", err + } + defer resp.Body.Close() + if os.Getenv("WB2A_DEBUG_CHAT") != "" { + fmt.Printf("[dbg] status=%d enc=%q\n", resp.StatusCode, resp.Header.Get("Content-Encoding")) + } + if resp.StatusCode != 200 { + b, _ := io.ReadAll(io.LimitReader(resp.Body, 200)) + return "", "", fmt.Errorf("chat http %d: %s", resp.StatusCode, b) + } + // 从 SSE 流抓第一个 data.id 作为服务端 requestId(读干流避免残留连接)。 + buf := make([]byte, 0, 1<<20) + tmp := make([]byte, 8192) + searchFrom := 0 + for { + n, rerr := resp.Body.Read(tmp) + if n > 0 { + buf = append(buf, tmp[:n]...) + if os.Getenv("WB2A_DEBUG_CHAT") != "" { + dbg := string(tmp[:n]) + if len(dbg) > 120 { + dbg = dbg[:120] + } + fmt.Printf("[dbg-rd %d] %q\n", n, dbg) + } + // 从上次搜索位置继续:SSE 里 `"id":"` 可能先出现在消息 id 等字段, + // 若不推进偏移,首个不匹配的 id 会让循环永远重复命中同一位置, + // 读满 1MB 后误报"未找到 requestId"。 + if i := bytes.Index(buf[searchFrom:], []byte(`"id":"`)); i >= 0 { + abs := searchFrom + i + rest := buf[abs+6:] + if end := bytes.IndexByte(rest, '"'); end > 0 { + id := string(rest[:end]) + if os.Getenv("WB2A_DEBUG_CHAT") != "" { + fmt.Printf("[dbg-id] %q match=%v\n", id, idRegex.MatchString(id)) + } + if idRegex.MatchString(id) { + return conversationID, id, nil + } + searchFrom = abs + 1 + } + } + } + if rerr != nil || len(buf) > 1<<20 { + break + } + } + return "", "", fmt.Errorf("SSE 中未找到服务端 requestId") +} + +// idRegex 服务端 requestId 形状(cmb- 前缀 32hex 或裸 32hex)。 +var idRegex = regexp.MustCompile(`^(cmb-)?[0-9a-f]{32}$`) + +// DesktopExpertSummonSequence 构造「召唤平台专家」事件组(expert_summon_click 等), +// 载荷对齐真实抓包样本(Sunny row 2644)。需配合 DesktopChatWithExpert + +// DesktopExpertActualUseEvent 完成一次完整「召唤+使用」。 +func DesktopExpertSummonSequence(e MarketExpert) []DesktopEvent { + cat := "expert-all" + if len(e.Categories) > 0 { + if s, ok := e.Categories[0].(string); ok { + cat = s + } + } + ver := e.Version + if ver == "" { + ver = "1.0.0" + } + return []DesktopEvent{ + { + "eventCode": "web_element_click", "source": e.ExpertID, "type": cat, "version": ver, + "elementId": "expert_summon_click", "elementName": "立即召唤", + "pageURL": "/C:/Program%20Files/WorkBuddy/resources/app.asar/renderer/index.html", + }, + { + "eventCode": "expert_summon_click", "id": e.ExpertID, "name": e.DisplayNameZH, + "expertTitle": e.ProfessionZH, "type": "expert-all", "position": 0, + "expertType": e.ExpertType, "version": ver, "mode": "LOCAL", + }, + { + "eventCode": "expert_summoned", "id": e.ExpertID, "name": e.DisplayNameZH, + "expertTitle": e.ProfessionZH, "type": "expert-all", + }, + } +} + +// DesktopExpertActualUseEvent 构造「专家真实使用」事件(expert_5/Expert_team_use_3 计数)。 +// requestID 必须是 DesktopChatWithExpert 返回的服务端 requestId。 +func DesktopExpertActualUseEvent(e MarketExpert, conversationID, requestID string) DesktopEvent { + ev := desktopExpertActualUse(e, conversationID, requestID) + ev["mode"] = "craft" + return ev +} + +// DesktopExpertActualUseLocal mode:"LOCAL" 变体(Expert_lighthouse 判据要求 LOCAL, +// 对齐真实样本 Sunny row 868:轻量云专家使用时 mode=LOCAL、type 为空、cost=0)。 +func DesktopExpertActualUseLocal(e MarketExpert, conversationID, requestID string) DesktopEvent { + ev := desktopExpertActualUse(e, conversationID, requestID) + ev["mode"] = "LOCAL" + return ev +} + +// desktopExpertActualUse expert_actual_use 公共载荷。 +func desktopExpertActualUse(e MarketExpert, conversationID, requestID string) DesktopEvent { + cat := "expert-all" + if len(e.Categories) > 0 { + if s, ok := e.Categories[0].(string); ok { + cat = s + } + } + ver := e.Version + if ver == "" { + ver = "1.0.0" + } + return DesktopEvent{ + "eventCode": "expert_actual_use", + "id": e.ExpertID, "name": e.DisplayNameZH, "expertTitle": e.ProfessionZH, + "type": cat, "expertType": e.ExpertType, "source": "builtin", "version": ver, + "cost": 9000, "characterCount": 14, + "conversationId": conversationID, "requestId": requestID, "messageId": "msg-" + requestID[len(requestID)-8:], + "requestModelId": "fast-model", "requestModelName": "fast-model", + } +} diff --git a/internal/upstream/desktop_test.go b/internal/upstream/desktop_test.go index 9bdf82c821e1727b03af06215f3bd031a7e3b45d..23023dd7367be5bfd39f3b5907da41560e016104 100644 --- a/internal/upstream/desktop_test.go +++ b/internal/upstream/desktop_test.go @@ -1,121 +1,122 @@ -package upstream - -import ( - "encoding/json" - "io" - "net/http" - "net/http/httptest" - "testing" - - "github.com/linguo2625469/workbuddy2api-panel/internal/auth" -) - -// TestReportDesktopEventFingerprint 断言桌面指纹上报:走 chatBase、UA 为桌面形状、 -// 事件数组自动注入 workbuddy-desktop 公共指纹(覆盖同名业务键)。 -func TestReportDesktopEventFingerprint(t *testing.T) { - var got []map[string]any - var gotUA string - srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { - if r.URL.Path != "/v2/report" { - t.Errorf("path=%s want /v2/report", r.URL.Path) - } - gotUA = r.Header.Get("User-Agent") - if r.Header.Get("X-User-Id") != "u-dt" { - t.Errorf("X-User-Id=%q want u-dt", r.Header.Get("X-User-Id")) - } - if r.Header.Get("X-Product") != "SaaS" { - t.Errorf("X-Product=%q want SaaS", r.Header.Get("X-Product")) - } - raw, _ := io.ReadAll(r.Body) - if err := json.Unmarshal(raw, &got); err != nil { - t.Fatalf("body must be array: %v", err) - } - w.Write([]byte(`{"code":0,"msg":"OK"}`)) - })) - defer srv.Close() - - c := &Client{HTTP: srv.Client(), ChatBaseCN: srv.URL} - err := c.ReportDesktopEvent(&auth.Auth{AccessToken: "at", UID: "u-dt", Nickname: "RenJie"}, - DesktopEvent{"eventCode": "agent_task_created", "mode": "craft"}) - if err != nil { - t.Fatalf("report desktop: %v", err) - } - if gotUA != desktopUA { - t.Errorf("UA=%q want %q", gotUA, desktopUA) - } - if len(got) != 1 { - t.Fatalf("events=%d want 1", len(got)) - } - ev := got[0] - if ev["extName"] != "workbuddy-desktop" { - t.Errorf("extName=%v want workbuddy-desktop", ev["extName"]) - } - if ev["ideType"] != "WorkBuddy" || ev["ideName"] != "WorkBuddy" { - t.Errorf("ideType/ideName=%v/%v want WorkBuddy", ev["ideType"], ev["ideName"]) - } - if ev["userId"] != "u-dt" { - t.Errorf("userId=%v want u-dt", ev["userId"]) - } - if ev["userNickname"] != "RenJie" { - t.Errorf("userNickname=%v want RenJie", ev["userNickname"]) - } - if ev["mode"] != "craft" { - t.Errorf("业务字段 mode=%v 被指纹覆盖或缺失", ev["mode"]) - } - // machineId 应为 uid 稳定派生(36 hex)。 - if len(ev["machineId"].(string)) != 36 { - t.Errorf("machineId 长度=%d want 36", len(ev["machineId"].(string))) - } -} - -// TestDesktopChatSequenceShape 断言完整对话事件链的事件码顺序与关键字段。 -func TestDesktopChatSequenceShape(t *testing.T) { - events := DesktopChatSequence("conv-1", "req-1", "msg-1", "fast-model", "fast-model") - wantCodes := []string{ - "agent_task_created", "chat_message_send", "chat_request_send", - "chat_message_response", "chat_message_status", "chat_request_response", - } - if len(events) != len(wantCodes) { - t.Fatalf("events=%d want %d", len(events), len(wantCodes)) - } - for i, want := range wantCodes { - if events[i]["eventCode"] != want { - t.Errorf("events[%d].eventCode=%v want %v", i, events[i]["eventCode"], want) - } - } - resp := events[3] - if resp["isSuccessful"] != true { - t.Errorf("chat_message_response.isSuccessful=%v want true(RichMeow 判据)", resp["isSuccessful"]) - } - if resp["finishReason"] != "stop" { - t.Errorf("finishReason=%v want stop", resp["finishReason"]) - } - if resp["conversationId"] != "conv-1" { - t.Errorf("conversationId=%v want conv-1", resp["conversationId"]) - } -} - -// TestSetAppearanceTheme 断言主题设置端点形状(点亮 Hp_Appearance 的 API)。 -func TestSetAppearanceTheme(t *testing.T) { - var got map[string]any - srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { - if r.URL.Path != "/v2/user-asset/appearance/set" { - t.Errorf("path=%s want /v2/user-asset/appearance/set", r.URL.Path) - } - if r.Header.Get("User-Agent") != desktopUA { - t.Errorf("UA=%q want desktop UA", r.Header.Get("User-Agent")) - } - raw, _ := io.ReadAll(r.Body) - json.Unmarshal(raw, &got) - w.Write([]byte(`{"code":0,"msg":"OK"}`)) - })) - defer srv.Close() - - c := &Client{HTTP: srv.Client(), ChatBaseCN: srv.URL} - if err := c.SetAppearanceTheme(&auth.Auth{AccessToken: "at", UID: "u1"}, "theme-tkmw7j"); err != nil { - t.Fatalf("set theme: %v", err) - } - if got["kind"] != "theme" || got["resource_key"] != "theme-tkmw7j" { - t.Errorf("body=%v want kind=theme resource_key=theme-tkmw7j", got) - } -} +package upstream + +import ( + "encoding/json" + "io" + "net/http" + "net/http/httptest" + "testing" + + "github.com/misakano7545/workbuddy2api-panel/internal/auth" +) + +// TestReportDesktopEventFingerprint 断言桌面指纹上报:走 chatBase、UA 为桌面形状、 +// 事件数组自动注入 workbuddy-desktop 公共指纹(覆盖同名业务键)。 +func TestReportDesktopEventFingerprint(t *testing.T) { + var got []map[string]any + var gotUA string + srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { + if r.URL.Path != "/v2/report" { + t.Errorf("path=%s want /v2/report", r.URL.Path) + } + gotUA = r.Header.Get("User-Agent") + if r.Header.Get("X-User-Id") != "u-dt" { + t.Errorf("X-User-Id=%q want u-dt", r.Header.Get("X-User-Id")) + } + if r.Header.Get("X-Product") != "SaaS" { + t.Errorf("X-Product=%q want SaaS", r.Header.Get("X-Product")) + } + raw, _ := io.ReadAll(r.Body) + if err := json.Unmarshal(raw, &got); err != nil { + t.Fatalf("body must be array: %v", err) + } + w.Write([]byte(`{"code":0,"msg":"OK"}`)) + })) + defer srv.Close() + + c := &Client{HTTP: srv.Client(), ChatBaseCN: srv.URL} + err := c.ReportDesktopEvent(&auth.Auth{AccessToken: "at", UID: "u-dt", Nickname: "RenJie"}, + DesktopEvent{"eventCode": "agent_task_created", "mode": "craft"}) + if err != nil { + t.Fatalf("report desktop: %v", err) + } + // CN 账号 → 国内版形态;国际版形态由 TestDesktopUARealmBrand 单独钉。 + if wantUA := desktopUAFor(&auth.Auth{AccessToken: "at", UID: "u-dt"}); gotUA != wantUA { + t.Errorf("UA=%q want %q", gotUA, wantUA) + } + if len(got) != 1 { + t.Fatalf("events=%d want 1", len(got)) + } + ev := got[0] + if ev["extName"] != "workbuddy-desktop" { + t.Errorf("extName=%v want workbuddy-desktop", ev["extName"]) + } + if ev["ideType"] != "WorkBuddy" || ev["ideName"] != "WorkBuddy" { + t.Errorf("ideType/ideName=%v/%v want WorkBuddy", ev["ideType"], ev["ideName"]) + } + if ev["userId"] != "u-dt" { + t.Errorf("userId=%v want u-dt", ev["userId"]) + } + if ev["userNickname"] != "RenJie" { + t.Errorf("userNickname=%v want RenJie", ev["userNickname"]) + } + if ev["mode"] != "craft" { + t.Errorf("业务字段 mode=%v 被指纹覆盖或缺失", ev["mode"]) + } + // machineId 应为 uid 稳定派生(36 hex)。 + if len(ev["machineId"].(string)) != 36 { + t.Errorf("machineId 长度=%d want 36", len(ev["machineId"].(string))) + } +} + +// TestDesktopChatSequenceShape 断言完整对话事件链的事件码顺序与关键字段。 +func TestDesktopChatSequenceShape(t *testing.T) { + events := DesktopChatSequence("conv-1", "req-1", "msg-1", "fast-model", "fast-model") + wantCodes := []string{ + "agent_task_created", "chat_message_send", "chat_request_send", + "chat_message_response", "chat_message_status", "chat_request_response", + } + if len(events) != len(wantCodes) { + t.Fatalf("events=%d want %d", len(events), len(wantCodes)) + } + for i, want := range wantCodes { + if events[i]["eventCode"] != want { + t.Errorf("events[%d].eventCode=%v want %v", i, events[i]["eventCode"], want) + } + } + resp := events[3] + if resp["isSuccessful"] != true { + t.Errorf("chat_message_response.isSuccessful=%v want true(RichMeow 判据)", resp["isSuccessful"]) + } + if resp["finishReason"] != "stop" { + t.Errorf("finishReason=%v want stop", resp["finishReason"]) + } + if resp["conversationId"] != "conv-1" { + t.Errorf("conversationId=%v want conv-1", resp["conversationId"]) + } +} + +// TestSetAppearanceTheme 断言主题设置端点形状(点亮 Hp_Appearance 的 API)。 +func TestSetAppearanceTheme(t *testing.T) { + var got map[string]any + srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { + if r.URL.Path != "/v2/user-asset/appearance/set" { + t.Errorf("path=%s want /v2/user-asset/appearance/set", r.URL.Path) + } + if r.Header.Get("User-Agent") != desktopUAFor(&auth.Auth{AccessToken: "at", UID: "u1"}) { + t.Errorf("UA=%q want desktop CN UA", r.Header.Get("User-Agent")) + } + raw, _ := io.ReadAll(r.Body) + json.Unmarshal(raw, &got) + w.Write([]byte(`{"code":0,"msg":"OK"}`)) + })) + defer srv.Close() + + c := &Client{HTTP: srv.Client(), ChatBaseCN: srv.URL} + if err := c.SetAppearanceTheme(&auth.Auth{AccessToken: "at", UID: "u1"}, "theme-tkmw7j"); err != nil { + t.Fatalf("set theme: %v", err) + } + if got["kind"] != "theme" || got["resource_key"] != "theme-tkmw7j" { + t.Errorf("body=%v want kind=theme resource_key=theme-tkmw7j", got) + } +} diff --git a/internal/upstream/device_token.go b/internal/upstream/device_token.go index 5dfa1eed69ff9d7c551341ce69b8786df63e05e4..fe87421b26912cf09680e7382b593f85cdfa34c7 100644 --- a/internal/upstream/device_token.go +++ b/internal/upstream/device_token.go @@ -1,83 +1,83 @@ -// device_token.go X-Device-Token 的文件兜底读取(与桌面端共用状态文件)。 -// -// 容器内无桌面端 Turing Shield SDK,无法像 Python fork(xiaofan6ya/converter.py)那样 -// 现取 token。这里提供另一条路径:宿主把桌面端生成的 device token 落 /app/data/device_token -// (或任意挂载路径),网关定期读取注入。读取频率限 5 分钟一次缓存,>1KB 或读失败则忽略 -// (优雅降级不注入,不影响主流程)。 -package upstream - -import ( - "errors" - "os" - "strings" - "sync" - "time" -) - -var errDeviceTokenTooLarge = errors.New("device token file too large") - -// deviceTokenFile 文件读取缓存 TTL(秒)。桌面端 SDK 自身也有缓存,这里再兜一层 -// 避免每次出站请求都 stat+read 文件。 -const deviceTokenFileTTL = 5 * time.Minute - -// deviceTokenFileMaxLen token 文件最大字节数。token 通常几百字节;超过 1KB -// 视为异常(非 token 内容 / 文件被误用),忽略不注入。 -const deviceTokenFileMaxLen = 1024 - -// deviceTokenFileCache 缓存 device token 文件读取结果(path → token+读取时刻)。 -type deviceTokenFileCache struct { - mu sync.Mutex - path string - token string - readAt time.Time - lastErr error -} - -var dtFileCache = &deviceTokenFileCache{} - -// readDeviceTokenFile 读取并缓存 device token 文件;5 分钟内复用上次结果。 -// 返回空串表示无可用 token(文件未配置 / 读失败 / 内容过长 / 空白)。 -func readDeviceTokenFile(path string) string { - if path == "" { - return "" - } - // 快路径:缓存命中且未过期,直接返回缓存值。注意全程持锁(defer Unlock)—— - // 含 5 分钟一次的过期重读(锁内读文件)。调用频率极低(每 5min 最多一次 - // 文件 IO,文件上限 1KB),锁内 IO 可接受;若未来出现 NFS 挂载 + 高并发的 - // 部署形态,再上 singleflight 包住重读段(YAGNI,现在不做)。 - dtFileCache.mu.Lock() - defer dtFileCache.mu.Unlock() - if path == dtFileCache.path && time.Since(dtFileCache.readAt) < deviceTokenFileTTL { - return dtFileCache.token - } - // 缓存未命中或过期:重新读文件。 - dtFileCache.path = path - tok, err := readTrimmedFile(path, deviceTokenFileMaxLen) - if err != nil { - // 读失败:清空缓存 token,避免注入过期/错误的值。 - dtFileCache.token = "" - dtFileCache.lastErr = err - dtFileCache.readAt = time.Now() - return "" - } - dtFileCache.token = tok - dtFileCache.lastErr = nil - dtFileCache.readAt = time.Now() - return tok -} - -// readTrimmedFile 读文件并 trim 首尾空白,超过 maxLen 返回错误(拒绝过长内容)。 -func readTrimmedFile(path string, maxLen int) (string, error) { - info, err := os.Stat(path) - if err != nil { - return "", err - } - if info.Size() > int64(maxLen) { - return "", errDeviceTokenTooLarge - } - raw, err := os.ReadFile(path) - if err != nil { - return "", err - } - return strings.TrimSpace(string(raw)), nil -} +// device_token.go X-Device-Token 的文件兜底读取(与桌面端共用状态文件)。 +// +// 容器内无桌面端 Turing Shield SDK,无法像 Python fork(xiaofan6ya/converter.py)那样 +// 现取 token。这里提供另一条路径:宿主把桌面端生成的 device token 落 /app/data/device_token +// (或任意挂载路径),网关定期读取注入。读取频率限 5 分钟一次缓存,>1KB 或读失败则忽略 +// (优雅降级不注入,不影响主流程)。 +package upstream + +import ( + "errors" + "os" + "strings" + "sync" + "time" +) + +var errDeviceTokenTooLarge = errors.New("device token file too large") + +// deviceTokenFile 文件读取缓存 TTL(秒)。桌面端 SDK 自身也有缓存,这里再兜一层 +// 避免每次出站请求都 stat+read 文件。 +const deviceTokenFileTTL = 5 * time.Minute + +// deviceTokenFileMaxLen token 文件最大字节数。token 通常几百字节;超过 1KB +// 视为异常(非 token 内容 / 文件被误用),忽略不注入。 +const deviceTokenFileMaxLen = 1024 + +// deviceTokenFileCache 缓存 device token 文件读取结果(path → token+读取时刻)。 +type deviceTokenFileCache struct { + mu sync.Mutex + path string + token string + readAt time.Time + lastErr error +} + +var dtFileCache = &deviceTokenFileCache{} + +// readDeviceTokenFile 读取并缓存 device token 文件;5 分钟内复用上次结果。 +// 返回空串表示无可用 token(文件未配置 / 读失败 / 内容过长 / 空白)。 +func readDeviceTokenFile(path string) string { + if path == "" { + return "" + } + // 快路径:缓存命中且未过期,直接返回缓存值。注意全程持锁(defer Unlock)—— + // 含 5 分钟一次的过期重读(锁内读文件)。调用频率极低(每 5min 最多一次 + // 文件 IO,文件上限 1KB),锁内 IO 可接受;若未来出现 NFS 挂载 + 高并发的 + // 部署形态,再上 singleflight 包住重读段(YAGNI,现在不做)。 + dtFileCache.mu.Lock() + defer dtFileCache.mu.Unlock() + if path == dtFileCache.path && time.Since(dtFileCache.readAt) < deviceTokenFileTTL { + return dtFileCache.token + } + // 缓存未命中或过期:重新读文件。 + dtFileCache.path = path + tok, err := readTrimmedFile(path, deviceTokenFileMaxLen) + if err != nil { + // 读失败:清空缓存 token,避免注入过期/错误的值。 + dtFileCache.token = "" + dtFileCache.lastErr = err + dtFileCache.readAt = time.Now() + return "" + } + dtFileCache.token = tok + dtFileCache.lastErr = nil + dtFileCache.readAt = time.Now() + return tok +} + +// readTrimmedFile 读文件并 trim 首尾空白,超过 maxLen 返回错误(拒绝过长内容)。 +func readTrimmedFile(path string, maxLen int) (string, error) { + info, err := os.Stat(path) + if err != nil { + return "", err + } + if info.Size() > int64(maxLen) { + return "", errDeviceTokenTooLarge + } + raw, err := os.ReadFile(path) + if err != nil { + return "", err + } + return strings.TrimSpace(string(raw)), nil +} diff --git a/internal/upstream/device_token_test.go b/internal/upstream/device_token_test.go index bebd0c2b6ade96797e536495f54430ab5d7e843c..0a1f9adb417e83a15852e0faf868f72543c06d30 100644 --- a/internal/upstream/device_token_test.go +++ b/internal/upstream/device_token_test.go @@ -1,180 +1,180 @@ -// device_token_test.go X-Device-Token 注入 + 文件兜底读取单测。 -package upstream - -import ( - "net/http" - "net/http/httptest" - "os" - "path/filepath" - "strings" - "sync" - "testing" - "time" - - "github.com/linguo2625469/workbuddy2api-panel/internal/auth" -) - -// TestDeviceTokenInjected_WhenSet auth.Auth.DeviceToken 非空时 chat/billing 请求均注入。 -func TestDeviceTokenInjected_WhenSet(t *testing.T) { - a := &auth.Auth{AccessToken: "at", UID: "u1", DeviceToken: "tok-from-auth"} - // 用 server 端验证而非 RoundTripper 捕获:更贴近真实注入路径。 - for _, tc := range []struct { - name string - apply func(c *Client, req *http.Request) - wantPath string - }{ - {"chat", func(c *Client, req *http.Request) { c.ChatHeaders(req, a, "", ChatMeta{}) }, "/v2/chat/completions"}, - {"billing", func(c *Client, req *http.Request) { c.BillingHeaders(req, a) }, "/v2/report"}, - } { - t.Run(tc.name, func(t *testing.T) { - var got string - srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { - got = r.Header.Get("X-Device-Token") - w.WriteHeader(200) - _, _ = w.Write([]byte(`{"code":0}`)) - })) - defer srv.Close() - c := &Client{ - HTTP: srv.Client(), - ChatHTTP: srv.Client(), - ChatBaseCN: srv.URL, - BillingBaseCN: srv.URL, - } - req, _ := http.NewRequest(http.MethodPost, srv.URL+tc.wantPath, nil) - tc.apply(c, req) - resp, err := c.HTTP.Do(req) - if err != nil { - t.Fatalf("do: %v", err) - } - resp.Body.Close() - if got != "tok-from-auth" { - t.Errorf("X-Device-Token = %q want %q", got, "tok-from-auth") - } - }) - } -} - -// TestDeviceTokenNotInjected_WhenEmpty 所有来源皆空时不注入该头。 -func TestDeviceTokenNotInjected_WhenEmpty(t *testing.T) { - a := &auth.Auth{AccessToken: "at", UID: "u1"} // DeviceToken 空 - var got string - srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { - got = r.Header.Get("X-Device-Token") - w.WriteHeader(200) - _, _ = w.Write([]byte(`{"code":0}`)) - })) - defer srv.Close() - c := &Client{ - HTTP: srv.Client(), - ChatHTTP: srv.Client(), - ChatBaseCN: srv.URL, - BillingBaseCN: srv.URL, - // DeviceToken / DeviceTokenFile 皆空 - } - req, _ := http.NewRequest(http.MethodPost, srv.URL+"/v2/chat/completions", nil) - c.ChatHeaders(req, a, "", ChatMeta{}) - resp, err := c.HTTP.Do(req) - if err != nil { - t.Fatalf("do: %v", err) - } - resp.Body.Close() - if got != "" { - t.Errorf("X-Device-Token = %q want empty (not injected)", got) - } -} - -// TestDeviceTokenFromConfigOrFile_Overrides 优先级:auth > config > 文件。 -// auth 有值时覆盖 config;auth 空时 config 兜底;auth 与 config 皆空时读文件。 -func TestDeviceTokenFromConfigOrFile_Overrides(t *testing.T) { - dir := t.TempDir() - fp := filepath.Join(dir, "device_token") - if err := os.WriteFile(fp, []byte("tok-from-file\n"), 0o600); err != nil { - t.Fatalf("write file: %v", err) - } - - cases := []struct { - name string - auth string - cfg string - want string - }{ - {"auth_over_config", "tok-auth", "tok-config", "tok-auth"}, - {"config_when_auth_empty", "", "tok-config", "tok-config"}, - {"file_when_auth_and_config_empty", "", "", "tok-from-file"}, - } - for _, tc := range cases { - t.Run(tc.name, func(t *testing.T) { - // 每个用例用独立缓存:device token 文件缓存 5 分钟,case 间会串扰。 - save := resetDeviceTokenFileCache(fp) - defer save() - a := &auth.Auth{AccessToken: "at", UID: "u1", DeviceToken: tc.auth} - var got string - srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { - got = r.Header.Get("X-Device-Token") - w.WriteHeader(200) - _, _ = w.Write([]byte(`{"code":0}`)) - })) - defer srv.Close() - c := &Client{ - HTTP: srv.Client(), - ChatHTTP: srv.Client(), - ChatBaseCN: srv.URL, - BillingBaseCN: srv.URL, - DeviceToken: tc.cfg, - DeviceTokenFile: fp, - } - req, _ := http.NewRequest(http.MethodPost, srv.URL+"/v2/chat/completions", nil) - c.ChatHeaders(req, a, "", ChatMeta{}) - resp, err := c.HTTP.Do(req) - if err != nil { - t.Fatalf("do: %v", err) - } - resp.Body.Close() - if got != tc.want { - t.Errorf("X-Device-Token = %q want %q", got, tc.want) - } - }) - } -} - -// TestDeviceTokenFileTooLarge 文件超过 1KB 时忽略不注入。 -func TestDeviceTokenFileTooLarge(t *testing.T) { - dir := t.TempDir() - fp := filepath.Join(dir, "device_token") - if err := os.WriteFile(fp, []byte(strings.Repeat("x", 2048)), 0o600); err != nil { - t.Fatalf("write file: %v", err) - } - save := resetDeviceTokenFileCache(fp) - defer save() - a := &auth.Auth{AccessToken: "at", UID: "u1"} - c := &Client{DeviceTokenFile: fp} - if tok := c.resolveDeviceToken(a); tok != "" { - t.Errorf("resolveDeviceToken() = %q want empty (file too large)", tok) - } -} - -// resetDeviceTokenFileCache 替换全局 device token 文件缓存并返回恢复函数。 -// 文件缓存 5 分钟 TTL,测试间需清空避免串扰。 -func resetDeviceTokenFileCache(path string) (restore func()) { - dtFileCache.mu.Lock() - origPath := dtFileCache.path - origTok := dtFileCache.token - origRead := dtFileCache.readAt - origErr := dtFileCache.lastErr - dtFileCache.path = path - dtFileCache.token = "" - dtFileCache.readAt = time.Time{} - dtFileCache.lastErr = nil - dtFileCache.mu.Unlock() - var once sync.Once - return func() { - once.Do(func() { - dtFileCache.mu.Lock() - dtFileCache.path = origPath - dtFileCache.token = origTok - dtFileCache.readAt = origRead - dtFileCache.lastErr = origErr - dtFileCache.mu.Unlock() - }) - } -} +// device_token_test.go X-Device-Token 注入 + 文件兜底读取单测。 +package upstream + +import ( + "net/http" + "net/http/httptest" + "os" + "path/filepath" + "strings" + "sync" + "testing" + "time" + + "github.com/misakano7545/workbuddy2api-panel/internal/auth" +) + +// TestDeviceTokenInjected_WhenSet auth.Auth.DeviceToken 非空时 chat/billing 请求均注入。 +func TestDeviceTokenInjected_WhenSet(t *testing.T) { + a := &auth.Auth{AccessToken: "at", UID: "u1", DeviceToken: "tok-from-auth"} + // 用 server 端验证而非 RoundTripper 捕获:更贴近真实注入路径。 + for _, tc := range []struct { + name string + apply func(c *Client, req *http.Request) + wantPath string + }{ + {"chat", func(c *Client, req *http.Request) { c.ChatHeaders(req, a, "", ChatMeta{}) }, "/v2/chat/completions"}, + {"billing", func(c *Client, req *http.Request) { c.BillingHeaders(req, a) }, "/v2/report"}, + } { + t.Run(tc.name, func(t *testing.T) { + var got string + srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { + got = r.Header.Get("X-Device-Token") + w.WriteHeader(200) + _, _ = w.Write([]byte(`{"code":0}`)) + })) + defer srv.Close() + c := &Client{ + HTTP: srv.Client(), + ChatHTTP: srv.Client(), + ChatBaseCN: srv.URL, + BillingBaseCN: srv.URL, + } + req, _ := http.NewRequest(http.MethodPost, srv.URL+tc.wantPath, nil) + tc.apply(c, req) + resp, err := c.HTTP.Do(req) + if err != nil { + t.Fatalf("do: %v", err) + } + resp.Body.Close() + if got != "tok-from-auth" { + t.Errorf("X-Device-Token = %q want %q", got, "tok-from-auth") + } + }) + } +} + +// TestDeviceTokenNotInjected_WhenEmpty 所有来源皆空时不注入该头。 +func TestDeviceTokenNotInjected_WhenEmpty(t *testing.T) { + a := &auth.Auth{AccessToken: "at", UID: "u1"} // DeviceToken 空 + var got string + srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { + got = r.Header.Get("X-Device-Token") + w.WriteHeader(200) + _, _ = w.Write([]byte(`{"code":0}`)) + })) + defer srv.Close() + c := &Client{ + HTTP: srv.Client(), + ChatHTTP: srv.Client(), + ChatBaseCN: srv.URL, + BillingBaseCN: srv.URL, + // DeviceToken / DeviceTokenFile 皆空 + } + req, _ := http.NewRequest(http.MethodPost, srv.URL+"/v2/chat/completions", nil) + c.ChatHeaders(req, a, "", ChatMeta{}) + resp, err := c.HTTP.Do(req) + if err != nil { + t.Fatalf("do: %v", err) + } + resp.Body.Close() + if got != "" { + t.Errorf("X-Device-Token = %q want empty (not injected)", got) + } +} + +// TestDeviceTokenFromConfigOrFile_Overrides 优先级:auth > config > 文件。 +// auth 有值时覆盖 config;auth 空时 config 兜底;auth 与 config 皆空时读文件。 +func TestDeviceTokenFromConfigOrFile_Overrides(t *testing.T) { + dir := t.TempDir() + fp := filepath.Join(dir, "device_token") + if err := os.WriteFile(fp, []byte("tok-from-file\n"), 0o600); err != nil { + t.Fatalf("write file: %v", err) + } + + cases := []struct { + name string + auth string + cfg string + want string + }{ + {"auth_over_config", "tok-auth", "tok-config", "tok-auth"}, + {"config_when_auth_empty", "", "tok-config", "tok-config"}, + {"file_when_auth_and_config_empty", "", "", "tok-from-file"}, + } + for _, tc := range cases { + t.Run(tc.name, func(t *testing.T) { + // 每个用例用独立缓存:device token 文件缓存 5 分钟,case 间会串扰。 + save := resetDeviceTokenFileCache(fp) + defer save() + a := &auth.Auth{AccessToken: "at", UID: "u1", DeviceToken: tc.auth} + var got string + srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { + got = r.Header.Get("X-Device-Token") + w.WriteHeader(200) + _, _ = w.Write([]byte(`{"code":0}`)) + })) + defer srv.Close() + c := &Client{ + HTTP: srv.Client(), + ChatHTTP: srv.Client(), + ChatBaseCN: srv.URL, + BillingBaseCN: srv.URL, + DeviceToken: tc.cfg, + DeviceTokenFile: fp, + } + req, _ := http.NewRequest(http.MethodPost, srv.URL+"/v2/chat/completions", nil) + c.ChatHeaders(req, a, "", ChatMeta{}) + resp, err := c.HTTP.Do(req) + if err != nil { + t.Fatalf("do: %v", err) + } + resp.Body.Close() + if got != tc.want { + t.Errorf("X-Device-Token = %q want %q", got, tc.want) + } + }) + } +} + +// TestDeviceTokenFileTooLarge 文件超过 1KB 时忽略不注入。 +func TestDeviceTokenFileTooLarge(t *testing.T) { + dir := t.TempDir() + fp := filepath.Join(dir, "device_token") + if err := os.WriteFile(fp, []byte(strings.Repeat("x", 2048)), 0o600); err != nil { + t.Fatalf("write file: %v", err) + } + save := resetDeviceTokenFileCache(fp) + defer save() + a := &auth.Auth{AccessToken: "at", UID: "u1"} + c := &Client{DeviceTokenFile: fp} + if tok := c.resolveDeviceToken(a); tok != "" { + t.Errorf("resolveDeviceToken() = %q want empty (file too large)", tok) + } +} + +// resetDeviceTokenFileCache 替换全局 device token 文件缓存并返回恢复函数。 +// 文件缓存 5 分钟 TTL,测试间需清空避免串扰。 +func resetDeviceTokenFileCache(path string) (restore func()) { + dtFileCache.mu.Lock() + origPath := dtFileCache.path + origTok := dtFileCache.token + origRead := dtFileCache.readAt + origErr := dtFileCache.lastErr + dtFileCache.path = path + dtFileCache.token = "" + dtFileCache.readAt = time.Time{} + dtFileCache.lastErr = nil + dtFileCache.mu.Unlock() + var once sync.Once + return func() { + once.Do(func() { + dtFileCache.mu.Lock() + dtFileCache.path = origPath + dtFileCache.token = origTok + dtFileCache.readAt = origRead + dtFileCache.lastErr = origErr + dtFileCache.mu.Unlock() + }) + } +} diff --git a/internal/upstream/dns_test.go b/internal/upstream/dns_test.go new file mode 100644 index 0000000000000000000000000000000000000000..9ed04f865bdb54d654deecd915fb03ea98020b11 --- /dev/null +++ b/internal/upstream/dns_test.go @@ -0,0 +1,116 @@ +// dns_test.go 出站 DNS 覆盖(config dns_servers / WB2A_DNS)回归。 +// +// 这条接线的价值全在「系统解析器不可用」的环境(Android 无 /etc/resolv.conf、本地 +// DNS 被污染)。测试不依赖外网:用本地 TCP 监听冒充 DNS 服务器,验证拨号器确实 +// 按配置的服务器建连、并按顺序在失败后换下一台。 +package upstream + +import ( + "context" + "net" + "net/http" + "testing" + "time" +) + +// 未配置服务器时必须是「系统解析器」原样:Resolver 为 nil,SetDNSDialer 也不动 +// Transport——否则一个默认配置的空列表会悄悄改掉所有出站解析行为。 +func TestNewDNSDialerWithoutServersKeepsSystemResolver(t *testing.T) { + d := NewDNSDialer(nil) + if d == nil || d.Resolver != nil { + t.Fatalf("空列表应返回系统解析器拨号器,got %+v", d) + } + if d.Timeout != dialTimeout || d.KeepAlive != dialKeepAlive { + t.Fatalf("连接层参数应沿用 newDialer:timeout=%v keepalive=%v", d.Timeout, d.KeepAlive) + } + + c := New() + c.SetDNSDialer(NewDNSDialer(nil)) + if c.HTTP.Transport.(*http.Transport).DialContext == nil { + t.Fatal("不应把 DialContext 清成 nil") + } +} + +// 配置了服务器时:PreferGo 必须开(cgo 解析器无视 Resolver.Dial,会继续走系统配置), +// 且首台连不上要自动换下一台,而不是整轮解析失败。 +func TestNewDNSDialerAdvancesThroughServers(t *testing.T) { + ln, err := net.Listen("tcp", "127.0.0.1:0") + if err != nil { + t.Fatalf("listen: %v", err) + } + defer ln.Close() + go func() { + for { + conn, err := ln.Accept() + if err != nil { + return + } + conn.Close() + } + }() + + // 第一台指向必然拒绝的端口(tcp 拨号会立刻 ECONNREFUSED),第二台是真监听。 + dead := "127.0.0.1:1" + alive := ln.Addr().String() + d := NewDNSDialer([]string{dead, alive}) + if d.Resolver == nil || !d.Resolver.PreferGo { + t.Fatalf("Resolver 必须存在且 PreferGo=true:%+v", d.Resolver) + } + + ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second) + defer cancel() + // 只验证「按配置的服务器建连」这一段(Dial 本身),不验证真实查询/应答: + // 冒充的服务器不回应 DNS 报文,但建连成功即证明走的是配置的解析器。 + conn, err := d.Resolver.Dial(ctx, "tcp", "ignored:53") + if err != nil { + t.Fatalf("应在首台失败后落到第二台:%v", err) + } + if got := conn.RemoteAddr().String(); got != alive { + conn.Close() + t.Fatalf("建连地址=%q want %q(未按顺序尝试配置的服务器)", got, alive) + } + conn.Close() +} + +// 全部服务器都连不上时返回错误(不是 panic、不是 nil 连接)。 +func TestNewDNSDialerAllServersFail(t *testing.T) { + d := NewDNSDialer([]string{"127.0.0.1:1"}) + ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second) + defer cancel() + conn, err := d.Resolver.Dial(ctx, "tcp", "ignored:53") + if err == nil { + conn.Close() + t.Fatal("全台失败应返回 error") + } +} + +// SetDNSDialer 必须把拨号器挂到两个 client 上(HTTP 与 ChatHTTP 共用 newTransport +// 实例;真实部署里两者可能被 Config 分别改写 Transport,故各自覆盖)。 +func TestSetDNSDialerWiresBothClients(t *testing.T) { + c := New() + d := NewDNSDialer([]string{"127.0.0.1:53"}) + c.SetDNSDialer(d) + for name, cl := range map[string]*http.Client{"HTTP": c.HTTP, "ChatHTTP": c.ChatHTTP} { + tr, ok := cl.Transport.(*http.Transport) + if !ok { + t.Fatalf("%s Transport 类型变了:%T", name, cl.Transport) + } + if tr.DialContext == nil { + t.Fatalf("%s DialContext 未接线", name) + } + } + // 连接池参数不能被顺手改掉(挂 DNS 只该动 DialContext)。 + tr := c.ChatHTTP.Transport.(*http.Transport) + if tr.MaxIdleConnsPerHost != maxIdleConnsPerHost || tr.IdleConnTimeout != idleConnTimeout { + t.Fatalf("连接池参数被改动:%+v", tr) + } +} + +// nil 拨号器不得panic、不得改动 Transport(配置解析失败路径会传 nil)。 +func TestSetDNSDialerIgnoresNil(t *testing.T) { + c := New() + c.SetDNSDialer(nil) + if c.HTTP.Transport.(*http.Transport).DialContext == nil { + t.Fatal("nil 拨号器不应清掉 DialContext") + } +} diff --git a/internal/upstream/dsml.go b/internal/upstream/dsml.go new file mode 100644 index 0000000000000000000000000000000000000000..1f4b963d00151da3b8424a9257c97495ae64082b --- /dev/null +++ b/internal/upstream/dsml.go @@ -0,0 +1,495 @@ +// dsml.go 上游正文里的「模型原生工具调用标记」修复层。 +// +// 背景:本网关背后的 WorkBuddy 上游最终由 DeepSeek 系模型出结果,它的工具调用原生 +// 语法不是 OpenAI 的 JSON tool_calls,而是一段带全角竖线分隔符的标记文本: +// +// DSML calls> +// DSML invoke name="exec_command"> +// DSML parameter name="cmd" string="true">ls -laDSML parameter> +// DSML invoke> +// DSML calls> +// +// (上面用 占位,真实分隔符是两个 U+FF5C 全角竖线,见 markupPipe 常量。) +// +// 上游只在请求**声明了 tools** 时才把这段标记解析成结构化 tool_calls。一旦某次请求 +// 没带上 tools(客户端一次性 exec 探测、auto-review 复核回合、或任何 tools 中途丢失 +// 的请求),模型仍然想调工具,于是这段标记以纯文本落进 content。下游没有任何一层 +// 认识它:Codex 只执行 Responses API 的结构化 function_call 条目,于是把标记当成 +// 普通助手文本写进会话历史,回合直接结束、工具一次都没跑——用户看到的就是历史会话 +// 里躺着一大段莫名其妙的标记,任务没有推进。 +// +// 本文件是最后一道防线:在出站响应(流式与非流式)里识别这段标记,还原成标准的 +// tool_calls / delta.tool_calls。 +// +// 判定分两级,因为「客户端声明了哪些工具」这件事在链路上并不可靠——实测最常见的 +// 泄漏场景恰恰是 tools 声明在中转环节丢失,此时请求体里根本没有 tools 名单: +// +// 严格判定(名单非空):块内每个 invoke 的工具名都必须在名单里。 +// 弱判定(名单为空):只要求块结构完美闭合、块内不夹带正文,且每个工具名形如 +// 合法标识符(markupToolNameRe)。模型在正文里「讨论」这段语法时写出的多是 +// 、NAME 之类占位符,会被形态检查挡住。 +// +// 两级判定共同的硬性前提(任一不满足即原文透出): +// +// - 标记块完整闭合,块内除 invoke/parameter 与空白外没有夹带其他正文; +// - 本回合上游没有给出任何结构化 tool_calls(不覆盖真实调用); +// - 非流式路径额外要求 finish_reason 为 stop(length 表示正文被截断,不作解释)。 +// +// 任何一条不满足 → 原文逐字节原样透出。修复层绝不吞字节:所有「拿不准」的分支都 +// 走回吐路径。 +package upstream + +import ( + "encoding/json" + "fmt" + "regexp" + "strings" + "time" +) + +// markupPipe 是模型原生工具调用标记的分隔符:两个全角竖线 U+FF5C。 +const markupPipe = "\uFF5C\uFF5C" + +// 标记块与内层元素的起止标记。 +// +// 结束标记一律比同名的开始标记多一个 '/',因此 markupInvokeRe / markupParamRe 里 +// 「< 开头」的匹配不可能落到结束标记上。 +const ( + markupOpen = "<" + markupPipe + "DSML" + markupPipe + " calls>" + markupClose = "" + markupInvokeClose = "" + markupParamClose = "" +) + +// markupTagPrefix 是开始标记的公共前缀(已转义,供下面两个正则复用)。 +var markupTagPrefix = regexp.QuoteMeta("<" + markupPipe + "DSML" + markupPipe) + +// markupInvokeRe 匹配 invoke 头:DSML invoke name="NAME">。 +// markupParamRe 匹配 parameter 头:DSML parameter name="NAME" string="true">, +// 其中 string 属性可选(缺省按 JSON 解析取值)。 +var ( + markupInvokeRe = regexp.MustCompile(markupTagPrefix + `\s+invoke\s+name="([^"]*)"\s*>`) + markupParamRe = regexp.MustCompile(markupTagPrefix + `\s+parameter\s+name="([^"]*)"(?:\s+string="(true|false)")?\s*>`) +) + +// markupToolNameRe 是工具名的合理形态:各家 SDK 的工具名一律是这种标识符。 +// 弱判定(客户端没给出 tools 名单)时用它兜底,挡住模型在正文里「讨论」这段语法 +// 时写出的 、NAME 之类占位符。 +var markupToolNameRe = regexp.MustCompile(`^[A-Za-z0-9_][A-Za-z0-9_.:-]{0,63}$`) + +// markupMaxBlockBytes 单次标记块的累积上限。正常块从几百字节(一条 ls)到几十 KB +// (一段 apply_patch)。超过上限仍未闭合 → 判定「这不是标记」(例如模型在正文里 +// 讨论这段语法),立即原文回吐并退出块态,避免无限缓冲。 +const markupMaxBlockBytes = 256 * 1024 + +// MarkupCall 是一次从正文里还原出来的工具调用。 +type MarkupCall struct { + Name string + Arguments string // JSON 对象文本 +} + +// MarkupRepair 是流式与非流式共用的标记修复状态机。 +// 非并发安全:一条响应流一个实例。零值不可用,请用 NewMarkupRepair 构造。 +type MarkupRepair struct { + allowed map[string]bool + allowUnknown bool + hold string // 已确认可能属于标记、但还不足以判定的尾部缓冲 + inBlock bool // 已消费掉 markupOpen,正在块内部累积 + seen int // 识别到的标记块数(含被拒绝的) + rejected int // 识别到但未转换的块数(观测/排障用) + converted int // 已还原的调用数(观测用) +} + +// NewMarkupRepair 按客户端声明的工具名构造修复器。 +// +// allowed 为请求体里提取到的工具名集合(可能为空——tools 声明在中转环节丢失是常态)。 +// allowUnknown 为 true 时启用弱判定:名单为空也尝试修复,改由「块结构完美 + 工具名 +// 形如标识符」把关。见文件头「判定分两级」。 +// +// 两者都为空/为 false → 修复器整体禁用(Enabled() 为 false),Feed 恒等透传。 +func NewMarkupRepair(allowed map[string]bool, allowUnknown bool) *MarkupRepair { + return &MarkupRepair{allowed: allowed, allowUnknown: allowUnknown} +} + +// Enabled 报告修复器是否启用。 +func (r *MarkupRepair) Enabled() bool { + return r != nil && (len(r.allowed) > 0 || r.allowUnknown) +} + +// Converted 返回本次流里已还原的工具调用总数(观测用)。 +func (r *MarkupRepair) Converted() int { + if r == nil { + return 0 + } + return r.converted +} + +// Seen 返回本次流里识别到的标记块数(含被拒绝的)。 +func (r *MarkupRepair) Seen() int { + if r == nil { + return 0 + } + return r.seen +} + +// Rejected 返回识别到但未转换的块数。Seen 与 Converted 的差额即此值; +// 单独暴露是为了排障时能一眼区分「没识别到」与「识别到但判定不通过」。 +func (r *MarkupRepair) Rejected() int { + if r == nil { + return 0 + } + return r.rejected +} + +// Feed 吃进一段正文增量,返回「应当作为正文透出的部分」与「还原出来的工具调用」。 +// 调用方必须把返回的正文按原顺序写出,并把返回的调用按出现顺序转成 tool_call。 +// +// 不变量:所有 Feed 的入参拼接后,等于「所有返回的正文 + Flush() + 被成功转换的 +// 标记块原文」。即除了被转换掉的标记块本身,一个字节都不会丢。 +func (r *MarkupRepair) Feed(text string) (string, []MarkupCall) { + if !r.Enabled() { + return text, nil + } + s := r.hold + text + r.hold = "" + var emit strings.Builder + var calls []MarkupCall + for { + if !r.inBlock { + i := markupStartCandidate(s) + if i < 0 { + emit.WriteString(s) + break + } + if len(s)-i < len(markupOpen) { + // 起点被截断在增量边界(上游把标记切成了两片):留到下一片再判定。 + emit.WriteString(s[:i]) + r.hold = s[i:] + break + } + emit.WriteString(s[:i]) + s = s[i+len(markupOpen):] + r.inBlock = true + continue + } + k := strings.Index(s, markupClose) + if k < 0 { + if len(s) > markupMaxBlockBytes { + // 超长未闭合:不是标记,原文回吐并退出块态。 + emit.WriteString(markupOpen) + emit.WriteString(s) + r.inBlock = false + break + } + r.hold = s + break + } + inner := s[:k] + s = s[k+len(markupClose):] + r.inBlock = false + r.seen++ + if got, ok := parseMarkupBlock(inner, r.allowed); ok { + calls = append(calls, got...) + r.converted += len(got) + continue + } + // 块内不是纯调用(夹带正文 / 工具名不合规 / 参数畸形):原文回吐,绝不吞字节。 + r.rejected++ + emit.WriteString(markupOpen) + emit.WriteString(inner) + emit.WriteString(markupClose) + } + return emit.String(), calls +} + +// Flush 在响应流结束时调用:把仍未判定的尾部缓冲原文交还。未闭合的块连同起始标记 +// 一起回吐——上游发了什么就透出什么。 +func (r *MarkupRepair) Flush() string { + if !r.Enabled() { + return "" + } + out := r.hold + if r.inBlock { + out = markupOpen + r.hold + } + r.hold = "" + r.inBlock = false + return out +} + +// markupStartCandidate 返回 s 中最早的「可能是 markupOpen 起点」的下标:该位置之后 +// 要么正好是完整的 markupOpen,要么是 markupOpen 的一个前缀(被增量边界截断)。 +// 没有候选返回 -1。 +func markupStartCandidate(s string) int { + for i := 0; i < len(s); i++ { + if s[i] != '<' { + continue + } + rest := s[i:] + if len(rest) >= len(markupOpen) { + if rest[:len(markupOpen)] == markupOpen { + return i + } + continue + } + if strings.HasPrefix(markupOpen, rest) { + return i + } + } + return -1 +} + +// parseMarkupBlock 解析 calls 块内部(外层起止标记之间的内容)。 +// +// 成功要求:块内除 invoke 与空白外没有别的字节;每个 invoke 都闭合;每个 invoke 的 +// 参数列表合法;工具名判定通过。工具名判定按 allowed 是否为空分两级(见文件头): +// 名单非空走严格比对,名单为空走形态检查。任一不满足返回 ok=false,由调用方原文回吐。 +func parseMarkupBlock(inner string, allowed map[string]bool) ([]MarkupCall, bool) { + strict := len(allowed) > 0 + var out []MarkupCall + pos := 0 + for { + loc := markupInvokeRe.FindStringSubmatchIndex(inner[pos:]) + if loc == nil { + break + } + if strings.TrimSpace(inner[pos:pos+loc[0]]) != "" { + return nil, false // invoke 之前夹带了正文 + } + name := inner[pos+loc[2] : pos+loc[3]] + bodyStart := pos + loc[1] + end := strings.Index(inner[bodyStart:], markupInvokeClose) + if end < 0 { + return nil, false // invoke 未闭合 + } + body := inner[bodyStart : bodyStart+end] + pos = bodyStart + end + len(markupInvokeClose) + args, ok := parseMarkupParams(body) + if !ok { + return nil, false + } + if strict { + if !allowed[name] { + return nil, false // 工具名不在客户端声明的 tools 里 → 不认,原文透出 + } + } else if !markupToolNameRe.MatchString(name) { + return nil, false // 名单缺失时的弱判定:名字不像工具名 → 不认,原文透出 + } + out = append(out, MarkupCall{Name: name, Arguments: args}) + } + if len(out) == 0 { + return nil, false + } + if strings.TrimSpace(inner[pos:]) != "" { + return nil, false // 最后一个 invoke 之后夹带了正文 + } + return out, true +} + +// parseMarkupParams 解析一个 invoke 内部的 parameter 列表,产出 JSON 对象文本。 +// +// string="true" 的取值按原文字符串处理(走 JSON 转义,命令里的换行/引号/反斜杠 +// 原样保留);其余先按 JSON 解析,失败则退化为字符串——参数值永远不丢,最坏情况 +// 是类型不如模型本意。无参数的工具产出 "{}"。 +func parseMarkupParams(body string) (string, bool) { + args := map[string]any{} + pos := 0 + for { + loc := markupParamRe.FindStringSubmatchIndex(body[pos:]) + if loc == nil { + break + } + if strings.TrimSpace(body[pos:pos+loc[0]]) != "" { + return "", false + } + name := body[pos+loc[2] : pos+loc[3]] + isString := loc[4] >= 0 && body[pos+loc[4]:pos+loc[5]] == "true" + valStart := pos + loc[1] + end := strings.Index(body[valStart:], markupParamClose) + if end < 0 { + return "", false + } + raw := body[valStart : valStart+end] + pos = valStart + end + len(markupParamClose) + if isString { + args[name] = raw + continue + } + var v any + if json.Unmarshal([]byte(strings.TrimSpace(raw)), &v) == nil { + args[name] = v + } else { + args[name] = raw + } + } + if strings.TrimSpace(body[pos:]) != "" { + return "", false + } + out, err := json.Marshal(args) + if err != nil { + return "", false + } + return string(out), true +} + +// ToolNameAllowlist 从客户端请求体里收集「可用于判定工具调用」的工具名集合。 +// +// 两个来源都要,因为二者会分别缺失: +// 1. 本请求声明的工具:OpenAI tools[].function.name、Responses 风格裸 tools[].name、 +// 旧版 functions[].name。tools 声明在中转环节丢失是实测常态。 +// 2. 会话历史里出现过的工具:messages[].tool_calls[].function.name 与旧版 +// messages[].function_call.name。多轮会话里这份名单几乎总在,且天然可信—— +// 它是客户端自己写进历史的工具名。 +// +// 两个来源都为空 → 返回 nil,由调用方决定是否启用弱判定(见 NewMarkupRepair)。 +// 解析失败按空处理(不编造名单)。 +func ToolNameAllowlist(body []byte) map[string]bool { + var req struct { + Tools []struct { + Name string `json:"name"` + Function *struct { + Name string `json:"name"` + } `json:"function"` + } `json:"tools"` + Functions []struct { + Name string `json:"name"` + } `json:"functions"` + Messages []struct { + ToolCalls []struct { + Function *struct { + Name string `json:"name"` + } `json:"function"` + } `json:"tool_calls"` + FunctionCall *struct { + Name string `json:"name"` + } `json:"function_call"` + } `json:"messages"` + } + if json.Unmarshal(body, &req) != nil { + return nil + } + names := map[string]bool{} + for _, t := range req.Tools { + if t.Function != nil && t.Function.Name != "" { + names[t.Function.Name] = true + continue + } + if t.Name != "" { + names[t.Name] = true + } + } + for _, f := range req.Functions { + if f.Name != "" { + names[f.Name] = true + } + } + for _, m := range req.Messages { + for _, tc := range m.ToolCalls { + if tc.Function != nil && tc.Function.Name != "" { + names[tc.Function.Name] = true + } + } + if m.FunctionCall != nil && m.FunctionCall.Name != "" { + names[m.FunctionCall.Name] = true + } + } + if len(names) == 0 { + return nil + } + return names +} + +// RepairAggregatedResponse 在非流式聚合响应里把正文中的标记还原为 tool_calls。 +// +// 只在「该 choice 没有结构化 tool_calls」且「finish_reason 为 stop」时生效:前者 +// 保证不覆盖真实调用,后者保证正文没有被 max_tokens 截断(截断的正文里标记必然 +// 不完整,本来也解析不出来,这里只是把语义写明确)。 +// +// 工具名判定按 allowed/allowUnknown 走严格或弱判定(见 NewMarkupRepair)。 +// 返回本次使用的修复器,调用方据 Converted/Seen/Rejected 记观测。 +func RepairAggregatedResponse(resp map[string]any, allowed map[string]bool, allowUnknown bool) *MarkupRepair { + r := NewMarkupRepair(allowed, allowUnknown) + if !r.Enabled() { + return r + } + choices, ok := resp["choices"].([]any) + if !ok { + return r + } + for _, ci := range choices { + c, ok := ci.(map[string]any) + if !ok { + continue + } + msg, ok := c["message"].(map[string]any) + if !ok { + continue + } + if tcs, ok := msg["tool_calls"].([]any); ok && len(tcs) > 0 { + continue + } + if fr, _ := c["finish_reason"].(string); fr != "stop" { + continue + } + text, _ := msg["content"].(string) + if text == "" || !strings.Contains(text, markupPipe) { + continue + } + emit, calls := r.Feed(text) + emit += r.Flush() + if len(calls) == 0 { + continue + } + msg["content"] = emit + msg["tool_calls"] = markupMessageToolCalls(calls) + c["finish_reason"] = "tool_calls" + } + return r +} + +// markupMessageToolCalls 把还原出来的调用转成**非流式** message.tool_calls 数组。 +// 非流式形态不带 index(index 是流式 delta 的分片归属标记,写进完整消息里属于 +// 多余字段,严格校验的客户端会挑刺)。 +func markupMessageToolCalls(calls []MarkupCall) []any { + out := make([]any, 0, len(calls)) + for i, call := range calls { + out = append(out, map[string]any{ + "id": markupCallID(i), + "type": "function", + "function": map[string]any{ + "name": call.Name, + "arguments": call.Arguments, + }, + }) + } + return out +} + +// markupToolCalls 把还原出来的调用转成**流式** delta.tool_calls 数组。 +// base 是首个 index(流式路径用它避开上游已用过的 index)。 +// +// index 写成 float64 而不是 int:上游帧经 json.Unmarshal 进来,数值一律是 float64, +// 下游(stripToolCallNames / writeChunk 的最大 index 统计)按 float64 读。合成帧若用 +// int,那些读取会静默失败并退回默认值 0——两个调用会被当成同一个 index,第二个的 +// function.name 被当作「同 index 的后续分片」删掉。 +func markupToolCalls(calls []MarkupCall, base int) []any { + out := make([]any, 0, len(calls)) + for i, call := range calls { + out = append(out, map[string]any{ + "index": float64(base + i), + "id": markupCallID(base + i), + "type": "function", + "function": map[string]any{ + "name": call.Name, + "arguments": call.Arguments, + }, + }) + } + return out +} + +// markupCallID 生成一个形态接近 OpenAI 的 tool_call id。序号参与其中,保证同一条 +// 响应里多个调用的 id 互不相同。 +func markupCallID(idx int) string { + return fmt.Sprintf("call_%d_%d", time.Now().UnixNano(), idx) +} diff --git a/internal/upstream/dsml_test.go b/internal/upstream/dsml_test.go new file mode 100644 index 0000000000000000000000000000000000000000..fed7b17521b83477cb68be71d07ffa245f506797 --- /dev/null +++ b/internal/upstream/dsml_test.go @@ -0,0 +1,544 @@ +// dsml_test.go 覆盖模型原生工具调用标记修复层(dsml.go)。 +// +// 所有夹具都用包内常量拼装(markupOpen / markupPipe / ...),不在源码里写死真实 +// 分隔符字面量:分隔符是全角字符,字面量容易被编辑器/复制粘贴静默改坏,而拼装 +// 出来的字节与上游实际下发的一致。 +package upstream + +import ( + "encoding/json" + "os" + "strings" + "testing" +) + +// --- 夹具构造 --------------------------------------------------------------- + +// mkParam 拼一个 string="true" 的 parameter(取值按原文字符串处理)。 +func mkParam(name, value string) string { + return "<" + markupPipe + "DSML" + markupPipe + " parameter name=\"" + name + "\" string=\"true\">" + + value + markupParamClose +} + +// mkJSONParam 拼一个不带 string 属性的 parameter(取值按 JSON 解析)。 +func mkJSONParam(name, raw string) string { + return "<" + markupPipe + "DSML" + markupPipe + " parameter name=\"" + name + "\">" + + raw + markupParamClose +} + +// mkInvoke 拼一次 invoke,params 为已拼好的 parameter 串。 +func mkInvoke(name string, params ...string) string { + body := "" + if len(params) > 0 { + body = "\n" + strings.Join(params, "\n") + "\n" + } + return "<" + markupPipe + "DSML" + markupPipe + " invoke name=\"" + name + "\">" + body + markupInvokeClose +} + +// mkBlock 拼一个完整的 calls 块。 +func mkBlock(invokes ...string) string { + return markupOpen + "\n" + strings.Join(invokes, "\n") + "\n" + markupClose +} + +// repairAll 按给定分片顺序喂完整条正文,返回透出文本与还原出的调用。 +func repairAll(allowed map[string]bool, chunks []string) (string, []MarkupCall) { + r := NewMarkupRepair(allowed, false) + var sb strings.Builder + var calls []MarkupCall + for _, c := range chunks { + emit, got := r.Feed(c) + sb.WriteString(emit) + calls = append(calls, got...) + } + sb.WriteString(r.Flush()) + return sb.String(), calls +} + +// argsOf 解析 arguments JSON 为 map,断言非法 JSON 直接失败。 +func argsOf(t *testing.T, raw string) map[string]any { + t.Helper() + var m map[string]any + if err := json.Unmarshal([]byte(raw), &m); err != nil { + t.Fatalf("arguments 不是合法 JSON 对象: %q (%v)", raw, err) + } + return m +} + +var testTools = map[string]bool{"exec_command": true, "write_stdin": true} + +// --- 基本解析 --------------------------------------------------------------- + +func TestMarkupRepairSingleCall(t *testing.T) { + in := mkBlock(mkInvoke("exec_command", mkParam("cmd", "ls -la /tmp"))) + out, calls := repairAll(testTools, []string{in}) + if out != "" { + t.Fatalf("整条正文都是标记 → 透出应为空,实际 %q", out) + } + if len(calls) != 1 { + t.Fatalf("应还原 1 次调用,实际 %d", len(calls)) + } + if calls[0].Name != "exec_command" { + t.Fatalf("工具名错误: %q", calls[0].Name) + } + if got := argsOf(t, calls[0].Arguments)["cmd"]; got != "ls -la /tmp" { + t.Fatalf("cmd 参数错误: %#v", got) + } +} + +func TestMarkupRepairMultipleCallsAndOrder(t *testing.T) { + in := mkBlock( + mkInvoke("exec_command", mkParam("cmd", "pwd")), + mkInvoke("write_stdin", mkParam("session_id", "s1"), mkParam("chars", "y\n")), + ) + out, calls := repairAll(testTools, []string{in}) + if out != "" { + t.Fatalf("透出应为空,实际 %q", out) + } + if len(calls) != 2 { + t.Fatalf("应还原 2 次调用,实际 %d", len(calls)) + } + if calls[0].Name != "exec_command" || calls[1].Name != "write_stdin" { + t.Fatalf("调用顺序/名字错误: %q, %q", calls[0].Name, calls[1].Name) + } + if got := argsOf(t, calls[1].Arguments)["chars"]; got != "y\n" { + t.Fatalf("chars 参数错误: %#v", got) + } +} + +func TestMarkupRepairKeepsSurroundingProse(t *testing.T) { + head := "先摸清接口清单,再落文档。\n\n" + tail := "\n\n以上是第一批调用。" + in := head + mkBlock(mkInvoke("exec_command", mkParam("cmd", "pwd"))) + tail + out, calls := repairAll(testTools, []string{in}) + if len(calls) != 1 { + t.Fatalf("应还原 1 次调用,实际 %d", len(calls)) + } + if out != head+tail { + t.Fatalf("正文应保留标记之外的部分\nwant %q\ngot %q", head+tail, out) + } +} + +func TestMarkupRepairNoParameters(t *testing.T) { + in := mkBlock(mkInvoke("exec_command")) + _, calls := repairAll(testTools, []string{in}) + if len(calls) != 1 { + t.Fatalf("应还原 1 次调用,实际 %d", len(calls)) + } + if calls[0].Arguments != "{}" { + t.Fatalf("无参工具应产出 {},实际 %q", calls[0].Arguments) + } +} + +func TestMarkupRepairStringParamEscaping(t *testing.T) { + // 真实场景:apply_patch 的命令里带换行、双引号、反斜杠、中文。 + value := "cd /tmp && apply_patch <<'PATCH'\n*** Begin Patch\n+ const s = \"a\\\\b\";\n+ // 中文注释\n*** End Patch\nPATCH" + in := mkBlock(mkInvoke("exec_command", mkParam("cmd", value))) + _, calls := repairAll(testTools, []string{in}) + if len(calls) != 1 { + t.Fatalf("应还原 1 次调用,实际 %d", len(calls)) + } + if got := argsOf(t, calls[0].Arguments)["cmd"]; got != value { + t.Fatalf("参数值经 JSON 转义后未能原样还原\nwant %q\ngot %q", value, got) + } +} + +func TestMarkupRepairJSONParam(t *testing.T) { + in := mkBlock(mkInvoke("exec_command", mkJSONParam("opts", `{"timeout":30,"force":true}`))) + _, calls := repairAll(testTools, []string{in}) + if len(calls) != 1 { + t.Fatalf("应还原 1 次调用,实际 %d", len(calls)) + } + opts, ok := argsOf(t, calls[0].Arguments)["opts"].(map[string]any) + if !ok { + t.Fatalf("opts 应解析为 JSON 对象") + } + if opts["timeout"] != float64(30) || opts["force"] != true { + t.Fatalf("opts 内容错误: %#v", opts) + } +} + +func TestMarkupRepairJSONParamFallbackToString(t *testing.T) { + // string 属性缺失且取值不是合法 JSON:退化为字符串,绝不丢值。 + in := mkBlock(mkInvoke("exec_command", mkJSONParam("cmd", "ls -la"))) + _, calls := repairAll(testTools, []string{in}) + if len(calls) != 1 { + t.Fatalf("应还原 1 次调用,实际 %d", len(calls)) + } + if got := argsOf(t, calls[0].Arguments)["cmd"]; got != "ls -la" { + t.Fatalf("退化字符串取值错误: %#v", got) + } +} + +// --- 不转换(原文透出)的边界 ----------------------------------------------- + +func TestMarkupRepairDisabledWithoutTools(t *testing.T) { + in := mkBlock(mkInvoke("exec_command", mkParam("cmd", "pwd"))) + out, calls := repairAll(nil, []string{in}) + if out != in || len(calls) != 0 { + t.Fatalf("未声明 tools 时应恒等透传,实际 out=%q calls=%d", out, len(calls)) + } +} + +func TestMarkupRepairUnknownToolNameStaysText(t *testing.T) { + in := mkBlock(mkInvoke("rm_rf_everything", mkParam("cmd", "pwd"))) + out, calls := repairAll(testTools, []string{in}) + if len(calls) != 0 { + t.Fatalf("未声明的工具名不得转换,实际 %d 次", len(calls)) + } + if out != in { + t.Fatalf("应逐字节原文透出\nwant %q\ngot %q", in, out) + } +} + +func TestMarkupRepairProseInsideBlockStaysText(t *testing.T) { + // 块里夹带正文 → 不是纯调用,整块原文透出。 + in := markupOpen + "\n我先说明一下:\n" + mkInvoke("exec_command", mkParam("cmd", "pwd")) + "\n" + markupClose + out, calls := repairAll(testTools, []string{in}) + if len(calls) != 0 || out != in { + t.Fatalf("块内夹带正文应原文透出,实际 calls=%d out=%q", len(calls), out) + } +} + +func TestMarkupRepairIncompleteBlockFlushesVerbatim(t *testing.T) { + in := "前置说明\n" + markupOpen + "\n" + mkInvoke("exec_command", mkParam("cmd", "pwd")) + out, calls := repairAll(testTools, []string{in}) + if len(calls) != 0 { + t.Fatalf("未闭合的块不得转换,实际 %d 次", len(calls)) + } + if out != in { + t.Fatalf("未闭合的块应连起始标记一起回吐\nwant %q\ngot %q", in, out) + } +} + +func TestMarkupRepairPartialStartTokenIsHeldThenFlushed(t *testing.T) { + // 正文恰好以起始标记的前缀结尾(增量边界切断):不能提前吐出半个标记, + // 也不能吞掉——流结束时原样交还。 + partial := markupOpen[:len(markupOpen)-3] + out, calls := repairAll(testTools, []string{"说明" + partial}) + if len(calls) != 0 || out != "说明"+partial { + t.Fatalf("半截起始标记应原样回吐,实际 calls=%d out=%q", len(calls), out) + } +} + +func TestMarkupRepairPlainAngleBracketsUnaffected(t *testing.T) { + // 单个全角竖线(半角全角混排)不能触发缓冲;按码点构造,避免源码里出现裸字面量。 + singlePipe := string(rune(0xFF5C)) + in := "普通 HTML:
a < b
,还有 3 < 5 与 <" + singlePipe + " 这种半角全角混排。" + out, calls := repairAll(testTools, []string{in}) + if len(calls) != 0 || out != in { + t.Fatalf("普通尖括号文本应逐字节透传,实际 calls=%d out=%q", len(calls), out) + } +} + +// --- 增量边界 --------------------------------------------------------------- + +func TestMarkupRepairAnyChunkBoundary(t *testing.T) { + in := "先读一遍控制器。\n\n" + + mkBlock( + mkInvoke("exec_command", mkParam("cmd", "cd /tmp && ls -la")), + mkInvoke("exec_command", mkParam("cmd", "pwd")), + ) + "\n收尾说明。" + want := "先读一遍控制器。\n\n\n收尾说明。" + + // 整条、逐字节、以及一个错位的固定步长,三种切法必须同结果。 + chunkings := map[string][]string{"whole": {in}} + byByte := make([]string, 0, len(in)) + for i := 0; i < len(in); i++ { + byByte = append(byByte, in[i:i+1]) + } + chunkings["byByte"] = byByte + step := make([]string, 0, len(in)/7+1) + for i := 0; i < len(in); i += 7 { + end := i + 7 + if end > len(in) { + end = len(in) + } + step = append(step, in[i:end]) + } + chunkings["step7"] = step + + for name, chunks := range chunkings { + out, calls := repairAll(testTools, chunks) + if out != want { + t.Fatalf("%s: 透出正文错误\nwant %q\ngot %q", name, want, out) + } + if len(calls) != 2 { + t.Fatalf("%s: 应还原 2 次调用,实际 %d", name, len(calls)) + } + if got := argsOf(t, calls[0].Arguments)["cmd"]; got != "cd /tmp && ls -la" { + t.Fatalf("%s: 首个调用参数错误: %#v", name, got) + } + } +} + +// TestMarkupRepairRealLeakedSample 用生产环境真实泄漏的正文做回归:夹具是 2026-10-06 +// 13:20 那次 Codex 会话里落盘的助手原文(testdata/leaked_markup.txt,逐字节复制)。 +// 它同时覆盖两个真实特征:标记前带一段正文、一次两个 invoke。 +func TestMarkupRepairRealLeakedSample(t *testing.T) { + raw, err := os.ReadFile("testdata/leaked_markup.txt") + if err != nil { + t.Fatalf("读取夹具失败: %v", err) + } + in := string(raw) + out, calls := repairAll(map[string]bool{"exec_command": true}, []string{in}) + if len(calls) != 2 { + t.Fatalf("真实样本应还原 2 次调用,实际 %d(out=%q)", len(calls), out) + } + if strings.Contains(out, markupPipe) { + t.Fatalf("透出正文里仍残留标记: %q", out) + } + if !strings.HasPrefix(out, "我先看一下仓库结构和图片内容,再定位价格同步逻辑。") { + t.Fatalf("标记前的正文丢了: %q", out) + } + for i, c := range calls { + if c.Name != "exec_command" { + t.Fatalf("第 %d 次调用工具名错误: %q", i, c.Name) + } + args := argsOf(t, c.Arguments) + if _, ok := args["cmd"]; !ok { + t.Fatalf("第 %d 次调用缺 cmd 参数: %s", i, c.Arguments) + } + } +} + +// TestMarkupRepairByteEquivalence 是修复层最重要的一条不变量:不转换时,透出字节 +// 与输入逐字节相同;转换时,透出字节等于「输入去掉被转换的标记块」。 +func TestMarkupRepairByteEquivalence(t *testing.T) { + cases := []struct { + name string + allowed map[string]bool + in string + want string + calls int + }{ + {"空正文", testTools, "", "", 0}, + {"纯正文", testTools, "hello 世界", "hello 世界", 0}, + {"未声明工具", nil, mkBlock(mkInvoke("exec_command", mkParam("cmd", "pwd"))), + mkBlock(mkInvoke("exec_command", mkParam("cmd", "pwd"))), 0}, + {"畸形参数", testTools, + markupOpen + mkInvoke("exec_command", "垃圾参数") + markupClose, + markupOpen + mkInvoke("exec_command", "垃圾参数") + markupClose, 0}, + {"单块", testTools, + "a" + mkBlock(mkInvoke("exec_command", mkParam("cmd", "pwd"))) + "b", "ab", 1}, + {"双块", testTools, + mkBlock(mkInvoke("exec_command", mkParam("cmd", "a"))) + "中间" + + mkBlock(mkInvoke("exec_command", mkParam("cmd", "b"))), "中间", 2}, + } + for _, tc := range cases { + out, calls := repairAll(tc.allowed, []string{tc.in}) + if out != tc.want { + t.Fatalf("%s: 透出正文错误\nwant %q\ngot %q", tc.name, tc.want, out) + } + if len(calls) != tc.calls { + t.Fatalf("%s: 调用数错误 want %d got %d", tc.name, tc.calls, len(calls)) + } + } +} + +func TestMarkupRepairConvertedCounter(t *testing.T) { + r := NewMarkupRepair(testTools, false) + in := mkBlock( + mkInvoke("exec_command", mkParam("cmd", "a")), + mkInvoke("exec_command", mkParam("cmd", "b")), + ) + if _, calls := r.Feed(in); len(calls) != 2 { + t.Fatalf("应还原 2 次调用,实际 %d", len(calls)) + } + if r.Converted() != 2 { + t.Fatalf("Converted 应为 2,实际 %d", r.Converted()) + } + // 未启用的修复器计数恒为 0。 + if got := NewMarkupRepair(nil, false).Converted(); got != 0 { + t.Fatalf("未启用时 Converted 应为 0,实际 %d", got) + } +} + +// --- 工具名单提取 ----------------------------------------------------------- + +func TestToolNameAllowlist(t *testing.T) { + cases := []struct { + name string + body string + want []string + }{ + {"openai 形态", `{"tools":[{"type":"function","function":{"name":"exec_command"}}, + {"type":"function","function":{"name":"write_stdin"}}]}`, []string{"exec_command", "write_stdin"}}, + {"responses 裸 name", `{"tools":[{"type":"function","name":"exec_command"}]}`, []string{"exec_command"}}, + {"旧版 functions", `{"functions":[{"name":"exec_command"}]}`, []string{"exec_command"}}, + {"历史 tool_calls", `{"messages":[{"role":"assistant","tool_calls":[{"function":{"name":"exec_command"}}]}]}`, []string{"exec_command"}}, + {"历史 function_call", `{"messages":[{"role":"assistant","function_call":{"name":"exec_command"}}]}`, []string{"exec_command"}}, + {"无工具", `{"model":"x","messages":[]}`, nil}, + {"空 tools", `{"tools":[]}`, nil}, + {"非法 JSON", `{`, nil}, + {"名字为空", `{"tools":[{"type":"function","function":{"name":""}}]}`, nil}, + } + for _, tc := range cases { + got := ToolNameAllowlist([]byte(tc.body)) + if len(got) != len(tc.want) { + t.Fatalf("%s: 工具数错误 want %v got %v", tc.name, tc.want, got) + } + for _, n := range tc.want { + if !got[n] { + t.Fatalf("%s: 缺少工具 %q(got %v)", tc.name, n, got) + } + } + } +} + +// --- 非流式聚合响应修复 ----------------------------------------------------- + +func aggregatedResponse(content, finish string) map[string]any { + return map[string]any{ + "id": "chatcmpl-test", "object": "chat.completion", "model": "global:deepseek-v4.1-flash", + "choices": []any{map[string]any{ + "index": 0, + "message": map[string]any{"role": "assistant", "content": content}, + "finish_reason": finish, + }}, + } +} + +func TestRepairAggregatedResponse(t *testing.T) { + content := "先读一遍控制器。\n\n" + mkBlock(mkInvoke("exec_command", mkParam("cmd", "ls -la"))) + resp := aggregatedResponse(content, "stop") + if RepairAggregatedResponse(resp, testTools, false).Converted() == 0 { + t.Fatal("应报告发生改写") + } + choice := resp["choices"].([]any)[0].(map[string]any) + msg := choice["message"].(map[string]any) + if got := msg["content"].(string); got != "先读一遍控制器。\n\n" { + t.Fatalf("正文应剥掉标记,实际 %q", got) + } + tcs, ok := msg["tool_calls"].([]any) + if !ok || len(tcs) != 1 { + t.Fatalf("应产出 1 个 tool_call,实际 %#v", msg["tool_calls"]) + } + tc := tcs[0].(map[string]any) + if tc["type"] != "function" || tc["id"] == "" { + t.Fatalf("tool_call 形态不合法: %#v", tc) + } + fn := tc["function"].(map[string]any) + if fn["name"] != "exec_command" { + t.Fatalf("工具名错误: %#v", fn["name"]) + } + if got := argsOf(t, fn["arguments"].(string))["cmd"]; got != "ls -la" { + t.Fatalf("参数错误: %#v", got) + } + if choice["finish_reason"] != "tool_calls" { + t.Fatalf("finish_reason 应改写为 tool_calls,实际 %#v", choice["finish_reason"]) + } +} + +func TestRepairAggregatedResponseSkips(t *testing.T) { + markup := mkBlock(mkInvoke("exec_command", mkParam("cmd", "ls -la"))) + + // 已有结构化 tool_calls → 不覆盖。 + withCalls := aggregatedResponse(markup, "stop") + withCalls["choices"].([]any)[0].(map[string]any)["message"].(map[string]any)["tool_calls"] = + []any{map[string]any{"id": "real", "type": "function"}} + if RepairAggregatedResponse(withCalls, testTools, false).Converted() != 0 { + t.Fatal("已有 tool_calls 时不得改写") + } + + // finish_reason=length(正文被截断)→ 不解释。 + if RepairAggregatedResponse(aggregatedResponse(markup, "length"), testTools, false).Converted() != 0 { + t.Fatal("finish_reason=length 时不得改写") + } + + // 客户端没声明 tools → 不启用。 + if RepairAggregatedResponse(aggregatedResponse(markup, "stop"), nil, false).Converted() != 0 { + t.Fatal("未声明 tools 时不得改写") + } + + // 纯正文 → 零改写。 + plain := aggregatedResponse("普通回答,没有任何标记。", "stop") + if RepairAggregatedResponse(plain, testTools, false).Converted() != 0 { + t.Fatal("纯正文不得改写") + } + if plain["choices"].([]any)[0].(map[string]any)["message"].(map[string]any)["content"] != + "普通回答,没有任何标记。" { + t.Fatal("纯正文内容被改动") + } +} + +// --- 弱判定(名单为空,实测最常见的泄漏形态)-------------------------------- + +// TestMarkupRepairWeakModeRealSample 生产场景回归:请求体里没有 tools 名单(tools 在 +// 中转环节丢失),夹具是真实泄漏正文。弱判定必须照样还原出 2 次调用。 +func TestMarkupRepairWeakModeRealSample(t *testing.T) { + raw, err := os.ReadFile("testdata/leaked_markup.txt") + if err != nil { + t.Fatalf("读取夹具失败: %v", err) + } + r := NewMarkupRepair(nil, true) + out, calls := r.Feed(string(raw)) + out += r.Flush() + if len(calls) != 2 { + t.Fatalf("弱判定应还原 2 次调用,实际 %d(out=%q)", len(calls), out) + } + if strings.Contains(out, markupPipe) { + t.Fatalf("透出正文里仍残留标记: %q", out) + } + if r.Converted() != 2 || r.Seen() != 1 || r.Rejected() != 0 { + t.Fatalf("计数错误 converted=%d seen=%d rejected=%d", r.Converted(), r.Seen(), r.Rejected()) + } +} + +// TestMarkupRepairWeakModeNameShape 弱判定靠名字形态把关:标识符放行,占位符/畸形拒绝。 +func TestMarkupRepairWeakModeNameShape(t *testing.T) { + cases := []struct { + name string + tool string + wantOK bool + }{ + {"下划线", "exec_command", true}, + {"点号冒号", "mcp.server:tool", true}, + {"短横线", "write-stdin", true}, + {"大写占位符", "NAME", true}, // 形态合法;拦它的是严格判定那条路 + {"尖括号占位符", "", false}, + {"空名", "", false}, + {"带空格", "exec command", false}, + {"超长", strings.Repeat("a", 65), false}, + } + for _, tc := range cases { + in := mkBlock(mkInvoke(tc.tool, mkParam("cmd", "ls"))) + r := NewMarkupRepair(nil, true) + out, got := r.Feed(in) + out += r.Flush() + if ok := len(got) == 1; ok != tc.wantOK { + t.Fatalf("%s: 弱判定结果=%v want %v(out=%q)", tc.name, ok, tc.wantOK, out) + } + } +} + +// TestMarkupRepairWeakModeStillRejectsMalformed 弱判定不放松结构要求:夹带正文 / +// 参数畸形 / 未闭合,一律原文透出。 +func TestMarkupRepairWeakModeStillRejectsMalformed(t *testing.T) { + cases := []string{ + markupOpen + "\n说明文字\n" + mkInvoke("exec_command", mkParam("cmd", "ls")) + "\n" + markupClose, + markupOpen + mkInvoke("exec_command", "垃圾参数") + markupClose, + markupOpen + mkInvoke("exec_command", mkParam("cmd", "ls")), + } + for i, in := range cases { + r := NewMarkupRepair(nil, true) + out, calls := r.Feed(in) + out += r.Flush() + if len(calls) != 0 || out != in { + t.Fatalf("case %d: 弱判定不得放行畸形块(calls=%d out=%q)", i, len(calls), out) + } + } +} + +// TestMarkupRepairDisabled 两个开关都为假(以及 nil 修复器)时整体禁用,恒等透传。 +func TestMarkupRepairDisabled(t *testing.T) { + in := mkBlock(mkInvoke("exec_command", mkParam("cmd", "ls"))) + for _, r := range []*MarkupRepair{NewMarkupRepair(nil, false), nil} { + if r.Enabled() { + t.Fatal("Enabled 应为 false") + } + out, calls := r.Feed(in) + if out != in || len(calls) != 0 || r.Flush() != "" { + t.Fatalf("禁用时应恒等透传: out=%q calls=%d", out, len(calls)) + } + } +} diff --git a/internal/upstream/dump.go b/internal/upstream/dump.go new file mode 100644 index 0000000000000000000000000000000000000000..d532aee5fa6d06d21a457bc5066a4910b83296f1 --- /dev/null +++ b/internal/upstream/dump.go @@ -0,0 +1,100 @@ +// dump.go 上游原始报文旁路落盘(诊断用,默认关闭)。 +// +// 背景(issue #149):客户端看到「带 tools 的 agentic 请求返回 stop + 零 tool_calls」, +// 但 request-logs 只有元数据(设计如此:不写正文),dsml 修复命中日志又在 stderr, +// 于是没有人能回答「上游到底发过 tool_calls 没有」。本文件给运维一个显式开关: +// Client.DumpDir(WB2A_DUMP_UPSTREAM)非空时,每次 chat 请求落一个自包含文件—— +// 出站请求体(我们真正发给上游的东西)+ 上游原始 SSE 字节,不经任何改写。 +// +// 只有显式配置目录才落盘:正文含用户提示词,不能默认开。单个文件封顶 8 MB +// (只停写不掐流,响应照常透传给客户端),写盘失败只记一行日志、绝不影响请求。 +package upstream + +import ( + "io" + "log" + "os" + "path/filepath" + "sync" + "time" + + "github.com/misakano7545/workbuddy2api-panel/internal/auth" +) + +// dumpLimit 单文件封顶:请求体 + 响应体合计。 +const dumpLimit = 8 << 20 + +// dumpRequestMax 请求体片段上限默认值:足够看清 tools / messages 结构,又不至于 +// 吃掉整个配额。Client.DumpRequestMax 可覆盖(长会话把 tools 排在几百条 messages +// 之后,默认值常在中途截断)。 +const dumpRequestMax = 1 << 18 + +// dumpUpstream 在 DumpDir 为空时原样返回 rc(零开销、零行为变化)。 +func (c *Client) dumpUpstream(rc io.ReadCloser, prepared []byte, a *auth.Auth) io.ReadCloser { + if c.DumpDir == "" { + return rc + } + if err := os.MkdirAll(c.DumpDir, 0o700); err != nil { + log.Printf("WARN: [upstream] dump dir %s: %v", c.DumpDir, err) + return rc + } + f, err := os.OpenFile(filepath.Join(c.DumpDir, dumpName(a)), os.O_CREATE|os.O_WRONLY|os.O_EXCL, 0o600) + if err != nil { + log.Printf("WARN: [upstream] dump open: %v", err) + return rc + } + reqMax := c.DumpRequestMax + if reqMax <= 0 { + reqMax = dumpRequestMax + } + head := prepared + if len(head) > reqMax { + head = head[:reqMax] + } + f.Write([]byte("=== request ===\n")) + f.Write(head) + f.Write([]byte("\n=== response ===\n")) + return &dumpReader{rc: rc, f: f, left: dumpLimit - int64(len(head))} +} + +// dumpName 用「时间-域-账号前 8 位」拼文件名:可排序、不落完整 UID。 +func dumpName(a *auth.Auth) string { + tag := "unknown" + if a != nil { + tag = a.Realm() + if uid := a.UID; uid != "" { + if len(uid) > 8 { + uid = uid[:8] + } + tag += "-" + uid + } + } + return time.Now().Format("20060102-150405.000") + "-" + tag + ".log" +} + +// dumpReader 边透传边写盘;配额用尽后只透传。Close 关闭文件。 +type dumpReader struct { + rc io.ReadCloser + f *os.File + left int64 + once sync.Once +} + +func (d *dumpReader) Read(p []byte) (int, error) { + n, err := d.rc.Read(p) + if n > 0 && d.left > 0 { + w := p[:n] + if int64(len(w)) > d.left { + w = w[:d.left] + } + d.f.Write(w) + d.left -= int64(len(w)) + } + return n, err +} + +func (d *dumpReader) Close() error { + err := d.rc.Close() + d.once.Do(func() { d.f.Close() }) + return err +} diff --git a/internal/upstream/dump_test.go b/internal/upstream/dump_test.go new file mode 100644 index 0000000000000000000000000000000000000000..58ad76b51e5d94c6ba0e22a31f96b531fc3d7027 --- /dev/null +++ b/internal/upstream/dump_test.go @@ -0,0 +1,76 @@ +package upstream + +import ( + "io" + "os" + "path/filepath" + "strings" + "testing" + + "github.com/misakano7545/workbuddy2api-panel/internal/auth" +) + +// DumpDir 为空时零改动:同一个 reader 原样返回,不建目录不写文件。 +func TestDumpUpstreamDisabled(t *testing.T) { + c := New() + rc := io.NopCloser(strings.NewReader("data: x\n\n")) + if got := c.dumpUpstream(rc, []byte(`{}`), nil); got != io.ReadCloser(rc) { + t.Fatalf("DumpDir 为空时应原样返回 reader") + } +} + +// 打开后一次请求一个自包含文件:出站请求体 + 上游原始字节,且字节不被改写。 +func TestDumpUpstreamWritesRaw(t *testing.T) { + dir := t.TempDir() + c := New() + c.DumpDir = dir + raw := "data: {\"choices\":[{\"delta\":{\"tool_calls\":[{\"index\":0}]}}]}\n\ndata: [DONE]\n\n" + a := &auth.Auth{UID: "0011223344556677", Domain: "www.codebuddy.cn"} + + rc := c.dumpUpstream(io.NopCloser(strings.NewReader(raw)), []byte(`{"model":"m"}`), a) + got, err := io.ReadAll(rc) + if err != nil || string(got) != raw { + t.Fatalf("透传字节被改写: %q err=%v", got, err) + } + rc.Close() + + files, _ := filepath.Glob(filepath.Join(dir, "*.log")) + if len(files) != 1 { + t.Fatalf("期望 1 个 dump 文件,得到 %d", len(files)) + } + b, _ := os.ReadFile(files[0]) + s := string(b) + if !strings.Contains(s, `{"model":"m"}`) || !strings.HasSuffix(s, raw) { + t.Fatalf("dump 文件应含请求体与原始响应,实际 %q", s) + } + if strings.Contains(filepath.Base(files[0]), "0011223344556677") { + t.Fatalf("文件名不应含完整 UID: %s", files[0]) + } +} + +// DumpRequestMax 覆盖默认 256 KB 请求体上限:片段按配置截断,响应段不受影响。 +func TestDumpUpstreamRequestMaxOverride(t *testing.T) { + dir := t.TempDir() + c := New() + c.DumpDir = dir + c.DumpRequestMax = 16 + raw := "data: [DONE]\n\n" + + req := `{"model":"m","tools":[{"type":"function","function":{"name":"read_file"}}]}` + rc := c.dumpUpstream(io.NopCloser(strings.NewReader(raw)), []byte(req), nil) + io.Copy(io.Discard, rc) + rc.Close() + + files, _ := filepath.Glob(filepath.Join(dir, "*.log")) + if len(files) != 1 { + t.Fatalf("期望 1 个 dump 文件,得到 %d", len(files)) + } + b, _ := os.ReadFile(files[0]) + s := string(b) + if !strings.Contains(s, req[:16]) || strings.Contains(s, `"read_file"`) { + t.Fatalf("请求段应截断到 16 字节,实际 %q", s) + } + if !strings.HasSuffix(s, raw) { + t.Fatalf("响应段不应受请求上限影响,实际 %q", s) + } +} diff --git a/internal/upstream/effort_catalog.go b/internal/upstream/effort_catalog.go index 13ba67beac5eb0dea7b084ac77d7c7c3ae23e8fc..cc3eb51961c6254659d0f04c1921d37e875f6f1a 100644 --- a/internal/upstream/effort_catalog.go +++ b/internal/upstream/effort_catalog.go @@ -1,145 +1,184 @@ -// effort_catalog.go 推理档位(reasoning effort)产品级静态兜底表。 -// -// 数据来源三级(吸收参考仓库 reconcileWithFallback/buddy-adapter.ts:499-523 语义): -// - 远端 FetchModels / global 探测已解析的 supportedEfforts/defaultEffort 桶(权威,优先); -// - 本文件按 realm 分开的产品级静态兜底表(远端缺失时补齐); -// - 两者皆无 → 不在 /v1/models 输出 effort 字段(omitted,不是空数组)。 -// -// 档位值照抄参考仓库 dsh-codearts:CN/CodeBuddy 面取 src/product.ts CODEBUDDY_FALLBACK_MODELS -// ∪ src/buddy-adapter.ts:126-137 REASONING_EFFORTS;global/WorkBuddy 面取 src/product.ts -// WORKBUDDY_FALLBACK_MODELS。两个 realm 对同一模型给出不同档位(如 deepseek-v4.1-flash: -// CN 三档 ['low','high','max']、global 仅 ['high']),故**按 realm 分表**,绝不混用。 -// -// 只列**可枚举**档位的模型;仅有固定默认档(glm-5.1/kimi-* 的 medium)同样入表, -// 但其档位是「可枚举单档」而非「无选择器」,照抄参考仓库如实暴露。 -package upstream - -// effortCap 一个模型的档位能力(对齐产品兜底表条目 reasoningEfforts + defaultReasoningEffort)。 -type effortCap struct { - efforts []string - defaultEffort string -} - -// cnEffortFallback CN / CodeBuddy 面静态兜底表。 -// 三档模型 defaultEffort 均为 high(product.ts CODEBUDDY_FALLBACK_MODELS 逐条 defaultReasoningEffort)。 -var cnEffortFallback = map[string]effortCap{ - "deepseek-v4-flash": {efforts: []string{"low", "high", "max"}}, - "deepseek-v4.1-flash": {efforts: []string{"low", "high", "max"}, defaultEffort: "high"}, - "deepseek-v4-pro": {efforts: []string{"low", "high", "xhigh"}, defaultEffort: "high"}, - "hy4-preview": {efforts: []string{"high"}, defaultEffort: "high"}, - "hy4-preview-x": {efforts: []string{"high"}}, - "hy3": {efforts: []string{"low", "high"}, defaultEffort: "high"}, - "hy3-x": {efforts: []string{"low", "high"}, defaultEffort: "high"}, - "glm-5.3": {efforts: []string{"low", "high", "max"}, defaultEffort: "high"}, - "glm-5.3-flash": {efforts: []string{"low", "high", "max"}, defaultEffort: "high"}, - "glm-5.2": {efforts: []string{"high", "xhigh"}, defaultEffort: "high"}, - "glm-5.1": {efforts: []string{"medium"}}, - "glm-5v-turbo": {efforts: []string{"medium"}}, - "kimi-k3-1": {efforts: []string{"medium"}}, - "kimi-k2.7": {efforts: []string{"medium"}}, - "kimi-k2.6": {efforts: []string{"medium"}}, - "minimax-m3": {efforts: []string{"medium"}}, -} - -// globalEffortFallback global / WorkBuddy 国际版面静态兜底表。 -// 注意 deepseek-v4.1-flash 在国际版**只有 ['high']**(product.ts:190 实测 IDE 缓存), -// 与 CN 面的三档刻意不同——往 WorkBuddy 上游发 low/max 是非法参数 400。 -var globalEffortFallback = map[string]effortCap{ - "fast-model": {efforts: []string{"medium"}}, - "balanced-model": {efforts: []string{"medium"}}, - "primary-model": {efforts: []string{"high"}}, - "hy4-preview-f": {efforts: []string{"high"}, defaultEffort: "high"}, - "hy3": {efforts: []string{"low", "high"}, defaultEffort: "high"}, - "deepseek-v4.1-flash": {efforts: []string{"high"}}, - "gpt-6-astra": {efforts: []string{"low", "medium", "high", "xhigh", "max"}, defaultEffort: "high"}, - "gpt-5.6-sol": {efforts: []string{"low", "medium", "high", "xhigh", "max"}, defaultEffort: "high"}, - "gpt-5.6-terra": {efforts: []string{"low", "medium", "high", "xhigh", "max"}, defaultEffort: "high"}, - "gpt-5.6-luna": {efforts: []string{"low", "medium", "high", "xhigh", "max"}, defaultEffort: "high"}, - "gpt-5.5": {efforts: []string{"low", "medium", "high", "xhigh"}, defaultEffort: "high"}, - "gpt-5.4": {efforts: []string{"low", "medium", "high", "xhigh"}, defaultEffort: "high"}, - "gpt-5.3-codex": {efforts: []string{"medium"}}, - "gemini-3.5-flash": {efforts: []string{"medium"}}, - "glm-5.3": {efforts: []string{"low", "high", "max"}, defaultEffort: "high"}, - "glm-5.2": {efforts: []string{"high", "xhigh"}, defaultEffort: "high"}, - "kimi-k3": {efforts: []string{"medium"}}, - "kimi-k2.6": {efforts: []string{"medium"}}, -} - -// staticEffortCap 按 realm 取静态兜底条目;未命中返回 zero effortCap(efforts=nil)。 -// realm 经 realmKey 归一化(空 → "cn"),与 efforts 缓存桶同口径。 -func staticEffortCap(realm, model string) effortCap { - table := cnEffortFallback - if realmKey(realm) == "global" { - table = globalEffortFallback - } - return table[model] -} - -// EffortListing 计算模型在 /v1/models 应暴露的 effort 能力(三级查找 + 默认档防御)。 -// -// remoteEfforts/remoteDefault 为远端(FetchModels / global 探测)已解析值; -// remoteEfforts 非空时以其为权威(不回落到静态表),否则落到产品级静态兜底表; -// 两者皆无 → efforts 返回 nil(调用方省略字段,不输出空数组)。 -// -// defaultEffort 仅在「efforts 非空且 default 命中 efforts」时才返回 -// (对齐参考仓库 resolveModel 的 `defaultEffort ∈ efforts` 防御:不宣称不支持的默认档)。 -// remoteDefault 空串不回落到静态默认档——默认档随档位表同源:remote 有档位就用 remote 默认档, -// 静态兜底档位就用静态默认档,避免跨源拼接出「档位是静态、默认档是 remote」的矛盾组合。 -func EffortListing(realm, model string, remoteEfforts []string, remoteDefault string) (efforts []string, defaultEffort string) { - var src effortCap - switch { - case len(remoteEfforts) > 0: - src = effortCap{efforts: remoteEfforts, defaultEffort: remoteDefault} - default: - src = staticEffortCap(realm, model) - } - if len(src.efforts) == 0 { - return nil, "" - } - efforts = append([]string(nil), src.efforts...) - if src.defaultEffort != "" && containsEffort(efforts, src.defaultEffort) { - defaultEffort = src.defaultEffort - } - return efforts, defaultEffort -} - -// containsEffort 档位成员判定(精确匹配,对齐参考仓库 `efforts.includes(defaultEffort)`)。 -func containsEffort(efforts []string, want string) bool { - for _, e := range efforts { - if e == want { - return true - } - } - return false -} - -// globalEffortMap global 域降级用的 effort 能力表:静态兜底表为基,远端桶覆盖(权威优先)。 -// -// prepareBody 对 global 请求调此函数(而非直接用远端桶),因为 global 上游可能不下发 -// supportedEfforts——此时也必须按产品静态表降级(issue #84:deepseek-v4.1-flash 国际版 -// 只认 high,客户端传 low/max 必降级到 high,否则上游 400 毁掉请求)。 -// 语义对齐参考仓库 effortsFor(remoteMeta → productFallback → 静态表),只取前两级: -// 远端桶(探测已解析)→ 本产品静态表(本文件),缺档位即无(不再到通用静态表)。 -func globalEffortMap(remoteEfforts map[string][]string, remoteDefaults map[string]string) (map[string][]string, map[string]string) { - efforts := make(map[string][]string, len(globalEffortFallback)+len(remoteEfforts)) - defs := make(map[string]string, len(globalEffortFallback)+len(remoteDefaults)) - // 静态兜底为基。 - for id, cap := range globalEffortFallback { - efforts[id] = append([]string(nil), cap.efforts...) - if cap.defaultEffort != "" { - defs[id] = cap.defaultEffort - } - } - // 远端权威覆盖(仅当远端确实下发了该模型档位)。 - for id, v := range remoteEfforts { - if len(v) > 0 { - efforts[id] = v - } - } - for id, v := range remoteDefaults { - if v != "" { - defs[id] = v - } - } - return efforts, defs -} +// effort_catalog.go 推理档位(reasoning effort)产品级静态兜底表。 +// +// 数据来源三级(吸收参考仓库 reconcileWithFallback/buddy-adapter.ts:499-523 语义): +// - 远端 FetchModels / global 探测已解析的 supportedEfforts/defaultEffort 桶(权威,优先); +// - 本文件按 realm 分开的产品级静态兜底表(远端缺失时补齐); +// - 两者皆无 → 不在 /v1/models 输出 effort 字段(omitted,不是空数组)。 +// +// 档位值照抄参考仓库 dsh-codearts:CN/CodeBuddy 面取 src/product.ts CODEBUDDY_FALLBACK_MODELS +// ∪ src/buddy-adapter.ts:126-137 REASONING_EFFORTS;global/WorkBuddy 面取 src/product.ts +// WORKBUDDY_FALLBACK_MODELS。两个 realm 对同一模型给出不同档位(如 deepseek-v4.1-flash: +// CN 三档 ['low','high','max']、global 仅 ['high']),故**按 realm 分表**,绝不混用。 +// +// 只列**可枚举**档位的模型;仅有固定默认档(glm-5.1/kimi-* 的 medium)同样入表, +// 但其档位是「可枚举单档」而非「无选择器」,照抄参考仓库如实暴露。 +package upstream + +// effortCap 一个模型的档位能力(对齐产品兜底表条目 reasoningEfforts + defaultReasoningEffort)。 +type effortCap struct { + efforts []string + defaultEffort string +} + +// cnEffortFallback CN / CodeBuddy 面静态兜底表。 +// 三档模型 defaultEffort 均为 high(product.ts CODEBUDDY_FALLBACK_MODELS 逐条 defaultReasoningEffort)。 +// +// 2026-10-21 国区 5.8.3 GUI 真机抓包核对(带鉴权 /v3/config,62 个模型): +// deepseek-v4.1-flash=low,high,max、glm-5.3=low,high,max、glm-5.2=high,xhigh、 +// hy4-preview=high、hy3=low,high 与本表一致;但 deepseek-v4-flash 实为 high,xhigh、 +// deepseek-v4-pro 实为 high,xhigh、kimi-k3-1 实为 low,high,xhigh —— 已按实测改正 +// (此前照 product.ts 抄的 low,high,max / low,high,xhigh / medium 与上游目录不符, +// 远程桶缺失时会按错档位降级)。 +var cnEffortFallback = map[string]effortCap{ + "deepseek-v4-flash": {efforts: []string{"high", "xhigh"}, defaultEffort: "high"}, + "deepseek-v4.1-flash": {efforts: []string{"low", "high", "max"}, defaultEffort: "high"}, + "deepseek-v4-pro": {efforts: []string{"high", "xhigh"}, defaultEffort: "high"}, + "hy4-preview": {efforts: []string{"high"}, defaultEffort: "high"}, + "hy4-preview-x": {efforts: []string{"high"}}, + "hy3": {efforts: []string{"low", "high"}, defaultEffort: "high"}, + "hy3-x": {efforts: []string{"low", "high"}, defaultEffort: "high"}, + "glm-5.3": {efforts: []string{"low", "high", "max"}, defaultEffort: "high"}, + "glm-5.3-flash": {efforts: []string{"low", "high", "max"}, defaultEffort: "high"}, + "glm-5.2": {efforts: []string{"high", "xhigh"}, defaultEffort: "high"}, + "glm-5.1": {efforts: []string{"medium"}}, + "glm-5v-turbo": {efforts: []string{"medium"}}, + "kimi-k3-1": {efforts: []string{"low", "high", "xhigh"}}, + "kimi-k2.7": {efforts: []string{"medium"}}, + "kimi-k2.6": {efforts: []string{"medium"}}, + "minimax-m3": {efforts: []string{"medium"}}, +} + +// globalEffortFallback global / WorkBuddy 国际版面静态兜底表。 +// +// 2026-10-29 WorkBuddy AI 5.9.3 真机核对(带鉴权 GET/POST https://www.workbuddy.ai/v3/config, +// data.models 25 条,逐条抄 reasoning.supportedEfforts / reasoning.defaultEffort / +// reasoning.effort)。上一版按 5.8.4 product.ts 与 IDE 缓存抄写,已与实际目录脱节: +// +// - **已下架**(目录里没有,留着只会给出不存在的档位):gpt-5.5、gpt-5.4、gpt-5.3-codex、 +// hy4-preview-f、gemini-3.5-flash、kimi-k2.6、glm-5.2;GL 目录里 hy4-preview 才是那个 +// 单档 "high" 的混元模型(-f 是 CN 侧变体命名)。 +// - **新上架/此前缺失**(远端桶取不到时无档位可报):glm-5.3-flash、kimi-k3.1-pro、 +// kimi-k3.1-pro-highspeed、minimax-m3.1-flash、gpt-6-sol、gpt-6-luna、gpt-6.1-sol、 +// gemini-3.8-flash、grok-4.7、hy4-preview、deepseek-v4.1-flash-sg。 +// - **deepseek-v4.1-flash 国际版是三档**:旧注释写「国际版只有 high,发 low/max 会 400」, +// 依据是 5.8.4 的 IDE 缓存;5.9.3 目录已明确下发 supportedEfforts=[low,high,max]。 +// +// 「单档」形态照旧写成唯一元素的可枚举档(上游用老的 reasoning.effort 键而非数组: +// fast-model=medium、balanced-model=medium、primary-model=high、kimi-k3=medium), +// 让 /v1/models 与面板有档位可展示,而不是整段省略。 +// +// default-model 与两个媒体模型(hy-image-3.5 出图 / kling-video-v3 出视频)目录里没有 +// reasoning 段——不编造,一律不入表。 +var globalEffortFallback = map[string]effortCap{ + "fast-model": {efforts: []string{"medium"}}, + "balanced-model": {efforts: []string{"medium"}}, + "primary-model": {efforts: []string{"high"}}, + "hy4-preview": {efforts: []string{"high"}, defaultEffort: "high"}, + "hy3": {efforts: []string{"low", "high"}, defaultEffort: "high"}, + "deepseek-v4.1-flash": {efforts: []string{"low", "high", "max"}, defaultEffort: "high"}, + "deepseek-v4.1-flash-sg": {efforts: []string{"low", "high", "max"}, defaultEffort: "high"}, + "glm-5.3": {efforts: []string{"low", "high", "max"}, defaultEffort: "high"}, + "glm-5.3-flash": {efforts: []string{"low", "high", "max"}, defaultEffort: "high"}, + "kimi-k3": {efforts: []string{"medium"}}, + "kimi-k3.1-pro": {efforts: []string{"low", "high", "max"}, defaultEffort: "high"}, + "kimi-k3.1-pro-highspeed": {efforts: []string{"low", "high", "max"}, defaultEffort: "high"}, + "gpt-5.6-sol": {efforts: []string{"low", "medium", "high", "xhigh", "max"}, defaultEffort: "high"}, + "gpt-5.6-terra": {efforts: []string{"low", "medium", "high", "xhigh", "max"}, defaultEffort: "high"}, + "gpt-5.6-luna": {efforts: []string{"low", "medium", "high", "xhigh", "max"}, defaultEffort: "high"}, + "gpt-6-astra": {efforts: []string{"low", "medium", "high", "xhigh", "max"}, defaultEffort: "high"}, + "gpt-6-sol": {efforts: []string{"low", "medium", "high", "xhigh"}, defaultEffort: "high"}, + "gpt-6-luna": {efforts: []string{"low", "medium", "high", "xhigh"}, defaultEffort: "high"}, + "gpt-6.1-sol": {efforts: []string{"low", "medium", "high", "xhigh"}, defaultEffort: "high"}, + "grok-4.7": {efforts: []string{"low", "medium", "high", "xhigh"}, defaultEffort: "high"}, + "gemini-3.8-flash": {efforts: []string{"low", "medium", "high"}, defaultEffort: "medium"}, + "minimax-m3.1-flash": {efforts: []string{"low", "medium", "high", "xhigh", "max"}, defaultEffort: "max"}, +} + +// staticEffortCap 按 realm 取静态兜底条目;未命中返回 zero effortCap(efforts=nil)。 +// realm 经 realmKey 归一化(空 → "cn"),与 efforts 缓存桶同口径。 +func staticEffortCap(realm, model string) effortCap { + table := cnEffortFallback + if realmKey(realm) == "global" { + table = globalEffortFallback + } + return table[model] +} + +// EffortListing 计算模型在 /v1/models 应暴露的 effort 能力(三级查找 + 默认档防御)。 +// +// remoteEfforts/remoteDefault 为远端(FetchModels / global 探测)已解析值; +// remoteEfforts 非空时以其为权威(不回落到静态表),否则落到产品级静态兜底表; +// 两者皆无 → efforts 返回 nil(调用方省略字段,不输出空数组)。 +// +// defaultEffort 仅在「efforts 非空且 default 命中 efforts」时才返回 +// (对齐参考仓库 resolveModel 的 `defaultEffort ∈ efforts` 防御:不宣称不支持的默认档)。 +// remoteDefault 空串不回落到静态默认档——默认档随档位表同源:remote 有档位就用 remote 默认档, +// 静态兜底档位就用静态默认档,避免跨源拼接出「档位是静态、默认档是 remote」的矛盾组合。 +func EffortListing(realm, model string, remoteEfforts []string, remoteDefault string) (efforts []string, defaultEffort string) { + var src effortCap + switch { + case len(remoteEfforts) > 0: + src = effortCap{efforts: remoteEfforts, defaultEffort: remoteDefault} + default: + src = staticEffortCap(realm, model) + } + if len(src.efforts) == 0 { + return nil, "" + } + efforts = append([]string(nil), src.efforts...) + if src.defaultEffort != "" && containsEffort(efforts, src.defaultEffort) { + defaultEffort = src.defaultEffort + } + return efforts, defaultEffort +} + +// containsEffort 档位成员判定(精确匹配,对齐参考仓库 `efforts.includes(defaultEffort)`)。 +func containsEffort(efforts []string, want string) bool { + for _, e := range efforts { + if e == want { + return true + } + } + return false +} + +// globalEffortMap global 域降级用的 effort 能力表:静态兜底表为基,远端桶覆盖(权威优先)。 +// +// prepareBody 对 global 请求调此函数(而非直接用远端桶),因为 global 上游可能不下发 +// supportedEfforts——此时也必须按产品静态表降级(issue #84:deepseek-v4.1-flash 国际版 +// 只认 high,客户端传 low/max 必降级到 high,否则上游 400 毁掉请求)。 +// 语义对齐参考仓库 effortsFor(remoteMeta → productFallback → 静态表),只取前两级: +// 远端桶(探测已解析)→ 本产品静态表(本文件),缺档位即无(不再到通用静态表)。 +func globalEffortMap(remoteEfforts map[string][]string, remoteDefaults map[string]string) (map[string][]string, map[string]string) { + return effortFallbackMap(globalEffortFallback, remoteEfforts, remoteDefaults) +} + +// cnEffortMap CN 域降级/补档用的 effort 能力表:与 globalEffortMap 同口径 +// (静态兜底为基,远端桶覆盖)。prepareBody 对 cn 请求调此函数,使请求侧解析 +// 与 /v1/models 的 EffortListing 声明同源——声明什么档位就按什么档位落地。 +func cnEffortMap(remoteEfforts map[string][]string, remoteDefaults map[string]string) (map[string][]string, map[string]string) { + return effortFallbackMap(cnEffortFallback, remoteEfforts, remoteDefaults) +} + +// effortFallbackMap 通用合并:静态兜底表为基,远端桶/默认档覆盖(仅非空项)。 +func effortFallbackMap(table map[string]effortCap, remoteEfforts map[string][]string, remoteDefaults map[string]string) (map[string][]string, map[string]string) { + efforts := make(map[string][]string, len(table)+len(remoteEfforts)) + defs := make(map[string]string, len(table)+len(remoteDefaults)) + for id, cap := range table { + efforts[id] = append([]string(nil), cap.efforts...) + if cap.defaultEffort != "" { + defs[id] = cap.defaultEffort + } + } + for id, v := range remoteEfforts { + if len(v) > 0 { + efforts[id] = v + } + } + for id, v := range remoteDefaults { + if v != "" { + defs[id] = v + } + } + return efforts, defs +} diff --git a/internal/upstream/effort_policy.go b/internal/upstream/effort_policy.go new file mode 100644 index 0000000000000000000000000000000000000000..f671e5d2a1c425606fd3c94a1f028bdbbb9c7872 --- /dev/null +++ b/internal/upstream/effort_policy.go @@ -0,0 +1,278 @@ +// effort_policy.go 网关侧思考档位策略(issue #18 / #21 的网关优先级一层)。 +// +// 语义(config thinking 节;经 Client.SetEffortPolicy 热更新): +// - Enabled=false:网关完全不碰档位,行为退回只有 injectThinking + 降级的旧管线; +// - ClientPriority=true:客户端发了档位就按客户端(含 off/关闭),只在客户端 +// **没发**档位时补网关默认档; +// - ClientPriority=false:网关优先。客户端显式档位一律改写为网关目标档; +// OverrideScope=level 时保留客户端「关闭思考」(off/none/disabled 或 +// thinking.type=disabled)的表达,=all 时连关闭也一并改写为开启 + 目标档。 +// +// 目标档解析(ResolveGatewayEffort):default_effort=max 取模型支持的最高档; +// 具体档位支持则用、不支持则取 ≤ 该档的最高支持档(没有则用最低支持档), +// 与 /v1/models 声明的 supportedEfforts 同源于 EffortListing。 +// +// 目标档也可以是 off(面板「网关档位」下拉里与 supportedEfforts 一起原样列出, +// 仅 canDisableThinking 的模型才有):表示该模型在网关侧固定关闭思考。客户端 +// 显式发档位且非 all 作用域时仍保留客户端档位(off 改开关,不越权覆盖 level 的约定)。 +package upstream + +import ( + "log" + "strings" +) + +const ( + // OverrideScopeLevel 网关优先只覆盖「档位」,尊重客户端的关闭意图。 + OverrideScopeLevel = "level" + // OverrideScopeAll 网关优先覆盖档位与开关:客户端 off/disabled 也会被改写成开启。 + OverrideScopeAll = "all" + // EffortOff 目标档为「关闭思考」:与 supportedEfforts 同列的下拉选项之一, + // 由网关在允许改写的时机写成 thinking.type=disabled(并删掉档位字段)。 + EffortOff = "off" +) + +// isOffEffort 档位字段里表达「关闭思考」的写法(与 effortValueOff 同口径)。 +func isOffEffort(s string) bool { + switch strings.ToLower(strings.TrimSpace(s)) { + case "off", "none", "disabled": + return true + } + return false +} + +// DefaultGatewayEffort 网关补缺档时用的默认思考档。 +// +// config 层(cmd/server 的 Default 与 normalizeThinking)与 EffortPolicy.Normalized +// 共用这一个值:两处此前各自写死 high / max,config 层先填值把 Normalized 的 high +// 盖掉,默认档实际一直是 max(思考吃光输出预算,正文只剩半句)。 +const DefaultGatewayEffort = "high" + +// EffortPolicy 网关思考档位策略(config thinking 节的运行时形态)。 +// +// 字段均带 json tag:面板保存后按 config 原样落盘/回显,热更新走同一个结构。 +type EffortPolicy struct { + Enabled bool `json:"enabled"` + DefaultEffort string `json:"default_effort"` + ClientPriority bool `json:"client_priority"` + OverrideScope string `json:"override_scope"` + // ModelDefaults 按模型覆盖默认档:键 "realm:model"(精确到域)或裸 "model" + // (两域共用),值 "max"/"high"/…;空或 "inherit" 表示不覆盖(解析时已剔除)。 + ModelDefaults map[string]string `json:"model_defaults,omitempty"` +} + +// Normalized 返回规范化副本(默认值补全 + 键值小写去空白)。 +// Client.SetEffortPolicy 存的是规范化结果,热路径不再做字符串处理。 +func (p EffortPolicy) Normalized() EffortPolicy { + p.DefaultEffort = strings.ToLower(strings.TrimSpace(p.DefaultEffort)) + if p.DefaultEffort == "" { + // 缺省 high 而不是 max:上游把思考与正文算在同一份额度里,max 档会把绝大部分 + // 预算烧在思考上——客户端给一个正常 max_tokens 时正文只剩半句(finish=length)。 + // 2026-11-07 本机对照实测(cn:deepseek-v4.1-flash,同一 8192 额度): + // max → think 8192 / 正文≈1906 token(3398 字),且曾出现 think 7612 触发截断 + // high → think 4068 / 正文≈3236 token(6011 字),正文多 70% + // 与 hub(wb_proxy.default_reasoning_effort_mode)的默认 high 同口径:那里 + // 明确记着「强补 high 让 deepseek 把整轮花在 reasoning 上、偶尔无正文」(#508)。 + p.DefaultEffort = DefaultGatewayEffort + } + p.OverrideScope = strings.ToLower(strings.TrimSpace(p.OverrideScope)) + if p.OverrideScope != OverrideScopeAll { + p.OverrideScope = OverrideScopeLevel + } + out := make(map[string]string, len(p.ModelDefaults)) + for k, v := range p.ModelDefaults { + key := strings.ToLower(strings.TrimSpace(k)) + val := strings.ToLower(strings.TrimSpace(v)) + if key == "" || val == "" || val == "inherit" { + continue + } + out[key] = val + } + p.ModelDefaults = out + return p +} + +// DefaultEffortFor 返回该模型应使用的网关目标档:先查 "realm:model",再查裸 +// "model",都没有则用全局 default_effort。返回值为未解析的愿望档(如 "max"), +// 由 ResolveGatewayEffort 落到具体支持档。 +func (p EffortPolicy) DefaultEffortFor(realm, model string) string { + if model == "" { + return p.DefaultEffort + } + model = strings.ToLower(strings.TrimSpace(model)) + if v, ok := p.ModelDefaults[realmKey(realm)+":"+model]; ok { + return v + } + if v, ok := p.ModelDefaults[model]; ok { + return v + } + return p.DefaultEffort +} + +// IsEffortLevel 报告 s 是否是可声明的思考档位(off 也算:它是「关闭」表达, +// config 侧单独拒绝,其它场景用于区分档位与任意字符串)。 +func IsEffortLevel(s string) bool { + _, ok := effortRank[strings.ToLower(strings.TrimSpace(s))] + return ok +} + +// ResolveGatewayEffort 把愿望档("max" / "high" / …)解析成模型实际支持的档位: +// - off/none/disabled → "off"(关闭思考,调用方转到 thinking 开关处理); +// - ""/"max" → 支持列表中的最高档(列表里没有可识别档位时取最后一项); +// - 具体档位 → 支持则原样;不支持取 ≤ 该档的最高支持档;没有更低的正档则取最低 +// **正**档(off 只作为显式目标,不参与降级——否则「要弱一档」会静默变成「关掉思考」); +// - 无法识别的愿望档 / 空支持列表 → ""(调用方不改写)。 +func ResolveGatewayEffort(want string, supported []string) string { + want = strings.ToLower(strings.TrimSpace(want)) + if isOffEffort(want) { + return EffortOff + } + if len(supported) == 0 { + return "" + } + if want == "" || want == "max" { + best, bestRank := "", -1 + for _, s := range supported { + if idx, ok := effortRank[strings.ToLower(strings.TrimSpace(s))]; ok && idx > bestRank { + best, bestRank = s, idx + } + } + if best != "" { + return best + } + return supported[len(supported)-1] + } + wantRank, known := effortRank[want] + if !known { + return "" + } + best, bestRank, lowest, lowestRank := "", -1, "", 1<<30 + for _, s := range supported { + idx, ok := effortRank[strings.ToLower(strings.TrimSpace(s))] + if !ok { + continue + } + if strings.EqualFold(strings.TrimSpace(s), want) { + return s + } + // off 不是可降级的档位,只作为**显式**的「关闭思考」目标(上面 isOffEffort + // 已单独处理)。留着它参与降级会造出静默的破坏性行为:glm-5.2 / + // deepseek-v4-pro 的支持列表是 [off, high, xhigh],默认档填 medium 或 low + // 时「没有更低的正档」会落到 off —— 操作员想要弱一档,拿到的是把该模型的 + // 思考完全关掉,而面板上显示的还是 medium。越过 off 后取最低正档(high)。 + // 与 normalizeReasoningEffort 的口径一致:off 只由客户端显式表达。 + if idx == effortRank[EffortOff] { + continue + } + if idx < lowestRank { + lowest, lowestRank = s, idx + } + if idx <= wantRank && idx > bestRank { + best, bestRank = s, idx + } + } + if best != "" { + return best + } + return lowest +} + +// applyEffortPolicy 在 injectThinking 之前执行档位策略,返回本次由网关写入的 +// 目标档("" = 未改写,后续仍走既有 injectThinking/normalize 管线)。 +// +// 必须在 injectThinking 之前:作用域 all 要把「关闭」改写成开启 + 带档位, +// 晚于 injectThinking 会被写成 thinking.type=disabled 且删掉档位。 +func applyEffortPolicy(obj map[string]any, model string, supported []string, policy *EffortPolicy, realm string) string { + if policy == nil || !policy.Enabled || model == "" { + return "" + } + target := ResolveGatewayEffort(policy.DefaultEffortFor(realm, model), supported) + if target == "" { + return "" + } + // 「关闭思考」在两种写法里都算客户端显式意图:档位 off/none/disabled, + // 或 thinking.type=disabled。作用域 level / 客户端优先时一律尊重。 + if effortValueOff(obj) || thinkingDisabled(obj) { + if policy.ClientPriority || policy.OverrideScope != OverrideScopeAll || target == EffortOff { + return "" + } + stripEffort(obj) + if th, ok := obj["thinking"].(map[string]any); ok { + th["type"] = "enabled" + } + obj["reasoning_effort"] = target + log.Printf("thinking policy: 网关优先(scope=all)改写关闭意图 model=%s -> %s", model, target) + return target + } + key, value := effortField(obj) + if key == "" { + // 客户端没发档位:补网关默认档(客户端优先模式下同样补——补的是缺失值, + // 不是覆盖客户端意图)。目标档为 off 时补「关闭思考」。 + if target == EffortOff { + disableThinking(obj) + log.Printf("thinking policy: 补网关默认档 model=%s -> off(关闭思考)", model) + return EffortOff + } + obj["reasoning_effort"] = target + return target + } + if policy.ClientPriority { + return "" + } + if target == EffortOff { + // 目标 off 要改 thinking 开关,scope=level 的约定是「只改档位」,所以 level + // 下保留客户端显式档位;scope=all 才连开关一起固定成关闭。 + if policy.OverrideScope != OverrideScopeAll { + return "" + } + disableThinking(obj) + log.Printf("thinking policy: 网关优先(scope=all)目标 off model=%s 改写关闭思考(client=%s)", model, value) + return EffortOff + } + if !strings.EqualFold(strings.TrimSpace(value), target) { + log.Printf("thinking policy: 网关优先改写 model=%s %s -> %s(client_priority=false)", model, value, target) + } + // 两个字段同时出现时只保留客户端实际生效的那个,避免旧值残留在另一字段 + // 被 injectThinking 的 off 判定命中、把请求改成关闭思考。 + stripEffort(obj) + obj[key] = target + return target +} + +// disableThinking 把请求体写成「关闭思考」形态:删掉档位字段(snake/camel 双删), +// thinking.type=disabled。deepseek 的 injectThinking 认这个形态;其它上游对 +// thinking.type 的接受度由上游决定(面板只给 canDisableThinking 的模型提供 off 选项)。 +func disableThinking(obj map[string]any) { + stripEffort(obj) + if th, ok := obj["thinking"].(map[string]any); ok { + th["type"] = "disabled" + return + } + obj["thinking"] = map[string]any{"type": "disabled"} +} + +// effortField 返回请求体里生效的档位字段与值(snake 优先,camel 兜底)。 +func effortField(obj map[string]any) (string, string) { + for _, k := range []string{"reasoning_effort", "reasoningEffort"} { + if v, ok := obj[k].(string); ok { + return k, v + } + } + return "", "" +} + +// thinkingDisabled 报告客户端是否用 thinking.type=disabled 显式关闭思考。 +func thinkingDisabled(obj map[string]any) bool { + th, ok := obj["thinking"].(map[string]any) + if !ok { + return false + } + typ, _ := th["type"].(string) + return strings.EqualFold(strings.TrimSpace(typ), "disabled") +} + +// stripEffort 删除 snake/camel 两个档位字段。 +func stripEffort(obj map[string]any) { + delete(obj, "reasoning_effort") + delete(obj, "reasoningEffort") +} diff --git a/internal/upstream/effort_policy_test.go b/internal/upstream/effort_policy_test.go new file mode 100644 index 0000000000000000000000000000000000000000..c22af84f04ac53ce1ccaccc0e904241088abd924 --- /dev/null +++ b/internal/upstream/effort_policy_test.go @@ -0,0 +1,241 @@ +package upstream + +import ( + "encoding/json" + "testing" +) + +func policyObj(t *testing.T, raw string) map[string]any { + t.Helper() + var obj map[string]any + if err := json.Unmarshal([]byte(raw), &obj); err != nil { + t.Fatalf("decode %s: %v", raw, err) + } + return obj +} + +func TestResolveGatewayEffort(t *testing.T) { + supported := []string{"low", "high", "xhigh"} + cases := []struct { + name string + want string + sup []string + exp string + }{ + {"max 取最高档", "max", supported, "xhigh"}, + {"空愿望档等同于 max", "", supported, "xhigh"}, + {"具体档支持则原样", "high", supported, "high"}, + {"不支持时落到不高于它的最高档", "medium", supported, "low"}, + {"低于最低支持档时取最低", "minimal", []string{"high", "max"}, "high"}, + // off 不是可降级档位:glm / v4-pro 这类 [off, high, xhigh] 的列表在「要的档 + // 比最低正档还低」时必须落到 high,而不是把思考静默关掉(修前是 off)。 + {"列表含 off 时不得降级到 off", "medium", []string{"high", "xhigh", "off"}, "high"}, + {"minimal 遇 off 列表仍取最低正档", "minimal", []string{"high", "xhigh", "off"}, "high"}, + {"low 遇 off 列表仍取最低正档", "low", []string{"high", "off"}, "high"}, + // 退化列表(只声明了 off):没有任何可降级的正档,返回 "" = 不改写,与 + // 「无法识别愿望档」同口径。绝不返回 off —— 那等于凭一个缺失的档位把思考关掉。 + {"只有 off 时无从降级", "low", []string{"off"}, ""}, + {"列表不含可识别档位时取最后一项", "max", []string{"weird-a", "weird-b"}, "weird-b"}, + {"空支持列表", "max", nil, ""}, + {"无法识别的愿望档", "turbo", supported, ""}, + } + for _, c := range cases { + t.Run(c.name, func(t *testing.T) { + if got := ResolveGatewayEffort(c.want, c.sup); got != c.exp { + t.Fatalf("ResolveGatewayEffort(%q,%v)=%q want %q", c.want, c.sup, got, c.exp) + } + }) + } +} + +func TestDefaultEffortForModelDefaults(t *testing.T) { + p := EffortPolicy{DefaultEffort: "max", ModelDefaults: map[string]string{ + "cn:m1": "low", + "m2": "high", + "global": "xhigh", + }} + if got := p.DefaultEffortFor("cn", "m1"); got != "low" { + t.Errorf("realm 精确覆盖=%q want low", got) + } + if got := p.DefaultEffortFor("global", "m1"); got != "max" { + t.Errorf("realm 不匹配时应回落全局=%q want max", got) + } + if got := p.DefaultEffortFor("cn", "m2"); got != "high" { + t.Errorf("裸名两域共用=%q want high", got) + } + if got := p.DefaultEffortFor("cn", "absent"); got != "max" { + t.Errorf("未配置=%q want max", got) + } +} + +func TestApplyEffortPolicyFillsMissing(t *testing.T) { + // 客户端没发档位:即使客户端优先也要补默认档(补的是缺失值,不是覆盖意图)。 + obj := policyObj(t, `{"model":"m"}`) + got := applyEffortPolicy(obj, "m", []string{"low", "high"}, &EffortPolicy{ + Enabled: true, ClientPriority: true, DefaultEffort: "max", + }, "cn") + if got != "high" || obj["reasoning_effort"] != "high" { + t.Fatalf("missing effort: got=%q body=%v", got, obj) + } +} + +func TestApplyEffortPolicyClientPriorityKeepsClient(t *testing.T) { + obj := policyObj(t, `{"reasoning_effort":"low"}`) + got := applyEffortPolicy(obj, "m", []string{"low", "high"}, &EffortPolicy{ + Enabled: true, ClientPriority: true, DefaultEffort: "max", + }, "cn") + if got != "" || obj["reasoning_effort"] != "low" { + t.Fatalf("client priority should keep client effort: got=%q body=%v", got, obj) + } +} + +func TestApplyEffortPolicyGatewayRewrites(t *testing.T) { + obj := policyObj(t, `{"reasoning_effort":"low"}`) + got := applyEffortPolicy(obj, "m", []string{"low", "high"}, &EffortPolicy{ + Enabled: true, ClientPriority: false, DefaultEffort: "max", OverrideScope: OverrideScopeLevel, + }, "cn") + if got != "high" || obj["reasoning_effort"] != "high" { + t.Fatalf("gateway priority should rewrite: got=%q body=%v", got, obj) + } +} + +func TestApplyEffortPolicyRespectsDisableByDefault(t *testing.T) { + // scope=level(默认)下,客户端显式关闭思考属于意图,网关不改写。 + for _, raw := range []string{ + `{"reasoning_effort":"off"}`, + `{"reasoningEffort":"none"}`, + `{"thinking":{"type":"disabled"}}`, + } { + obj := policyObj(t, raw) + got := applyEffortPolicy(obj, "m", []string{"low", "high"}, &EffortPolicy{ + Enabled: true, ClientPriority: false, DefaultEffort: "max", OverrideScope: OverrideScopeLevel, + }, "cn") + if got != "" { + t.Fatalf("%s: disable intent must be respected, got=%q body=%v", raw, got, obj) + } + } +} + +func TestApplyEffortPolicyScopeAllForcesThinking(t *testing.T) { + obj := policyObj(t, `{"reasoning_effort":"off","thinking":{"type":"disabled"}}`) + got := applyEffortPolicy(obj, "m", []string{"low", "xhigh"}, &EffortPolicy{ + Enabled: true, ClientPriority: false, DefaultEffort: "max", OverrideScope: OverrideScopeAll, + }, "cn") + th, _ := obj["thinking"].(map[string]any) + if got != "xhigh" || obj["reasoning_effort"] != "xhigh" || th["type"] != "enabled" { + t.Fatalf("scope=all should force thinking: got=%q body=%v", got, obj) + } +} + +func TestApplyEffortPolicyModelDefault(t *testing.T) { + obj := policyObj(t, `{"model":"m"}`) + got := applyEffortPolicy(obj, "m", []string{"low", "high"}, &EffortPolicy{ + Enabled: true, ClientPriority: true, DefaultEffort: "max", + ModelDefaults: map[string]string{"cn:m": "low"}, + }, "cn") + if got != "low" || obj["reasoning_effort"] != "low" { + t.Fatalf("model default: got=%q body=%v", got, obj) + } +} + +func TestApplyEffortPolicyNoop(t *testing.T) { + cases := []struct { + name string + policy *EffortPolicy + sup []string + }{ + {"nil 策略", nil, []string{"low"}}, + {"策略关闭", &EffortPolicy{Enabled: false, DefaultEffort: "max"}, []string{"low"}}, + {"模型无档位", &EffortPolicy{Enabled: true, DefaultEffort: "max"}, nil}, + } + for _, c := range cases { + t.Run(c.name, func(t *testing.T) { + obj := policyObj(t, `{"model":"m"}`) + if got := applyEffortPolicy(obj, "m", c.sup, c.policy, "cn"); got != "" { + t.Fatalf("expected no rewrite, got=%q body=%v", got, obj) + } + }) + } +} + +func TestResolveGatewayEffortOff(t *testing.T) { + // off 是「关闭思考」的目标档(面板下拉里与 supportedEfforts 同列), + // 必须原样解析成 off,不能被就近降级成最弱正档。 + for _, want := range []string{"off", "none", "disabled", " OFF "} { + if got := ResolveGatewayEffort(want, []string{"low", "high"}); got != EffortOff { + t.Errorf("ResolveGatewayEffort(%q)=%q want off", want, got) + } + } + if got := ResolveGatewayEffort("off", nil); got != EffortOff { + t.Errorf("off should resolve without supported list, got=%q", got) + } +} + +func TestApplyEffortPolicyOffTargetFillsDisable(t *testing.T) { + // 目标 off:客户端没发档位时补「关闭思考」形态(thinking.type=disabled,删档位)。 + obj := policyObj(t, `{"model":"m"}`) + got := applyEffortPolicy(obj, "m", []string{"low", "high"}, &EffortPolicy{ + Enabled: true, ClientPriority: true, DefaultEffort: "max", + ModelDefaults: map[string]string{"cn:m": "off"}, + }, "cn") + th, _ := obj["thinking"].(map[string]any) + if got != EffortOff || th["type"] != "disabled" { + t.Fatalf("off target should disable thinking: got=%q body=%v", got, obj) + } + if _, ok := obj["reasoning_effort"]; ok { + t.Fatalf("off target must drop effort field: %v", obj) + } +} + +func TestApplyEffortPolicyOffTargetRespectsScope(t *testing.T) { + // scope=level:off 要改开关,约定是「只改档位」——客户端显式档位保留。 + obj := policyObj(t, `{"reasoning_effort":"high"}`) + p := &EffortPolicy{Enabled: true, DefaultEffort: "max", OverrideScope: OverrideScopeLevel, + ModelDefaults: map[string]string{"m": "off"}} + if got := applyEffortPolicy(obj, "m", []string{"low", "high"}, p, "cn"); got != "" || obj["reasoning_effort"] != "high" { + t.Fatalf("scope=level should keep client effort: got=%q body=%v", got, obj) + } + // scope=all:连开关一起固定成关闭。 + p.OverrideScope = OverrideScopeAll + obj = policyObj(t, `{"reasoning_effort":"high"}`) + got := applyEffortPolicy(obj, "m", []string{"low", "high"}, p, "cn") + th, _ := obj["thinking"].(map[string]any) + if got != EffortOff || th["type"] != "disabled" { + t.Fatalf("scope=all off target: got=%q body=%v", got, obj) + } + if _, ok := obj["reasoning_effort"]; ok { + t.Fatalf("scope=all off target must drop effort: %v", obj) + } +} + +func TestEffortPolicyNormalized(t *testing.T) { + p := EffortPolicy{ + DefaultEffort: " MAX ", OverrideScope: "BOGUS", + ModelDefaults: map[string]string{" GLM-5.2 ": " High ", "x": "inherit", "": "max", "y": ""}, + }.Normalized() + if p.DefaultEffort != "max" || p.OverrideScope != OverrideScopeLevel { + t.Fatalf("normalized=%+v", p) + } + if len(p.ModelDefaults) != 1 || p.ModelDefaults["glm-5.2"] != "high" { + t.Fatalf("model defaults=%v", p.ModelDefaults) + } +} + +// TestEffortPolicyEmptyDefaultIsHigh 空档位回落 high 而不是 max。 +// +// 依据(2026-11-07 本机对照实测,cn:deepseek-v4.1-flash,同一 max_tokens=8192): +// +// max → think 8192 / 正文≈1906 token;另一轮 think=7612 直接把额度吃光触发截断 +// high → think 4068 / 正文≈3236 token(正文多 70%) +// +// 上游把思考与正文算在同一份输出额度里,max 并不是「更强的回答」,而是「更长的思考」。 +// hub(wb_proxy.default_reasoning_effort_mode)同样默认 high,并在注释里记着 issue #508。 +func TestEffortPolicyEmptyDefaultIsHigh(t *testing.T) { + if got := (EffortPolicy{}).Normalized().DefaultEffort; got != "high" { + t.Fatalf("空 default_effort 应回落 high,got %q", got) + } + // 显式配置仍然照单全收:要最深推理的人写 max 就该是 max。 + if got := (EffortPolicy{DefaultEffort: "max"}).Normalized().DefaultEffort; got != "max" { + t.Fatalf("显式 max 不应被改写,got %q", got) + } +} diff --git a/internal/upstream/embeddings.go b/internal/upstream/embeddings.go new file mode 100644 index 0000000000000000000000000000000000000000..222ac950a5f41e4bfe1a048e511fb95636d9d45b --- /dev/null +++ b/internal/upstream/embeddings.go @@ -0,0 +1,100 @@ +// embeddings.go 上游嵌入端点 POST /v2/embeddings(与 chat 同域同头)。 +// +// 上游嵌入模型与对话模型是**两套注册表**:/v3/config 的 models 列表里没有嵌入模型, +// 唯一实测可用的是 bge-m3(1024 维)。请求未知模型时上游统一回 500 + +// code=11351「embedding model [x] not found」——这是「模型不存在」而不是「服务坏了」, +// 所以本文件把它单独成 ErrEmbeddingModelNotFound,供 HTTP 层映射成 404。 +// +// 响应体是 OpenAI 形状的 {code,msg,model,data[{embedding}],usage}(data 里可能缺 +// object/index,由网关补齐——见 server/embeddings.go)。向量是 float 数组,批量 +// 1024 维可达 MB 级,故读体上限放到 16 MiB(chat 的 1 MiB 不够)。 +package upstream + +import ( + "bytes" + "context" + "encoding/json" + "errors" + "fmt" + "io" + "net/http" + + "github.com/misakano7545/workbuddy2api-panel/internal/auth" +) + +// EmbeddingsPath 上游嵌入端点路径(与 chat 共用 base,realm 决定 CN / global)。 +const EmbeddingsPath = "/v2/embeddings" + +// EmbeddingModelBGE 上游唯一实测可用的嵌入模型(1024 维)。仅用于错误文案与文档, +// 请求里仍按客户端给的模型名透传(不替客户端改模型)。 +const EmbeddingModelBGE = "bge-m3" + +// ErrEmbeddingModelNotFound 上游 11351:请求的嵌入模型不在上游注册表。 +// HTTP 层据此回 404(OpenAI 语义),其余上游失败仍按 502/503 处理。 +var ErrEmbeddingModelNotFound = errors.New("embedding model not found") + +// EmbeddingUsage 上游用量(字段名与 OpenAI 一致,缺失即为 0)。 +type EmbeddingUsage struct { + PromptTokens int `json:"prompt_tokens"` + TotalTokens int `json:"total_tokens"` +} + +// Embeddings 发起一次嵌入请求,返回上游原文 JSON({code,msg,model,data,usage})。 +// +// input 必须是字符串数组(单条也包成一条数组——上游只认数组形态)。 +// ≥400 走 Classify 定 Kind,供调用方复用 chat/images 的失败处置;业务 code 非 0 +// 即使 HTTP 200 也当错误返回(不把错误信封当向量透传给客户端)。 +func (c *Client) Embeddings(ctx context.Context, a *auth.Auth, model string, input []string) (json.RawMessage, error) { + body, err := json.Marshal(map[string]any{"model": model, "input": input}) + if err != nil { + return nil, err + } + req, err := http.NewRequestWithContext(ctx, http.MethodPost, c.chatBase(a)+EmbeddingsPath, bytes.NewReader(body)) + if err != nil { + return nil, err + } + req.Header.Set("Content-Type", "application/json") + c.ChatHeaders(req, a, "", ChatMeta{}) + resp, err := c.do(req, a, false) + if err != nil { + return nil, err + } + defer resp.Body.Close() + raw, err := io.ReadAll(io.LimitReader(resp.Body, 16<<20)) + if err != nil { + return nil, fmt.Errorf("read body: %w", err) + } + // 业务信封先解一次:11351 在 500 上也要能识别,故先于状态码判定。 + var env struct { + Code int `json:"code"` + Msg string `json:"msg"` + } + _ = json.Unmarshal(raw, &env) + if env.Code == 11351 { + return nil, fmt.Errorf("%w: %s", ErrEmbeddingModelNotFound, truncate(env.Msg, 160)) + } + // 限流/排队的等待口径随信封带出:头优先,6020/6021 的 data.retry_after 兜底 + // (与 chat 链路同口径,见 parseQueueRetryAfter)。缺了它 handler 只能按基数冷却。 + upErr := func() *Error { + kind := Classify(resp.StatusCode, string(raw)) + if kind == ErrNone { + kind = ErrClient + } + ue := &Error{Kind: kind, Status: resp.StatusCode, Msg: truncate(string(raw), 200)} + if d, ok := ParseRetryAfter(resp.Header); ok { + ue.RetryAfter = d + } else if kind == ErrUpstreamBusy { + if d, ok := parseQueueRetryAfter(raw); ok { + ue.RetryAfter = d + } + } + return ue + } + if resp.StatusCode >= 400 { + return nil, upErr() + } + if env.Code != 0 { + return nil, upErr() + } + return json.RawMessage(raw), nil +} diff --git a/internal/upstream/embeddings_test.go b/internal/upstream/embeddings_test.go new file mode 100644 index 0000000000000000000000000000000000000000..e17489fc76ce317bbc89e6699a75690cac0ac74b --- /dev/null +++ b/internal/upstream/embeddings_test.go @@ -0,0 +1,100 @@ +package upstream + +import ( + "context" + "encoding/json" + "errors" + "io" + "net/http" + "strings" + "testing" + + "github.com/misakano7545/workbuddy2api-panel/internal/auth" +) + +// embedClient 构造指向固定响应的客户端(ChatBaseCN 走假 Transport)。 +func embedClient(status int, body string, got *[]string) *Client { + return &Client{ + HTTP: &http.Client{Transport: rtFunc(func(r *http.Request) (*http.Response, error) { + raw, _ := io.ReadAll(r.Body) + if got != nil { + *got = append(*got, r.URL.Path+" "+string(raw)) + } + return jsonResp(status, body), nil + })}, + ChatBaseCN: "https://cn.example", + } +} + +// TestEmbeddingsUpstreamPathAndBody 落点 /v2/embeddings、请求体是 {model,input[]}。 +func TestEmbeddingsUpstreamPathAndBody(t *testing.T) { + var got []string + c := embedClient(200, `{"code":0,"model":"bge-m3","data":[{"embedding":[0.1]}],"usage":{"total_tokens":3}}`, &got) + if _, err := c.Embeddings(context.Background(), &auth.Auth{UID: "u1", AccessToken: "at"}, "bge-m3", []string{"你好"}); err != nil { + t.Fatalf("err=%v", err) + } + if len(got) != 1 { + t.Fatalf("请求次数=%d want 1", len(got)) + } + if !strings.HasPrefix(got[0], "/v2/embeddings ") { + t.Fatalf("落点=%q want /v2/embeddings", got[0]) + } + var sent struct { + Model string `json:"model"` + Input []string `json:"input"` + } + if err := json.Unmarshal([]byte(strings.TrimPrefix(got[0], "/v2/embeddings ")), &sent); err != nil { + t.Fatalf("请求体不是 JSON: %v", err) + } + if sent.Model != "bge-m3" || len(sent.Input) != 1 || sent.Input[0] != "你好" { + t.Errorf("请求体=%+v", sent) + } +} + +// TestEmbeddingsModelNotFound 11351(上游包在 HTTP 500 里)必须能被 errors.Is 认出, +// HTTP 层靠它回 404 而不是 500。 +func TestEmbeddingsModelNotFound(t *testing.T) { + c := embedClient(500, `{"code":11351,"msg":"embedding model [nope] not found"}`, nil) + _, err := c.Embeddings(context.Background(), &auth.Auth{UID: "u1", AccessToken: "at"}, "nope", []string{"x"}) + if !errors.Is(err, ErrEmbeddingModelNotFound) { + t.Fatalf("err=%v want ErrEmbeddingModelNotFound", err) + } +} + +// TestEmbeddingsBusinessCodeError HTTP 200 但业务 code 非 0:不得当成向量透传。 +func TestEmbeddingsBusinessCodeError(t *testing.T) { + c := embedClient(200, `{"code":10001,"msg":"quota exceeded"}`, nil) + _, err := c.Embeddings(context.Background(), &auth.Auth{UID: "u1", AccessToken: "at"}, "bge-m3", []string{"x"}) + if err == nil { + t.Fatal("业务 code 非 0 必须报错") + } + var ue *Error + if !errors.As(err, &ue) { + t.Fatalf("err=%T want *upstream.Error", err) + } + if ue.Kind == ErrNone { + t.Error("Kind 不得为空(调用方靠它决定罚号/换号)") + } +} + +// TestEmbeddingsHTTPErrorClassified 500 走 Classify,Kind 非空供失败处置。 +func TestEmbeddingsHTTPErrorClassified(t *testing.T) { + c := embedClient(503, `{"code":500,"msg":"upstream busy"}`, nil) + _, err := c.Embeddings(context.Background(), &auth.Auth{UID: "u1", AccessToken: "at"}, "bge-m3", []string{"x"}) + var ue *Error + if !errors.As(err, &ue) { + t.Fatalf("err=%T want *upstream.Error", err) + } + if ue.Status != 503 || ue.Kind == ErrNone { + t.Errorf("status=%d kind=%v want 503 / 非空 Kind", ue.Status, ue.Kind) + } +} + +func TestEmbeddingsClassifiesBusinessEnvelope(t *testing.T) { + c := embedClient(200, `{"code":6020,"msg":"queue.waiting.title"}`, nil) + _, err := c.Embeddings(context.Background(), &auth.Auth{UID: "u1", AccessToken: "at"}, "bge-m3", []string{"x"}) + var ue *Error + if !errors.As(err, &ue) || ue.Kind != ErrUpstreamBusy { + t.Fatalf("queue envelope misclassified: %v", err) + } +} diff --git a/internal/upstream/empty_text_part.go b/internal/upstream/empty_text_part.go new file mode 100644 index 0000000000000000000000000000000000000000..5724a713b90988172534d4d99611a33ae5429472 --- /dev/null +++ b/internal/upstream/empty_text_part.go @@ -0,0 +1,158 @@ +// empty_text_part.go 出站前修掉「空 text 段」(上游 400 / code 11151)。 +// +// 上游对每个 text 段做长度校验:`text` 为空串或缺失,整条消息判 `a message has +// empty content`,本次请求 400。麻烦在于这条**不可自愈**:客户端每次重试都在 +// 重放同一段历史,换账号、换模型之外没有出路,多号池只会把同一个坏请求在上游 +// 撞满一轮。 +// +// 触发点不止「客户端真的发了 parts 数组」这一种(2026-11-08 上游实测,kimi-k3.1-pro +// + cn 号池,逐形态对照): +// +// [{"type":"text","text":""}] -> 400 / 11151 +// [{"type":"text","text":null}] -> 400 / 11151 +// [{"type":"text"}] -> 400 / 11151 +// [{"type":"text","text":" "}] -> 200(只判长度是否为零,不 trim) +// [{"type":"textarea","text":""}] -> 200(未识别的 type 被忽略) +// {"type":"text","text":""}(非数组)-> 200(不嗅探对象) +// +// 更需要兜住的是最后一行背后那条规律:**字符串 content 只要去空白后以 `[` 开头, +// 上游就会把它当 parts 数组解析**。工具结果里常见的表单/按钮抓取恰好是这个形状 +// (`[{"type":"text","text":""},…]`),于是一段本该是「数据」的字符串被嗅探成一个 +// 空文本段。这里按同一口径嗅探、补值、重新序列化。 +// +// 修法是**只补值、不删段**:空 text 段填一个空格。删段会改段落数量与下标(客户端 +// 侧的多模态顺序、工具结果的段序都可能被别处引用),而补一个空格对模型上下文没有 +// 语义影响——它本来就看不到内容。注意不能用「加前缀空格」来规避嗅探:上游会先跳过 +// 空白再解析,那种写法挡不住。 +package upstream + +import ( + "encoding/json" + "strings" +) + +// emptyTextPartFill 空 text 段的占位值。单个空格:上游只看长度是否为零(" " 实测 +// 放行),且该段本来就没有内容可给模型看。 +const emptyTextPartFill = " " + +// guardEmptyTextParts 把 messages 里所有空 text 段就地补位。 +// +// 只在真有改动时才替换 content 字段:数组形态换成新 slice(只克隆要改的 text 段, +// 图片等其余段保持原引用),字符串形态重新序列化。无改动时整条消息一字不动—— +// 这条是「普通请求零影响」的判据。改动都落在 map 上,调用方持有的 slice 无需回写。 +func guardEmptyTextParts(messages []any) { + if len(messages) == 0 { + return + } + for _, rawMsg := range messages { + msg, ok := rawMsg.(map[string]any) + if !ok { + continue + } + content, has := msg["content"] + if !has { + continue + } + switch v := content.(type) { + case []any: + parts := make([]any, len(v)) + copied := false + for i, rawPart := range v { + part, ok := rawPart.(map[string]any) + if !ok || partType(part) != "text" { + parts[i] = rawPart + continue + } + if !isEmptyText(part) { + parts[i] = rawPart + continue + } + clone := make(map[string]any, len(part)+1) + for k, val := range part { + clone[k] = val + } + clone["text"] = emptyTextPartFill + parts[i] = clone + copied = true + } + if copied { + msg["content"] = parts + } + case string: + // 字符串信封被上游当 parts 嗅探:只有「解析出非空对象数组」才算,否则原样 + // 保留(普通文本、数字、以 [ 开头但解析失败的串都不动)。 + parts := sniffParts(v) + if parts == nil { + continue + } + if !fillEmptyTextParts(parts) { + continue + } + if nb, err := json.Marshal(parts); err == nil { + msg["content"] = string(nb) + } + } + } +} + +// sniffParts 复刻上游的嗅探口径:字符串去前导空白后以 `[` 开头、且能解析成 +// 「非空的对象数组」时返回该数组,否则 nil(表示上游不会把它当 parts)。 +func sniffParts(content string) []any { + stripped := strings.TrimLeft(content, " \t\r\n") + if !strings.HasPrefix(stripped, "[") { + return nil + } + var parts []any + if err := json.Unmarshal([]byte(stripped), &parts); err != nil { + return nil + } + if len(parts) == 0 { + return nil + } + for _, p := range parts { + if _, ok := p.(map[string]any); !ok { + return nil + } + } + return parts +} + +// fillEmptyTextParts 就地补位,返回是否有改动。 +func fillEmptyTextParts(parts []any) bool { + changed := false + for _, rawPart := range parts { + part, ok := rawPart.(map[string]any) + if !ok || partType(part) != "text" { + continue + } + if !isEmptyText(part) { + continue + } + part["text"] = emptyTextPartFill + changed = true + } + return changed +} + +// partType 取段类型。上游只对精确的 "text" 做校验,"textarea" 这类未知 type 被忽略, +// 所以这里**不做**前缀/大小写归一——归一反而会把"不受校验"的段拉进校验。 +func partType(part map[string]any) string { + t, _ := part["type"].(string) + return t +} + +// isEmptyText 该 text 段是否会被上游判为空:text 缺失、null、或空串。 +// 只判零长度、不 trim——" " 实测放行,把它当空来补等于改动了上游本来接受的报文。 +func isEmptyText(part map[string]any) bool { + v, has := part["text"] + if !has || v == nil { + return true + } + s, ok := v.(string) + if !ok { + // 非字符串(数字/对象等)不在此列:上游这句话只对「空串/缺失」下结论, + // 其余形态没有实测依据,改动它属于猜测。 + return false + } + return s == "" +} diff --git a/internal/upstream/enterprise_resource_test.go b/internal/upstream/enterprise_resource_test.go new file mode 100644 index 0000000000000000000000000000000000000000..713af73a74c5f5ab8016d031076889d6aa1c1cae --- /dev/null +++ b/internal/upstream/enterprise_resource_test.go @@ -0,0 +1,170 @@ +package upstream + +import ( + "net/http" + "net/http/httptest" + "strings" + "testing" + "time" + + "github.com/misakano7545/workbuddy2api-panel/internal/auth" +) + +// TestEnterpriseResourceMapsAllocatedQuota 企业版额度走 get-enterprise-user-usage: +// credit 是**已用**(与个人口径相反),故 remain = limitNum - credit、total = limitNum。 +func TestEnterpriseResourceMapsAllocatedQuota(t *testing.T) { + end := time.Now().Add(10 * 24 * time.Hour).Format(packageEndLayout) + var gotPath, gotEnt string + srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { + gotPath = r.URL.Path + gotEnt = r.Header.Get("X-Enterprise-Id") + w.Write([]byte(`{"code":0,"msg":"OK","data":{"credit":812.45,"limitNum":2000,` + + `"cycleStartTime":"2026-09-27 00:00:00","cycleEndTime":"` + end + `",` + + `"cycleResetTime":"2026-10-27 00:00:00"}}`)) + })) + defer srv.Close() + + c := &Client{HTTP: srv.Client(), BillingBaseCN: srv.URL} + a := &auth.Auth{UID: "u1", AccessToken: "at", EnterpriseID: "ent-1"} + + // soon=0:不分桶,但最早到期批次仍要记录。 + remain, total, expiring, earliestAt, earliestRemaining, err := c.UserResourceDetailedWithExpiry(a, 0) + if err != nil { + t.Fatalf("err=%v", err) + } + if !strings.HasSuffix(gotPath, "/v2/billing/meter/get-enterprise-user-usage") { + t.Errorf("path=%s want .../get-enterprise-user-usage", gotPath) + } + if gotEnt != "ent-1" { + t.Errorf("X-Enterprise-Id=%q want ent-1", gotEnt) + } + // 2000 - round(812.45) = 1188。 + if remain != 1188 || total != 2000 { + t.Errorf("remain=%d total=%d want 1188/2000", remain, total) + } + if expiring != 0 { + t.Errorf("soon=0 不应分桶,expiring=%d", expiring) + } + if earliestAt.IsZero() || earliestRemaining != 1188 { + t.Errorf("最早到期批次未记录:at=%v remaining=%d", earliestAt, earliestRemaining) + } + + // soon 覆盖周期末 → 整份剩余额度计入 expiring(prefer_expiring 据此优先消耗)。 + _, _, expiring2, _, _, err := c.UserResourceDetailedWithExpiry(a, 30*24*time.Hour) + if err != nil { + t.Fatalf("err=%v", err) + } + if expiring2 != 1188 { + t.Errorf("周期内 expiring=%d want 1188", expiring2) + } +} + +// TestEnterpriseResourceUnlimited 上游 limitNum=-1 表示不限量:池内用大剩余量表示, +// total 记 -1(面板显示「不限」),且不参与周期分桶(不限量没有"未用完作废"语义)。 +func TestEnterpriseResourceUnlimited(t *testing.T) { + srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { + w.Write([]byte(`{"code":0,"msg":"OK","data":{"credit":0,"limitNum":-1}}`)) + })) + defer srv.Close() + + c := &Client{HTTP: srv.Client(), BillingBaseCN: srv.URL} + a := &auth.Auth{UID: "u1", AccessToken: "at", EnterpriseID: "ent-1"} + + remain, total, expiring, earliestAt, earliestRemaining, err := c.UserResourceDetailedWithExpiry(a, 30*24*time.Hour) + if err != nil { + t.Fatalf("err=%v", err) + } + if remain != enterpriseUnlimitedRemain || total != enterpriseUnlimitedTotal { + t.Errorf("remain=%d total=%d want %d/-1", remain, total, enterpriseUnlimitedRemain) + } + if expiring != 0 || !earliestAt.IsZero() || earliestRemaining != 0 { + t.Errorf("不限量不应有周期批次:expiring=%d at=%v remaining=%d", expiring, earliestAt, earliestRemaining) + } +} + +// TestEnterpriseResourceSnakeCase 兼容上游第二套字段命名(桌面端另一条解析路径读 +// limit_num/used_num)。 +func TestEnterpriseResourceSnakeCase(t *testing.T) { + srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { + w.Write([]byte(`{"code":0,"msg":"OK","data":{"used_num":500,"limit_num":1500}}`)) + })) + defer srv.Close() + + c := &Client{HTTP: srv.Client(), BillingBaseCN: srv.URL} + a := &auth.Auth{UID: "u1", AccessToken: "at", EnterpriseID: "ent-1"} + + remain, total, _, _, _, err := c.UserResourceDetailedWithExpiry(a, 0) + if err != nil { + t.Fatalf("err=%v", err) + } + if remain != 1000 || total != 1500 { + t.Errorf("remain=%d total=%d want 1000/1500", remain, total) + } +} + +// TestPersonalResourceStaysOnPackageEndpoint 个人号零回归:仍走资源包端点, +// 企业端点一次都不发。 +func TestPersonalResourceStaysOnPackageEndpoint(t *testing.T) { + var paths []string + srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { + paths = append(paths, r.URL.Path) + if strings.Contains(r.URL.Path, "get-enterprise-user-usage") { + t.Errorf("个人号不应调用企业额度端点") + } + w.Write([]byte(`{"code":0,"data":{"Response":{"Data":{"Accounts":` + + `[{"CycleCapacitySize":1000,"CycleCapacityRemain":900,"CycleCapacityUsed":100}]}}}}`)) + })) + defer srv.Close() + + c := &Client{HTTP: srv.Client(), BillingBaseCN: srv.URL} + a := &auth.Auth{UID: "u1", AccessToken: "at"} + + remain, total, _, _, _, err := c.UserResourceDetailedWithExpiry(a, 0) + if err != nil { + t.Fatalf("err=%v", err) + } + if remain != 900 || total != 1000 { + t.Errorf("remain=%d total=%d want 900/1000", remain, total) + } + if len(paths) == 0 { + t.Fatal("应至少请求一次资源包端点") + } +} + +// TestAPIKeyResourceUsesEnterpriseEndpoint 静态 API Key 的额度必须走企业口径端点。 +// +// 判据为什么收在 auth.UsesEnterpriseBilling:个人 get-user-resource 对 ck_/pt_ Key +// 恒返回空 Accounts(实测 code 0、Accounts null),若这里漏掉 Key 分支,静态 Key 账号 +// 的余额会恒为 0,积分保底(credit_floor)把它当成耗尽号直接挡出选号——号是好的, +// 只是账单查错了地方。 +func TestAPIKeyResourceUsesEnterpriseEndpoint(t *testing.T) { + var paths []string + srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { + paths = append(paths, r.URL.Path) + if !strings.Contains(r.URL.Path, "get-enterprise-user-usage") { + t.Errorf("静态 API Key 不该走个人资源包端点:%s", r.URL.Path) + } + // 静态 Key 无企业身份,不该注入 X-Enterprise-Id(否则上游按企业上下文鉴权)。 + if ent := r.Header.Get("X-Enterprise-Id"); ent != "" { + t.Errorf("静态 Key 不该带 X-Enterprise-Id:%q", ent) + } + w.Write([]byte(`{"code":0,"msg":"OK","data":{"credit":100,"limitNum":1000}}`)) + })) + defer srv.Close() + + c := &Client{HTTP: srv.Client(), BillingBaseCN: srv.URL} + for _, token := range []string{"ck_abc123.secret", "pt_zzz.999"} { + paths = nil + a := &auth.Auth{UID: "u1", AccessToken: token} + remain, total, _, _, _, err := c.UserResourceDetailedWithExpiry(a, 0) + if err != nil { + t.Fatalf("token=%q err=%v", token, err) + } + if remain != 900 || total != 1000 { + t.Errorf("token=%q remain=%d total=%d want 900/1000", token, remain, total) + } + if len(paths) == 0 { + t.Fatalf("token=%q 应至少请求一次额度端点", token) + } + } +} diff --git a/internal/upstream/fingerprint_test.go b/internal/upstream/fingerprint_test.go new file mode 100644 index 0000000000000000000000000000000000000000..e7bbb91ee4151cba864d00919d2a09179a689a94 --- /dev/null +++ b/internal/upstream/fingerprint_test.go @@ -0,0 +1,470 @@ +// fingerprint_test.go 官方客户端指纹对齐真机(国内 5.9.3 / 国际 5.8.4)的回归。 +// +// 证据来源:2026-10-20 桌面客户端真实启动流量(mitmproxy 抓到 www.workbuddy.ai +// 183 条请求)+ 客户端 app.asar / cli/dist 静态反编译。以下每个断言都对应一处 +// 与真机不一致的地方——不一致本身是「被判定非官方客户端」的候选指纹。 +package upstream + +import ( + "encoding/base64" + "encoding/json" + "net/http" + "net/http/httptest" + "net/url" + "strings" + "testing" + "time" + + "github.com/misakano7545/workbuddy2api-panel/internal/auth" +) + +func globalAuth() *auth.Auth { + return &auth.Auth{UID: "u-g", AccessToken: "at", Domain: "www.workbuddy.ai", Nickname: "g"} +} + +// v3ProbeUACNForTest 国内版 /v3/config 实测 UA(默认 Client、CN 账号)。 +// +// 2026-10-30 国内 5.9.3 抓包复核:真机 /v3/config 是**两段式** +// `WorkBuddy/5.9.3 CLI/2.165.0`。同一账号同一 token 用三段 / 两段分别打, +// 返回逐字节相同的 64866 字节(61 模型 / agents=cli:16)——UA 家族不再分流。 +const v3ProbeUACNForTest = "WorkBuddy/5.9.3 CLI/2.165.0" + +// TestUARealmBrand 首段恒驼峰 WorkBuddy,只有第二段品牌随 realm 变。 +// +// 2026-10-30 双版本真机抓包(chat 链 /v2/chat/completions): +// +// CN 5.9.3 → WorkBuddy/5.9.3 WorkBuddy/5.9.3 CLI/2.165.0 +// global 5.9.4 → WorkBuddy/5.9.4 workbuddy-ai/5.9.4 CLI/2.165.0 +// +// 关键:首段永远是驼峰 `WorkBuddy`——官方 chat 走 OpenAI SDK 的 buildUserAgent, +// 首段取 productName 原样,第二段才是打包期改写的 slug。曾把 global 首段也写成 +// `workbuddy-ai/`(与 /v2/report 那类非 SDK 请求混淆),与 chat 真机不符。 +func TestUARealmBrand(t *testing.T) { + c := New() + + cn := &auth.Auth{UID: "u-c", AccessToken: "at"} + if got, want := c.userAgent(cn), "WorkBuddy/5.9.3 WorkBuddy/5.9.3 CLI/2.165.0"; got != want { + t.Errorf("CN UA=%q want %q", got, want) + } + if got, want := c.userAgent(globalAuth()), "WorkBuddy/5.9.4 workbuddy-ai/5.9.4 CLI/2.165.0"; got != want { + t.Errorf("global UA=%q want %q", got, want) + } + // 显式配置仍然赢(用户自定义品牌/版本)。 + c.ClientVersion = "9.9.9" + c.CliVersion = "1.2.3" + if got, want := c.userAgent(globalAuth()), "WorkBuddy/9.9.9 workbuddy-ai/9.9.9 CLI/1.2.3"; got != want { + t.Errorf("override UA=%q want %q", got, want) + } +} + +// TestV3ProbeUAOfficial 目录探测 UA 必须是官方真实形态,不能是 CodeBuddy 家族。 +// +// 2026-10-30 双版本真机 /v3/config UA **同一形态**(两段、单品牌): +// +// CN 5.9.3 → WorkBuddy/5.9.3 CLI/2.165.0 +// global 5.9.4 → WorkBuddy/5.9.4 CLI/2.165.0 +// +// 旧实现给 CN 发三段重复品牌(5.8.3 时代的抓包结论),5.9.3 已不成立:同 token +// 三段/两段返回逐字节相同。更早的 `CodeBuddyIDE/4.12.0 CodeBuddy/4.12.0` / +// `CLI/2.63.2 CodeBuddy/2.63.2` 两个串在 WorkBuddy 分发包里根本不存在。 +func TestV3ProbeUAOfficial(t *testing.T) { + c := New() + cn := &auth.Auth{UID: "u-c", AccessToken: "at"} + + if got, want := c.v3ProbeUA(cn), "WorkBuddy/5.9.3 CLI/2.165.0"; got != want { + t.Errorf("CN v3ProbeUA=%q want %q", got, want) + } + if got, want := c.v3ProbeUA(globalAuth()), "WorkBuddy/5.9.4 CLI/2.165.0"; got != want { + t.Errorf("global v3ProbeUA=%q want %q", got, want) + } + // 第二路与主路同串(真机只有这一种形态;双路只为沿用 global 的并集调用链)。 + if got, want := c.v3ProbeUALite(cn), "WorkBuddy/5.9.3 CLI/2.165.0"; got != want { + t.Errorf("CN v3ProbeUALite=%q want %q", got, want) + } + // 任何一路都不许再出现 CodeBuddy 字面量。 + for _, ua := range []string{c.v3ProbeUA(cn), c.v3ProbeUA(globalAuth()), c.v3ProbeUALite(cn), c.desktopProbeUA()} { + if strings.Contains(ua, "CodeBuddy") { + t.Errorf("探测 UA 仍含 CodeBuddy 家族字面量: %q", ua) + } + } +} + +// TestBillingUAAxiosBothRealms 两版计费请求的 UA 都是 axios 默认串。 +// +// 真机实测:CN 与 GL 的 `/billing/meter/get-user-resource-*`、`-summary`、 +// `checkin-activity-status` 的 UA 全是 `axios/1.16.1` —— billing 层走 axios 实例, +// 不带任何品牌段。旧实现 CN 侧发 `WorkBuddy/` 是按客户端 UA 推理的产物。 +func TestBillingUAAxiosBothRealms(t *testing.T) { + c := New() + if got := c.billingUA(globalAuth()); got != "axios/1.16.1" { + t.Errorf("global billing UA=%q want axios/1.16.1", got) + } + if got := c.billingUA(&auth.Auth{UID: "u-c", AccessToken: "at"}); got != "axios/1.16.1" { + t.Errorf("CN billing UA=%q want axios/1.16.1", got) + } +} + +// TestIdentityHeadersPersonalSendsNone 个人号三头全不发。 +// +// 反编译的 runIdentityHeaders() 只在「有 enterpriseId / idSource / token_source 任一」 +// 时才发 X-Userinfo;真机个人号抓包里 X-Userinfo / X-Auth-Method / X-Id-Source 全都不存在。 +// 凭「个人号也该有」去补空值是伪造指纹,比不发更容易被识别。 +func TestIdentityHeadersPersonalSendsNone(t *testing.T) { + c := New() + a := globalAuth() + req := httptest.NewRequest("POST", "https://www.workbuddy.ai/v2/chat/completions", nil) + c.injectIdentityHeaders(req, a) + for _, h := range []string{"X-Userinfo", "X-Auth-Method", "X-Id-Source"} { + if v := req.Header.Get(h); v != "" { + t.Errorf("个人号不该发 %s=%q", h, v) + } + } +} + +// TestIdentityHeadersEnterpriseUserinfo 企业号发 X-Userinfo,内容是 base64(JSON{uin,owner_uin})。 +// uin 段取 uid(反编译逻辑是 {uin: n.uid}),owner_uin 取 enterpriseId。 +func TestIdentityHeadersEnterpriseUserinfo(t *testing.T) { + c := New() + a := globalAuth() + a.EnterpriseID = "ent-1" + req := httptest.NewRequest("POST", "https://www.workbuddy.ai/v2/chat/completions", nil) + c.injectIdentityHeaders(req, a) + + raw := req.Header.Get("X-Userinfo") + if raw == "" { + t.Fatal("企业号应发 X-Userinfo") + } + dec, err := base64.StdEncoding.DecodeString(raw) + if err != nil { + t.Fatalf("X-Userinfo 不是标准 base64: %v", err) + } + var payload map[string]string + if err := json.Unmarshal(dec, &payload); err != nil { + t.Fatalf("X-Userinfo 不是 JSON: %v (%s)", err, dec) + } + if payload["uin"] != "u-g" { + t.Errorf("uin=%q want u-g(反编译逻辑是 {uin: uid})", payload["uin"]) + } + if payload["owner_uin"] != "ent-1" { + t.Errorf("owner_uin=%q want ent-1", payload["owner_uin"]) + } + if _, ok := payload["token_source"]; ok { + t.Errorf("无 token_source 时不该写入该键(不是写空串):%v", payload) + } +} + +// TestIdentityHeadersPersonalWithTokenSourceSendsNone 个人号即使 token 带 +// token_source 也不发 X-Auth-Method / X-Userinfo(issue #51)。 +// +// 背景:`login.sh` 的设备流拿到的 CN token 声明里有 token_source=enterprise_switch, +// 旧逻辑据此给个人号注入了这两个头;而两版客户端的个人号真机抓包都没有它们 +// (capture/raw3/001-chat.json 国际版、capture/raw8/002-chat.json 国内版)。 +// token_source 是 token 的来路,不是账号身份——个人号 enterpriseId 为空即无企业语义。 +func TestIdentityHeadersPersonalWithTokenSourceSendsNone(t *testing.T) { + payload := base64.RawURLEncoding.EncodeToString([]byte(`{"token_source":"enterprise_switch"}`)) + a := &auth.Auth{UID: "u1", AccessToken: "h." + payload + ".s"} // 无 EnterpriseID = 个人号 + req := httptest.NewRequest("POST", "https://example/v2/chat/completions", nil) + New().injectIdentityHeaders(req, a) + + for _, h := range []string{"X-Auth-Method", "X-Userinfo", "X-Id-Source"} { + if v := req.Header.Get(h); v != "" { + t.Errorf("个人号不该发 %s=%q(官方两版个人号都没有这个头)", h, v) + } + } +} + +// TestIdentityHeadersEnterpriseWithTokenSource 企业号仍按 token_source 注入。 +func TestIdentityHeadersEnterpriseWithTokenSource(t *testing.T) { + payload := base64.RawURLEncoding.EncodeToString([]byte(`{"token_source":"enterprise_switch"}`)) + a := &auth.Auth{UID: "u1", EnterpriseID: "ent-1", AccessToken: "h." + payload + ".s"} + req := httptest.NewRequest("POST", "https://example/v2/chat/completions", nil) + New().injectIdentityHeaders(req, a) + + if got := req.Header.Get("X-Auth-Method"); got != "enterprise_switch" { + t.Fatalf("企业号 X-Auth-Method=%q want enterprise_switch", got) + } + dec, _ := base64.StdEncoding.DecodeString(req.Header.Get("X-Userinfo")) + var m map[string]string + _ = json.Unmarshal(dec, &m) + if m["token_source"] != "enterprise_switch" || m["uin"] != "u1" || m["owner_uin"] != "ent-1" { + t.Fatalf("X-Userinfo=%s", dec) + } +} + +// TestChatCarriesPrivateData 真机 chat 出站恒带 X-Private-Data: **false**。 +// +// 5.9.3 真机 7 条 /v2/chat/completions 一律 `X-Private-Data: false`(含 main 与 +// auxiliary)。客户端语义是「开了模型优化 → 声明 false」,只有企业版/显式关优化才发 true。 +func TestChatCarriesPrivateData(t *testing.T) { + c := New() + c.ChatBaseCN = "https://cn.example" + a := &auth.Auth{UID: "u1", AccessToken: "at"} + req := httptest.NewRequest("POST", "https://cn.example/v2/chat/completions", nil) + c.ChatHeaders(req, a, "", ChatMeta{ConversationID: "c1", ConversationRequestID: "r1"}) + if got := req.Header.Get("X-Private-Data"); got != "false" { + t.Fatalf("X-Private-Data=%q want false", got) + } + // 同批真机头里必带 X-Agent-Runtime: local-agent。 + if got := req.Header.Get("X-Agent-Runtime"); got != "local-agent" { + t.Fatalf("X-Agent-Runtime=%q want local-agent", got) + } + // baggage 必须与同请求的会话头同值(头体/头间一致性)。 + if got := req.Header.Get("baggage"); !strings.Contains(got, "codebuddy.session_id=c1") || + !strings.Contains(got, "codebuddy.conversation_request_id=r1") { + t.Fatalf("baggage=%q 需含 session/conversation_request 同值", got) + } +} + +// TestDesktopReportDomainIsHost X-Domain 必须是裸主机名,不是带 scheme 的 URL。 +// 真机:`X-Domain: www.workbuddy.ai`;原实现塞的是 desktopBase(https://...)。 +func TestDesktopReportDomainIsHost(t *testing.T) { + var gotDomain string + srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { + gotDomain = r.Header.Get("X-Domain") + w.Write([]byte(`{"code":0,"msg":"OK"}`)) + })) + defer srv.Close() + + // 用真 base 形式(带 scheme)验证剥离逻辑:client 的 base 就是 URL。 + c := &Client{HTTP: srv.Client(), ChatBaseGlobal: srv.URL, GlobalEnabled: true} + if err := c.ReportDesktopEvent(globalAuth(), DesktopEvent{"eventCode": "x"}); err != nil { + t.Fatalf("report: %v", err) + } + // Hostname() 剥掉 scheme 与端口(真机 X-Domain 是纯主机名,无端口)。 + u, _ := url.Parse(srv.URL) + want := u.Hostname() + if gotDomain != want { + t.Fatalf("X-Domain=%q want %q(裸 host,不带 scheme)", gotDomain, want) + } +} + +// TestDesktopReportFingerprintPerRealm /v2/report 的版本三元组按 realm 分档, +// 且 qimei36 只在国内版出现。 +// +// 2026-10-20 双版本真机抓包(同一台机器): +// +// CN ideVersion 5.9.3 commit d4692421… releaseDate 1793093056315,**带** qimei36 +// global ideVersion 5.8.4 commit 73952edb48da… releaseDate 1792063084107,**无** qimei36 +// +// 键数差集恰好只有 qimei36(CN 28 键 / GL 27 键)。此前不分档、恒用 GL 的三元组, +// 等于给每个国内号都盖了国际版的包指纹;给 GL 补 qimei36 则是无中生有。 +func TestDesktopReportFingerprintPerRealm(t *testing.T) { + cases := []struct { + name string + auth *auth.Auth + ver string + commit string + release int64 + qimei bool + }{ + {"CN", &auth.Auth{UID: "u-c", AccessToken: "at", Nickname: "cn"}, + "5.9.3", "d46924219e79332f49c37ccebf27292f87001b19", 1793093056315, true}, + {"global", globalAuth(), + "5.9.4", "fa0a0901906addaa1a4259f6df347388a5563ded", 1793288804029, false}, + } + for _, tc := range cases { + t.Run(tc.name, func(t *testing.T) { + fp := desktopFingerprint(tc.auth) + if fp["ideVersion"] != tc.ver || fp["extVersion"] != tc.ver { + t.Errorf("ideVersion/extVersion=%v/%v want %s", fp["ideVersion"], fp["extVersion"], tc.ver) + } + if fp["commit"] != tc.commit { + t.Errorf("commit=%v want %s", fp["commit"], tc.commit) + } + if fp["releaseDate"] != tc.release { + t.Errorf("releaseDate=%v want %d", fp["releaseDate"], tc.release) + } + got, has := fp["qimei36"] + if has != tc.qimei { + t.Fatalf("qimei36 存在性=%v want %v(CN 有 / global 无)", has, tc.qimei) + } + if tc.qimei { + s, _ := got.(string) + if len(s) != 36 { + t.Errorf("qimei36=%q 长度=%d want 36 hex", s, len(s)) + } + // 同号幂等:设备标识跨调用必须恒同值。 + if again := desktopFingerprint(tc.auth)["qimei36"]; again != got { + t.Errorf("qimei36 非幂等: %v vs %v", got, again) + } + } + }) + } +} + +// TestDesktopUAPerRealm 桌面端 UA 的品牌段与客户端版本都跟着 realm 走。 +func TestDesktopUAPerRealm(t *testing.T) { + cn := &auth.Auth{UID: "u-c", AccessToken: "at"} + if got, want := desktopUAFor(cn), "WorkBuddy/5.9.3 WorkBuddy/5.9.3 CLI/2.165.0"; got != want { + t.Errorf("CN desktop UA=%q want %q", got, want) + } + if got, want := desktopUAFor(globalAuth()), "workbuddy-ai/5.9.4 workbuddy-ai/5.9.4 CLI/2.165.0"; got != want { + t.Errorf("global desktop UA=%q want %q", got, want) + } + // RPC 层 UA 与 desktop 同形(首段即品牌 slug),chat 层则由 userAgent 覆盖。 + if got, want := (&Client{}).rpcUAFor(globalAuth()), "workbuddy-ai/5.9.4 workbuddy-ai/5.9.4 CLI/2.165.0"; got != want { + t.Errorf("global rpc UA=%q want %q", got, want) + } + if got, want := (&Client{}).rpcUAFor(cn), "WorkBuddy/5.9.3 WorkBuddy/5.9.3 CLI/2.165.0"; got != want { + t.Errorf("CN rpc UA=%q want %q(CN 下与 chat 同值)", got, want) + } +} + +// TestAcceptLanguageSameBothRealms Accept-Language 不按账号域切。 +// +// 真机实测:跟随操作系统区域,同一台中文机器上 CN/GL 都是 `zh`(billing 层固定) +// 或 `zh-CN`(渲染层),多数请求干脆不带。旧实现「global → en-US」是臆测。 +func TestAcceptLanguageSameBothRealms(t *testing.T) { + cn, gl := acceptLanguageFor(&auth.Auth{UID: "u-c"}), acceptLanguageFor(globalAuth()) + if cn != gl { + t.Errorf("两域取值不一致: CN=%q GL=%q(真机同机同值)", cn, gl) + } + if cn == "en-US" { + t.Errorf("不应按域硬编码 en-US(实测仅出现 1 次,非常态)") + } +} + +// TestGlobalPackageDetailsBodyShapes paid / free 两份明细的请求体**不同形**。 +// +// 2026-10-20 双版本真机抓包(CN/GL 一致): +// +// paid-packages: {PageNumber, PageSize, PackageCodes, Status:[0,3], NeedRenewInfo:true} +// —— 无 SlicePeriod 时间切片 +// free-packages: … + SlicePeriodStartTime / SlicePeriodEndTime +// —— 无 NeedRenewInfo +// +// 此前两条共用同一 body(都带切片、都无 NeedRenewInfo),paid 包因此拿不到续订窗口。 +func TestGlobalPackageDetailsBodyShapes(t *testing.T) { + bodies := map[string]map[string]any{} + srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { + var m map[string]any + _ = json.NewDecoder(r.Body).Decode(&m) + name := r.URL.Path[strings.LastIndex(r.URL.Path, "/")+1:] + bodies[name] = m + w.Write([]byte(`{"code":0,"msg":"OK","data":{"Accounts":[]}}`)) + })) + defer srv.Close() + + c := &Client{HTTP: srv.Client(), BillingBaseGlobal: srv.URL, GlobalEnabled: true} + c.globalPackageDetails(globalAuth(), []string{"PKG-A"}) + + paid, ok := bodies["get-user-resource-paid-packages"] + if !ok { + t.Fatalf("未请求 paid-packages,实际=%v", bodies) + } + if _, has := paid["SlicePeriodStartTime"]; has { + t.Errorf("paid-packages 不该带时间切片: %v", paid) + } + if paid["NeedRenewInfo"] != true { + t.Errorf("paid-packages 必须带 NeedRenewInfo:true,实际=%v", paid["NeedRenewInfo"]) + } + + free, ok := bodies["get-user-resource-free-packages"] + if !ok { + t.Fatalf("未请求 free-packages,实际=%v", bodies) + } + if _, has := free["NeedRenewInfo"]; has { + t.Errorf("free-packages 不该带 NeedRenewInfo: %v", free) + } + if free["SlicePeriodStartTime"] == nil || free["SlicePeriodEndTime"] == nil { + t.Errorf("free-packages 必须带时间切片: %v", free) + } + + // 两条共有字段必须一致(差集只允许上面那两处)。 + for _, k := range []string{"PageNumber", "PageSize", "PackageCodes", "Status"} { + if paid[k] == nil || free[k] == nil { + t.Errorf("共有字段 %s 缺失: paid=%v free=%v", k, paid[k], free[k]) + } + } +} + +// TestGlobalBillingSummary 国际版余额走 summary + paid/free 明细: +// remain/total 取 summary 的 Cycle{Remain,Total}Capacity(字符串小数), +// 到期批次按 PackageCode 与明细关联。 +func TestGlobalBillingSummary(t *testing.T) { + var paths []string + srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { + paths = append(paths, r.URL.Path) + switch { + case strings.HasSuffix(r.URL.Path, "/get-user-resource-summary"): + w.Write([]byte(`{"code":0,"msg":"OK","data":{"Packages":[` + + `{"PackageCode":"PKG-A","CycleTotalCapacity":"540","CycleRemainCapacity":"335.47000026","CycleUsedCapacity":"204.52999974","CapacityUnit":"credit"},` + + `{"PackageCode":"PKG-B","CycleTotalCapacity":"100","CycleRemainCapacity":"0","CycleUsedCapacity":"100"}` + + `],"SubscriptionPackageName":"免费版","IsPaidUser":false}}`)) + case strings.HasSuffix(r.URL.Path, "/get-user-resource-free-packages"): + soon := time.Now().Add(48 * time.Hour).Format("2006-01-02 15:04:05") + w.Write([]byte(`{"code":0,"msg":"OK","data":{"Accounts":[` + + `{"PackageCode":"PKG-A","PackageName":"权益赠送包","CycleCapacitySize":540,"CycleCapacityRemain":335,` + + `"CycleEndTime":"` + soon + `","DeductionEndTime":0,"ExpiredTime":""}` + + `],"TotalCount":1}}`)) + case strings.HasSuffix(r.URL.Path, "/get-user-resource-paid-packages"): + w.Write([]byte(`{"code":0,"msg":"OK","data":{"Accounts":[],"TotalCount":0}}`)) + default: + w.WriteHeader(404) + } + })) + defer srv.Close() + + c := &Client{HTTP: srv.Client(), BillingBaseGlobal: srv.URL, GlobalEnabled: true} + remain, total, expiring, earliestAt, earliestRemaining, buckets, err := + c.UserResourceSnapshot(globalAuth(), 168*time.Hour) + if err != nil { + t.Fatalf("snapshot: %v", err) + } + // 540 + 100 = 640 total;335.47 + 0 → 截断 335 remain。 + if total != 640 { + t.Errorf("total=%d want 640", total) + } + if remain != 335 { + t.Errorf("remain=%d want 335(字符串小数按整数截断,与既有口径一致)", remain) + } + if len(buckets) != 1 || buckets[0].Remain != 335 { + t.Fatalf("buckets=%+v want 单批 335", buckets) + } + if earliestAt.IsZero() || earliestRemaining != 335 { + t.Errorf("earliestAt=%v earliestRemaining=%d want 非零/335", earliestAt, earliestRemaining) + } + // 48h 后到期、窗口 168h → 该批整笔计入 expiring。 + if expiring != 335 { + t.Errorf("expiring=%d want 335(48h < 168h 窗口)", expiring) + } + // 必须打的是国际版新三件套,不能退回 CN 的 get-user-resource。 + for _, p := range paths { + if strings.HasSuffix(p, "/billing/meter/get-user-resource") { + t.Fatalf("国际版不该再走 CN 分页路径:%v", paths) + } + } +} + +// TestGlobalBillingFallsBackToCNPath summary 失败时回落 CN 分页路径(老路径兼容尝试)。 +func TestGlobalBillingFallsBackToCNPath(t *testing.T) { + var sawCN bool + srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { + if strings.HasSuffix(r.URL.Path, "/get-user-resource-summary") { + w.WriteHeader(500) + return + } + if strings.Contains(r.URL.Path, "get-user-resource") && + !strings.Contains(r.URL.Path, "paid-packages") && + !strings.Contains(r.URL.Path, "free-packages") { + sawCN = true + w.Write([]byte(`{"code":0,"data":{"Response":{"Data":{"Accounts":` + + `[{"CycleCapacitySize":1000,"CycleCapacityRemain":900,"CycleCapacityUsed":100}]}}}}`)) + return + } + w.WriteHeader(404) + })) + defer srv.Close() + + c := &Client{HTTP: srv.Client(), BillingBaseGlobal: srv.URL, GlobalEnabled: true} + remain, total, _, _, _, _, err := c.UserResourceSnapshot(globalAuth(), 0) + if err != nil { + t.Fatalf("snapshot: %v", err) + } + if !sawCN { + t.Fatal("summary 失败时应回落到 CN 分页路径") + } + if remain != 900 || total != 1000 { + t.Errorf("remain=%d total=%d want 900/1000", remain, total) + } +} diff --git a/internal/upstream/gl_contract_test.go b/internal/upstream/gl_contract_test.go new file mode 100644 index 0000000000000000000000000000000000000000..03806e195c170e0389e9be76ad583df2676b1a3d --- /dev/null +++ b/internal/upstream/gl_contract_test.go @@ -0,0 +1,225 @@ +// gl_contract_test.go GL 客户端请求契约回归(黄金头集来自 WorkBuddy AI 5.9.4 真机抓包)。 +// +// 与 cn_contract_test.go 同构,但锁的是**国际版 5.9.4** 的出站形态。本文件覆盖三处 +// 2026-10-30 抓包才暴露、且与 CN 不同形的差异: +// +// 1. X-Private-Data:国际发行版 productFeatures.DefaultModelOptimizationOff=true +// (国内 5.9.3 是 false)→ 个人号声明 true。旧实现按企业/个人判,方向反了。 +// 2. RPC/REST 族 UA 首段是品牌 slug(workbuddy-ai/…),chat 族首段才是驼峰 +// WorkBuddy/… —— 同一会话内两族并存,是客户端真实形态。 +// 3. baggage 只有 4 个成员。 +// +// 抓包环境:WorkBuddy AI 5.9.4(CLI 2.165.0),个人号,www.workbuddy.ai。 +// 取每条路径全部样本的交集;连接层/传输层头与 CN 侧同规则剔除。 +package upstream + +import ( + "bytes" + "compress/gzip" + "io" + "net/http" + "net/http/httptest" + "sort" + "strings" + "testing" + + "github.com/misakano7545/workbuddy2api-panel/internal/auth" +) + +// glGlobalAuth 国际版个人号(Domain 落 www.workbuddy.ai,与真机 X-Domain 同值)。 +func glGlobalAuth() *auth.Auth { + return &auth.Auth{ + UID: "00000000-0000-4000-8000-000000000001", AccessToken: "AT", + RefreshToken: "RT", Nickname: "misakano7545", + Domain: "www.workbuddy.ai", + } +} + +var glGoldenCases = []cnGolden{ + { + // 真机 idx 4 条 /v2/chat/completions 同构。 + path: "/v2/chat/completions", + headers: []string{ + "accept", "authorization", "acp-connection-id", "b3", "baggage", + "content-type", "traceparent", "user-agent", + "x-agent-intent", "x-agent-purpose", "x-agent-runtime", "x-agent-type", + "x-b3-parentspanid", "x-b3-sampled", "x-b3-spanid", "x-b3-traceid", + "x-codebuddy-request", "x-conversation-id", "x-conversation-message-id", + "x-conversation-request-id", "x-domain", "x-ide-name", "x-ide-type", + "x-ide-version", "x-private-data", "x-product", "x-request-id", + "x-requested-with", "x-root-request-id", "x-trace-id", "x-user-id", + "x-stainless-arch", "x-stainless-lang", "x-stainless-os", + "x-stainless-package-version", "x-stainless-retry-count", + "x-stainless-runtime", "x-stainless-runtime-version", + }, + values: map[string]string{ + "accept": "application/json", + "user-agent": "WorkBuddy/5.9.4 workbuddy-ai/5.9.4 CLI/2.165.0", + "x-private-data": "true", + "x-domain": "www.workbuddy.ai", + "x-ide-name": "WorkBuddy", + "x-ide-type": "WorkBuddy", + "x-ide-version": "5.9.4", + "x-product": "SaaS", + "x-agent-intent": "craft", + "x-agent-purpose": "conversation", + "x-agent-runtime": "local-agent", + "x-agent-type": "main", + "x-requested-with": "XMLHttpRequest", + "x-codebuddy-request": "1", + }, + absent: []string{"origin", "referer", "accept-language", "x-enterprise-id"}, + }, + { + // 真机 /v2/chat/busy:RPC 族,UA 首段是 slug。 + // X-Domain 的值由 chat base 推出(本测试指到 httptest),只断言键存在。 + path: "/v2/chat/busy", + headers: []string{ + "accept", "authorization", "content-type", "user-agent", + "x-domain", "x-product", "x-request-id", "x-user-id", + }, + values: map[string]string{ + "accept": "application/json, text/plain, */*", + "user-agent": "workbuddy-ai/5.9.4 workbuddy-ai/5.9.4 CLI/2.165.0", + "x-product": "SaaS", + }, + absent: []string{"origin", "referer", "x-codebuddy-request", "x-private-data", "x-requested-with"}, + }, + { + // 真机 /v2/report:桌面端上报,同样是 RPC 族 UA。 + // 取**已登录**样本的头集(登录前那几条没有 x-domain / x-user-id): + // accept / authorization / content-type / user-agent / x-domain / + // x-product / x-request-id / x-user-id,且无 X-Requested-With。 + path: "/v2/report", + headers: []string{ + "accept", "authorization", "content-type", "user-agent", + "x-domain", "x-product", "x-request-id", "x-user-id", + }, + values: map[string]string{ + "user-agent": "workbuddy-ai/5.9.4 workbuddy-ai/5.9.4 CLI/2.165.0", + "x-product": "SaaS", + }, + absent: []string{"origin", "referer", "x-codebuddy-request", "x-requested-with"}, + }, + { + // 真机 /v3/config:两段单品牌,恒不带 x-codebuddy-request。 + // XRW:RPC 层不打此头(见 headers.go CommonHeaders 注释)。 + path: "/v3/config", + headers: []string{ + "accept", "authorization", "user-agent", "x-domain", + "x-product", "x-request-id", "x-user-id", + }, + values: map[string]string{ + "accept": "application/json, text/plain, */*", + "user-agent": "WorkBuddy/5.9.4 CLI/2.165.0", + "x-domain": "www.workbuddy.ai", + "x-product": "SaaS", + }, + absent: []string{"origin", "referer", "accept-language", "x-codebuddy-request"}, + }, +} + +// TestGLContractGolden 用生产代码真实构造 GL 四条关键路径,逐条比对黄金头集。 +func TestGLContractGolden(t *testing.T) { + captured := map[string]http.Header{} + srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { + raw, _ := io.ReadAll(r.Body) + if r.Header.Get("Content-Encoding") == "gzip" && len(raw) > 2 && raw[0] == 0x1f { + if zr, err := gzip.NewReader(bytes.NewReader(raw)); err == nil { + raw, _ = io.ReadAll(zr) + } + } + if _, seen := captured[r.URL.Path]; !seen { + captured[r.URL.Path] = r.Header.Clone() + } + w.Write([]byte(`{"code":0,"msg":"OK","data":{}}`)) + })) + defer srv.Close() + + a := glGlobalAuth() + c := &Client{ + HTTP: srv.Client(), ChatHTTP: srv.Client(), + ChatBaseCN: srv.URL, BillingBaseCN: srv.URL, WebBaseCN: srv.URL, + ChatBaseGlobal: srv.URL, BillingBaseGlobal: srv.URL, + GlobalEnabled: true, + } + c.SanitizeFingerprints.Store(true) + c.SanitizeBrandScope.Store("all") + + body := []byte(`{"model":"deepseek-v4.1-flash","messages":[{"role":"system","content":"s"},{"role":"user","content":"hi"}]}`) + meta := ChatMeta{ + ConversationID: "0173f340-72d0-485a-8940-06c8ab3b5e8d", + ConversationRequestID: "01a18b7d9dc479fc8d872ebc6b07665f", + } + if rc, _, _, err := c.ChatStream(a, body, "", meta); err == nil && rc != nil { + io.Copy(io.Discard, rc) + rc.Close() + } + _ = c.ReportChatActivity(a, "0173f340-72d0-485a-8940-06c8ab3b5e8d", "01a18b7d9dc479fc8d872ebc6b07665f") + _, _ = c.ModelBusy(a, []string{"deepseek-v4.1-flash"}) + _, _, _ = c.fetchV3ConfigModelMap(a, "") + + for _, g := range glGoldenCases { + t.Run(strings.TrimPrefix(g.path, "/"), func(t *testing.T) { + hdr, ok := captured[g.path] + if !ok { + t.Fatalf("未捕获到 %s 的出站请求", g.path) + } + got := map[string]bool{} + for k := range hdr { + lk := strings.ToLower(k) + if !transportOnly[lk] { + got[lk] = true + } + } + want := map[string]bool{} + for _, k := range g.headers { + want[k] = true + } + var extra, missing []string + for k := range got { + if !want[k] { + extra = append(extra, k) + } + } + for k := range want { + if !got[k] { + missing = append(missing, k) + } + } + sort.Strings(extra) + sort.Strings(missing) + if len(extra) > 0 { + t.Errorf("多发了客户端没有的头: %v", extra) + } + if len(missing) > 0 { + t.Errorf("漏发了真机必带的头: %v", missing) + } + for k, v := range g.values { + if got := hdr.Get(k); got != v { + t.Errorf("%s=%q want %q", k, got, v) + } + } + for _, k := range g.absent { + if got := hdr.Get(k); got != "" { + t.Errorf("%s 不应出现(真机无),实际=%q", k, got) + } + } + }) + } +} + +// TestGLBaggageExactMembers 真机 baggage 恰好 4 个成员,顺序固定,两个 buddy 键留空值。 +func TestGLBaggageExactMembers(t *testing.T) { + c := &Client{} + req := httptest.NewRequest("POST", "https://www.workbuddy.ai/v2/chat/completions", nil) + c.ChatHeaders(req, glGlobalAuth(), "", ChatMeta{ + ConversationID: "0173f340-72d0-485a-8940-06c8ab3b5e8d", + ConversationRequestID: "01a18b7d9dc479fc8d872ebc6b07665f", + }) + want := "buddyId=,buddyName=,codebuddy.session_id=0173f340-72d0-485a-8940-06c8ab3b5e8d," + + "codebuddy.conversation_request_id=01a18b7d9dc479fc8d872ebc6b07665f" + if got := req.Header.Get("baggage"); got != want { + t.Errorf("baggage 成员/顺序不符\n got=%q\nwant=%q", got, want) + } +} diff --git a/internal/upstream/global_models.go b/internal/upstream/global_models.go index 89fb8c023d016268d36647d1da75035a5d624591..d73f4f0d257cebac3cd33306f9095b3ae3c70112 100644 --- a/internal/upstream/global_models.go +++ b/internal/upstream/global_models.go @@ -1,668 +1,858 @@ -// global 模型目录探测:纯动态产出模型名及其窗口 / 能力元数据(v3-config-merge)。 -// -// 探测并发四路:/v3/config 的三种 UA(桌面端主路 + IDE + CLI)与企业端点家族 -// (/v2 → /console 补缺),并集 = v3 条目为主、企业端点补 v3 缺失的 id -// (如 gpt-5.3-codex 只在 /v2 下发)。倍率字段(credits)虽随目录下发,但 -// 只透出展示,不注入 costTier、不参与选号。 -// -// 纯动态:不再回落任何静态名单——拉不出目录即意味着该域上游不可用, -// 假名单只会让客户端选到 11102 的模型(产品决策:无兜底)。 -package upstream - -import ( - "encoding/json" - "fmt" - "io" - "log" - "net/http" - "sort" - "strings" - "sync" - "time" - - "github.com/linguo2625469/workbuddy2api-panel/internal/auth" -) - -// GlobalModelNames 国际版(global realm)历史静态名单(PLAN §7.2 附录 21 名)。 -// 纯动态化后**不再作为模型目录的基底/兜底**:/v1/models 只透出上游实际下发的模型。 -// 保留仅作历史对照(global e2e 观测日志差集参照)。 -var GlobalModelNames = []string{ - "default-model", - "fast-model", - "balanced-model", - "primary-model", - "hy4-preview", - "gpt-5.6-sol", - "gpt-5.6-terra", - "deep-model", - "deepseek-v4.1-flash", - "gpt-6-astra", - "hy4-preview-f", - "hy3", - "glm-5.2", - "gpt-5.6-luna", - "gpt-5.5", - "gpt-5.4", - "gpt-5.3-codex", - "gemini-3.5-flash", - "glm-5.3", - "kimi-k3", - "kimi-k2.6", -} - -// fetchGlobalModelsCache 探测结果缓存(语义参照 CN 侧 handler.dynamicModelsCache:1h TTL + -// 5min 失败负缓存)。按 Client 实例持有(effortsMu 同模式),测试新建 Client 即隔离。 -// Mutex 内嵌,与 modelList 无并发读路径竞争(唯一读写点本文件内)。 -type fetchGlobalModelsCache struct { - sync.Mutex - names []string // 成功缓存:并集模型名(已去重);nil = 未探测/失败 - infos []ModelInfo // 成功缓存:对象形态的全字段条目(窄表/失败形态为 nil) - fetched time.Time - lastFail time.Time -} - -// globalModelsTTL / globalModelsFailCooldown 探测缓存时长:成功 1h,失败 5min 负缓存。 -const ( - globalModelsTTL = time.Hour - globalModelsFailCooldown = 5 * time.Minute -) - -// globalModelsProbePaths global 企业模型目录端点候选序列(按 realm 切 base,路径"家族"): -// /v2 家族优先(实测 /v2/enterprises/personal/models 200 含完整模型表), -// /console 作 fallback(同域旧路径,或 500)。v3-config-merge 后该家族降为企业补充路 -// (/v3/config 为主路,与家族并发探测;gpt-5.3-codex 等家族独有模型经此进并集)。 -var globalModelsProbePaths = []string{ - "/v2/enterprises/personal/models", - "/console/enterprises/personal/models", -} - -// FetchGlobalModels 探测 global 账号的模型名目录并返回**模型名列表**(无元数据)。 -// -// 纯动态:成功返回并集结果(去重),缓存 1h;失败(两路全非 2xx / 解析失败 / -// 空列表)记 5min 负缓存,返回 nil(无静态回落)。缓存/负缓存命中:直接返回,零上游调用。 -// -// 调用方负责:仅在有 global 账号时调用(无则不探测);GlobalEnabled 关闭时(逃生门) -// 不得调用——本方法由 globalOn(a) 内部兜底,若账号因开关回落 cn 则返回 nil。 -func (c *Client) FetchGlobalModels(a *auth.Auth) []string { - names, _ := c.fetchGlobalModelsOnce(a) - return names -} - -// FetchGlobalModelInfos 探测 global 账号的模型目录并返回全字段 ModelInfo 列表。 -// 与 FetchGlobalModels 共享同一次探测与缓存(names + infos 一体落缓存): -// 对象形态 200 → 全字段条目;窄表形态 / 探测失败 / 负缓存 / 非 global 路由账号 -// → nil(调用方按 ID 名单输出裸条目,不编造字段)。 -// 账号因 GlobalEnabled 开关回落 cn 时不探测(globalOn 兜底,零上游调用)。 -func (c *Client) FetchGlobalModelInfos(a *auth.Auth) []ModelInfo { - _, infos := c.fetchGlobalModelsOnce(a) - return infos -} - -// fetchGlobalModelsOnce 单次探测决策(缓存命中/负缓存/触发探测),返回 (names, infos)。 -// 纯动态:成功 = 并集结果去重;一切失败 = nil(不回落静态)。 -// infos 仅对象形态成功探测时非 nil。 -func (c *Client) fetchGlobalModelsOnce(a *auth.Auth) (names []string, infos []ModelInfo) { - if !c.globalOn(a) { - // 逃生门兜底:账号不路由 global 上游 → 不探测(零上游调用)。 - return nil, nil - } - - c.globalModels.Lock() - if len(c.globalModels.names) > 0 && time.Since(c.globalModels.fetched) < globalModelsTTL { - names, infos := c.globalModels.names, c.globalModels.infos - c.globalModels.Unlock() - return names, infos - } - if !c.globalModels.lastFail.IsZero() && time.Since(c.globalModels.lastFail) < globalModelsFailCooldown { - // 负缓存冷却期内:避免反复打上游,直接按失败处理(无静态回落)。 - c.globalModels.Unlock() - return nil, nil - } - c.globalModels.Unlock() - - names, infos, efforts, defaults, err := c.probeGlobalModels(a) - if err != nil || len(names) == 0 { - // 探测失败:负缓存 + 返回 nil(effort 桶不写,prepareBody 走 globalEffortMap 静态兜底)。 - c.globalModels.Lock() - c.globalModels.lastFail = time.Now() - c.globalModels.names = nil - c.globalModels.infos = nil - c.globalModels.Unlock() - return nil, nil - } - // global 域 effort 能力:探测下发的 supportedEfforts/defaultEffort 权威写入 global 桶 - // (raw remote,不并入静态表——静态兜底在 prepareBody 的 globalEffortMap 与 - // /v1/models 的 EffortListing 里按需 fallback)。空探测不写(防清既有桶)。 - if len(efforts) > 0 || len(defaults) > 0 { - c.storeEfforts("global", efforts, defaults) - } - c.storeModelRates("global", infos) - - // 成功:探测结果去重。names/infos 均落缓存;倍率等选号敏感字段只透出展示, - // 不注入 costTier。 - seen := make(map[string]bool, len(names)) - merged := make([]string, 0, len(names)) - for _, id := range names { - if id == "" || seen[id] { - continue - } - seen[id] = true - merged = append(merged, id) - } - - c.globalModels.Lock() - c.globalModels.names = merged - c.globalModels.infos = infos - c.globalModels.fetched = time.Now() - c.globalModels.lastFail = time.Time{} - c.globalModels.Unlock() - return merged, infos -} - -// probeGlobalModels 发起一次 global 模型目录探测(v3-config-merge + desktop-ua): -// /v3/config(三路 UA:桌面端主路 + IDE + CLI)与企业端点家族(/v2 → /console 兜底, -// 补缺)**并发**探测后并集合并。返回模型名列表(已合并、未再去重——去重在 -// fetchGlobalModelsOnce)、全字段 ModelInfo(对象形态;窄表为 nil)及 effort -// 能力桶(supportedEfforts/defaultEffort,可为空)。 -// -// 三路 UA 缺一不可(2026-10-02 实测,同一 global 账号): -// - 桌面端 UA → 29 条:**唯一含 gpt-6-sol / gpt-6-luna / grok-4.7 / gemini-3.8-flash** -// - IDE UA → 13 条:独有 o4-mini / enhance-1.0 / auto-chat -// - CLI UA → 22 条:独有 deepseek 系列 / gpt-6-astra / kimi-k2.8-preview -// -// 桌面端 UA 为主路:它是项目 chat 路径实际使用的 UA(与客户端看到的目录同源), -// 且实测在两路共有的模型上字段完整度不低于另两路(窗口/effort/credits 齐全)。 -// 合并口径:桌面端条目字段权威,IDE/CLI 只补桌面端缺失的模型 id;去重 key = -// 模型 id,输出顺序稳定。全部 v3 路失败且企业端点也失败才返回错误;单路失败 -// 降级为其余路结果 + warn 日志,互不拖累。 -func (c *Client) probeGlobalModels(a *auth.Auth) (names []string, infos []ModelInfo, efforts map[string][]string, defaults map[string]string, err error) { - // probeV3 单次 /v3/config 探测(UA 参数化)。该端点对不同 UA 下发**不同模型集合**: - // 桌面端 / IDE / CLI 三路各有独有模型(见 probeGlobalModels 注释),故并发三路取并集。 - probeV3 := func(ua string) chan probeResult { - ch := make(chan probeResult, 1) - go func() { - // chatBase 已按 realm 切 global base。 - byID, perr := c.fetchV3ConfigModelMap(a, ua) - if perr != nil { - ch <- probeResult{err: perr} - return - } - ids := make([]string, 0, len(byID)) - outInfos := make([]ModelInfo, 0, len(byID)) - for _, mi := range byID { - if nonChatModel(mi.ID, mi.MaxTokens, mi.Tags) { - continue - } - ids = append(ids, mi.ID) - outInfos = append(outInfos, mi) - } - sort.Strings(ids) // map 迭代序随机,排序保输出稳定 - ch <- probeResult{names: ids, infos: outInfos} - }() - return ch - } - // 桌面端 UA(主路):项目 chat 路径实际使用的 UA,与官方客户端看到的目录同源。 - // 按账号 realm 生成(global → `WorkBuddy AI` 平台段),故必须传 a 而非用常量。 - v3DesktopCh := probeV3(c.defaultWorkBuddyUAFor(a)) - v3IDECh := probeV3(codeBuddyIDEUA) - v3CLICh := probeV3(codeBuddyCLIUA) - enterpriseCh := make(chan probeResult, 1) - go func() { - // 企业端点家族:/v2 首选 → /console 兜底(既有探活序,零回归)。 - var lastErr error - for _, path := range globalModelsProbePaths { - names, infos, perr := c.globalModelsOnce(a, path) - if perr != nil { - lastErr = perr - continue - } - enterpriseCh <- probeResult{names: names, infos: infos} - return - } - enterpriseCh <- probeResult{err: lastErr} - }() - v3Desktop := <-v3DesktopCh - v3IDE := <-v3IDECh - v3CLI := <-v3CLICh - enterprise := <-enterpriseCh - // v3 三路自合并:桌面端路字段权威(主路),IDE/CLI 只补主路缺失的模型 id - // (只补 id,字段仍取自各自条目——主路没有该 id 时才轮到它们)。 - // 逐路容错:全失败才带 err 进入下游降级判断,部分失败 warn 后继续。 - v3 := mergeV3Routes([]struct { - label string - res probeResult - }{ - {"desktop-UA", v3Desktop}, - {"IDE-UA", v3IDE}, - {"CLI-UA", v3CLI}, - }) - - if v3.err != nil && enterprise.err != nil { - // 两路全失败 → 负缓存语义(等价原家族端点全非 2xx)。 - return nil, nil, nil, nil, v3.err - } - if v3.err != nil { - // /v3 失败降级:不拖累企业端点结果(降级仅企业端点 + warn)。 - log.Printf("WARN: [upstream] global models: v3/config probe failed (degraded to enterprise endpoint): %v", v3.err) - names, infos, efforts, defaults = extractEfforts(enterprise.infos) - return names, infos, efforts, defaults, nil - } - if enterprise.err != nil { - log.Printf("WARN: [upstream] global models: enterprise endpoint failed (v3/config only): %v", enterprise.err) - names, infos, efforts, defaults = extractEfforts(v3.infos) - return names, infos, efforts, defaults, nil - } - // 两路皆成功:v3 为主、企业端点补缺合并(含 effort 桶合并,v3 权威)。 - v3Names, v3Infos, v3Efforts, v3Defaults := extractEfforts(v3.infos) - if len(v3Names) == 0 { - v3Names = v3.names - } - entNames, entInfos, entEfforts, entDefaults := extractEfforts(enterprise.infos) - if len(entNames) == 0 { - entNames = enterprise.names - } - names, infos = mergeGlobalCatalog(v3Names, v3Infos, entNames, entInfos) - efforts = mergeEffortBuckets(v3Efforts, entEfforts) - defaults = mergeEffortDefaults(v3Defaults, entDefaults) - return names, infos, efforts, defaults, nil -} - -// probeResult 单路模型目录探测结果(/v3/config 某 UA 路,或企业端点家族)。 -// infos 为对象形态条目(窄表探测为 nil),names 与之平行;err 非 nil 表示该路失败。 -type probeResult struct { - names []string - infos []ModelInfo - err error -} - -// mergeV3Routes 按优先级合并 /v3/config 多路 UA 探测结果:routes 必须**按权威 -// 顺序**传入(主路在前)。前序路的字段权威,后续路只补前序路缺失的模型 id -// (条目字段仍取自其所属路——该 id 只有那一路知道)。 -// -// 容错:全路失败才返回 err(取首路错误,与既有「v3 全失败」降级语义一致); -// 部分失败 warn 日志后用成功路继续,单路故障不拖垮整次探测。 -// 全路成功但并集为空时保留空结果(由调用方按「空列表 = 失败」处理)。 -func mergeV3Routes(routes []struct { - label string - res probeResult -}) probeResult { - var out probeResult - var firstErr error - nOK := 0 - for _, r := range routes { - if r.res.err != nil { - log.Printf("WARN: [upstream] global models: v3/config %s probe failed: %v", r.label, r.res.err) - if firstErr == nil { - firstErr = r.res.err - } - continue - } - nOK++ - if out.err != nil || (len(out.names) == 0 && len(out.infos) == 0) { - // 首个成功路:整体作为基底(字段权威)。 - out = r.res - continue - } - // 后续成功路:只补缺失的 id。 - mergedNames, mergedInfos := mergeGlobalCatalog(out.names, out.infos, r.res.names, r.res.infos) - out.names, out.infos = mergedNames, mergedInfos - } - if nOK == 0 { - return probeResult{err: firstErr} - } - return out -} - -// extractEfforts 从条目列表抽取 effort 能力桶(supportedEfforts 数组优先; -// 缺数组但 defaultEffort 单档非空也入 defaults 桶)并顺带返回有序 names。 -func extractEfforts(infos []ModelInfo) (names []string, out []ModelInfo, efforts map[string][]string, defaults map[string]string) { - names = make([]string, 0, len(infos)) - for _, mi := range infos { - if mi.ID == "" { - continue - } - names = append(names, mi.ID) - out = append(out, mi) - if len(mi.Efforts) > 0 { - if efforts == nil { - efforts = make(map[string][]string) - } - efforts[mi.ID] = mi.Efforts - } - if mi.DefaultEffort != "" { - if defaults == nil { - defaults = make(map[string]string) - } - defaults[mi.ID] = mi.DefaultEffort - } - } - return names, out, efforts, defaults -} - -// mergeGlobalCatalog 两路合并(v3 主、企业补缺):names 按 id 去重(v3 原序在前、 -// 企业端点补充项在其原序后追加——稳定输出);infos 同步合并(v3 条目字段权威, -// 企业端点条目只在 id 缺失时进并集)。 -// 窄表形态(infos nil)时保持 nil——无对象字段不编造。 -func mergeGlobalCatalog(primaryNames []string, primaryInfos []ModelInfo, secondaryNames []string, secondaryInfos []ModelInfo) (names []string, infos []ModelInfo) { - if len(secondaryNames) == 0 { - return primaryNames, primaryInfos - } - seen := make(map[string]bool, len(primaryNames)+len(secondaryNames)) - out := make([]string, 0, len(primaryNames)+len(secondaryNames)) - for _, id := range primaryNames { - if id == "" || seen[id] { - continue - } - seen[id] = true - out = append(out, id) - } - var outInfos []ModelInfo - if primaryInfos != nil { - outInfos = make([]ModelInfo, 0, len(primaryInfos)+len(secondaryInfos)) - outInfos = append(outInfos, primaryInfos...) - } - for _, id := range secondaryNames { - if id == "" || seen[id] { - continue - } - seen[id] = true - out = append(out, id) - // 窄表企业响应(secondaryInfos nil / 超出条目数)时该 id 无对象字段, - // infos 保持原样(调用方按 id 名单输出裸条目,不编造字段)。 - for _, mi := range secondaryInfos { - if mi.ID == id { - outInfos = append(outInfos, mi) - break - } - } - } - return out, outInfos -} - -// mergeEffortBuckets 合并两路 effort 桶:主路(v3)权威,企业端点只补主路缺失的模型档位。 -func mergeEffortBuckets(primary, secondary map[string][]string) map[string][]string { - if len(secondary) == 0 { - return primary - } - out := primary - if out == nil { - out = make(map[string][]string, len(secondary)) - } - for id, v := range secondary { - if _, ok := out[id]; !ok { - out[id] = v - } - } - return out -} - -// mergeEffortDefaults 合并两路 defaultEffort:主路(v3)权威,企业端点只补缺失。 -func mergeEffortDefaults(primary, secondary map[string]string) map[string]string { - if len(secondary) == 0 { - return primary - } - out := primary - if out == nil { - out = make(map[string]string, len(secondary)) - } - for id, v := range secondary { - if _, ok := out[id]; !ok { - out[id] = v - } - } - return out -} - -// globalModelsOnce 单端点探测。2xx + 解析出非空名单 → (names, infos, nil);否则 (nil, nil, err)。 -func (c *Client) globalModelsOnce(a *auth.Auth, path string) ([]string, []ModelInfo, error) { - url := c.chatBase(a) + path // 按 realm 切 base:global 账号 → global base - req, err := http.NewRequest(http.MethodGet, url, nil) - if err != nil { - return nil, nil, err - } - c.CommonHeaders(req, a) // 共享请求头(Origin/Referer/UA),与 FetchModels 同款 - // AccessToken 加锁快照(见 auth.AccessTokenValue:keepalive 刷新在 a.mu 内改写)。 - req.Header.Set("Authorization", "Bearer "+a.AccessTokenValue()) - resp, err := c.HTTP.Do(req) - if err != nil { - return nil, nil, err - } - defer resp.Body.Close() - raw, err := io.ReadAll(io.LimitReader(resp.Body, 1<<20)) - if err != nil { - // 读失败 → 传输层错误:半截 body 不进解析(探测负缓存走 lastFail,不罚号)。 - return nil, nil, fmt.Errorf("read body: %w", err) - } - if resp.StatusCode != http.StatusOK { - return nil, nil, fmt.Errorf("global models status %d: %s", resp.StatusCode, truncate(string(raw), 120)) - } - names, infos, _, _, err := parseGlobalModelNames(raw) - return names, infos, err -} - -// parseGlobalModelNames 多信封兼容解析模型目录(国际站曾在多种 envelope 间切换, -// 只认单一形态会把登录成功的账号误判为"无模型"): -// - 信封:code 存在且非 0 才拒(无 code 字段也放行);payload = data(非空非 -// null 时)否则整包; -// - 模型数组定位:payload 本身是数组,或是 map 下 models/items/list/data/result -// 任一键(递归一层层往下找第一个非空数组)——覆盖 data.models / data.items / -// data.list / 顶层 models 等变体; -// - 数组主形态:对象数组按 dynModelEntry 全字段解析(与 CN 目录同构,字段零 -// 漂移):maxInputTokens/maxOutputTokens/maxAllowedSize/supportsReasoning/ -// supportsImages/reasoning.*;id 缺省时回退 name;disabled 剔除; -// - 窄表:字符串数组 → 仅 ID,元数据留空(窗口由调用方四级查找链兜底); -// - 动态兜底:主形态解析不出任何可用条目时(上游换了键名),逐对象宽松解析—— -// id 依次回退 id/modelId/model/name,窗口键回退 contextWindow/maxTokens, -// reasoning 档位(defaultEffort 新键优先、effort 老键兜底)保留。 -// -// 同时产出 effort 能力桶(supportedEfforts/defaultEffort)。 -// 解析成功但名单为空 → 返回错误(等价"该端点没给全")。 -func parseGlobalModelNames(raw []byte) (names []string, infos []ModelInfo, efforts map[string][]string, defaults map[string]string, err error) { - fail := func(e error) ([]string, []ModelInfo, map[string][]string, map[string]string, error) { - return nil, nil, nil, nil, e - } - // 信封层:code 拒绝非 0 业务码(字段缺失 = 放行,兼容无信封直出的目录端点)。 - var envelope map[string]json.RawMessage - if err := json.Unmarshal(raw, &envelope); err != nil { - return fail(fmt.Errorf("global models parse: %w", err)) - } - if codeRaw, ok := envelope["code"]; ok { - var code int - if json.Unmarshal(codeRaw, &code) == nil && code != 0 { - return fail(fmt.Errorf("global models code=%d", code)) - } - } - payload := json.RawMessage(raw) - if data, ok := envelope["data"]; ok { - if t := strings.TrimSpace(string(data)); t != "" && t != "null" { - payload = data - } - } - arr, ok := resolveGlobalModelsArray(payload) - if !ok { - return fail(fmt.Errorf("global models empty list")) - } - - // 主形态:对象数组 → dynModelEntry 全字段(与 CN FetchModels 共用解析,零口径漂移)。 - var entries []dynModelEntry - if json.Unmarshal(arr, &entries) == nil { - out := make([]string, 0, len(entries)) - objInfos := make([]ModelInfo, 0, len(entries)) - for _, m := range entries { - // id 回退链 id→modelId→model→name(宽松键仅出现在 global 目录变体里)。 - id := m.ID - if id == "" { - id = m.ModelID - } - if id == "" { - id = m.Model - } - if id == "" { - id = m.Name - } - if id == "" || m.Disabled { - continue - } - out = append(out, id) - mi := m.modelInfo() - mi.ID = id // name 兜底形态下 id 取自 name,对齐 names 输出 - objInfos = append(objInfos, mi) - if len(m.Reasoning.SupportedEfforts) > 0 { - if efforts == nil { - efforts = make(map[string][]string) - } - efforts[id] = m.Reasoning.SupportedEfforts - } - if d := m.Reasoning.DefaultEffort; d != "" { - if defaults == nil { - defaults = make(map[string]string) - } - defaults[id] = d - } - } - if len(out) > 0 { - return out, objInfos, efforts, defaults, nil - } - // 可用条目为 0(键名全对不上):落入下方动态兜底,不在这里报空。 - efforts, defaults = nil, nil - } - - // 窄表:字符串数组 → 仅 ID(无 effort 元数据、无对象字段 → infos nil)。 - var strs []string - if json.Unmarshal(arr, &strs) == nil { - out := make([]string, 0, len(strs)) - for _, id := range strs { - if id = strings.TrimSpace(id); id != "" { - out = append(out, id) - } - } - if len(out) > 0 { - return out, nil, nil, nil, nil - } - return fail(fmt.Errorf("global models empty list")) - } - - // 动态兜底:逐对象宽松解析(上游换键名时不至于整域空列表)。 - var items []any - if json.Unmarshal(arr, &items) != nil { - return fail(fmt.Errorf("global models parse: unsupported payload shape")) - } - out := make([]string, 0, len(items)) - infos = make([]ModelInfo, 0, len(items)) - for _, item := range items { - switch v := item.(type) { - case string: // 混合数组里的裸 ID:按窄表条目处理 - if id := strings.TrimSpace(v); id != "" { - out = append(out, id) - infos = append(infos, ModelInfo{ID: id}) - } - case map[string]any: - mi, ok := parseGlobalModelLoose(v) - if !ok { - continue - } - out = append(out, mi.ID) - infos = append(infos, mi) - if len(mi.Efforts) > 0 { - if efforts == nil { - efforts = make(map[string][]string) - } - efforts[mi.ID] = mi.Efforts - } - if mi.DefaultEffort != "" { - if defaults == nil { - defaults = make(map[string]string) - } - defaults[mi.ID] = mi.DefaultEffort - } - } - } - if len(out) == 0 { - return fail(fmt.Errorf("global models empty list")) - } - return out, infos, efforts, defaults, nil -} - -// resolveGlobalModelsArray 从 payload 定位模型数组:payload 本身是数组直接用; -// 是 map 则依次尝试 models/items/list/data/result 键(递归下钻,取第一个能解析出 -// 数组的分支)。找不到数组 → false。 -func resolveGlobalModelsArray(payload json.RawMessage) (json.RawMessage, bool) { - trimmed := strings.TrimSpace(string(payload)) - if strings.HasPrefix(trimmed, "[") { - return payload, true - } - var obj map[string]json.RawMessage - if json.Unmarshal(payload, &obj) != nil { - return nil, false - } - for _, key := range []string{"models", "items", "list", "data", "result"} { - if nested, ok := obj[key]; ok { - if arr, ok2 := resolveGlobalModelsArray(nested); ok2 { - return arr, true - } - } - } - return nil, false -} - -// parseGlobalModelLoose 单模型对象的宽松解析(多信封兜底路径):id 依次回退 -// id/modelId/model/name;窗口/上限键回退 contextWindow/maxTokens;reasoning 档位 -// defaultEffort 新键优先、effort 老键兜底。disabled 剔除。Credits 恒不解析 -// (PLAN §3.D2:倍率不进 global 路径)。 -func parseGlobalModelLoose(obj map[string]any) (ModelInfo, bool) { - str := func(key string) string { - s, _ := obj[key].(string) - return strings.TrimSpace(s) - } - id := str("id") - for _, k := range []string{"modelId", "model", "name"} { - if id != "" { - break - } - id = str(k) - } - if id == "" { - return ModelInfo{}, false - } - if disabled, ok := obj["disabled"].(bool); ok && disabled { - return ModelInfo{}, false - } - num := func(keys ...string) int64 { - for _, k := range keys { - if n, ok := obj[k].(float64); ok && n > 0 { - return int64(n) - } - } - return 0 - } - mi := ModelInfo{ - ID: id, - Name: str("name"), - ContextWindow: num("maxInputTokens", "contextWindow"), - MaxTokens: num("maxOutputTokens", "maxTokens"), - MaxAllowedSize: num("maxAllowedSize"), - } - mi.SupportsReasoning, _ = obj["supportsReasoning"].(bool) - mi.SupportsImages, _ = obj["supportsImages"].(bool) - if r, ok := obj["reasoning"].(map[string]any); ok { - reasonStr := func(key string) string { - s, _ := r[key].(string) - return strings.TrimSpace(s) - } - mi.DefaultEffort = reasonStr("defaultEffort") - if mi.DefaultEffort == "" { - mi.DefaultEffort = reasonStr("effort") // 老模型键兜底,与 CN 侧同款 - } - mi.CanDisableThinking, _ = r["canDisableThinking"].(bool) - if arr, ok := r["supportedEfforts"].([]any); ok { - for _, item := range arr { - if s, ok := item.(string); ok { - if s = strings.TrimSpace(s); s != "" { - mi.Efforts = append(mi.Efforts, s) - } - } - } - } - } - return mi, true -} +// global 模型目录探测:纯动态产出模型名及其窗口 / 能力元数据(v3-config-merge)。 +// +// 探测两路并发:/v3/config(主路,IDE UA 完整能力版)+ 企业端点家族 +// (/v2 → /console 补缺),并集 = v3 条目为主、企业端点补 v3 缺失的 id +// (如 gpt-5.3-codex 只在 /v2 下发)。倍率字段(credits)虽随目录下发,但 +// 只透出展示,不注入 costTier、不参与选号。 +// +// 纯动态:不再回落任何静态名单——拉不出目录即意味着该域上游不可用, +// 假名单只会让客户端选到 11102 的模型(产品决策:无兜底)。 +package upstream + +import ( + "encoding/json" + "fmt" + "io" + "log" + "net/http" + "sort" + "strings" + "sync" + "time" + + "github.com/misakano7545/workbuddy2api-panel/internal/auth" +) + +// GlobalModelNames 国际版(global realm)历史静态名单(2026-10-29 WorkBuddy AI 5.9.3 +// 真机 /v3/config 实测 25 条,与 GlobalCatalogSource=v3-desktop 的目录逐条对齐)。 +// +// 纯动态化后**不再作为模型目录的基底/兜底**:/v1/models 只透出上游实际下发的模型。 +// 保留仅作历史对照(global e2e 观测日志差集参照)与「目录是否整体换了代」的肉眼基准。 +// +// 上一版是 5.8.4 时期的 21 条,含 gpt-5.5 / gpt-5.4 / gpt-5.3-codex / gemini-3.5-flash / +// glm-5.2 / kimi-k2.6 / hy4-preview-f 等已下架 id,且缺 gpt-6 系与 glm-5.3-flash、 +// kimi-k3.1-pro、grok-4.7、gemini-3.8-flash、minimax-m3.1-flash 等 5.9.3 新增——拿它做 +// 差集参照会得出一半假差异,故按实测刷新。 +var GlobalModelNames = []string{ + "default-model", + "fast-model", + "balanced-model", + "primary-model", + "deepseek-v4.1-flash", + "deepseek-v4.1-flash-sg", + "glm-5.3", + "glm-5.3-flash", + "hy4-preview", + "hy3", + "kimi-k3", + "kimi-k3.1-pro", + "kimi-k3.1-pro-highspeed", + "minimax-m3.1-flash", + "gpt-5.6-sol", + "gpt-5.6-terra", + "gpt-5.6-luna", + "gpt-6-astra", + "gpt-6-sol", + "gpt-6-luna", + "gpt-6.1-sol", + "gemini-3.8-flash", + "grok-4.7", + // 媒体生成(tags 决定进 GenerationModels 而不是对话列表) + "hy-image-3.5", + "kling-video-v3", +} + +// fetchGlobalModelsCache 探测结果缓存(语义参照 CN 侧 handler.dynamicModelsCache:1h TTL + +// 5min 失败负缓存)。按 Client 实例持有(effortsMu 同模式),测试新建 Client 即隔离。 +// Mutex 内嵌,与 modelList 无并发读路径竞争(唯一读写点本文件内)。 +type fetchGlobalModelsCache struct { + sync.Mutex + names []string // 成功缓存:并集模型名(已去重);nil = 未探测/失败 + infos []ModelInfo // 成功缓存:对象形态的全字段条目(窄表/失败形态为 nil) + fetched time.Time + lastFail time.Time + // source 本次成功探测的目录来源:globalCatalogSourceDesktop / ...Union / ...Enterprise。 + // 面板用它把「拿到的是窄目录/旧目录」直接摆给运维看(issue #216 现象 1 就是 + // v3 探测失败静默降级到企业端点,用户只看到「少了 11 个模型」)。 + source string +} + +// 目录来源标识(fetchGlobalModelsCache.source)。 +const ( + globalCatalogSourceDesktop = "v3-desktop" // 桌面端 UA 族权威目录(官方 picker 口径) + globalCatalogSourceUnion = "v3-union" // 桌面族探测失败的回落:IDE+CLI 并集 + globalCatalogSourceEnterprise = "enterprise" // v3 全失败,只剩企业端点(窄目录 + 旧倍率) +) + +// GlobalCatalogSource 返回最近一次成功探测的目录来源(空 = 尚未探测)。 +func (c *Client) GlobalCatalogSource() string { + if c == nil { + return "" + } + c.globalModels.Lock() + defer c.globalModels.Unlock() + return c.globalModels.source +} + +// InvalidateGlobalModelsCache 清空 global 目录探测缓存(names/infos/成功与失败时间戳), +// 使下一次 FetchGlobalModels/FetchGlobalModelInfos 立即重新探测上游。 +// +// 存在理由:面板「模型与档位 → 重新获取」此前只是重读 1h 缓存,点了数量纹丝不动 +// (issue #216 现象 3)。上游目录变动后运维需要一个立即生效的按钮,而不是等 TTL。 +func (c *Client) InvalidateGlobalModelsCache() { + if c == nil { + return + } + c.globalModels.Lock() + defer c.globalModels.Unlock() + c.globalModels.names = nil + c.globalModels.infos = nil + c.globalModels.fetched = time.Time{} + c.globalModels.lastFail = time.Time{} + c.globalModels.source = "" +} + +// globalModelsTTL / globalModelsFailCooldown 探测缓存时长:成功 1h,失败 5min 负缓存。 +const ( + globalModelsTTL = time.Hour + globalModelsFailCooldown = 5 * time.Minute +) + +// globalModelsProbePaths global 企业模型目录端点候选序列(按 realm 切 base,路径"家族"): +// /v2 家族优先(实测 /v2/enterprises/personal/models 200 含完整模型表), +// /console 作 fallback(同域旧路径,或 500)。v3-config-merge 后该家族降为企业补充路 +// (/v3/config 为主路,与家族并发探测;gpt-5.3-codex 等家族独有模型经此进并集)。 +var globalModelsProbePaths = []string{ + "/v2/enterprises/personal/models", + "/console/enterprises/personal/models", +} + +// FetchGlobalModels 探测 global 账号的模型名目录并返回**模型名列表**(无元数据)。 +// +// 纯动态:成功返回并集结果(去重),缓存 1h;失败(两路全非 2xx / 解析失败 / +// 空列表)记 5min 负缓存,返回 nil(无静态回落)。缓存/负缓存命中:直接返回,零上游调用。 +// +// 调用方负责:仅在有 global 账号时调用(无则不探测);GlobalEnabled 关闭时(逃生门) +// 不得调用——本方法由 globalOn(a) 内部兜底,若账号因开关回落 cn 则返回 nil。 +func (c *Client) FetchGlobalModels(a *auth.Auth) []string { + names, _ := c.fetchGlobalModelsOnce(a) + return names +} + +// FetchGlobalModelInfos 探测 global 账号的模型目录并返回全字段 ModelInfo 列表。 +// 与 FetchGlobalModels 共享同一次探测与缓存(names + infos 一体落缓存): +// 对象形态 200 → 全字段条目;窄表形态 / 探测失败 / 负缓存 / 非 global 路由账号 +// → nil(调用方按 ID 名单输出裸条目,不编造字段)。 +// 账号因 GlobalEnabled 开关回落 cn 时不探测(globalOn 兜底,零上游调用)。 +func (c *Client) FetchGlobalModelInfos(a *auth.Auth) []ModelInfo { + _, infos := c.fetchGlobalModelsOnce(a) + return infos +} + +// fetchGlobalModelsOnce 单次探测决策(缓存命中/负缓存/触发探测),返回 (names, infos)。 +// 纯动态:成功 = 并集结果去重;一切失败 = nil(不回落静态)。 +// infos 仅对象形态成功探测时非 nil。 +func (c *Client) fetchGlobalModelsOnce(a *auth.Auth) (names []string, infos []ModelInfo) { + if !c.globalOn(a) { + // 逃生门兜底:账号不路由 global 上游 → 不探测(零上游调用)。 + return nil, nil + } + + c.globalModels.Lock() + if len(c.globalModels.names) > 0 && time.Since(c.globalModels.fetched) < globalModelsTTL { + names, infos := c.globalModels.names, c.globalModels.infos + c.globalModels.Unlock() + return names, infos + } + if !c.globalModels.lastFail.IsZero() && time.Since(c.globalModels.lastFail) < globalModelsFailCooldown { + // 负缓存冷却期内:避免反复打上游,直接按失败处理(无静态回落)。 + c.globalModels.Unlock() + return nil, nil + } + c.globalModels.Unlock() + + names, infos, efforts, defaults, source, err := c.probeGlobalModels(a) + if err != nil || len(names) == 0 { + // 探测失败:负缓存 + 返回 nil(effort 桶不写,prepareBody 走 globalEffortMap 静态兜底)。 + c.globalModels.Lock() + c.globalModels.lastFail = time.Now() + c.globalModels.names = nil + c.globalModels.infos = nil + c.globalModels.Unlock() + return nil, nil + } + // global 域 effort 能力:探测下发的 supportedEfforts/defaultEffort 权威写入 global 桶 + // (raw remote,不并入静态表——静态兜底在 prepareBody 的 globalEffortMap 与 + // /v1/models 的 EffortListing 里按需 fallback)。空探测不写(防清既有桶)。 + if len(efforts) > 0 || len(defaults) > 0 { + c.storeEfforts("global", efforts, defaults) + } + c.storeModelRates("global", infos) + c.storeModelMaxOut("global", infos) + + // 成功:探测结果去重。names/infos 均落缓存;倍率等选号敏感字段只透出展示, + // 不注入 costTier。 + seen := make(map[string]bool, len(names)) + merged := make([]string, 0, len(names)) + for _, id := range names { + if id == "" || seen[id] { + continue + } + seen[id] = true + merged = append(merged, id) + } + + c.globalModels.Lock() + c.globalModels.names = merged + c.globalModels.infos = infos + c.globalModels.fetched = time.Now() + c.globalModels.lastFail = time.Time{} + c.globalModels.source = source + c.globalModels.Unlock() + return merged, infos +} + +// desktopProbeUA /v3/config 第三路(桌面端形态)探测用的 UA。 +// +// 该端点按 UA 家族下发不同目录,三族各有独有模型(2026-10-03 实测,同一账号 +// 同一端点:CN IDE 19 / CLI 32 / 桌面端 54,global 13 / 22 / 29)。global 侧 +// gpt-6-luna 只在桌面端目录出现,但请求实测可正常返回 200——只探 IDE + CLI 时 +// 它永远进不了 /v1/models(用户侧表现为「模型列表不全」)。版本号升降不改结果 +// (IDE 4.12→5.0、CLI 2.63→2.80 目录条数一致),故只补家族。 +// +// 平台段固定用 CN 形态(`WorkBuddy`,= defaultWorkBuddyUAFor(nil)):本次实测即 +// 该形态、两个 base 都返回最大目录;global 形态(`WorkBuddy AI`)未实测,不臆造。 +func (c *Client) desktopProbeUA() string { + return c.defaultWorkBuddyUAFor(nil) +} + +// probeGlobalModels 发起一次 global 模型目录探测(v3-config-merge): +// /v3/config(主,IDE / CLI / 桌面端**三种 UA 家族**并发探测取并集)与企业端点 +// 家族(/v2 → /console 兜底,补缺)**并发**探测后并集合并。返回模型名列表 +// (已合并、未再去重——去重在 fetchGlobalModelsOnce)、全字段 ModelInfo(对象 +// 形态;窄表为 nil)及 effort 能力桶(supportedEfforts/defaultEffort,可为空)。 +// 合并口径:v3 条目为主(credits 等字段以 v3 为准),企业端点只补 v3 缺失的 +// 模型 id;去重 key = 模型 id,输出顺序稳定。v3 与家族两路全失败才返回错误 +// (等价原「家族端点全非 2xx」负缓存语义);单路失败降级为其余路结果 + warn +// 日志,互不拖累。 +func (c *Client) probeGlobalModels(a *auth.Auth) (names []string, infos []ModelInfo, efforts map[string][]string, defaults map[string]string, source string, err error) { + type probeResult struct { + names []string + infos []ModelInfo + err error + } + // probeV3 单次 /v3/config 探测(UA 参数化)。该端点按 UA **家族**(客户端形态) + // 下发**不同模型集合**:IDE / CLI / 桌面端三族各有独有模型,故并发多路取并集。 + // 实测(2026-10-03,同一账号同一端点)目录条数:CN 19 / 32 / 54,global 13 / 22 / 29; + // 版本号升降不改变结果,只有家族变(见 desktopProbeUA 注释)。 + probeV3 := func(ua string) chan probeResult { + ch := make(chan probeResult, 1) + go func() { + // chatBase 已按 realm 切 global base。 + byID, pick, perr := c.fetchV3ConfigModelMap(a, ua) + if perr != nil { + ch <- probeResult{err: perr} + return + } + // 出图模型旁路留存(/v1/models 以 image_generation 标记列出),照旧不进对话列表。 + // 必须在可见性过滤前做:媒体模型不在 agent 菜单里。 + c.stashGenerationModels("global", sortedInfos(byID)) + ids := make([]string, 0, len(byID)) + outInfos := make([]ModelInfo, 0, len(byID)) + if vis := pick.ordered(byID); vis != nil { + // 客户端 picker 口径(见 clientpick.go):哪一族 UA 探测,就按那一族 + // 自己下发的 agents 名单裁剪——客户端用哪族 UA 就只显示那族的菜单项。 + // INTL 实测:目录 25 条,菜单 22 条(去掉 paidId deepseek-v4.1-flash-sg + // 与 hy-image-3.5 / kling-video-v3 两个媒体模型)。 + for _, id := range vis { + mi := byID[id] + if nonChatModel(mi.ID, mi.MaxTokens, mi.Tags) { + continue + } + ids = append(ids, id) + outInfos = append(outInfos, mi) + } + ch <- probeResult{names: ids, infos: outInfos} + return + } + // 口径缺失(上游无 agents):照旧全量 + 排序,保持既有输出稳定语义。 + for _, mi := range byID { + if nonChatModel(mi.ID, mi.MaxTokens, mi.Tags) { + continue + } + ids = append(ids, mi.ID) + outInfos = append(outInfos, mi) + } + sort.Strings(ids) // map 迭代序随机,排序保输出稳定 + ch <- probeResult{names: ids, infos: outInfos} + }() + return ch + } + v3IDECh := probeV3(c.v3ProbeUA(a)) + v3CLICh := probeV3(c.v3ProbeUALite(a)) + // 第三路:桌面端形态。缺它就会漏掉仅桌面端下发的模型——global 侧 gpt-6-luna + // 即此例(目录里没有、实际可调用),用户侧表现为「模型列表不全」。 + v3DesktopCh := probeV3(c.desktopProbeUA()) + enterpriseCh := make(chan probeResult, 1) + go func() { + // 企业端点家族:/v2 首选 → /console 兜底(既有探活序,零回归)。 + var lastErr error + for _, path := range globalModelsProbePaths { + names, infos, perr := c.globalModelsOnce(a, path) + if perr != nil { + lastErr = perr + continue + } + enterpriseCh <- probeResult{names: names, infos: infos} + return + } + enterpriseCh <- probeResult{err: lastErr} + }() + v3IDE := <-v3IDECh + v3CLI := <-v3CLICh + v3Desktop := <-v3DesktopCh + enterprise := <-enterpriseCh + // v3 多路自合并:IDE 路字段权威(响应更大、单条字段更全),CLI 路与桌面路只补 + // 缺失的模型 id。任一路成功即用为主路;全失败才带 err 进入下游降级判断。 + // 单路失败照旧 WARN,不拖累其他路(与上游 PR #103 同口径)。 + v3Probes := []struct { + label string + res probeResult + }{ + {"IDE-UA", v3IDE}, + {"CLI-UA", v3CLI}, + {"desktop-UA", v3Desktop}, + } + var okProbes []probeResult + for _, p := range v3Probes { + if p.res.err != nil { + log.Printf("WARN: [upstream] global models: v3/config %s probe failed: %v", p.label, p.res.err) + continue + } + okProbes = append(okProbes, p.res) + } + var v3 probeResult + // catalogSource 记录本次目录由哪一族给出(写入缓存供面板展示)。 + catalogSource := globalCatalogSourceDesktop + switch { + case len(okProbes) == 0: + // 三路全失败:err 非空,下游按既有「v3 失败」分支降级或负缓存。 + v3 = probeResult{err: v3IDE.err} + case v3Desktop.err == nil: + // 桌面端 UA 族是**目录权威**(issue #216):官方桌面端 picker 就是这一族, + // 2026-10-17 实测 global 侧桌面族 27 条与 picker 一一对应,而 IDE/CLI 族的 + // 独有模型(o4-mini / auto-chat / deep-model)在同一 chat 端点回 11102 + // 「service info not found」——列出来只会让客户端选到死模型。 + // + // 故:桌面族成功时,**模型 id 只取桌面族**;IDE/CLI 族降级为元数据 + // (context/efforts/credits 缺字段时补),不再贡献 id。 + v3 = probeResult{names: v3Desktop.names, infos: v3Desktop.infos} + var enrichSources [][]ModelInfo + if v3IDE.err == nil { + enrichSources = append(enrichSources, v3IDE.infos) + } + if v3CLI.err == nil { + enrichSources = append(enrichSources, v3CLI.infos) + } + if len(enrichSources) > 0 { + v3.infos = enrichModelInfos(v3.infos, enrichSources...) + } + case len(okProbes) == 1: + v3 = okProbes[0] + catalogSource = globalCatalogSourceUnion + default: + // 桌面族探测失败(或未返回):回落既有并集语义,宁可多列也不空表; + // 来源标成 union,面板据此提示「拿到的是回落目录」。 + vn, vi := okProbes[0].names, okProbes[0].infos + for _, p := range okProbes[1:] { + vn, vi = mergeGlobalCatalog(vn, vi, p.names, p.infos) + } + v3 = probeResult{names: vn, infos: vi} + catalogSource = globalCatalogSourceUnion + } + + if v3.err != nil && enterprise.err != nil { + // 两路全失败 → 负缓存语义(等价原家族端点全非 2xx)。 + return nil, nil, nil, nil, "", v3.err + } + if v3.err != nil { + // /v3 失败降级:不拖累企业端点结果(降级仅企业端点 + warn)。 + // 这条路径就是 issue #216 的现场:企业端点只有 18 条旧目录,且 hy4-preview + // 的 credits 在那里是 x0.00(v3 是 x0.29)——来源必须能被面板看见,否则 + // 用户只会看到「模型少了 11 个、倍率是 0」而不知道是降级。 + log.Printf("WARN: [upstream] global models: v3/config probe failed (degraded to enterprise endpoint): %v", v3.err) + names, infos, efforts, defaults = extractEfforts(enterprise.infos) + if len(names) == 0 { + names = enterprise.names + } + return names, infos, efforts, defaults, globalCatalogSourceEnterprise, nil + } + if enterprise.err != nil { + log.Printf("WARN: [upstream] global models: enterprise endpoint failed (v3/config only): %v", enterprise.err) + names, infos, efforts, defaults = extractEfforts(v3.infos) + if len(names) == 0 { + names = v3.names + } + return names, infos, efforts, defaults, catalogSource, nil + } + v3Names, v3Infos, v3Efforts, v3Defaults := extractEfforts(v3.infos) + if len(v3Names) == 0 { + v3Names = v3.names + } + entNames, entInfos, entEfforts, entDefaults := extractEfforts(enterprise.infos) + if len(entNames) == 0 { + entNames = enterprise.names + } + if catalogSource == globalCatalogSourceDesktop { + // 桌面族权威:企业端点**不贡献 id**(它带着 deep-model / gpt-5.3-codex 这类 + // 已下架或 11102 的旧条目),只按同 id 补元数据(它给的 credits 也可能过期, + // 故只补缺失字段,不覆盖桌面族已有值)。 + names, infos = v3Names, enrichModelInfos(v3Infos, entInfos) + } else { + names, infos = mergeGlobalCatalog(v3Names, v3Infos, entNames, entInfos) + } + efforts = mergeEffortBuckets(v3Efforts, entEfforts) + defaults = mergeEffortDefaults(v3Defaults, entDefaults) + return names, infos, efforts, defaults, catalogSource, nil +} + +// extractEfforts 从条目列表抽取 effort 能力桶(supportedEfforts 数组优先; +// 缺数组但 defaultEffort 单档非空也入 defaults 桶)并顺带返回有序 names。 +func extractEfforts(infos []ModelInfo) (names []string, out []ModelInfo, efforts map[string][]string, defaults map[string]string) { + names = make([]string, 0, len(infos)) + for _, mi := range infos { + if mi.ID == "" { + continue + } + names = append(names, mi.ID) + out = append(out, mi) + if len(mi.Efforts) > 0 { + if efforts == nil { + efforts = make(map[string][]string) + } + efforts[mi.ID] = mi.Efforts + } + if mi.DefaultEffort != "" { + if defaults == nil { + defaults = make(map[string]string) + } + defaults[mi.ID] = mi.DefaultEffort + } + } + return names, out, efforts, defaults +} + +// enrichModelInfos 仅按同 id 补元数据:base 里已有非零值的字段一律保留(base 权威), +// 缺字段才从后续来源取第一个非零值。**不新增 id**——这是与 mergeGlobalCatalog 的关键 +// 差别:issue #216 要求模型目录对齐官方桌面端 picker,别的 UA 族/企业端点只用来给 +// 同一批模型补 context/efforts/credits 等字段。 +func enrichModelInfos(base []ModelInfo, sources ...[]ModelInfo) []ModelInfo { + if len(base) == 0 || len(sources) == 0 { + return base + } + index := make(map[string]ModelInfo, len(sources[0])) + for _, src := range sources { + for _, mi := range src { + if mi.ID == "" { + continue + } + if _, ok := index[mi.ID]; !ok { + index[mi.ID] = mi + } + } + } + out := make([]ModelInfo, 0, len(base)) + for _, mi := range base { + extra, ok := index[mi.ID] + if !ok { + out = append(out, mi) + continue + } + if mi.ContextWindow == 0 { + mi.ContextWindow = extra.ContextWindow + } + if mi.MaxTokens == 0 { + mi.MaxTokens = extra.MaxTokens + } + if mi.MaxAllowedSize == 0 { + mi.MaxAllowedSize = extra.MaxAllowedSize + } + if mi.Credits == "" { + mi.Credits = extra.Credits + } + if len(mi.Tags) == 0 { + mi.Tags = extra.Tags + } + if len(mi.Efforts) == 0 { + mi.Efforts = extra.Efforts + } + if mi.DefaultEffort == "" { + mi.DefaultEffort = extra.DefaultEffort + } + if mi.Description == "" { + mi.Description = extra.Description + } + if mi.Vendor == "" { + mi.Vendor = extra.Vendor + } + if !mi.SupportsImagesSet && extra.SupportsImagesSet { + mi.SupportsImages, mi.SupportsImagesSet = extra.SupportsImages, true + } + if !mi.SupportsReasoning { + mi.SupportsReasoning = extra.SupportsReasoning + } + if !mi.SupportsToolCall { + mi.SupportsToolCall = extra.SupportsToolCall + } + if !mi.OnlyReasoning { + mi.OnlyReasoning = extra.OnlyReasoning + } + if !mi.CanDisableThinking { + mi.CanDisableThinking = extra.CanDisableThinking + } + out = append(out, mi) + } + return out +} + +// mergeGlobalCatalog 两路合并(v3 主、企业补缺):names 按 id 去重(v3 原序在前、 +// 企业端点补充项在其原序后追加——稳定输出);infos 同步合并(v3 条目字段权威, +// 企业端点条目只在 id 缺失时进并集)。 +// 窄表形态(infos nil)时保持 nil——无对象字段不编造。 +func mergeGlobalCatalog(primaryNames []string, primaryInfos []ModelInfo, secondaryNames []string, secondaryInfos []ModelInfo) (names []string, infos []ModelInfo) { + if len(secondaryNames) == 0 { + return primaryNames, primaryInfos + } + seen := make(map[string]bool, len(primaryNames)+len(secondaryNames)) + out := make([]string, 0, len(primaryNames)+len(secondaryNames)) + for _, id := range primaryNames { + if id == "" || seen[id] { + continue + } + seen[id] = true + out = append(out, id) + } + var outInfos []ModelInfo + if primaryInfos != nil { + outInfos = make([]ModelInfo, 0, len(primaryInfos)+len(secondaryInfos)) + outInfos = append(outInfos, primaryInfos...) + } + for _, id := range secondaryNames { + if id == "" || seen[id] { + continue + } + seen[id] = true + out = append(out, id) + // 窄表企业响应(secondaryInfos nil / 超出条目数)时该 id 无对象字段, + // infos 保持原样(调用方按 id 名单输出裸条目,不编造字段)。 + for _, mi := range secondaryInfos { + if mi.ID == id { + outInfos = append(outInfos, mi) + break + } + } + } + return out, outInfos +} + +// mergeEffortBuckets 合并两路 effort 桶:主路(v3)权威,企业端点只补主路缺失的模型档位。 +func mergeEffortBuckets(primary, secondary map[string][]string) map[string][]string { + if len(secondary) == 0 { + return primary + } + out := primary + if out == nil { + out = make(map[string][]string, len(secondary)) + } + for id, v := range secondary { + if _, ok := out[id]; !ok { + out[id] = v + } + } + return out +} + +// mergeEffortDefaults 合并两路 defaultEffort:主路(v3)权威,企业端点只补缺失。 +func mergeEffortDefaults(primary, secondary map[string]string) map[string]string { + if len(secondary) == 0 { + return primary + } + out := primary + if out == nil { + out = make(map[string]string, len(secondary)) + } + for id, v := range secondary { + if _, ok := out[id]; !ok { + out[id] = v + } + } + return out +} + +// globalModelsOnce 单端点探测。2xx + 解析出非空名单 → (names, infos, nil);否则 (nil, nil, err)。 +func (c *Client) globalModelsOnce(a *auth.Auth, path string) ([]string, []ModelInfo, error) { + url := c.chatBase(a) + path // 按 realm 切 base:global 账号 → global base + req, err := http.NewRequest(http.MethodGet, url, nil) + if err != nil { + return nil, nil, err + } + c.CommonHeaders(req, a) // 共享请求头(Origin/Referer/UA),与 FetchModels 同款 + // AccessToken 加锁快照(见 auth.AccessTokenValue:keepalive 刷新在 a.mu 内改写)。 + req.Header.Set("Authorization", "Bearer "+a.AccessTokenValue()) + resp, err := c.do(req, a, false) + if err != nil { + return nil, nil, err + } + defer resp.Body.Close() + raw, err := io.ReadAll(io.LimitReader(resp.Body, 1<<20)) + if err != nil { + // 读失败 → 传输层错误:半截 body 不进解析(探测负缓存走 lastFail,不罚号)。 + return nil, nil, fmt.Errorf("read body: %w", err) + } + if resp.StatusCode != http.StatusOK { + return nil, nil, fmt.Errorf("global models status %d: %s", resp.StatusCode, truncate(string(raw), 120)) + } + names, infos, _, _, err := parseGlobalModelNames(raw) + // 媒体生成模型的旁路留存不在这里做:parse 已把它们剔出对话名单,出图/出视频模型由 + // /v3/config 那条探测路径留存(那份目录完整、含 tag,见 probeGlobalModels)。 + return names, infos, err +} + +// parseGlobalModelNames 多信封兼容解析模型目录(国际站曾在多种 envelope 间切换, +// 只认单一形态会把登录成功的账号误判为"无模型"): +// - 信封:code 存在且非 0 才拒(无 code 字段也放行);payload = data(非空非 +// null 时)否则整包; +// - 模型数组定位:payload 本身是数组,或是 map 下 models/items/list/data/result +// 任一键(递归一层层往下找第一个非空数组)——覆盖 data.models / data.items / +// data.list / 顶层 models 等变体; +// - 数组主形态:对象数组按 dynModelEntry 全字段解析(与 CN 目录同构,字段零 +// 漂移):maxInputTokens/maxOutputTokens/maxAllowedSize/supportsReasoning/ +// supportsImages/reasoning.*;id 缺省时回退 name;disabled 剔除; +// - 窄表:字符串数组 → 仅 ID,元数据留空(窗口由调用方四级查找链兜底); +// - 动态兜底:主形态解析不出任何可用条目时(上游换了键名),逐对象宽松解析—— +// id 依次回退 id/modelId/model/name,窗口键回退 contextWindow/maxTokens, +// reasoning 档位(defaultEffort 新键优先、effort 老键兜底)保留。 +// +// 同时产出 effort 能力桶(supportedEfforts/defaultEffort)。 +// 解析成功但名单为空 → 返回错误(等价"该端点没给全")。 +func parseGlobalModelNames(raw []byte) (names []string, infos []ModelInfo, efforts map[string][]string, defaults map[string]string, err error) { + fail := func(e error) ([]string, []ModelInfo, map[string][]string, map[string]string, error) { + return nil, nil, nil, nil, e + } + // 信封层:code 拒绝非 0 业务码(字段缺失 = 放行,兼容无信封直出的目录端点)。 + var envelope map[string]json.RawMessage + if err := json.Unmarshal(raw, &envelope); err != nil { + return fail(fmt.Errorf("global models parse: %w", err)) + } + if codeRaw, ok := envelope["code"]; ok { + var code int + if json.Unmarshal(codeRaw, &code) == nil && code != 0 { + return fail(fmt.Errorf("global models code=%d", code)) + } + } + payload := json.RawMessage(raw) + if data, ok := envelope["data"]; ok { + if t := strings.TrimSpace(string(data)); t != "" && t != "null" { + payload = data + } + } + arr, ok := resolveGlobalModelsArray(payload) + if !ok { + return fail(fmt.Errorf("global models empty list")) + } + + // 主形态:对象数组 → dynModelEntry 全字段(与 CN FetchModels 共用解析,零口径漂移)。 + var entries []dynModelEntry + if json.Unmarshal(arr, &entries) == nil { + out := make([]string, 0, len(entries)) + objInfos := make([]ModelInfo, 0, len(entries)) + for _, m := range entries { + // id 回退链 id→modelId→model→name(宽松键仅出现在 global 目录变体里)。 + id := m.ID + if id == "" { + id = m.ModelID + } + if id == "" { + id = m.Model + } + if id == "" { + id = m.Name + } + if id == "" || m.Disabled { + continue + } + // 非对话条目同样剔掉:这条路径此前**完全没过滤**——seedance-2.5(text-to-video) + // 因此被当成对话模型列进 global 名单,面板里显示"不支持思考"。媒体生成模型 + // (出图/出视频)的旁路留存由调用方 globalModelsOnce 做(它手上有 Client)。 + mi := m.modelInfo() + mi.ID = id // name 兜底形态下 id 取自 name,对齐 names 输出 + if nonChatModel(id, m.MaxOutputTokens, m.Tags) { + continue + } + out = append(out, id) + objInfos = append(objInfos, mi) + if len(m.Reasoning.SupportedEfforts) > 0 { + if efforts == nil { + efforts = make(map[string][]string) + } + efforts[id] = m.Reasoning.SupportedEfforts + } + if d := m.Reasoning.DefaultEffort; d != "" { + if defaults == nil { + defaults = make(map[string]string) + } + defaults[id] = d + } + } + if len(out) > 0 { + return out, objInfos, efforts, defaults, nil + } + // 可用条目为 0(键名全对不上):落入下方动态兜底,不在这里报空。 + efforts, defaults = nil, nil + } + + // 窄表:字符串数组 → 仅 ID(无 effort 元数据、无对象字段 → infos nil)。 + var strs []string + if json.Unmarshal(arr, &strs) == nil { + out := make([]string, 0, len(strs)) + for _, id := range strs { + if id = strings.TrimSpace(id); id != "" { + out = append(out, id) + } + } + if len(out) > 0 { + return out, nil, nil, nil, nil + } + return fail(fmt.Errorf("global models empty list")) + } + + // 动态兜底:逐对象宽松解析(上游换键名时不至于整域空列表)。 + var items []any + if json.Unmarshal(arr, &items) != nil { + return fail(fmt.Errorf("global models parse: unsupported payload shape")) + } + out := make([]string, 0, len(items)) + infos = make([]ModelInfo, 0, len(items)) + for _, item := range items { + switch v := item.(type) { + case string: // 混合数组里的裸 ID:按窄表条目处理 + if id := strings.TrimSpace(v); id != "" { + out = append(out, id) + infos = append(infos, ModelInfo{ID: id}) + } + case map[string]any: + mi, ok := parseGlobalModelLoose(v) + if !ok { + continue + } + out = append(out, mi.ID) + infos = append(infos, mi) + if len(mi.Efforts) > 0 { + if efforts == nil { + efforts = make(map[string][]string) + } + efforts[mi.ID] = mi.Efforts + } + if mi.DefaultEffort != "" { + if defaults == nil { + defaults = make(map[string]string) + } + defaults[mi.ID] = mi.DefaultEffort + } + } + } + if len(out) == 0 { + return fail(fmt.Errorf("global models empty list")) + } + return out, infos, efforts, defaults, nil +} + +// resolveGlobalModelsArray 从 payload 定位模型数组:payload 本身是数组直接用; +// 是 map 则依次尝试 models/items/list/data/result 键(递归下钻,取第一个能解析出 +// 数组的分支)。找不到数组 → false。 +func resolveGlobalModelsArray(payload json.RawMessage) (json.RawMessage, bool) { + trimmed := strings.TrimSpace(string(payload)) + if strings.HasPrefix(trimmed, "[") { + return payload, true + } + var obj map[string]json.RawMessage + if json.Unmarshal(payload, &obj) != nil { + return nil, false + } + for _, key := range []string{"models", "items", "list", "data", "result"} { + if nested, ok := obj[key]; ok { + if arr, ok2 := resolveGlobalModelsArray(nested); ok2 { + return arr, true + } + } + } + return nil, false +} + +// parseGlobalModelLoose 单模型对象的宽松解析(多信封兜底路径):id 依次回退 +// id/modelId/model/name;窗口/上限键回退 contextWindow/maxTokens;reasoning 档位 +// defaultEffort 新键优先、effort 老键兜底。disabled 剔除。Credits 恒不解析 +// (PLAN §3.D2:倍率不进 global 路径)。 +func parseGlobalModelLoose(obj map[string]any) (ModelInfo, bool) { + str := func(key string) string { + s, _ := obj[key].(string) + return strings.TrimSpace(s) + } + id := str("id") + for _, k := range []string{"modelId", "model", "name"} { + if id != "" { + break + } + id = str(k) + } + if id == "" { + return ModelInfo{}, false + } + if disabled, ok := obj["disabled"].(bool); ok && disabled { + return ModelInfo{}, false + } + num := func(keys ...string) int64 { + for _, k := range keys { + if n, ok := obj[k].(float64); ok && n > 0 { + return int64(n) + } + } + return 0 + } + mi := ModelInfo{ + ID: id, + Name: str("name"), + ContextWindow: num("maxInputTokens", "contextWindow"), + MaxTokens: num("maxOutputTokens", "maxTokens"), + MaxAllowedSize: num("maxAllowedSize"), + } + mi.SupportsReasoning, _ = obj["supportsReasoning"].(bool) + // ok 必须保留:上游「没声明 supportsImages」与「显式声明 false」是两件事。此前 + // 丢掉 ok 把两者都折成 false,于是 11133 的 gateway_hint 会对目录里根本没声明 + // 图片能力的模型断言「不支持图片」(本仓实测 /v1/models 52 个模型 0 个 false, + // 即 false 基本只来自「缺声明」)——那是编造能力事实,客户端会照 hint 白换模型。 + if v, ok := obj["supportsImages"].(bool); ok { + mi.SupportsImages, mi.SupportsImagesSet = v, true + } + if r, ok := obj["reasoning"].(map[string]any); ok { + reasonStr := func(key string) string { + s, _ := r[key].(string) + return strings.TrimSpace(s) + } + mi.DefaultEffort = reasonStr("defaultEffort") + if mi.DefaultEffort == "" { + mi.DefaultEffort = reasonStr("effort") // 老模型键兜底,与 CN 侧同款 + } + mi.CanDisableThinking, _ = r["canDisableThinking"].(bool) + if arr, ok := r["supportedEfforts"].([]any); ok { + for _, item := range arr { + if s, ok := item.(string); ok { + if s = strings.TrimSpace(s); s != "" { + mi.Efforts = append(mi.Efforts, s) + } + } + } + } + } + return mi, true +} diff --git a/internal/upstream/global_models_routes_test.go b/internal/upstream/global_models_routes_test.go deleted file mode 100644 index ad55a2efe4e3d1c69740f1b3fe2f96832d8603fa..0000000000000000000000000000000000000000 --- a/internal/upstream/global_models_routes_test.go +++ /dev/null @@ -1,172 +0,0 @@ -package upstream - -import ( - "errors" - "testing" - - "github.com/linguo2625469/workbuddy2api-panel/internal/auth" -) - -// TestMergeV3RoutesPriority 主路字段权威:同 id 在三路都出现时,字段取自主路 -// (桌面端 UA),后续路不得覆盖其窗口/effort/credits。 -func TestMergeV3RoutesPriority(t *testing.T) { - mk := func(id string, ctx, out int64, credits string, efforts []string) ModelInfo { - return ModelInfo{ID: id, ContextWindow: ctx, MaxTokens: out, Credits: credits, Efforts: efforts} - } - desktop := probeResult{ - names: []string{"shared", "only-desktop"}, - infos: []ModelInfo{ - mk("shared", 1000000, 128000, "x1.33", []string{"low", "high"}), - mk("only-desktop", 500000, 64000, "x0.10", []string{"medium"}), - }, - } - ide := probeResult{ - names: []string{"shared", "only-ide"}, - infos: []ModelInfo{ - // 同 id 但字段不同:不得覆盖主路。 - mk("shared", 176000, 24000, "x9.99", []string{"max"}), - mk("only-ide", 200000, 32000, "x0.20", nil), - }, - } - cli := probeResult{ - names: []string{"shared", "only-cli"}, - infos: []ModelInfo{ - mk("shared", 272000, 72000, "x8.88", []string{"xhigh"}), - mk("only-cli", 256000, 32000, "x0.30", nil), - }, - } - got := mergeV3Routes([]struct { - label string - res probeResult - }{ - {"desktop-UA", desktop}, - {"IDE-UA", ide}, - {"CLI-UA", cli}, - }) - if got.err != nil { - t.Fatalf("unexpected err: %v", got.err) - } - wantIDs := []string{"shared", "only-desktop", "only-ide", "only-cli"} - if len(got.names) != len(wantIDs) { - t.Fatalf("names = %v, want %v", got.names, wantIDs) - } - for i, id := range wantIDs { - if got.names[i] != id { - t.Errorf("names[%d] = %q, want %q (full %v)", i, got.names[i], id, got.names) - } - } - // 主路字段权威:shared 的窗口必须是主路值。 - var shared *ModelInfo - for i := range got.infos { - if got.infos[i].ID == "shared" { - shared = &got.infos[i] - } - } - if shared == nil { - t.Fatal("shared model missing from infos") - } - if shared.ContextWindow != 1000000 || shared.MaxTokens != 128000 { - t.Errorf("shared window = %d/%d, want 1000000/128000 (primary route must win)", shared.ContextWindow, shared.MaxTokens) - } - if shared.Credits != "x1.33" { - t.Errorf("shared credits = %q, want x1.33", shared.Credits) - } - if len(shared.Efforts) != 2 || shared.Efforts[0] != "low" { - t.Errorf("shared efforts = %v, want [low high]", shared.Efforts) - } -} - -// TestMergeV3RoutesPartialFailure 单路失败不拖垮整次探测:失败的路由被跳过, -// 成功路并集照常产出;全路失败才返回 err。 -func TestMergeV3RoutesPartialFailure(t *testing.T) { - mk := func(id string) ModelInfo { return ModelInfo{ID: id} } - ok := probeResult{names: []string{"a"}, infos: []ModelInfo{mk("a")}} - bad := probeResult{err: errors.New("v3/config status 500")} - - got := mergeV3Routes([]struct { - label string - res probeResult - }{ - {"desktop-UA", bad}, - {"IDE-UA", ok}, - {"CLI-UA", bad}, - }) - if got.err != nil { - t.Fatalf("partial failure should not error, got %v", got.err) - } - if len(got.names) != 1 || got.names[0] != "a" { - t.Errorf("names = %v, want [a]", got.names) - } - - // 全路失败 → err(取首路错误,供调用方降级到企业端点)。 - all := mergeV3Routes([]struct { - label string - res probeResult - }{ - {"desktop-UA", bad}, - {"IDE-UA", bad}, - {"CLI-UA", bad}, - }) - if all.err == nil { - t.Fatal("all routes failed: want err, got nil") - } -} - -// TestNonChatModelGenerationTags 生成类(图片/视频)模型不得进对话目录。 -// 回归用例:nonChatModel 早期只拦 text-to-image,桌面端目录下的 -// text-to-video / image-to-video(seedance 系列)会漏过并混进 /v1/models。 -func TestNonChatModelGenerationTags(t *testing.T) { - cases := []struct { - name string - id string - out int64 - tags []string - want bool - }{ - {"图片生成(既有规则)", "hunyuan-image-alpha", 0, []string{"text-to-image"}, true}, - {"图生图", "gpt-image-2.5-sunburst", 0, []string{"text-to-image", "image-to-image"}, true}, - {"文生视频(本次修复)", "seedance-2.5", 0, []string{"text-to-video", "image-to-video"}, true}, - {"图生视频(本次修复)", "seedance-2.5-pro", 1024, []string{"image-to-video"}, true}, - {"普通对话模型", "gpt-6-sol", 128000, nil, false}, - {"新模型无 tags", "grok-4.7", 128000, []string{}, false}, - {"对话模型带无关 tag", "balanced-model", 32000, []string{"craft"}, false}, - {"tiny 输出仍剔除", "completion-1.0", 256, nil, true}, - {"nes 前缀仍剔除", "nes-1.2", 8192, nil, true}, - } - for _, c := range cases { - if got := nonChatModel(c.id, c.out, c.tags); got != c.want { - t.Errorf("%s: nonChatModel(%q, %d, %v) = %v, want %v", c.name, c.id, c.out, c.tags, got, c.want) - } - } -} - -// TestDesktopUAForGlobalAccount 桌面端 UA 按 realm 切平台段:global 账号必须是 -// `WorkBuddy AI`(送错平台段会触发上游 403 code=11140 风控)。探测主路用这个 UA, -// 与 chat 路径同源——global 目录探测因此拿到客户端同款模型集。 -func TestDesktopUAForGlobalAccount(t *testing.T) { - c := New() - global := &auth.Auth{UID: "u1", Domain: "www.workbuddy.ai"} - global.BackfillRealm() - ua := c.defaultWorkBuddyUAFor(global) - if want := "WorkBuddy AI"; !contains(ua, want) { - t.Errorf("global desktop UA = %q, want it to contain %q", ua, want) - } - if !contains(ua, "CLI/") { - t.Errorf("global desktop UA = %q, want CLI segment", ua) - } - // CN 账号保持 WorkBuddy(零回归)。 - cn := &auth.Auth{UID: "u2", Domain: "copilot.tencent.com"} - cn.BackfillRealm() - if ua := c.defaultWorkBuddyUAFor(cn); contains(ua, "WorkBuddy AI") { - t.Errorf("cn desktop UA = %q, must not contain 'WorkBuddy AI'", ua) - } -} - -func contains(s, sub string) bool { - for i := 0; i+len(sub) <= len(s); i++ { - if s[i:i+len(sub)] == sub { - return true - } - } - return false -} diff --git a/internal/upstream/global_models_test.go b/internal/upstream/global_models_test.go new file mode 100644 index 0000000000000000000000000000000000000000..9873c62287439b93fc64935adf717ca9d3eba850 --- /dev/null +++ b/internal/upstream/global_models_test.go @@ -0,0 +1,263 @@ +// global_models_test.go global 模型目录探测的 UA 家族覆盖回归。 +package upstream + +import ( + "encoding/json" + "net/http" + "net/http/httptest" + "strings" + "sync" + "sync/atomic" + "testing" + + "github.com/misakano7545/workbuddy2api-panel/internal/auth" +) + +// TestGlobalCatalogProbesDesktopUA 锁定「/v3/config 目录按 UA 家族分档」这一上游事实: +// 仅桌面端 UA 下发的模型必须出现在并集里。 +// +// 回归目标(上游 #102 / PR #103):gpt-6-luna 只在桌面端目录下发、实际可调用 +// (实测 HTTP 200),只探 IDE + CLI 两路时它永远进不了 /v1/models。 +func TestGlobalCatalogProbesDesktopUA(t *testing.T) { + prev := auth.GlobalEnabled() + auth.SetGlobalEnabled(true) + defer auth.SetGlobalEnabled(prev) + + const desktopOnly = "gpt-6-luna" + // 三路 /v3/config 并发探测 → handler 并发写,必须加锁(CI 曾现 concurrent map writes)。 + var seenMu sync.Mutex + seenUA := map[string]bool{} + + srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { + if !strings.HasSuffix(r.URL.Path, "/v3/config") { + // 企业端点家族一律 500:本用例只验证 v3 多路并集,同时覆盖 + // 「家族路失败不拖累 v3 结果」的降级语义。 + w.WriteHeader(http.StatusInternalServerError) + return + } + ua := r.Header.Get("User-Agent") + seenMu.Lock() + seenUA[ua] = true + seenMu.Unlock() + ids := []string{"shared-model"} + // 官方 UA 只有两种形态(2026-10-20 真机抓包):三段重复品牌(桌面族)与 + // 两段单品牌(CLI 族)。旧的 CodeBuddyIDE/CLI 家族字面量在分发包里不存在。 + switch { + case repeatedBrand(ua): + ids = append(ids, desktopOnly) + case strings.HasPrefix(ua, "WorkBuddy/"), strings.HasPrefix(ua, "workbuddy-ai/"): + ids = append(ids, "cli-only") + default: + t.Errorf("v3/config 探测带了非预期 UA: %q", ua) + } + models := make([]map[string]any, 0, len(ids)) + for _, id := range ids { + models = append(models, map[string]any{ + "id": id, "maxInputTokens": 100000, "maxOutputTokens": 32000, + }) + } + _ = json.NewEncoder(w).Encode(map[string]any{ + "code": 0, + "data": map[string]any{"models": models}, + }) + })) + defer srv.Close() + + c := New() + c.HTTP = srv.Client() + c.ChatBaseGlobal = srv.URL + c.GlobalEnabled = true + a := &auth.Auth{UID: "g1", AccessToken: "at", Domain: "www.workbuddy.ai"} + + names := c.FetchGlobalModels(a) + got := make(map[string]bool, len(names)) + for _, n := range names { + got[n] = true + } + for _, want := range []string{"shared-model", desktopOnly} { + if !got[want] { + t.Errorf("FetchGlobalModels 缺少 %q(并集=%v)", want, names) + } + } + // issue #216:桌面族成功时它是目录权威,IDE/CLI 独有模型不再进目录 + //(实测它们在 chat 端点回 11102 “service info not found”,列出来只会让 + // 客户端选到死模型;官方桌面端 picker 也只显示桌面族那 27 个)。 + for _, unwanted := range []string{"ide-only", "cli-only"} { + if got[unwanted] { + t.Errorf("桌面族成功时不应列出非桌面族独有模型 %q(目录=%v)", unwanted, names) + } + } + if src := c.GlobalCatalogSource(); src != globalCatalogSourceDesktop { + t.Errorf("目录来源=%q want %q", src, globalCatalogSourceDesktop) + } + seenMu.Lock() + seen := make([]string, 0, len(seenUA)) + for ua := range seenUA { + seen = append(seen, ua) + } + seenMu.Unlock() + if len(seen) != 2 { + t.Errorf("v3/config 应探 2 种官方 UA 形态,实际 %d 种: %v", len(seen), seen) + } +} + +// TestGlobalCatalogDesktopProbeFailureFallsBackToUnion 桌面族探测失败时回落 +// IDE+CLI 并集(宁可多列也不空表),并把来源标成 v3-union 供面板提示。 +func TestGlobalCatalogDesktopProbeFailureFallsBackToUnion(t *testing.T) { + prev := auth.GlobalEnabled() + auth.SetGlobalEnabled(true) + defer auth.SetGlobalEnabled(prev) + + srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { + if !strings.HasSuffix(r.URL.Path, "/v3/config") { + w.WriteHeader(http.StatusInternalServerError) + return + } + ua := r.Header.Get("User-Agent") + var ids []string + switch { + case repeatedBrand(ua): + // 桌面族失败(模拟上游对该族 500)。 + w.WriteHeader(http.StatusInternalServerError) + return + case strings.HasPrefix(ua, "WorkBuddy/"): + ids = []string{"cli-model"} + default: + ids = []string{"other-model"} + } + models := make([]map[string]any, 0, len(ids)) + for _, id := range ids { + models = append(models, map[string]any{"id": id, "maxInputTokens": 1000, "maxOutputTokens": 1000}) + } + _ = json.NewEncoder(w).Encode(map[string]any{"code": 0, "data": map[string]any{"models": models}}) + })) + defer srv.Close() + + c := New() + c.HTTP = srv.Client() + c.ChatBaseGlobal = srv.URL + c.GlobalEnabled = true + names := c.FetchGlobalModels(&auth.Auth{UID: "g1", AccessToken: "at", Domain: "www.workbuddy.ai"}) + got := map[string]bool{} + for _, n := range names { + got[n] = true + } + if !got["cli-model"] { + t.Fatalf("桌面族失败时应回落 CLI 族结果,实际=%v", names) + } + if src := c.GlobalCatalogSource(); src != globalCatalogSourceUnion { + t.Errorf("目录来源=%q want %q", src, globalCatalogSourceUnion) + } +} + +// TestGlobalCatalogDesktopAuthorityExcludesEnterpriseLegacy 桌面族成功时,企业端点 +// **不得**再往目录里加 id(它带着 deep-model / gpt-5.3-codex 这类已下架或 11102 的 +// 旧条目)——这正是 issue #216 里「多出两个官方目录没有的模型」的来源。 +// 企业端点的同 id 条目仍用于补元数据。 +func TestGlobalCatalogDesktopAuthorityExcludesEnterpriseLegacy(t *testing.T) { + prev := auth.GlobalEnabled() + auth.SetGlobalEnabled(true) + defer auth.SetGlobalEnabled(prev) + + srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { + switch { + case strings.HasSuffix(r.URL.Path, "/v3/config"): + _ = json.NewEncoder(w).Encode(map[string]any{"code": 0, "data": map[string]any{ + "models": []map[string]any{{"id": "desk-model", "maxOutputTokens": 32000}}, + }}) + case strings.HasSuffix(r.URL.Path, "/v2/enterprises/personal/models"): + _ = json.NewEncoder(w).Encode(map[string]any{"code": 0, "data": map[string]any{ + "models": []map[string]any{ + {"id": "desk-model", "maxInputTokens": 176000}, + {"id": "deep-model"}, {"id": "gpt-5.3-codex"}, + }, + }}) + default: + w.WriteHeader(http.StatusInternalServerError) + } + })) + defer srv.Close() + + c := New() + c.HTTP = srv.Client() + c.ChatBaseGlobal = srv.URL + c.GlobalEnabled = true + names := c.FetchGlobalModels(&auth.Auth{UID: "g1", AccessToken: "at", Domain: "www.workbuddy.ai"}) + got := map[string]bool{} + for _, n := range names { + got[n] = true + } + if !got["desk-model"] { + t.Fatalf("桌面族模型缺失: %v", names) + } + for _, legacy := range []string{"deep-model", "gpt-5.3-codex"} { + if got[legacy] { + t.Errorf("企业端点旧条目 %q 不应进目录: %v", legacy, names) + } + } +} + +// TestInvalidateGlobalModelsCacheReprobes 锁定「重新获取」按钮的语义(issue #216 现象 3): +// 清缓存后必须真的再打一次上游,而不是继续读 1h 缓存。 +func TestInvalidateGlobalModelsCacheReprobes(t *testing.T) { + prev := auth.GlobalEnabled() + auth.SetGlobalEnabled(true) + defer auth.SetGlobalEnabled(prev) + + var v3Hits, entHits int32 + srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { + switch { + case strings.HasSuffix(r.URL.Path, "/v3/config"): + atomic.AddInt32(&v3Hits, 1) + _ = json.NewEncoder(w).Encode(map[string]any{"code": 0, "data": map[string]any{ + "models": []map[string]any{{"id": "m1"}}, + }}) + case strings.HasSuffix(r.URL.Path, "/v2/enterprises/personal/models"): + atomic.AddInt32(&entHits, 1) + _ = json.NewEncoder(w).Encode(map[string]any{"code": 0, "data": map[string]any{ + "models": []map[string]any{{"id": "m1"}}, + }}) + default: + w.WriteHeader(http.StatusInternalServerError) + } + })) + defer srv.Close() + + c := New() + c.HTTP = srv.Client() + c.ChatBaseGlobal = srv.URL + c.GlobalEnabled = true + a := &auth.Auth{UID: "g1", AccessToken: "at", Domain: "www.workbuddy.ai"} + + c.FetchGlobalModels(a) + first := atomic.LoadInt32(&v3Hits) + if first == 0 { + t.Fatal("首次探测没有打上游") + } + // 缓存命中:不再打上游。 + c.FetchGlobalModels(a) + if got := atomic.LoadInt32(&v3Hits); got != first { + t.Fatalf("缓存命中期间不应再探上游:before=%d after=%d", first, got) + } + // 清缓存后必须重探。 + c.InvalidateGlobalModelsCache() + if src := c.GlobalCatalogSource(); src != "" { + t.Errorf("清缓存后来源应为空,got %q", src) + } + c.FetchGlobalModels(a) + if got := atomic.LoadInt32(&v3Hits); got <= first { + t.Fatalf("清缓存后应重新探测:before=%d after=%d", first, got) + } +} + +// repeatedBrand 报告 UA 是否形态为「品牌段重复两次」(官方桌面族三段式特征): +// `WorkBuddy/5.8.3 WorkBuddy/5.8.3 CLI/2.161.0` / +// `workbuddy-ai/5.8.4 workbuddy-ai/5.8.4 CLI/2.161.0`。 +func repeatedBrand(ua string) bool { + for _, b := range []string{"WorkBuddy/", "workbuddy-ai/"} { + if strings.Count(ua, b) >= 2 { + return true + } + } + return false +} diff --git a/internal/upstream/global_register.go b/internal/upstream/global_register.go index 82474fe22d5cbf37f6441974fa5a72cb2afa6dd4..bc8616d70e159f54d0fa306a3f9a83a373900565 100644 --- a/internal/upstream/global_register.go +++ b/internal/upstream/global_register.go @@ -1,232 +1,234 @@ -// global_register.go 国际版(global realm)新账号注册激活与地区完善。 -// -// 背景(ANALYSIS-workbuddy-client-reverse.md):新 global 账号需先完成注册地区 -// (/login/register/user/complete 补地区)再调 register 接口激活 Trial,chat 才不报 -// 14017 trial not activated。链路(逆向自 web 注册完善页 RegisterRegion-*.js): -// -// POST /billing/area/get-country-code {filterForbidden:1} → 可取国家列表 -// POST /billing/area/get-user-area-info {action:getUserAreaInfo} → 检测当前地区 -// POST /console/login/account {attributes:{countryCode,countryFullName,countryName}} → 提交地区(幂等) -// GET /auth/realms/copilot/overseas/user/register?userId= → 注册激活(code:200 成功;code:500 "region required" 需补地区) -// POST /billing/ide/trial → 一次性加油包(幂等码 14051,见 trial.go) -// -// 响应体注意:get-country-code / get-user-area-info 的 data 是 JSON 字符串 -// (双层信封),需二次解析。 -package upstream - -import ( - "bytes" - "encoding/json" - "fmt" - "io" - "net/http" - "strings" - - "github.com/linguo2625469/workbuddy2api-panel/internal/auth" -) - -// globalWebUA 国际版 web 端 UA(注册完善页走 web 指纹,非桌面端 CLI 指纹)。 -const globalWebUA = "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 " + - "(KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36" - -// GlobalCountry 可选注册地区(对应 get-country-code 的 list 元素)。 -type GlobalCountry struct { - EnName string `json:"EnName"` // 英文全名(countryFullName) - Name string `json:"Name"` // 显示名 - IOS2 string `json:"IOS2"` // 二字码(countryName) - IOS3 string `json:"IOS3"` - Code string `json:"Code"` // 数字码(countryCode) -} - -// globalRegisterBase 注册激活端点的 base(注册链路在 www.workbuddy.ai,与 globalBillingBase 同域)。 -// 独立成方法便于测试替换。 -func (c *Client) globalRegisterBase() string { - if c.BillingBaseGlobal != "" { - return c.BillingBaseGlobal - } - return defaultGlobalBase -} - -// globalRegisterReq 注册链路通用请求构造:web 指纹 UA + Origin/Referer 同域 + Bearer。 -func (c *Client) globalRegisterReq(method, url, token string, body any) (*http.Request, error) { - var rdr io.Reader - if body != nil { - raw, err := json.Marshal(body) - if err != nil { - return nil, err - } - rdr = bytes.NewReader(raw) - } - req, err := http.NewRequest(method, url, rdr) - if err != nil { - return nil, err - } - base := c.globalRegisterBase() - req.Header.Set("User-Agent", globalWebUA) - req.Header.Set("Accept", "application/json, text/plain, */*") - req.Header.Set("Content-Type", "application/json") - req.Header.Set("Origin", base) - req.Header.Set("Referer", base+"/") - if token != "" { - req.Header.Set("Authorization", "Bearer "+token) - } - return req, nil -} - -// globalRegisterJSON 发注册链路请求并解外层信封(code/msg)。 -func (c *Client) globalRegisterJSON(req *http.Request) (code int, msg string, raw json.RawMessage, err error) { - resp, err := c.HTTP.Do(req) - if err != nil { - return 0, "", nil, err - } - defer resp.Body.Close() - data, _ := io.ReadAll(io.LimitReader(resp.Body, 1<<20)) - var env struct { - Code int `json:"code"` - Msg string `json:"msg"` - Data json.RawMessage `json:"data"` - } - if err := json.Unmarshal(data, &env); err != nil { - return 0, "", nil, fmt.Errorf("global register parse: %w", err) - } - return env.Code, env.Msg, env.Data, nil -} - -// GlobalFetchCountries 拉取可选注册地区列表(global 账号登录后调用)。 -// intlOnly=true 时按国际版 web 白名单过滤(HK/MO/SG/TH/PH/MY/ID,对齐 web 展示集)。 -func (c *Client) GlobalFetchCountries(a *auth.Auth, intlOnly bool) ([]GlobalCountry, error) { - if a == nil || a.Realm() != "global" { - return nil, fmt.Errorf("fetch countries: only global accounts") - } - req, err := c.globalRegisterReq(http.MethodPost, c.globalRegisterBase()+"/billing/area/get-country-code", a.AccessTokenValue(), map[string]any{"filterForbidden": 1}) - if err != nil { - return nil, err - } - code, msg, raw, err := c.globalRegisterJSON(req) - if err != nil { - return nil, err - } - if code != 0 { - return nil, fmt.Errorf("get-country-code: %s (code=%d)", msg, code) - } - // data 是 JSON 字符串(双层信封)或对象,需二次解析。 - var inner struct { - Data struct { - List []GlobalCountry `json:"list"` - } `json:"data"` - } - if s := strings.TrimSpace(string(raw)); strings.HasPrefix(s, "\"") { - var s2 string - if err := json.Unmarshal(raw, &s2); err != nil { - return nil, fmt.Errorf("country list unwrap: %w", err) - } - raw = json.RawMessage(s2) - } - if err := json.Unmarshal(raw, &inner); err != nil { - return nil, fmt.Errorf("country list parse: %w", err) - } - list := inner.Data.List - if !intlOnly { - return list, nil - } - // 国际版 web 白名单过滤(HK, MO, SG, TH, PH, MY, ID,顺序对齐 web 展示)。 - whitelist := []string{"HK", "MO", "SG", "TH", "PH", "MY", "ID"} - byCode := make(map[string]GlobalCountry, len(list)) - for _, ctry := range list { - byCode[ctry.IOS2] = ctry - } - out := make([]GlobalCountry, 0, len(whitelist)) - for _, code := range whitelist { - if ctry, ok := byCode[code]; ok { - out = append(out, ctry) - } - } - return out, nil -} - -// GlobalRegisterStatus 报告 global 账号注册激活状态:是否需要补地区、是否已激活。 -func (c *Client) GlobalRegisterStatus(a *auth.Auth) (activated bool, needsRegion bool, msg string, err error) { - if a == nil || a.Realm() != "global" { - return false, false, "", fmt.Errorf("register status: only global accounts") - } - req, err := c.globalRegisterReq(http.MethodGet, - c.globalRegisterBase()+"/auth/realms/copilot/overseas/user/register?userId="+a.UID, - a.AccessTokenValue(), nil) - if err != nil { - return false, false, "", err - } - req.Header.Set("X-User-Id", a.UID) - code, m, _, err := c.globalRegisterJSON(req) - if err != nil { - return false, false, "", err - } - switch { - case code == 200: - return true, false, "register success", nil - case code == 500 || strings.Contains(strings.ToLower(m), "region required"): - return false, true, m, nil - default: - return false, false, m, nil - } -} - -// GlobalSubmitRegion 提交注册地区(幂等)。country 来自 GlobalFetchCountries。 -func (c *Client) GlobalSubmitRegion(a *auth.Auth, country GlobalCountry) error { - if a == nil || a.Realm() != "global" { - return fmt.Errorf("submit region: only global accounts") - } - attrs := map[string]any{ - "countryCode": []string{country.Code}, - "countryFullName": []string{country.EnName}, - "countryName": []string{country.IOS2}, - } - req, err := c.globalRegisterReq(http.MethodPost, c.globalRegisterBase()+"/console/login/account", - a.AccessTokenValue(), map[string]any{"attributes": attrs}) - if err != nil { - return err - } - code, msg, _, err := c.globalRegisterJSON(req) - if err != nil { - return err - } - if code != 0 { - return fmt.Errorf("submit region: %s (code=%d)", msg, code) - } - return nil -} - -// GlobalCompleteRegistration 一键注册激活:先查状态,需补地区则按默认地区(白名单首个, -// 通常 HK)提交后重新激活。activated 表示调用后账号已激活可用。幂等(已激活直接返回)。 -// 失败不阻断调用方(panel login 已落盘),仅返回错误供日志。 -func (c *Client) GlobalCompleteRegistration(a *auth.Auth) (activated bool, err error) { - activated, needsRegion, msg, err := c.GlobalRegisterStatus(a) - if err != nil { - return false, err - } - if activated { - return true, nil - } - if !needsRegion { - return false, fmt.Errorf("register not activated: %s", msg) - } - // 需补地区:拉白名单,取首个(HK)提交。 - countries, err := c.GlobalFetchCountries(a, true) - if err != nil { - return false, fmt.Errorf("fetch countries: %w", err) - } - if len(countries) == 0 { - return false, fmt.Errorf("no countries available") - } - if err := c.GlobalSubmitRegion(a, countries[0]); err != nil { - return false, fmt.Errorf("submit region: %w", err) - } - // 重新激活验证。 - activated, needsRegion, msg, err = c.GlobalRegisterStatus(a) - if err != nil { - return false, err - } - if !activated { - return false, fmt.Errorf("register still not activated after region submit: %s", msg) - } - return true, nil -} +// global_register.go 国际版(global realm)新账号注册激活与地区完善。 +// +// 背景(ANALYSIS-workbuddy-client-reverse.md):新 global 账号需先完成注册地区 +// (/login/register/user/complete 补地区)再调 register 接口激活 Trial,chat 才不报 +// 14017 trial not activated。链路(逆向自 web 注册完善页 RegisterRegion-*.js): +// +// POST /billing/area/get-country-code {filterForbidden:1} → 可取国家列表 +// POST /billing/area/get-user-area-info {action:getUserAreaInfo} → 检测当前地区 +// POST /console/login/account {attributes:{countryCode,countryFullName,countryName}} → 提交地区(幂等) +// GET /auth/realms/copilot/overseas/user/register?userId= → 注册激活(code:200 成功;code:500 "region required" 需补地区) +// POST /billing/ide/trial → 一次性加油包(幂等码 14051,见 trial.go) +// +// 响应体注意:get-country-code / get-user-area-info 的 data 是 JSON 字符串 +// (双层信封),需二次解析。 +package upstream + +import ( + "bytes" + "encoding/json" + "fmt" + "io" + "net/http" + "strings" + + "github.com/misakano7545/workbuddy2api-panel/internal/auth" +) + +// globalWebUA 国际版 web 端 UA(注册完善页走 web 指纹,非桌面端 CLI 指纹)。 +const globalWebUA = "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 " + + "(KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36" + +// GlobalCountry 可选注册地区(对应 get-country-code 的 list 元素)。 +type GlobalCountry struct { + EnName string `json:"EnName"` // 英文全名(countryFullName) + Name string `json:"Name"` // 显示名 + IOS2 string `json:"IOS2"` // 二字码(countryName) + IOS3 string `json:"IOS3"` + Code string `json:"Code"` // 数字码(countryCode) +} + +// globalRegisterBase 注册激活端点的 base:与 globalBillingBase 同域(按账号 domain +// 选官方国际站 codebuddy.ai 或旧桌面端 workbuddy.ai,两域同后端)。 +// 独立成方法便于测试替换。 +func (c *Client) globalRegisterBase(a *auth.Auth) string { + return c.globalBillingBase(a) +} + +// globalRegisterReq 注册链路通用请求构造:web 指纹 UA + Origin/Referer 同域 + Bearer。 +// base 由调用方按账号 domain 传入(codebuddy.ai / workbuddy.ai 两域并存, +// Origin/Referer 必须与目标主机同域,否则上游按跨域拒绝)。 +func (c *Client) globalRegisterReq(method, url, token string, body any, base string) (*http.Request, error) { + var rdr io.Reader + if body != nil { + raw, err := json.Marshal(body) + if err != nil { + return nil, err + } + rdr = bytes.NewReader(raw) + } + req, err := http.NewRequest(method, url, rdr) + if err != nil { + return nil, err + } + req.Header.Set("User-Agent", globalWebUA) + req.Header.Set("Accept", "application/json, text/plain, */*") + req.Header.Set("Content-Type", "application/json") + req.Header.Set("Origin", base) + req.Header.Set("Referer", base+"/") + if token != "" { + req.Header.Set("Authorization", "Bearer "+token) + } + return req, nil +} + +// globalRegisterJSON 发注册链路请求并解外层信封(code/msg)。 +func (c *Client) globalRegisterJSON(req *http.Request, a *auth.Auth) (code int, msg string, raw json.RawMessage, err error) { + resp, err := c.do(req, a, false) + if err != nil { + return 0, "", nil, err + } + defer resp.Body.Close() + data, _ := io.ReadAll(io.LimitReader(resp.Body, 1<<20)) + var env struct { + Code int `json:"code"` + Msg string `json:"msg"` + Data json.RawMessage `json:"data"` + } + if err := json.Unmarshal(data, &env); err != nil { + return 0, "", nil, fmt.Errorf("global register parse: %w", err) + } + return env.Code, env.Msg, env.Data, nil +} + +// GlobalFetchCountries 拉取可选注册地区列表(global 账号登录后调用)。 +// intlOnly=true 时按国际版 web 白名单过滤(HK/MO/SG/TH/PH/MY/ID,对齐 web 展示集)。 +func (c *Client) GlobalFetchCountries(a *auth.Auth, intlOnly bool) ([]GlobalCountry, error) { + if a == nil || a.Realm() != "global" { + return nil, fmt.Errorf("fetch countries: only global accounts") + } + base := c.globalRegisterBase(a) + req, err := c.globalRegisterReq(http.MethodPost, base+"/billing/area/get-country-code", a.AccessTokenValue(), map[string]any{"filterForbidden": 1}, base) + if err != nil { + return nil, err + } + code, msg, raw, err := c.globalRegisterJSON(req, a) + if err != nil { + return nil, err + } + if code != 0 { + return nil, fmt.Errorf("get-country-code: %s (code=%d)", msg, code) + } + // data 是 JSON 字符串(双层信封)或对象,需二次解析。 + var inner struct { + Data struct { + List []GlobalCountry `json:"list"` + } `json:"data"` + } + if s := strings.TrimSpace(string(raw)); strings.HasPrefix(s, "\"") { + var s2 string + if err := json.Unmarshal(raw, &s2); err != nil { + return nil, fmt.Errorf("country list unwrap: %w", err) + } + raw = json.RawMessage(s2) + } + if err := json.Unmarshal(raw, &inner); err != nil { + return nil, fmt.Errorf("country list parse: %w", err) + } + list := inner.Data.List + if !intlOnly { + return list, nil + } + // 国际版 web 白名单过滤(HK, MO, SG, TH, PH, MY, ID,顺序对齐 web 展示)。 + whitelist := []string{"HK", "MO", "SG", "TH", "PH", "MY", "ID"} + byCode := make(map[string]GlobalCountry, len(list)) + for _, ctry := range list { + byCode[ctry.IOS2] = ctry + } + out := make([]GlobalCountry, 0, len(whitelist)) + for _, code := range whitelist { + if ctry, ok := byCode[code]; ok { + out = append(out, ctry) + } + } + return out, nil +} + +// GlobalRegisterStatus 报告 global 账号注册激活状态:是否需要补地区、是否已激活。 +func (c *Client) GlobalRegisterStatus(a *auth.Auth) (activated bool, needsRegion bool, msg string, err error) { + if a == nil || a.Realm() != "global" { + return false, false, "", fmt.Errorf("register status: only global accounts") + } + base := c.globalRegisterBase(a) + req, err := c.globalRegisterReq(http.MethodGet, + base+"/auth/realms/copilot/overseas/user/register?userId="+a.UID, + a.AccessTokenValue(), nil, base) + if err != nil { + return false, false, "", err + } + req.Header.Set("X-User-Id", a.UID) + code, m, _, err := c.globalRegisterJSON(req, a) + if err != nil { + return false, false, "", err + } + switch { + case code == 200: + return true, false, "register success", nil + case code == 500 || strings.Contains(strings.ToLower(m), "region required"): + return false, true, m, nil + default: + return false, false, m, nil + } +} + +// GlobalSubmitRegion 提交注册地区(幂等)。country 来自 GlobalFetchCountries。 +func (c *Client) GlobalSubmitRegion(a *auth.Auth, country GlobalCountry) error { + if a == nil || a.Realm() != "global" { + return fmt.Errorf("submit region: only global accounts") + } + attrs := map[string]any{ + "countryCode": []string{country.Code}, + "countryFullName": []string{country.EnName}, + "countryName": []string{country.IOS2}, + } + base := c.globalRegisterBase(a) + req, err := c.globalRegisterReq(http.MethodPost, base+"/console/login/account", + a.AccessTokenValue(), map[string]any{"attributes": attrs}, base) + if err != nil { + return err + } + code, msg, _, err := c.globalRegisterJSON(req, a) + if err != nil { + return err + } + if code != 0 { + return fmt.Errorf("submit region: %s (code=%d)", msg, code) + } + return nil +} + +// GlobalCompleteRegistration 一键注册激活:先查状态,需补地区则按默认地区(白名单首个, +// 通常 HK)提交后重新激活。activated 表示调用后账号已激活可用。幂等(已激活直接返回)。 +// 失败不阻断调用方(panel login 已落盘),仅返回错误供日志。 +func (c *Client) GlobalCompleteRegistration(a *auth.Auth) (activated bool, err error) { + activated, needsRegion, msg, err := c.GlobalRegisterStatus(a) + if err != nil { + return false, err + } + if activated { + return true, nil + } + if !needsRegion { + return false, fmt.Errorf("register not activated: %s", msg) + } + // 需补地区:拉白名单,取首个(HK)提交。 + countries, err := c.GlobalFetchCountries(a, true) + if err != nil { + return false, fmt.Errorf("fetch countries: %w", err) + } + if len(countries) == 0 { + return false, fmt.Errorf("no countries available") + } + if err := c.GlobalSubmitRegion(a, countries[0]); err != nil { + return false, fmt.Errorf("submit region: %w", err) + } + // 重新激活验证。 + activated, needsRegion, msg, err = c.GlobalRegisterStatus(a) + if err != nil { + return false, err + } + if !activated { + return false, fmt.Errorf("register still not activated after region submit: %s", msg) + } + return true, nil +} diff --git a/internal/upstream/headcase.go b/internal/upstream/headcase.go new file mode 100644 index 0000000000000000000000000000000000000000..93bf1d7b5f5f906edaa2df35ee1f740a8af05ce2 --- /dev/null +++ b/internal/upstream/headcase.go @@ -0,0 +1,114 @@ +// headcase.go 出站请求头**大小写拼写**对齐官方真机。 +// +// 背景:Go 的 net/http 对 header key 做 CanonicalMIMEHeaderKey 归一化 +// (`acp-connection-id` → `Acp-Connection-Id`、`X-B3-ParentSpanId` → +// `X-B3-Parentspanid`),而官方客户端是 Node,wire 上写的是代码里的字面量。 +// 头名集合可以完全一致、值可以完全一致,但逐字节看仍然是两族包。 +// +// 2026-11-01 双版本真机抓包(testdata/official_*_head.txt 逐名提取)确认 +// 官方的拼写是**大小写混合**的,不是全大写也不是全小写: +// +// 小写: x-stainless-*(8 个)、acp-connection-id、x-codebuddy-request、 +// baggage、traceparent、b3 +// 大写: X-Conversation-ID / X-Request-ID / X-IDE-{Type,Name,Version} / +// X-Trace-ID / X-Root-Request-ID / X-B3-{TraceId,ParentSpanId,SpanId} +// +// 所以正确的做法是**逐名映射**,不是无差别小写化——后者会把 User-Agent 打回 +// `Go-http-client/1.1`(见 normalizeHeaderSpelling 的注释)。 +package upstream + +import ( + "net/http" + "strings" +) + +// officialHeaderSpelling 官方出站头的精确拼写(key 一律小写,value 是 wire 上 +// 真实出现的形式)。表内含 45 个真机确认过的头名,是本项目的单一事实来源。 +// +// 只放真机样本里**实际出现过**的名字:X-Enterprise-Id / X-Tenant-Id 这类企业号 +// 才有、个人号抓包里没有的头不在表里,落到 default 分支保持原样(不乱猜)。 +var officialHeaderSpelling = map[string]string{ + // —— 本来就与 Go canonical 一致,列出来是为了钉死(防止被将来谁改成小写) —— + "accept": "Accept", + "accept-encoding": "Accept-Encoding", + "accept-language": "Accept-Language", + "authorization": "Authorization", + "content-encoding": "Content-Encoding", + "content-length": "Content-Length", + "content-type": "Content-Type", + "cookie": "Cookie", + "origin": "Origin", + "referer": "Referer", + "user-agent": "User-Agent", + "x-agent-intent": "X-Agent-Intent", + "x-agent-purpose": "X-Agent-Purpose", + "x-agent-runtime": "X-Agent-Runtime", + "x-agent-type": "X-Agent-Type", + "x-b3-sampled": "X-B3-Sampled", + "x-domain": "X-Domain", + "x-private-data": "X-Private-Data", + "x-product": "X-Product", + "x-requested-with": "X-Requested-With", + "x-user-id": "X-User-Id", + "x-client-platform": "X-Client-Platform", + + // —— 官方全小写(Node 侧字面量就是小写;三个 B3/链路头尤其) —— + "x-stainless-arch": "x-stainless-arch", + "x-stainless-lang": "x-stainless-lang", + "x-stainless-os": "x-stainless-os", + "x-stainless-package-version": "x-stainless-package-version", + "x-stainless-retry-count": "x-stainless-retry-count", + "x-stainless-runtime": "x-stainless-runtime", + "x-stainless-runtime-version": "x-stainless-runtime-version", + "acp-connection-id": "acp-connection-id", + "x-codebuddy-request": "x-codebuddy-request", + "baggage": "baggage", + "traceparent": "traceparent", + "b3": "b3", + + // —— 官方保留大写缩写(Go 会把这些缩写拍成首字母大写,是最明显的 Go 痕迹) —— + "x-conversation-id": "X-Conversation-ID", + "x-conversation-message-id": "X-Conversation-Message-ID", + "x-conversation-request-id": "X-Conversation-Request-ID", + "x-request-id": "X-Request-ID", + "x-root-request-id": "X-Root-Request-ID", + "x-trace-id": "X-Trace-ID", + "x-ide-type": "X-IDE-Type", + "x-ide-name": "X-IDE-Name", + "x-ide-version": "X-IDE-Version", + "x-b3-traceid": "X-B3-TraceId", + "x-b3-parentspanid": "X-B3-ParentSpanId", + "x-b3-spanid": "X-B3-SpanId", +} + +// normalizeHeaderSpelling 返回一个 header 拼写已对齐官方的请求副本。 +// +// 为什么返回副本而不是原地改:调用方与测试常在发请求后回读 req.Header, +// 原地改写会让 `Header.Get("X-Request-ID")` 之类取不到值(Get 会先把查询键 +// canonicalize 成 `X-Request-Id`,而 map 里存的是 `X-Request-ID`)。 +// +// 为什么不用"全部小写化"这一招:Go 的 Request.write 用 **canonical key** 查 +// 六个特判头——User-Agent / Host / Content-Length / Transfer-Encoding / +// Trailer / Accept-Encoding。把它们存成小写会导致: +// - `user-agent` 查不到 → 回落成 `Go-http-client/1.1`,精心对齐的 UA 全废 +// - `content-length` 不被跳过 → 与真实长度重复发送 +// - `accept-encoding` 被判为未设置 → Transport 自己再补一个 gzip +// +// 逐名映射恰好避开全部三个坑:官方那六个的拼写本来就是 canonical 形式, +// 表里写的就是原样值。这也是本方案与"无差别小写"最本质的区别。 +func normalizeHeaderSpelling(req *http.Request) *http.Request { + if req == nil || len(req.Header) == 0 { + return req + } + r2 := req.Clone(req.Context()) + h := make(http.Header, len(req.Header)) + for k, v := range req.Header { + if want, ok := officialHeaderSpelling[strings.ToLower(k)]; ok { + h[want] = v + continue + } + h[k] = v // 表外头(企业号专属等)保持原样,不猜 + } + r2.Header = h + return r2 +} diff --git a/internal/upstream/headcase_test.go b/internal/upstream/headcase_test.go new file mode 100644 index 0000000000000000000000000000000000000000..0b44e11638fe137c13dfc8e245822c24ae93e42c --- /dev/null +++ b/internal/upstream/headcase_test.go @@ -0,0 +1,101 @@ +// headcase_test.go 头名拼写纠正的回归测试与测试辅助。 +// +// 本文件的 headerFold 是给**测试**用的:normalizeHeaderSpelling 把出站头 key +// 换成了官方拼写(`X-Conversation-ID` 而非 Go canonical 的 `X-Conversation-Id`), +// 而 http.Header.Get 会先把查询键 canonicalize 再查 map,于是取不到值。 +// 在自定义 RoundTripper 里读**出站**头的测试必须用它。 +// +// 生产代码没有这个依赖:所有读 req.Header 的地方都在构造阶段(do() 之前), +// 那时 key 还是 canonical 形式。这一点若被将来改动打破,本文件的用例会先红。 +package upstream + +import ( + "net/http" + "net/http/httptest" + "strings" + "testing" +) + +// headerFold 大小写不敏感地取头值(取第一个)。 +func headerFold(h http.Header, key string) string { + for k, v := range h { + if strings.EqualFold(k, key) && len(v) > 0 { + return v[0] + } + } + return "" +} + +// TestNormalizeHeaderSpelling 拼写纠正必须逐名命中真机形式,且不能碰六个 +// Go 特判头(碰了会让 UA 回落 Go-http-client、content-length 重发)。 +func TestNormalizeHeaderSpelling(t *testing.T) { + req := httptest.NewRequest(http.MethodPost, "https://www.workbuddy.cn/v2/chat/completions", nil) + + // 模拟 ChatHeaders 写出来的 canonical key + req.Header.Set("X-Conversation-ID", "c1") + req.Header.Set("X-B3-ParentSpanId", "p1") + req.Header.Set("X-B3-SpanId", "s1") + req.Header.Set("X-B3-TraceId", "t1") + req.Header.Set("Acp-Connection-Id", "a1") + req.Header.Set("Baggage", "b=1") + req.Header.Set("B3", "x-1") + req.Header.Set("Traceparent", "00-x") + req.Header.Set("X-Stainless-Arch", "x64") + req.Header.Set("X-Request-Id", "r1") + req.Header.Set("X-Ide-Version", "5.9.3") + req.Header.Set("X-Trace-Id", "t1") + req.Header.Set("User-Agent", "WorkBuddy/5.9.3 WorkBuddy/5.9.3 CLI/2.165.0") + req.Header.Set("Accept-Encoding", "gzip, compress, deflate, br") + req.Header.Set("X-Enterprise-Id", "ent-1") // 表外,应原样保留 + + got := normalizeHeaderSpelling(req) + + want := map[string]string{ + "X-Conversation-ID": "c1", + "X-B3-ParentSpanId": "p1", + "X-B3-SpanId": "s1", + "X-B3-TraceId": "t1", + "acp-connection-id": "a1", + "baggage": "b=1", + "b3": "x-1", + "traceparent": "00-x", + "x-stainless-arch": "x64", + "X-Request-ID": "r1", + "X-IDE-Version": "5.9.3", + "X-Trace-ID": "t1", + "User-Agent": "WorkBuddy/5.9.3 WorkBuddy/5.9.3 CLI/2.165.0", + "Accept-Encoding": "gzip, compress, deflate, br", + "X-Enterprise-Id": "ent-1", + } + for k, v := range want { + if h, ok := got.Header[k]; !ok { + t.Errorf("缺头 %q(实际 key 集合见下)", k) + } else if len(h) == 0 || h[0] != v { + t.Errorf("%s=%q want %q", k, h, v) + } + } + + // 六个特判头必须仍是 canonical 拼写,否则 net/http 查不到 + for _, k := range []string{"User-Agent", "Accept-Encoding"} { + if _, ok := got.Header[k]; !ok { + t.Errorf("%s 必须保留 canonical 拼写(否则 Transport 行为改变)", k) + } + } + + // 原请求不受影响(调用方/测试还要回读它) + if req.Header.Get("X-Conversation-ID") != "c1" { + t.Error("原 req 的 header 被改写了——normalizeHeaderSpelling 必须返回副本") + } +} + +// TestHeaderFoldFindsOfficialSpelling 确认测试辅助本身能穿透官方拼写。 +func TestHeaderFoldFindsOfficialSpelling(t *testing.T) { + h := http.Header{"X-Conversation-ID": []string{"c9"}} + if got := headerFold(h, "X-Conversation-ID"); got != "c9" { + t.Errorf("headerFold=%q want c9", got) + } + // canonical 查询键(Get 的用法)在官方拼写下取不到——这正是要绕开的行为 + if got := h.Get("X-Conversation-ID"); got != "" { + t.Logf("提示:Go 版本行为变化,Header.Get 已能取到 %q", got) + } +} diff --git a/internal/upstream/headers.go b/internal/upstream/headers.go index 9d99388f109be22843a8369038fd952ded031d82..d2e83bc334c162d796d89e5eaf40145718cbc218 100644 --- a/internal/upstream/headers.go +++ b/internal/upstream/headers.go @@ -1,411 +1,967 @@ -// Package headers 构造三类上游请求头(common / chat / billing / refresh)。 -// 规则来自 docs/api-reference.md §0/§4/§6。 -package upstream - -import ( - "crypto/sha256" - "encoding/hex" - "net/http" - "strings" - - "github.com/linguo2625469/workbuddy2api-panel/internal/auth" - "github.com/linguo2625469/workbuddy2api-panel/internal/session" -) - -const ( - // defaultClientVersion 出站 WorkBuddy 客户端版本段(UA 的 `WorkBuddy/` 与 - // 白名单头组的 X-IDE-Version)。对齐官方 WorkBuddy Desktop 分发包版本(5.5.4)。 - // config upstream.client_version 可覆盖(空 = 内置默认)。 - defaultClientVersion = "5.5.4" - // defaultCliVersion 出站 UA 中 `CLI/` 段版本。对齐官方内置 CLI(2.137.1)。 - // config upstream.cli_version 可覆盖(空 = 内置默认)。 - defaultCliVersion = "2.137.1" - - originRefererCN = "https://www.codebuddy.cn" - originRefererGlobal = "https://www.workbuddy.ai" -) - -// originRefererFor 按账号 realm 返回 Origin/Referer 基础域: -// global → https://www.workbuddy.ai;cn(含全局开关未开)→ https://www.codebuddy.cn。 -func originRefererFor(a *auth.Auth) string { - if a != nil && a.IsGlobal() { - return originRefererGlobal - } - return originRefererCN -} - -// clientVersion 生效的 WorkBuddy 客户端版本:Client.ClientVersion 非空则取之, -// 否则内置默认 defaultClientVersion。 -func (c *Client) clientVersion() string { - if c != nil && c.ClientVersion != "" { - return c.ClientVersion - } - return defaultClientVersion -} - -// cliVersion 生效的 CLI 版本:Client.CliVersion 非空则取之,否则内置默认 defaultCliVersion。 -func (c *Client) cliVersion() string { - if c != nil && c.CliVersion != "" { - return c.CliVersion - } - return defaultCliVersion -} - -// defaultWorkBuddyUAFor 组装默认客户端出站 UA(官方桌面端 RestOperations 层形状): -// `WorkBuddy/ / CLI/`。 -// 平台段(第二段)品牌按 realm 切换——CN 用 applicationName 同值 `WorkBuddy`, -// global 用官方国际版 productName `WorkBuddy AI`(intl 项目逆向证据: -// `WorkBuddy/5.5.2 WorkBuddy AI/5.5.2 CLI/5.5.2`)。 -// global 账号送错平台段(`WorkBuddy` 非 `WorkBuddy AI`)可能触发上游 403 code 11140 -// "request illegal" 风控。官方无任何 UA 随机化,故默认确定性。 -func (c *Client) defaultWorkBuddyUAFor(a *auth.Auth) string { - platform := "WorkBuddy" - if a != nil && a.IsGlobal() { - platform = "WorkBuddy AI" - } - return "WorkBuddy/" + c.clientVersion() + " " + platform + "/" + c.clientVersion() + " CLI/" + c.cliVersion() -} - -// defaultWorkBuddyUA 返回 CN 形态的默认 UA(默认账号形态即 CN,零回归兼容既有调用/测试)。 -func (c *Client) defaultWorkBuddyUA() string { - return c.defaultWorkBuddyUAFor(nil) -} - -// userAgent 返回当前出站 UA(客户端出站路径:chat/refresh/FetchModels)。 -// 优先级:Client.UserAgent(config user_agent)显式覆盖 > 按账号 realm 的默认 WorkBuddy 三段式。 -// 显式覆盖兼容既有覆盖逻辑:用户配了即以用户值为准(自定义品牌/版本), -// 未配则走官方桌面端默认形态(global 换 `WorkBuddy AI` 平台段)。 -func (c *Client) userAgent(a *auth.Auth) string { - if c != nil && c.UserAgent != "" { - return c.UserAgent - } - return c.defaultWorkBuddyUAFor(a) -} - -// billingUA 白名单类(billing/checkin/banner)出站 UA:单段 `WorkBuddy/` -// (官方 banner 显式覆写形态,不带 CLI 段)。默认生效(伪造官方桌面端指纹); -// 显式 client_name="SaaS" 才不设 UA(还原旧行为,Go 默认 UA)。 -func (c *Client) billingUA() string { - if c == nil || c.attributionClientName() == "SaaS" { - return "" - } - return "WorkBuddy/" + c.clientVersion() -} - -// resolveDeviceToken 解析本次请求的 X-Device-Token 取值。 -// 优先级:auth.Auth.DeviceToken(每号)> Client.DeviceToken(config 全局)> 文件兜底。 -// 三者皆空/读失败则返回空串(调用方不注入该头,优雅降级)。 -func (c *Client) resolveDeviceToken(a *auth.Auth) string { - if a != nil && a.DeviceToken != "" { - return a.DeviceToken - } - if c != nil && c.DeviceToken != "" { - return c.DeviceToken - } - if c != nil && c.DeviceTokenFile != "" { - return readDeviceTokenFile(c.DeviceTokenFile) - } - return "" -} - -// injectDeviceToken 在 req 注入 X-Device-Token 头(仅当取到非空 token)。 -func (c *Client) injectDeviceToken(req *http.Request, a *auth.Auth) { - if tok := c.resolveDeviceToken(a); tok != "" { - req.Header.Set("X-Device-Token", tok) - } -} - -// deriveAccountStableID 按 uid + 用途盐稳定派生 36 hex 设备/会话标识。 -// 跨重启稳定(固定盐 "wb2a:",不随进程换——这是与 session 包派生盐的本质差异: -// 那是会话键维度的进程级随机盐,重启换新;本函数是账号维度,必须跨重启恒定)、 -// 账号间互异(uid 不同则不同)、同 uid 同用途恒同值(幂等)。用 sha256 与项目 -// 既有派生(session/ids.go、cache_key.go)保持一致;截 36 hex 提供更长熵。 -// -// 两个用途: -// - purpose="machine" → X-Machine-ID(设备级,跨会话稳定) -// - purpose="session" → X-Session-ID(账号固定会话,跨重启稳定) -// -// 与 injectDeviceToken 的 X-Device-Token 并存不冲突:那是登录时上游签发的 -// 真实设备令牌(有则发,权威);本对头是「每账号一台固定虚拟设备」的稳定指纹, -// 防多号被上游按设备指纹缺失/漂移关联风控。两者是不同头族,官方桌面端都发。 -func deriveAccountStableID(uid, purpose string) string { - sum := sha256.Sum256([]byte("wb2a:" + purpose + ":" + uid)) - return hex.EncodeToString(sum[:18]) // 36 hex chars -} - -// injectAccountStableHeaders 在 req 注入 X-Machine-ID / X-Session-ID:按 uid 稳定 -// 派生,跨重启固定、账号间互异。uid 为空时不注入(匿名请求无设备标识,上游不要求)。 -func (c *Client) injectAccountStableHeaders(req *http.Request, a *auth.Auth) { - if a == nil || a.UID == "" { - return - } - req.Header.Set("X-Machine-ID", deriveAccountStableID(a.UID, "machine")) - req.Header.Set("X-Session-ID", deriveAccountStableID(a.UID, "session")) -} - -// CommonHeaders 设置所有 API 共享的请求头。 -func (c *Client) CommonHeaders(req *http.Request, a *auth.Auth) { - req.Header.Set("Content-Type", "application/json") - // Accept 非流式默认 application/json(D6:去掉宽松的 text/plain, */*)。 - // chat 流式路径在 ChatHeaders 覆盖为 event-stream。 - req.Header.Set("Accept", "application/json") - req.Header.Set("X-Requested-With", "XMLHttpRequest") - origin := originRefererFor(a) - req.Header.Set("Origin", origin) - req.Header.Set("Referer", origin+"/") - req.Header.Set("User-Agent", c.userAgent(a)) - // X-CodeBuddy-Request: 1(官方客户端风控闸门头,所有 API 请求必带,D1)。 - req.Header.Set("X-CodeBuddy-Request", "1") - // Accept-Language 按 realm 切(D5):CN zh-CN,global en-US。官方客户端按账号域 - // 发对应语言标识,对齐避免上游风控按语言缺失误判。 - req.Header.Set("Accept-Language", acceptLanguageFor(a)) - // X-Machine-ID / X-Session-ID:按 uid 稳定派生的账号级设备头(见 - // injectAccountStableHeaders)。注入在 CommonHeaders——chat 经 ChatHeaders - // 叠加 CommonHeaders 天然继承;billing 域另行注入,全出站覆盖。 - c.injectAccountStableHeaders(req, a) -} - -// acceptLanguageFor 按账号 realm 返回 Accept-Language:global → en-US,cn → zh-CN。 -func acceptLanguageFor(a *auth.Auth) string { - if a != nil && a.IsGlobal() { - return "en-US" - } - return "zh-CN" -} - -// injectCodeBuddyRequest 在 req 注入 X-CodeBuddy-Request: 1。 -// billing 域未走 CommonHeaders,单独注入保证全出站覆盖(D1)。 -func (c *Client) injectCodeBuddyRequest(req *http.Request) { - req.Header.Set("X-CodeBuddy-Request", "1") -} - -// ChatMeta 一次 chat 出站的会话头族元数据(issue #35:后台按 X-Conversation-Request-ID -// 聚合请求,官方客户端一次 user send 内所有 tool call/重试/换号复用同一个 ID)。 -// handler 在轮转循环外生成 conversationID / conversationRequestID,循环内每次出站 -// 复用同值;TraceID 透传入站值(空 = 回落 conversationRequestID)。 -// messageID(消息级,每条独立)由 ChatHeaders 内部生成,无需外部可见。 -type ChatMeta struct { - ConversationID string // X-Conversation-ID:body 提取的入站值,空则不发(透传优先,不伪造) - ConversationRequestID string // X-Conversation-Request-ID / X-Root-Request-ID:聚合主键,必发 - TraceID string // X-Trace-ID:入站透传值,空则回落 conversationRequestID -} - -// ChatHeaders 在 common 之上加 chat 专属的账号头。 -// 缺省字段用 X-No-* 约定(与 CodeBuddy 官方 CLI 一致)。 -// clientIP 为本次请求的客户端 IP(按参数传递,不读共享字段——避免并发串扰); -// PassthroughIP=false 或 clientIP 为空时不注入 IP 头。 -// meta 为会话头族元数据(纯新增,不改既有头),见 injectConversationHeaders。 -func (c *Client) ChatHeaders(req *http.Request, a *auth.Auth, clientIP string, meta ChatMeta) { - c.CommonHeaders(req, a) - // chat 流式 Accept 覆盖 CommonHeaders 的非流式默认(D6)。 - req.Header.Set("Accept", "application/json, text/event-stream") - // AccessToken 加锁快照:keepalive 定时刷新会在 a.mu 内改写它,锁外直读构成数据竞争 - // (见 auth.AccessTokenValue 注释)。 - if at := a.AccessTokenValue(); at != "" { - req.Header.Set("Authorization", "Bearer "+at) - } else { - req.Header.Set("X-No-Authorization", "1") - } - if a.UID != "" { - req.Header.Set("X-User-Id", a.UID) - } else { - req.Header.Set("X-No-User-Id", "1") - } - // 安全红线:绝不在 chat 请求里携带 X-Refresh-Token。 - // 企业与域头按 realm 分发:CN 走既有分支(EnterpriseID/Domain 原样透传,缺省 X-No-*); - // global 账号由 injectGlobalChatHeaders 统一覆写为国际客户端形态 - // (X-No-Enterprise-Id=1 声明无企业 + X-Domain=www.workbuddy.ai 声明国际版域), - // 且不回退 X-Domain 到登录会话原值——对齐 intl 项目出站头。 - if a != nil && !a.IsGlobal() { - if a.EnterpriseID != "" { - req.Header.Set("X-Enterprise-Id", a.EnterpriseID) - } else { - req.Header.Set("X-No-Enterprise-Id", "1") - } - if d := a.DomainValue(); d != "" { - req.Header.Set("X-Domain", d) - } else { - req.Header.Set("X-No-Department-Info", "1") - } - } else { - c.injectGlobalChatHeaders(req, a) - } - // 用量归属头:默认伪造 WorkBuddy 桌面端指纹(client_name="SaaS" 还原旧行为)。 - c.injectAttribution(req) - // 客户端 IP 透传(仅 PassthroughIP=true 且本次请求带 IP)。 - c.injectClientIP(req, clientIP) - // 设备风控头:auth 每号 > config 全局 > 文件兜底;空则不注入。 - c.injectDeviceToken(req, a) - // 会话头族(对话/请求/消息/B3 链路),见 injectConversationHeaders。 - c.injectConversationHeaders(req, meta) -} - -// injectGlobalChatHeaders global 账号(无企业 ID)的 chat 专属声明头,对齐 intl 项目 -// (ANALYSIS-global-chat-solutions.md): -// - X-No-Enterprise-Id: 1 个人账号无企业 ID,显式声明(避免上游按缺省/可疑判定) -// - X-Domain: www.workbuddy.ai 显式声明国际版域(与 Origin/Referer 同域) -// -// 仅 global realm 注入;CN 账号走既有 X-No-Department-Info 等分支,零回归。 -func (c *Client) injectGlobalChatHeaders(req *http.Request, a *auth.Auth) { - if a == nil || !a.IsGlobal() { - return - } - req.Header.Set("X-No-Enterprise-Id", "1") - req.Header.Set("X-Domain", "www.workbuddy.ai") -} - -// injectConversationHeaders 注入官方客户端会话头族(issue #35 后台聚合)。 -// 头族分四层,各司其职: -// - X-Conversation-ID:会话级,多轮稳定(body 的 conversationId)。空则不发—— -// 透传客户端原值优先,客户端没给就不伪造,避免误导后台建错会话。 -// - X-Conversation-Request-ID:**对话轮级聚合主键**,必发。一次 user send 内的 -// 所有 tool call/重试/换号/降级复用同一个 → 后台按它聚合成一条(不再碎片化)。 -// - X-Conversation-Message-ID = X-Request-ID:消息级,每条独立(32 位 hex)。 -// - X-Root-Request-ID:= conversationRequestID(根请求追踪)。 -// - X-Trace-ID:入站透传或 = conversationRequestID。 -// - X-B3-TraceId / X-B3-SpanId / X-B3-Sampled:链路族。B3 规范只认 16/32 hex -// TraceId 与 16 hex SpanId;入站 conversationRequestID 非法时 TraceId 回落 -// messageID(恒 32 hex),SpanId 取 messageID[:16](每消息新)。 -func (c *Client) injectConversationHeaders(req *http.Request, meta ChatMeta) { - convReqID := meta.ConversationRequestID - if convReqID == "" { - // 零值 meta(直接调 ChatHeaders 的调用方/测试)也要保证聚合主键必发: - // 本级补一个 32 hex,调用方(handler)已生成稳定的不走到这里。 - convReqID = session.NewMessageID() - } - messageID := session.NewMessageID() - if meta.ConversationID != "" { - req.Header.Set("X-Conversation-ID", meta.ConversationID) - } - req.Header.Set("X-Conversation-Request-ID", convReqID) - req.Header.Set("X-Conversation-Message-ID", messageID) - req.Header.Set("X-Request-ID", messageID) - req.Header.Set("X-Root-Request-ID", convReqID) - traceID := meta.TraceID - if traceID == "" { - traceID = convReqID - } - req.Header.Set("X-Trace-ID", traceID) - b3Trace := convReqID - if !validTraceID(b3Trace) { - b3Trace = messageID // 非法 B3 TraceId → 回落恒 32 hex 的消息级 ID - } - req.Header.Set("X-B3-TraceId", b3Trace) - req.Header.Set("X-B3-SpanId", messageID[:16]) - req.Header.Set("X-B3-Sampled", "1") -} - -// validTraceID 判断 B3 TraceId 是否合法:16 或 32 位 hex(大小写均可)。 -// 官方客户端生成的 conversationRequestId 是 32 位 hex(UUID 去横线),入站透传值 -// 可能是任意形状(含横线/超长/非 hex),直接塞进 B3 头会破坏链路关联(issue #35)。 -func validTraceID(s string) bool { - if len(s) != 16 && len(s) != 32 { - return false - } - for i := 0; i < len(s); i++ { - ch := s[i] - if !((ch >= '0' && ch <= '9') || (ch >= 'a' && ch <= 'f') || (ch >= 'A' && ch <= 'F')) { - return false - } - } - return true -} - -// attributionClientName 生效的用量归属名:ClientName 非空取之; -// 空默认 "WorkBuddy"(伪造官方桌面端指纹;显式配 "SaaS" 可还原旧行为)。 -func (c *Client) attributionClientName() string { - if c != nil && c.ClientName != "" { - return c.ClientName - } - return "WorkBuddy" -} - -// injectAttribution 注入用量归属头(X-Agent-Purpose / X-IDE-* / X-Product)。 -// 仅在 chat/completions 路径生效(ChatHeaders 调用)。 -// -// 默认(ClientName 空)即对齐官方 WorkBuddy 桌面端指纹:X-Agent-Purpose="conversation" -// + X-IDE-Name/Type/Product="WorkBuddy" + X-IDE-Version=client_version,上游用量归因 -// 不再出现 client/agentPurpose 为空的「网关特征」。显式 ClientName="SaaS" 还原旧行为 -// (仅 X-Product="SaaS",不设 X-IDE-*);配其他值则四头跟随该值。 -func (c *Client) injectAttribution(req *http.Request) { - name := c.attributionClientName() - if name == "SaaS" { - req.Header.Set("X-Product", "SaaS") - return - } - req.Header.Set("X-Agent-Purpose", "conversation") - req.Header.Set("X-IDE-Name", name) - req.Header.Set("X-IDE-Type", name) - req.Header.Set("X-IDE-Version", c.clientVersion()) - req.Header.Set("X-Product", name) -} - -// injectClientIP 在 PassthroughIP 开启时把 clientIP 参数透传给上游(三等价头)。 -func (c *Client) injectClientIP(req *http.Request, clientIP string) { - if c == nil || !c.PassthroughIP || clientIP == "" { - return - } - req.Header.Set("X-Forwarded-For", clientIP) - req.Header.Set("X-Real-IP", clientIP) - req.Header.Set("X-Client-IP", clientIP) -} - -// ExtractClientIP 从入站请求提取客户端 IP 首段(X-Forwarded-For 首段,回落 X-Real-IP)。 -func ExtractClientIP(r *http.Request) string { - if r == nil { - return "" - } - if xff := r.Header.Get("X-Forwarded-For"); xff != "" { - for i := 0; i < len(xff); i++ { - if xff[i] == ',' { - return strings.TrimSpace(xff[:i]) - } - } - return strings.TrimSpace(xff) - } - if real := strings.TrimSpace(r.Header.Get("X-Real-IP")); real != "" { - return real - } - return "" -} - -// BillingHeaders billing 接口请求头。 -// UA 语义:默认**不设置**(保持现状,Go 客户端自带默认 UA);仅当显式配置 -// c.UserAgent 非空才覆盖——避免默认路径给 billing 引入新的 UA 指纹。 -func (c *Client) BillingHeaders(req *http.Request, a *auth.Auth) { - // AccessToken 加锁快照(同 ChatHeaders:keepalive 可在 a.mu 内改写)。 - req.Header.Set("Authorization", "Bearer "+a.AccessTokenValue()) - req.Header.Set("Accept", "application/json") - req.Header.Set("Content-Type", "application/json") - c.injectCodeBuddyRequest(req) - // Accept-Language 按 realm 切(D5,billing 域未走 CommonHeaders,单独注入)。 - req.Header.Set("Accept-Language", acceptLanguageFor(a)) - if c != nil && c.UserAgent != "" { - req.Header.Set("User-Agent", c.UserAgent) - } else if ua := c.billingUA(); ua != "" { - req.Header.Set("User-Agent", ua) - } - if a.UID != "" { - req.Header.Set("X-User-Id", a.UID) - } - if a.EnterpriseID != "" { - req.Header.Set("X-Enterprise-Id", a.EnterpriseID) - req.Header.Set("X-Tenant-Id", a.EnterpriseID) - } - if d := a.DomainValue(); d != "" { - req.Header.Set("X-Domain", d) - } - // 设备风控头:billing 域(report/travel/balance/checkin)同样注入。 - c.injectDeviceToken(req, a) -} - -// RefreshHeaders refresh 端点专属头(X-Refresh-Token 只允许出现在这里)。 -func (c *Client) RefreshHeaders(req *http.Request, a *auth.Auth) { - c.CommonHeaders(req, a) - req.Header.Set("X-Refresh-Token", a.RefreshToken) - if a.EnterpriseID != "" { - req.Header.Set("X-Enterprise-Id", a.EnterpriseID) - } - // X-Auth-Refresh-Source 对齐官方客户端 refresh 渠道标识 "plugin"(D3)。 - req.Header.Set("X-Auth-Refresh-Source", "plugin") -} +// Package headers 构造三类上游请求头(common / chat / billing / refresh)。 +// 规则来自 docs/api-reference.md §0/§4/§6。 +package upstream + +import ( + "crypto/sha256" + "encoding/base64" + "encoding/hex" + "encoding/json" + "net/http" + "strings" + + "github.com/misakano7545/workbuddy2api-panel/internal/auth" + "github.com/misakano7545/workbuddy2api-panel/internal/session" +) + +const ( + // defaultClientVersionCN / defaultClientVersionGlobal 出站 WorkBuddy 客户端版本段 + // (UA 的 `/` 与白名单头组的 X-IDE-Version)。 + // + // 取值来源:官方分发包 resources/install-manifest.json(appVersion)+ cli/product.json + // (genieVersion)。 + // + // 国内版 WorkBuddy 5.9.3(endpoint www.workbuddy.cn,DefaultModelOptimizationOff=false) + // 国际版 WorkBuddy AI 5.9.4(endpoint www.workbuddy.ai,isOversea=true) + // + // 5.9.4 国际版取值证据(2026-10-30 拆包 + 真机抓包): + // - app.asar/package.json version / cli/product.json genieVersion = 5.9.4 + // - 真机 /v2/chat/completions UA = `WorkBuddy/5.9.4 workbuddy-ai/5.9.4 CLI/2.165.0` + // - 真机 X-IDE-Version: 5.9.4,/v3/config UA = `WorkBuddy/5.9.4 CLI/2.165.0` + // + // config upstream.client_version 可覆盖(空 = 按 realm 取内置默认)。 + defaultClientVersionCN = "5.9.3" + defaultClientVersionGlobal = "5.9.4" + // defaultCliVersion 出站 UA 中 `CLI/` 段版本。对齐官方内置 CLI **2.165.0** + // (cli/package.json 的 @genie/agent-cli version;5.9.3 真机 UA 实测同值)。 + // config upstream.cli_version 可覆盖。 + defaultCliVersion = "2.165.0" + + // originRefererCN / originRefererGlobal 只给**web 层**(渲染器/登录页那类浏览器语义 + // 的请求)用,RPC 层不发(见 CommonHeaders 注释)。 + // + // 2026-10-28 修正:CN 侧旧值 `https://www.codebuddy.cn` 是 CodeBuddy CLI 时代的遗留。 + // 5.9.3 桌面端真机全量扫描(661 条带 Origin/Referer 的请求)里,**没有一条**把 + // codebuddy.cn 当 Origin——一律是 `https://www.workbuddy.cn`(/console/auth/risk-context、 + // /billing/ide/trial、/billing/pay/get-order-list、/v2/report(web) 等)。 + // codebuddy.cn 只是 billing 的 **API 主机名**(BillingBaseCN),从不当 Origin。 + originRefererCN = "https://www.workbuddy.cn" + originRefererGlobal = "https://www.workbuddy.ai" +) + +// originRefererFor 按账号 realm 返回 Origin/Referer 基础域(**仅 web 层使用**): +// global → https://www.workbuddy.ai;cn(含全局开关未开)→ https://www.workbuddy.cn。 +func originRefererFor(a *auth.Auth) string { + if a != nil && a.IsGlobal() { + return originRefererGlobal + } + return originRefererCN +} + +// clientVersion 生效的 WorkBuddy 客户端版本:Client.ClientVersion 非空则取之, +// 否则按 realm 取内置默认(CN 5.8.3 / global 5.8.4)。 +func (c *Client) clientVersion(a *auth.Auth) string { + if c != nil && c.ClientVersion != "" { + return c.ClientVersion + } + if a != nil && a.IsGlobal() { + return defaultClientVersionGlobal + } + return defaultClientVersionCN +} + +// cliVersion 生效的 CLI 版本:Client.CliVersion 非空则取之,否则内置默认 defaultCliVersion。 +func (c *Client) cliVersion() string { + if c != nil && c.CliVersion != "" { + return c.CliVersion + } + return defaultCliVersion +} + +// defaultWorkBuddyUAFor 组装默认客户端出站 UA(官方 `buildUserAgent` 形态): +// `WorkBuddy/ / CLI/` +// +// 首段**恒为驼峰 `WorkBuddy`**,只有第二段随 realm 换品牌: +// +// CN 5.9.3 → WorkBuddy/5.9.3 WorkBuddy/5.9.3 CLI/2.165.0 +// global 5.8.4 → WorkBuddy/5.8.4 workbuddy-ai/5.8.4 CLI/2.165.0 +// +// 2026-10-28 国内版 **5.9.3** 真机抓包复核(/v2/chat/completions ×7)实测仍是上式, +// 客户端与 CLI 版本段同步升到 5.9.3 / 2.165.0。 +// +// 2026-10-21 国际版 5.8.4 GUI 真机抓包(/v2/chat/completions,主对话 + 标题生成 +// 两条)实测即为上式:官方 chat 走 OpenAI SDK(请求带 x-stainless-* 头),SDK 的 +// buildUserAgent 把首段固定成 productName 的驼峰形式 `WorkBuddy/`,第二段才用 +// 打包期改写后的 slug `workbuddy-ai/`。 +// +// 旧实现把首段也写成 realm 品牌(global → `workbuddy-ai/5.8.4 workbuddy-ai/5.8.4`), +// 与真机不符——那是 /v2/report、/v3/config 这类非 SDK 请求的形态,chat 链路从不用它。 +// global 账号整体送错品牌段可能触发上游 403 code 11140 "request illegal" 风控。 +// 官方无任何 UA 随机化,故默认确定性。 +func (c *Client) defaultWorkBuddyUAFor(a *auth.Auth) string { + ver := c.clientVersion(a) + return "WorkBuddy/" + ver + " " + uaBrandFor(a) + "/" + ver + " CLI/" + c.cliVersion() +} + +// uaBrandFor 出站 UA 的**第二段**品牌:按 realm 取,两版形态不同(不同分发包)。 +// +// 2026-10-20 真机双版本抓包实测(同一台机器、同一套代理): +// - 国内版 5.8.3(productName `WorkBuddy`)→ `WorkBuddy/5.8.3`,**驼峰原样**, +// 业务链路 28 个路径全部如此; +// - 国际版 5.8.4(productName `WorkBuddy AI`)→ `workbuddy-ai/5.8.4`,**小写连字符 +// slug**,业务链路 22 个路径全部如此。 +// +// 为什么两版规则不同:brand 段来自 buildUserAgent() 的 applicationName/productName, +// 而 applicationName 在打包期被改写。CN 包直接沿用驼峰 productName;GL 包走了 +// Electron 的 userAgentFallback 替换路径(asciiSlug:非字母数字换成 `-` 并转小写), +// 于是 `WorkBuddy AI` → `workbuddy-ai`。 +// +// 反例警示:曾把 CN 也写成小写 `workbuddy`(按 GL 规则统一),与实测不符——CN 的 +// 每个业务请求都是驼峰,写成 slug 反而成了最明显的非官方指纹。 +func uaBrandFor(a *auth.Auth) string { + if a != nil && a.IsGlobal() { + return "workbuddy-ai" + } + return "WorkBuddy" +} + +// defaultWorkBuddyUA 返回 CN 形态的默认 UA(默认账号形态即 CN,零回归兼容既有调用/测试)。 +func (c *Client) defaultWorkBuddyUA() string { + return c.defaultWorkBuddyUAFor(nil) +} + +// v3ProbeUA /v3/config 目录探测的官方 UA(真机实测形态)。 +// +// 2026-10-30 双版本真机抓包(国际 5.9.4 / 国内 5.9.3)**两版同一形态**: +// +// CN 5.9.3 → WorkBuddy/5.9.3 CLI/2.165.0 +// global 5.9.4 → WorkBuddy/5.9.4 CLI/2.165.0 +// +// 都是两段、单品牌。旧实现在 CN 下发三段重复品牌(`WorkBuddy/ WorkBuddy/ +// CLI/`),依据是 5.8.3 时代的抓包——那条结论在 5.9.3 上已不成立:同一账号 +// 同一 token 用三段 / 两段分别打 /v3/config,返回**逐字节相同**的 64866 字节 +// (61 个模型、agents=cli/16),UA 家族对该端点已不再区分模型集合。 +// +// 历史反例(保留警示):更早的 `CodeBuddyIDE/4.12.0 CodeBuddy/4.12.0` 与 +// `CLI/2.63.2 CodeBuddy/2.63.2` 是从旧版 IDE 客户端抄的,WorkBuddy 分发包里 +// 根本不存在这两个串,属于最显眼的非官方指纹。 +func (c *Client) v3ProbeUA(a *auth.Auth) string { + return c.v3ProbeUALite(a) +} + +// v3ProbeUALite /v3/config 第二路探测 UA:单品牌两段式(= 真机唯一形态)。 +// +// 保留双路探测只是为了让 global 的既有「取并集」调用链零改动(两路同串时并集 +// 退化为重复请求,无害)。**不要**据此认为存在「按 UA 分族的第三族模型」: +// 2026-10-30 实测国内 5.9.3 两族返回完全相同,global 侧两路本来就同串。 +func (c *Client) v3ProbeUALite(a *auth.Auth) string { + return "WorkBuddy/" + c.clientVersion(a) + " CLI/" + c.cliVersion() +} + +// rpcUAFor 桌面端 **RPC/REST 层**出站 UA(不是 chat 那条 SDK 链)。 +// +// 2026-10-30 双版本真机抓包(同一台机器、同一会话)实测两族并存: +// +// chat → WorkBuddy/ / CLI/ (SDK buildUserAgent,首段恒驼峰) +// RPC → / / CLI/ (首段即品牌 slug) +// +// RPC 族覆盖 /v2/report、/v2/chat/busy、/console/as/*、/v2/plugin/auth/token/refresh、 +// /v2/as/scheduler/tasks、/v2/user-asset/*、/portal/*: +// +// CN 5.9.3 → WorkBuddy/5.9.3 WorkBuddy/5.9.3 CLI/2.165.0 +// global 5.9.4 → workbuddy-ai/5.9.4 workbuddy-ai/5.9.4 CLI/2.165.0 +// +// CN 下与 userAgent() 同值(品牌段本来就是驼峰),只有 global 会分叉——旧实现让 +// global 的 RPC 请求也发 `WorkBuddy/…` 首段,与真机不符。 +func (c *Client) rpcUAFor(a *auth.Auth) string { + if c != nil && c.UserAgent != "" { + return c.UserAgent + } + ver := c.clientVersion(a) + brand := uaBrandFor(a) + return brand + "/" + ver + " " + brand + "/" + ver + " CLI/" + c.cliVersion() +} + +// userAgent 返回当前出站 UA(客户端出站路径:chat/refresh/FetchModels)。 +// 优先级:Client.UserAgent(config user_agent)显式覆盖 > 按账号 realm 的默认 WorkBuddy 三段式。 +// 显式覆盖兼容既有覆盖逻辑:用户配了即以用户值为准(自定义品牌/版本), +// 未配则走官方桌面端默认形态(global 换 `WorkBuddy AI` 平台段)。 +func (c *Client) userAgent(a *auth.Auth) string { + if c != nil && c.UserAgent != "" { + return c.UserAgent + } + return c.defaultWorkBuddyUAFor(a) +} + +// billingUA 白名单类(billing/checkin/banner)出站 UA:**恒为 axios 默认串**。 +// +// 2026-10-20 双版本真机抓包实测:两版 billing 层(summary / paid-packages / +// free-packages / checkin-activity-status / ambassador status)发的都是 +// `axios/1.16.1`,与客户端自身 UA 完全不同——billing 域的 RestOperations 走 +// axios 实例而非 SDK 客户端,所以不带任何品牌段。 +// +// 此前 CN 侧发 `WorkBuddy/`:那是「按客户端 UA 推理」的产物,实测不符。 +// 显式 client_name="SaaS" 时仍不设 UA(保留既有逃生开关,还原 Go 默认 UA)。 +func (c *Client) billingUA(a *auth.Auth) string { + if c == nil || c.attributionClientName() == "SaaS" { + return "" + } + return "axios/1.16.1" +} + +// resolveDeviceToken 解析本次请求的 X-Device-Token 取值。 +// 优先级:auth.Auth.DeviceToken(每号)> Client.DeviceToken(config 全局)> 文件兜底。 +// 三者皆空/读失败则返回空串(调用方不注入该头,优雅降级)。 +func (c *Client) resolveDeviceToken(a *auth.Auth) string { + if a != nil && a.DeviceToken != "" { + return a.DeviceToken + } + if c != nil && c.DeviceToken != "" { + return c.DeviceToken + } + if c != nil && c.DeviceTokenFile != "" { + return readDeviceTokenFile(c.DeviceTokenFile) + } + return "" +} + +// injectDeviceToken 在 req 注入 X-Device-Token 头(仅当取到非空 token)。 +func (c *Client) injectDeviceToken(req *http.Request, a *auth.Auth) { + if tok := c.resolveDeviceToken(a); tok != "" { + req.Header.Set("X-Device-Token", tok) + } +} + +// deriveAccountStableID 按 uid + 用途盐稳定派生 36 hex 设备/会话标识。 +// 跨重启稳定(固定盐 "wb2a:",不随进程换——这是与 session 包派生盐的本质差异: +// 那是会话键维度的进程级随机盐,重启换新;本函数是账号维度,必须跨重启恒定)、 +// 账号间互异(uid 不同则不同)、同 uid 同用途恒同值(幂等)。用 sha256 与项目 +// 既有派生(session/ids.go、cache_key.go)保持一致;截 36 hex 提供更长熵。 +// +// 两个用途: +// - purpose="machine" → X-Machine-ID(设备级,跨会话稳定) +// - purpose="session" → X-Session-ID(账号固定会话,跨重启稳定) +// +// 与 injectDeviceToken 的 X-Device-Token 并存不冲突:那是登录时上游签发的 +// 真实设备令牌(有则发,权威);本对头是「每账号一台固定虚拟设备」的稳定指纹, +// 防多号被上游按设备指纹缺失/漂移关联风控。两者是不同头族,官方桌面端都发。 +func deriveAccountStableID(uid, purpose string) string { + sum := sha256.Sum256([]byte("wb2a:" + purpose + ":" + uid)) + return hex.EncodeToString(sum[:18]) // 36 hex chars +} + +// injectAccountStableHeaders 在 req 注入 X-Machine-ID / X-Session-ID:按 uid 稳定 +// 派生,跨重启固定、账号间互异。uid 为空时不注入(匿名请求无设备标识,上游不要求)。 +func (c *Client) injectAccountStableHeaders(req *http.Request, a *auth.Auth) { + if a == nil || a.UID == "" { + return + } + req.Header.Set("X-Machine-ID", deriveAccountStableID(a.UID, "machine")) + req.Header.Set("X-Session-ID", deriveAccountStableID(a.UID, "session")) +} + +// CommonHeaders 设置所有 API 共享的请求头。 +func (c *Client) CommonHeaders(req *http.Request, a *auth.Auth) { + req.Header.Set("Content-Type", "application/json") + // Accept:RPC/REST 层真机恒发宽松值 `application/json, text/plain, */*` + // (2026-10-30 双版本实测:/v2/report、/v2/chat/busy、/console/as/*、 + // /v2/plugin/auth/token/refresh、/v2/user-asset/*、/portal/* 全部同值)。 + // chat 那条链只发 `application/json`,由 ChatHeaders 收窄覆盖。 + req.Header.Set("Accept", "application/json, text/plain, */*") + // X-Requested-With:**RPC/REST 层不发**。 + // + // 2026-10-30 双版本全量扫描(1182 条 flow,125 条路径)按 UA 族切开后形态是干净的: + // + // UA workbuddy-ai/… → 无 XRW(30/30) ← RPC 层(node fetch) + // UA WorkBuddy/ WorkBuddy/ CLI/… → 无 XRW(26/26) ← CN 的 RPC 层 + // UA WorkBuddy/ / CLI/… → 有 XRW(10/10) ← 渲染器侧另一条链 + // + // 即「带不带 XRW」由**哪条代码路径发的**决定,不是按 realm 切。本函数服务的是 + // RPC 层(refresh / report / busy / console-as / user-asset / portal), + // 恒不带。chat 那条(SDK 链)**带**,由 ChatHeaders 自己补。 + req.Header.Set("X-Product", "SaaS") + // Accept-Encoding:**与真机完全一致的四段声明**(夹具 + // testdata/official_chat_head.txt / official_report_cn_head.txt 逐字节确认, + // chat / report / busy / refresh 全链路同值 `gzip, compress, deflate, br`)。 + // + // 代价:显式声明会关闭 net/http 的透明解压,所以 RPC 链路的响应体必须由 + // doJSON → decodeResponseBody 自己解 gzip/deflate/br。漏了那一步所有 + // JSON 接口都会解析失败——这两处是一个整体,不能只改一头。 + // + // chat 链路例外:ChatHeaders 会把这个头 Del 掉,交回 net/http 自动 gzip + // (SSE 长流的解压改造风险太大,见那边的注释)。 + req.Header.Set("Accept-Encoding", "gzip, compress, deflate, br") + // Origin / Referer:**不发**。桌面端 RPC 层(refresh / v3-config / chat / busy / + // report)是 node fetch 调用,没有浏览器同源语义,5.9.3 真机这些路径一律不带这两个头 + // (refresh idx 556、/v3/config idx 558 逐头确认)。旧实现在 CommonHeaders 里塞 + // Origin+Referer,等于给每个 RPC 请求盖一个浏览器痕迹——反而不是客户端形态。 + // 需要浏览器语义的调用方(登录页 / web 层)自行设置 originRefererFor。 + req.Header.Set("User-Agent", c.rpcUAFor(a)) + // X-CodeBuddy-Request:**只有 chat 带**(见 ChatHeaders)。5.9.3 真机全量扫描—— + // 7 条 /v2/chat/completions 全带(`x-codebuddy-request: 1`),而 busy / report / + // refresh / v3-config / billing 等 30+ 条业务路径**一条都没有**。旧实现把它放在 + // CommonHeaders 里"全出站覆盖",等于给 refresh 等轻请求多发一个客户端从不发的头。 + // (CLI 文档说「所有 API 请求必须携带」是 CLI 自身网关的口径,桌面端并非如此。) + // + // Accept-Language:客户端 RPC 层同样不发(refresh / v3-config / busy / report / + // chat 逐条确认均无该头)。浏览器语义的 web 层才由 Chromium 自动带。 + // X-Machine-ID / X-Session-ID 已移除(2026-10-28,5.9.3 真机 + 静态反编译双重确认): + // 客户端**从不发这两个头**——app.asar(main/ + renderer/)与内置 cli/dist 全量字符串 + // 里 `X-Machine-ID` 命中 0 次,`X-Session-ID` 只作为常量表条目存在、从不出现在出站 + // 头里;真机 /v2/chat/completions 的 40 个出站头逐一比对也没有它们。设备标识是放在 + // /v2/report 的 **body** 里(machineId / sessionId 字段),不是头。旧实现按 uid 派生 + // 两个 36 hex 塞进头里,是纯粹的网关自造指纹。 +} + +// acceptLanguageFor 返回 Accept-Language。 +// +// 2026-10-28 更新:**出站已不再调用本函数**。5.9.3 真机确认桌面端 RPC 层(chat / +// refresh / v3-config / busy / report / billing)全部不发 Accept-Language—— +// 只有浏览器语义的 web 层才由 Chromium 自动带。保留函数是因为仍有测试钉住 +// 「两域同值」这条历史结论,且将来若要给 web 层补这个头可直接复用。 +// +// 2026-10-20 双版本真机抓包实测:这个头**不按账号域切**,而是跟随操作系统区域。 +// 同一台中文系统机器上,CN 与 GL 的表现一致:多数请求根本不带该头(CN 128 条里 +// 71 条无、GL 218 条里 80 条无),显式带上时以 `zh`(billing 层固定)与 +// `zh-CN`(Chromium 渲染层)为主,`en-US` 只在 GL 出现 1 次。 +// +// 旧实现「global → en-US」是按账号域臆测的,实测不成立(曾据此把国际版所有请求 +// 都打成 en-US,反而成了与真机不符的指纹)。网关没有操作系统区域可言,统一取 +// billing 层实测的 `zh`,两端同值。 +func acceptLanguageFor(a *auth.Auth) string { + return "zh" +} + +// injectIdentityHeaders 注入官方客户端的身份头族(X-Auth-Method / X-Id-Source / +// X-Userinfo)。三个头都是**按账号形态条件发送**,不是常量——官方客户端的 +// runIdentityHeaders()(cli 5.8.4 模块 30876 反编译)等价于: +// +// 有 uid → X-User-Id = uid +// 有 enterpriseId → X-Enterprise-Id = enterpriseId +// 有 auth.method → X-Auth-Method = method(= JWT 的 token_source 声明) +// 有 idSource → X-Id-Source = idSource +// 有 uid 且 (enterpriseId 或 idSource 或 method 任一存在) → +// X-Userinfo = base64(JSON{uin, owner_uin?, id_source?, token_source?}) +// +// X-Userinfo 的三段都是**条件拼接**:缺哪个字段就不出现在 JSON 里,而不是写空串。 +// 个人号三个维度全缺——实测国际版个人账号的出站头里这三头都不存在,故本函数对纯 +// 个人号零注入。这不是省略,是与客户端一致:凭「个人号也该有 X-Userinfo」去补空值 +// 反而是伪造指纹,比不发更容易被识别。 +// +// uin 段取 uid(不是账号的 uin 数字串):反编译逻辑写的就是 {uin: n.uid}。 +// +// 2026-10-22 补充(issue #51):**个人号即使 token 带 token_source 也不发**。 +// 起因是 `login.sh` 的设备流拿到的 CN token 声明里有 `token_source: "enterprise_switch"`, +// 旧逻辑据此给个人号注入了 `X-Auth-Method: enterprise_switch` + `X-Userinfo`, +// 而国际版 5.8.4 与国内版 5.8.3 真机实测的个人号**两个头都不发** +// (capture/raw3/001-chat.json、capture/raw8/002-chat.json)。 +// `token_source` 描述的是 token 的来路(企业切换),不是账号身份;个人号的 +// `enterprise_id` 为空,本就不存在「企业」这层语义。判定只看 EnterpriseID。 +func (c *Client) injectIdentityHeaders(req *http.Request, a *auth.Auth) { + if a == nil || a.UID == "" { + return + } + enterprise := strings.TrimSpace(a.EnterpriseID) + method := a.TokenSource() + idSource := a.IdSource() + // 2026-10-28 补(issue #35 后续):X-Id-Source 是**独立于企业态**的身份维度。 + // 反编译的 runIdentityHeaders() 里 enterpriseId 与 idSource 各自触发各自的头: + // 有 idSource 就发 X-Id-Source,X-Userinfo 里也带 id_source 段。旧实现只要 + // EnterpriseID 为空就整函数 return,带 id_source 声明的个人号因此漏发该头、 + // X-Userinfo 也少一段——与真机形态对不上。 + if idSource != "" { + req.Header.Set("X-Id-Source", idSource) + } + // 个人号且无身份来源:与官方客户端一致,三头全不发(**不看** token_source, + // 见下方 2026-10-22 补注)。 + if enterprise == "" && idSource == "" { + return + } + if enterprise != "" && method != "" { + req.Header.Set("X-Auth-Method", method) + } + // X-Userinfo 的每段都是**条件拼接**:缺哪个维度就不出现该键,而不是写空串。 + payload := map[string]any{"uin": a.UID} + if enterprise != "" { + payload["owner_uin"] = enterprise + } + if idSource != "" { + payload["id_source"] = idSource + } + // token_source 只在企业态下才进 X-Userinfo:个人号那一条是 token 的来路声明, + // 不是身份语义(issue #51,两版真机个人号都没有该段)。 + if enterprise != "" && method != "" { + payload["token_source"] = method + } + raw, err := json.Marshal(payload) + if err != nil { + return + } + req.Header.Set("X-Userinfo", base64.StdEncoding.EncodeToString(raw)) +} + +// injectCodeBuddyRequest 在 req 注入 X-CodeBuddy-Request: 1。 +// **仅 chat 路径调用**:5.9.3 真机只有 /v2/chat/completions 带该头(7/7), +// 其余 30+ 业务路径一条都没有。 +func (c *Client) injectCodeBuddyRequest(req *http.Request) { + req.Header.Set("X-CodeBuddy-Request", "1") +} + +// ChatMeta 一次 chat 出站的会话头族元数据(issue #35:后台按 X-Conversation-Request-ID +// 聚合请求,官方客户端一次 user send 内所有 tool call/重试/换号复用同一个 ID)。 +// handler 在轮转循环外生成 conversationID / conversationRequestID,循环内每次出站 +// 复用同值;TraceID 透传入站值(空 = 回落 conversationRequestID)。 +// messageID(消息级,每条独立)由 ChatHeaders 内部生成,无需外部可见。 +type ChatMeta struct { + ConversationID string // X-Conversation-ID:body 提取的入站值,空则不发(透传优先,不伪造) + // CacheKeyID prompt_cache_key 的会话段来源(网关派生的粘性会话键 sessKey)。 + // 与 ConversationID 分开:头是「客户端声明的会话」,缓存槽是「网关认的同一会话」—— + // 无 conversation_id 的客户端(Claude Code 等)只填这个,头部仍不伪造。 + CacheKeyID string + ConversationRequestID string // X-Conversation-Request-ID:对话轮级聚合主键,必发 + // RootRequestID X-Root-Request-ID:**会话级根**请求 ID(真机取 session.meta.rootRequestId, + // 会话首个请求生成、整会话复用,与轮级的 ConversationRequestID 不是同一个值)。 + // 空 → 回落 ConversationRequestID:真机 chat 7/7 都带该头,零值 meta 的调用方 + // (夜猫子、面板任务、测试)不能因为「没有根」就把头整个丢掉。 + RootRequestID string + TraceID string // X-Trace-ID:入站透传值,空则回落 conversationRequestID + // AgentType X-Agent-Type 场景枚举:空 = main(用户主对话)。网关自发、不属于用户 + // 对话的模型调用(面板自动任务、夜猫子、工具侧摘要)填 auxiliary。真机另有 + // compaction / subagent / team 三档,网关没有对应路径,故不预留假值。 + AgentType string +} + +// ChatHeaders 在 common 之上加 chat 专属的账号头。 +// 缺省字段用 X-No-* 约定(与 CodeBuddy 官方 CLI 一致)。 +// clientIP 为本次请求的客户端 IP(按参数传递,不读共享字段——避免并发串扰); +// PassthroughIP=false 或 clientIP 为空时不注入 IP 头。 +// meta 为会话头族元数据(纯新增,不改既有头),见 injectConversationHeaders。 +func (c *Client) ChatHeaders(req *http.Request, a *auth.Auth, clientIP string, meta ChatMeta) { + c.CommonHeaders(req, a) + // chat 出站头剥离:CommonHeaders 是 REST 层通用形态,桌面端 chat 并不发这几个 + // (两版客户端真机实测,见 capture/raw3 + capture/raw8 的逐头对照): + // Origin / Referer ← CLI 客户端没有浏览器语义,chat 路径从不发 + // Accept-Language ← 桌面端 chat 不发(billing 层才偶发 zh) + // X-Machine-ID / X-Session-ID 已从 CommonHeaders 整体移除(客户端从不发), + // 这里保留 Del 是给外部直接构造的 req 兜底,无副作用。 + req.Header.Del("Origin") + req.Header.Del("Referer") + req.Header.Del("Accept-Language") + req.Header.Del("X-Machine-ID") + req.Header.Del("X-Session-ID") + // Accept-Encoding:**必须删掉交给 net/http 自己写 gzip**。 + // + // CommonHeaders 已按真机声明 `gzip, compress, deflate, br`(RPC 链路由 + // doJSON 的 decodeResponseBody 自己解压)。但 chat 是 **SSE 长流**:一旦显式 + // 声明就关闭 net/http 的透明解压,resp.Body 变成压缩流,ChatStreamContext + // 原样透传给下游 → 客户端收到乱码。这条链路的解压改造要动 monitorBody / + // idle 监控 / 首包计时三处,风险远大于一个头带来的收益,故保持 Go 自动 gzip。 + // + // 已知残留差异(写死在这里,别再当"忘了"):真机 chat 是 + // `Accept-Encoding: gzip, compress, deflate, br`,我们是 `gzip`。 + req.Header.Del("Accept-Encoding") + // Accept 与官方 chat 完全一致:客户端只发 application/json,照样收 SSE 流 + // (两版实测;旧值多带 ", text/event-stream" 属自造)。 + // Accept-Encoding 的处理见上方 Del —— chat 保持 Go 自动 gzip。 + req.Header.Set("Accept", "application/json") + // X-Requested-With:**chat 必带**(CommonHeaders 已不再设它,见那边的注释)。 + // 2026-10-30 抓包:/v2/chat/completions 5/5 条全带 `x-requested-with: XMLHttpRequest`, + // 而 RPC 族(report / busy / console-as / refresh)一条都没有——chat 是唯一带的业务链。 + req.Header.Set("X-Requested-With", "XMLHttpRequest") + // User-Agent:chat 走 OpenAI SDK 的 buildUserAgent,首段**恒为驼峰 productName** + // `WorkBuddy/`,第二段才是品牌 slug——与 RPC/REST 层(首段即 slug,见 + // rpcUAFor)不同。CommonHeaders 已按 RPC 形态设过,这里按 chat 形态覆盖。 + // + // CN 5.9.3 → WorkBuddy/5.9.3 WorkBuddy/5.9.3 CLI/2.165.0 + // global 5.9.4 → WorkBuddy/5.9.4 workbuddy-ai/5.9.4 CLI/2.165.0 + // + // 2026-10-30 双版本真机 /v2/chat/completions 实测即上式(同一会话里 RPC 族 + // 首段是 slug,两族并存本身就是官方形态)。 + req.Header.Set("User-Agent", c.userAgent(a)) + // AccessToken 加锁快照:keepalive 定时刷新会在 a.mu 内改写它,锁外直读构成数据竞争 + // (见 auth.AccessTokenValue 注释)。 + if at := a.AccessTokenValue(); at != "" { + req.Header.Set("Authorization", "Bearer "+at) + // 静态 API Key 账号:官方 CLI 两个头都发(Authorization 与 X-API-Key 任一 + // 均可鉴权)。双头对齐官方形态,避免只看 X-API-Key 的边缘网关判定缺头。 + if a.IsAPIKey() { + req.Header.Set("X-API-Key", at) + } + } else { + req.Header.Set("X-No-Authorization", "true") + } + if a.UID != "" { + req.Header.Set("X-User-Id", a.UID) + } else { + req.Header.Set("X-No-User-Id", "true") + } + // 安全红线:绝不在 chat 请求里携带 X-Refresh-Token。 + // 企业/域头:**只发有值的**。桌面端个人号实测两个方向都不发 X-No-* 哨兵头 + // (capture/raw3 国际版、capture/raw8 国内版,逐头对照均无 X-No-Enterprise-Id / + // X-No-Department-Info)。旧实现用 X-No-* 声明「无企业」,那是 CodeBuddy CLI 的 + // 约定,不是 WorkBuddy 桌面端的形态——多发一个客户端从不发的头同样是指纹。 + if a != nil && !a.IsGlobal() { + if a.EnterpriseID != "" { + req.Header.Set("X-Enterprise-Id", a.EnterpriseID) + } + // X-Domain 必发:5.9.3 真机 chat 恒带 `X-Domain: www.workbuddy.cn`(裸主机名)。 + // auth 文件没写 domain 时回落 chat base 的主机名,而不是干脆不发——该头缺失 + // 同样是可判别形态(客户端从无「缺 X-Domain 的 chat」)。 + req.Header.Set("X-Domain", c.chatHost(a)) + } else { + c.injectGlobalChatHeaders(req, a) + } + // 用量归属头:默认伪造 WorkBuddy 桌面端指纹(client_name="SaaS" 还原旧行为)。 + c.injectAttribution(req, a) + // X-Private-Data: **false** —— 5.9.3 真机实测值为 "false",不是 "true"。 + // + // 客户端逻辑(cli/dist 反编译 applyPrivateDataHeaderPolicy + ModelProvider): + // + // p[PRIVATE_DATA_HEADER] = resolveModelOptimizationEnabled(...) ? "false" : "true" + // + // 即「开了模型优化(默认开)→ 声明 false(允许用于改进)」;只有企业版或用户显式 + // 关掉优化时才发 "true"。真机 7 条 /v2/chat/completions 全部是 `X-Private-Data: false` + // (含 main 与 auxiliary 两条链)。旧实现写死 "true",与客户端默认态相反。 + // 2026-10-28 补:值不再写死 false —— privateDataHeaderValue 按账号形态二选一 + // (企业版默认关模型优化 → true;个人号 → false)。 + req.Header.Set("X-Private-Data", privateDataHeaderValue(a)) + // 身份头族(X-Auth-Method / X-Userinfo):按账号形态条件注入,见 + // injectIdentityHeaders——个人号三头全不发才是官方形态。 + c.injectIdentityHeaders(req, a) + // 客户端 IP 透传(仅 PassthroughIP=true 且本次请求带 IP)。 + c.injectClientIP(req, clientIP) + // 设备风控头:auth 每号 > config 全局 > 文件兜底;空则不注入。 + c.injectDeviceToken(req, a) + // 会话头族(对话/请求/消息/B3 链路),见 injectConversationHeaders。 + c.injectConversationHeaders(req, a.UID, meta) + // SDK / agent 段指纹头(x-stainless-* / x-agent-type / x-agent-intent)。 + c.injectClientSDKHeaders(req, meta.AgentType) + // X-CodeBuddy-Request: 1 —— 5.9.3 真机**仅 chat** 携带(真机为小写键,HTTP 头大小写 + // 不敏感,等价)。其余业务路径不带,故从 CommonHeaders 移到这里。 + c.injectCodeBuddyRequest(req) + // X-Agent-Runtime: local-agent —— 5.9.3 真机 chat 必带(本地 agent 运行时)。 + // 值是枚举 ["local-agent","cloud-agent","agent-agent"] 之一,桌面端本地对话取 + // local-agent;客户端常量表 hK.AGENT_RUNTIME 与 cli resolveAgentRuntime 同源。 + req.Header.Set("X-Agent-Runtime", agentRuntimeLocal) + // baggage:W3C 传播头,客户端把会话/轮次 ID 以逗号分隔的 k=v 列表塞进去 + // (真机:buddyId=,buddyName=,codebuddy.session_id=,codebuddy.conversation_request_id=)。 + // 注意空值也发(`buddyId=`),是与 OTel baggage 序列化一致的形态,不是漏填。 + c.injectBaggage(req, a.UID, meta) +} + +// privateDataHeaderValue 出站 X-Private-Data 取值。 +// +// 客户端逻辑(cli/dist 反编译 applyPrivateDataHeaderPolicy): +// +// A = resolveModelOptimizationEnabled({explicitEnabled, productDefaultEnabled, isEnterpriseEdition}) +// p[PRIVATE_DATA_HEADER] = A ? "false" : "true" +// resolveModelOptimizationEnabled = (t,i,n) => typeof t=="boolean" ? t : !n && (i ?? true) +// +// 其中 productDefaultEnabled = !productFeatures.DefaultModelOptimizationOff,i.e. +// +// 真机值 = 企业版 || (发行版 DefaultModelOptimizationOff==true) ? "true" : "false" +// +// **判定维度是发行版,不是账号形态**——2026-10-30 双版本真机 + 拆包双向确认: +// +// 国际版 5.9.4 product.json DefaultModelOptimizationOff = true → 个人号发 "true"(实测 4/4 条) +// 国内版 5.9.3 product.json DefaultModelOptimizationOff = false → 个人号发 "false"(实测) +// +// 旧实现按「企业号 → true,其余 false」,把国际版个人号判成 false,方向正好相反 +// (每条 chat 都错)。网关没有「用户手动关优化」这个开关可读,故按 realm 取发行版默认。 +func privateDataHeaderValue(a *auth.Auth) string { + if a == nil { + return "false" + } + if a.IsEnterprise() { + return "true" + } + // 国际版(workbuddy.ai / codebuddy.ai)发行版默认关模型优化 → 声明 true。 + if a.IsGlobal() { + return "true" + } + return "false" +} + +// injectGlobalChatHeaders global 账号的 chat 专属域声明头。 +// +// 只发 X-Domain:桌面端个人号实测并不发 X-No-Enterprise-Id(旧实现按 CodeBuddy CLI +// 约定补的哨兵头),国际版 5.8.4 与国内版 5.8.3 的真机报文里都不存在该头 +// (capture/raw3/001-chat.json、capture/raw8/002-chat.json)。 +func (c *Client) injectGlobalChatHeaders(req *http.Request, a *auth.Auth) { + if a == nil || !a.IsGlobal() { + return + } + req.Header.Set("X-Domain", "www.workbuddy.ai") +} + +// injectConversationHeaders 注入官方客户端会话头族(issue #35 后台聚合)。 +// 头族分四层,各司其职: +// - X-Conversation-ID:会话级,多轮稳定。客户端声明(body conversationId)→ 原值透传; +// 客户端没声明 → 用网关的 uid 隔离会话键(见 issue #169 实验:该头是前缀缓存槽的 +// 实际来源,缺了它大前缀在 hy4/step 这类后端上恒 0% 命中);两者都没有(零值 +// ChatMeta)→ 现造 32 hex,**不留空**——上游按三件套是否齐全做渠道校验,缺任一头 +// 即 400 code=11-128 "conversation id missing"。 +// - X-Conversation-Request-ID:**对话轮级聚合主键**,必发。一次 user send 内的 +// 所有 tool call/重试/换号/降级复用同一个 → 后台按它聚合成一条(不再碎片化)。 +// - X-Conversation-Message-ID = X-Request-ID:消息级,每条独立(32 位 hex)。 +// - X-Root-Request-ID:= conversationRequestID(根请求追踪)。 +// - X-Trace-ID:入站透传,否则独立新值(**不**回落 conversationRequestID——官方实测 +// 两族恒不相等,见下方实现注释)。 +// - X-B3-TraceId / X-B3-SpanId / X-B3-Sampled:链路族,TraceId 跟随 X-Trace-ID。 +// B3 规范只认 16/32 hex TraceId 与 16 hex SpanId;入站透传值非法时 TraceId 回落 +// messageID(恒 32 hex),SpanId 取 messageID[:16](每消息新)。 +func (c *Client) injectConversationHeaders(req *http.Request, uid string, meta ChatMeta) { + convReqID := meta.ConversationRequestID + if convReqID == "" { + // 零值 meta(直接调 ChatHeaders 的调用方/测试)也要保证聚合主键必发: + // 本级补一个 32 hex,调用方(handler)已生成稳定的不走到这里。 + convReqID = session.NewMessageID() + } + messageID := session.NewMessageID() + if meta.ConversationID != "" { + req.Header.Set("X-Conversation-ID", meta.ConversationID) + } else if src := cacheKeySource(meta); src != "" { + // 客户端没声明会话:用与 prompt_cache_key 同源的 uid 隔离键填该头。 + // 不带 uid 段的话,同一客户端会话打在不同账号上会共用同一个上游缓存槽(见文件头隔离约束)。 + // 形态必须 v7(真机恒 01a1815d-… 时间有序),故走 buildTimeOrderedUUID 而非 + // buildCacheKey——后者是 v4,摆到该头上就是与真机相反的形态(见该函数注释)。 + req.Header.Set("X-Conversation-ID", buildTimeOrderedUUID(uid, src, "")) + } else { + // 零值 ChatMeta(夜猫子对话、面板模型任务等无 body 会话概念的调用方): + // 头族是**渠道校验**的一部分——上游要求三件套齐全,缺任一头即 400 + // code=11-128 "conversation id missing"(官方客户端 chat/speech 都带)。 + // 故不留空,现造一个**客户端同形态**的时间有序 UUIDv7。旧实现发 32 hex 无 + // 横线串,而 5.9.3 真机的 X-Conversation-ID 恒为 `01a1815d-dacf-75f1-…` + // 这种 36 字符 v7 形态(见 session.NewTimeOrderedID)。 + req.Header.Set("X-Conversation-ID", session.NewTimeOrderedID()) + } + req.Header.Set("X-Conversation-Request-ID", convReqID) + req.Header.Set("X-Conversation-Message-ID", messageID) + req.Header.Set("X-Request-ID", messageID) + // X-Root-Request-ID:真机取 session.meta.rootRequestId(会话根,整会话复用), + // 删掉「恒等于轮级聚合主键」的旧行为——那让该头只是 X-Conversation-Request-ID 的 + // 复制品,两族恒等本身就是网关自造的痕迹(真机两者语义分层:根 vs 轮)。 + // 调用方给不出会话根时(零值 meta)仍回落轮级值,头不丢。 + rootReqID := meta.RootRequestID + if rootReqID == "" { + rootReqID = convReqID + } + req.Header.Set("X-Root-Request-ID", rootReqID) + // X-Trace-ID 与 request id **互不回落**:国际版 5.8.4 真机实测,X-Trace-ID 恒为 + // 一条独立的 32 hex(样本 0ece3294f88c4ec5a02e78547617f874),而 + // X-Conversation-Request-ID 是另一条时间有序 ID(01a160b2…),二者从无相等。 + // 旧实现空则回落 convReqID,导致两族头恒等——是「网关自造」的可见痕迹(issue #51)。 + // 入站透传值仍优先(客户端自己给了就尊重)。 + traceID := meta.TraceID + if traceID == "" { + traceID = session.NewTraceID() + } + req.Header.Set("X-Trace-ID", traceID) + // B3 跟着 trace 走(官方 X-B3-TraceId == X-Trace-ID),而不是 request id。 + b3Trace := traceID + if !validTraceID(b3Trace) { + b3Trace = messageID // 入站透传值非法(含横线/超长/非 hex)→ 回落恒 32 hex + } + req.Header.Set("X-B3-TraceId", b3Trace) + // SpanId 必须独立随机:官方 span(9795d0f16a68bd32)与 trace/request 均无关系。 + // 曾用 messageID[:16],那会把这个头的 12 hex 时间前缀一起带出来。 + spanID := session.NewSpanID() + req.Header.Set("X-B3-SpanId", spanID) + // ParentSpanId:官方每条 chat 都带(两版实测),值是上一级 span 的 16 hex。 + // 网关没有真实 span 树,取独立随机值——上游无法校验父子关系,但**缺这个头** + // 与「有 span 无 parent」在形态上是可区分的。 + parentSpanID := session.NewSpanID() + req.Header.Set("X-B3-ParentSpanId", parentSpanID) + req.Header.Set("X-B3-Sampled", "1") + // B3 单头与 W3C traceparent:官方两版都双发(b3 = trace-span-flags-parent, + // traceparent = 00-trace-span-flags)。缺这两个头时只有 X-B3-* 三件套, + // 而客户端从不只发三件套。 + req.Header.Set("b3", b3Trace+"-"+spanID+"-1-"+parentSpanID) + req.Header.Set("traceparent", "00-"+b3Trace+"-"+spanID+"-01") + // acp-connection-id:官方把它列进**标准出站头族**(asar applyGatewayHeaders 与 + // X-Conversation-ID / X-Conversation-Request-ID 同一批设置),值来自会话注册表的 + // acpConnectionId —— 每个 session 生成一次、同会话多轮复用、跨会话不同 + // (`acquire(): metadata={acpConnectionId: uuid(), conversationRequestId: uuid()}`)。 + // 网关没有 ACP 连接层,按「同 (账号, 会话) 稳定、与会话 ID 不同值」派生, + // 语义与官方一致;无会话源时现造一个(该路径无跨请求稳定语义)。 + if src := cacheKeySource(meta); src != "" { + // 同样必须 v7:真机 acp-connection-id 与 X-Conversation-ID 同为 `01a1815d-…` + // 时间有序形态(只是值不同),旧实现摆 v4 位是错的(见 buildTimeOrderedUUID)。 + req.Header.Set("acp-connection-id", buildTimeOrderedUUID(uid, src, "acp")) + } else { + // 无会话源:现造客户端同形态 v7 UUID(真机 acp-connection-id 与 + // X-Conversation-ID 同为 `01a1815d-…` 时间有序形态,只是值不同)。 + req.Header.Set("acp-connection-id", session.NewTimeOrderedID()) + } +} + +// 官方 chat 出站的自报 SDK 指纹(国际版 5.8.4 与国内版 5.8.3 实测**完全一致**, +// 见 capture/raw3/001-chat.json 与 capture/raw8/002-chat.json)。 +// +// 这些是 openai-node SDK 自动加的 x-stainless-* 头 + 业务语义头 x-agent-type/intent。 +// 网关是 Go 实现,没有对应的 SDK 运行时;这里按官方实测值固定,理由是「客户端形态 +// 一致性」优先——不发这几个头,上游看到的是一份缺了 SDK 段的残缺头集合。 +// 一旦客户端版本变化(package-version / node 版本),这几个常量需要跟着更新。 +const ( + clientArch = "x64" + clientOS = "Windows" + clientLang = "js" + clientRuntime = "node" + clientNodeVer = "v22.21.1" + clientSDKVer = "6.25.0" + agentTypeMain = "main" + agentIntentCrf = "craft" + // agentTypeAuxiliary 辅助链档位:真机 resolveModelCallAgentType 的次要分支取值, + // 用于非用户主对话的模型调用(标题/摘要/网关自发任务)。主对话恒 main。 + agentTypeAuxiliary = "auxiliary" +) + +// X-Agent-Type 的服务层取值(ChatMeta.AgentType 用):空串等价 AgentTypeMain。 +const ( + AgentTypeMain = agentTypeMain + AgentTypeAuxiliary = agentTypeAuxiliary +) + +// injectClientSDKHeaders 注入 x-stainless-* 与 x-agent-* 两族出站头。 +// 仅在 chat 路径调用(ChatHeaders)——billing / checkin 等 REST 域没有真机对照证据, +// 不臆造。 +func (c *Client) injectClientSDKHeaders(req *http.Request, agentType string) { + // X-Agent-Type 按场景取(ChatMeta.AgentType):空 = 用户主对话 main; + // auxiliary = 网关自发/辅助链。真机还会出 compaction/subagent/team,网关无对应 + // 路径,不臆造。旧实现恒发 main,等于让面板任务、夜猫子都自称用户主对话。 + if agentType == "" { + agentType = agentTypeMain + } + req.Header.Set("X-Agent-Type", agentType) + req.Header.Set("X-Agent-Intent", agentIntentCrf) + req.Header.Set("X-Stainless-Lang", clientLang) + req.Header.Set("X-Stainless-Package-Version", clientSDKVer) + req.Header.Set("X-Stainless-OS", clientOS) + req.Header.Set("X-Stainless-Arch", clientArch) + req.Header.Set("X-Stainless-Runtime", clientRuntime) + req.Header.Set("X-Stainless-Runtime-Version", clientNodeVer) + req.Header.Set("X-Stainless-Retry-Count", "0") +} + +// agentRuntimeLocal 出站 X-Agent-Runtime 取值(桌面端本地 agent)。 +const agentRuntimeLocal = "local-agent" + +// injectBaggage 注入 W3C `baggage` 头,对齐客户端 chat 出站形态。 +// +// 5.9.3 真机逐字(main 与 auxiliary 两条链同形): +// +// baggage: buddyId=,buddyName=,codebuddy.session_id=, +// codebuddy.conversation_request_id= +// +// 客户端由 OTel W3CBaggagePropagator 序列化(空值保留 `k=` 形态),故 buddyId / +// buddyName 恒为空串但仍在列表里。这里照抄:两个 buddy 键发空值,两个 codebuddy.* +// 键取本次出站真实值,保证与同请求的 X-Conversation-ID / X-Conversation-Request-ID +// 一致(头体不一致本身就是可判别形态)。 +func (c *Client) injectBaggage(req *http.Request, uid string, meta ChatMeta) { + conv := meta.ConversationID + if conv == "" { + conv = req.Header.Get("X-Conversation-ID") + } + reqID := meta.ConversationRequestID + if reqID == "" { + reqID = req.Header.Get("X-Conversation-Request-ID") + } + // 2026-10-30 双版本真机复核(国际 5.9.4 4 条 + 国内 5.9.3 1 条 /v2/chat/completions + // 逐字比对):baggage **只有 4 个成员**,两个 buddy 键留空值: + // + // buddyId=,buddyName=,codebuddy.session_id=,codebuddy.conversation_request_id= + // + // 此前按「客户端 resolveAgentRuntime / resolveRequestScene 从 baggage 读这两项」 + // 推断了 x-agent-runtime / x-agent-intent 两个成员并注入——真机报文里没有, + // 多出的成员让 baggage 的序列化结构与客户端不一致(baggage 是 OTel 传播器 + // 序列化的整体串,成员集合本身就是可比对的形态)。故删除,改回 4 键。 + req.Header.Set("baggage", "buddyId=,buddyName=,codebuddy.session_id="+conv+ + ",codebuddy.conversation_request_id="+reqID) +} + +// validTraceID 判断 B3 TraceId 是否合法:16 或 32 位 hex(大小写均可)。 +// 官方客户端生成的 conversationRequestId 是 32 位 hex(UUID 去横线),入站透传值 +// 可能是任意形状(含横线/超长/非 hex),直接塞进 B3 头会破坏链路关联(issue #35)。 +func validTraceID(s string) bool { + if len(s) != 16 && len(s) != 32 { + return false + } + for i := 0; i < len(s); i++ { + ch := s[i] + if !((ch >= '0' && ch <= '9') || (ch >= 'a' && ch <= 'f') || (ch >= 'A' && ch <= 'F')) { + return false + } + } + return true +} + +// attributionClientName 生效的用量归属名:ClientName 非空取之; +// 空默认 "WorkBuddy"(伪造官方桌面端指纹;显式配 "SaaS" 可还原旧行为)。 +func (c *Client) attributionClientName() string { + if c != nil && c.ClientName != "" { + return c.ClientName + } + return "WorkBuddy" +} + +// injectAttribution 注入用量归属头(X-Agent-Purpose / X-IDE-* / X-Product)。 +// 仅在 chat/completions 路径生效(ChatHeaders 调用)。 +// +// X-Product 恒为 "SaaS",与 X-IDE-* 分开取值——这是真机抓包纠正过的形态(issue #51): +// +// 国际版 5.8.4 出站:X-Product: SaaS X-IDE-Name: WorkBuddy X-IDE-Type: WorkBuddy X-IDE-Version: 5.8.4 +// (capture/raw3/001-chat.json 官方全量头;CN 侧 desktop.go 文件头的逆向结论同为 SaaS) +// +// 旧实现让 X-Product 也取客户端名(=WorkBuddy),于是同一个头官方发 SaaS、网关发 WorkBuddy +// ——「同名不同值」比多一个头更容易被规则命中。X-IDE-* 才是承载产品名的地方。 +func (c *Client) injectAttribution(req *http.Request, a *auth.Auth) { + name := c.attributionClientName() + // X-Product 是 SKU 段,恒 SaaS:官方两版实测都不是产品名。 + req.Header.Set("X-Product", "SaaS") + if name == "SaaS" { + // 显式 ClientName=SaaS:仅声明 SKU,不补 X-IDE-*(旧行为,保留兼容)。 + return + } + req.Header.Set("X-Agent-Purpose", "conversation") + req.Header.Set("X-IDE-Name", name) + req.Header.Set("X-IDE-Type", name) + req.Header.Set("X-IDE-Version", c.clientVersion(a)) +} + +// injectClientIP 在 PassthroughIP 开启时把 clientIP 参数透传给上游(三等价头)。 +func (c *Client) injectClientIP(req *http.Request, clientIP string) { + if c == nil || !c.PassthroughIP || clientIP == "" { + return + } + req.Header.Set("X-Forwarded-For", clientIP) + req.Header.Set("X-Real-IP", clientIP) + req.Header.Set("X-Client-IP", clientIP) +} + +// ExtractClientIP 从入站请求提取客户端 IP 首段(X-Forwarded-For 首段,回落 X-Real-IP)。 +func ExtractClientIP(r *http.Request) string { + if r == nil { + return "" + } + if xff := r.Header.Get("X-Forwarded-For"); xff != "" { + for i := 0; i < len(xff); i++ { + if xff[i] == ',' { + return strings.TrimSpace(xff[:i]) + } + } + return strings.TrimSpace(xff) + } + if real := strings.TrimSpace(r.Header.Get("X-Real-IP")); real != "" { + return real + } + return "" +} + +// chatHost 返回当前 chat base 的裸主机名(X-Domain 用),解析失败回落 +// www.workbuddy.cn。客户端 X-Domain 恒为主机名,不带 scheme/端口。 +func (c *Client) chatHost(a *auth.Auth) string { + return hostOf(c.chatBase(a), "www.workbuddy.cn") +} + +// billingHost 返回当前 billing base 的裸主机名(X-Domain 兜底用)。 +func (c *Client) billingHost(a *auth.Auth) string { + return hostOf(c.billingBase(a), "www.workbuddy.cn") +} + +// hostOf 从 base URL 剥出裸主机名(去 scheme 与路径/端口后的 host:port 原样保留 +// 会与真机不符,故同时去掉端口)。空 base 回落 fallback。 +func hostOf(base, fallback string) string { + if i := strings.Index(base, "://"); i >= 0 { + base = base[i+3:] + } + if i := strings.IndexByte(base, '/'); i >= 0 { + base = base[:i] + } + if base == "" { + return fallback + } + return base +} + +// BillingHeaders billing 接口请求头。 +// UA 语义:默认**不设置**(保持现状,Go 客户端自带默认 UA);仅当显式配置 +// c.UserAgent 非空才覆盖——避免默认路径给 billing 引入新的 UA 指纹。 +func (c *Client) BillingHeaders(req *http.Request, a *auth.Auth) { + // AccessToken 加锁快照(同 ChatHeaders:keepalive 可在 a.mu 内改写)。 + req.Header.Set("Authorization", "Bearer "+a.AccessTokenValue()) + req.Header.Set("Accept", "application/json") + req.Header.Set("Content-Type", "application/json") + // Accept-Encoding:真机 billing 族 21/21 条全是四段声明(抓包统计, + // 与 chat / report 同值)。显式声明关闭透明解压,响应由 doJSON 解。 + req.Header.Set("Accept-Encoding", "gzip, compress, deflate, br") + // X-Request-ID:5.9.3 真机 billing 族必带(checkin 23 条、resource-summary 等全部有)。 + // 值为纯随机 32 hex(无时间前缀)。 + req.Header.Set("X-Request-ID", session.NewTraceID()) + // X-CodeBuddy-Request / Accept-Language:客户端 billing 族**都不发**,故不注入。 + //(旧实现两个都发,是多出来的形态。) + if c != nil && c.UserAgent != "" { + req.Header.Set("User-Agent", c.UserAgent) + } else if ua := c.billingUA(a); ua != "" { + req.Header.Set("User-Agent", ua) + } + if a.UID != "" { + req.Header.Set("X-User-Id", a.UID) + } + if a.EnterpriseID != "" { + req.Header.Set("X-Enterprise-Id", a.EnterpriseID) + req.Header.Set("X-Tenant-Id", a.EnterpriseID) + } + // X-Domain:客户端恒发裸主机名(真机 `X-Domain: www.workbuddy.cn`)。优先用 auth 文件 + // 声明的 domain,空则回落 billing base 的主机名——缺头是可判别形态。 + if d := a.DomainValue(); d != "" { + req.Header.Set("X-Domain", d) + } else { + req.Header.Set("X-Domain", c.billingHost(a)) + } + // 设备风控头:billing 域(report/travel/balance/checkin)同样注入。 + c.injectDeviceToken(req, a) +} + +// RefreshHeaders refresh 端点专属头(X-Refresh-Token 只允许出现在这里)。 +// +// 头族按 5.9.3 真机 /v2/plugin/auth/token/refresh(idx 556)逐头对齐: +// +// Accept: application/json, text/plain, */* +// Content-Type: application/json +// X-Requested-With: XMLHttpRequest +// X-Domain: www.workbuddy.cn X-Product: SaaS +// X-Refresh-Token / X-Auth-Refresh-Source: plugin +// X-Request-ID / User-Agent(三段) / Authorization / X-User-Id +// +// 客户端这条路径**不发** X-CodeBuddy-Request 与 Accept-Language,且 body 是 `{}`。 +func (c *Client) RefreshHeaders(req *http.Request, a *auth.Auth) { + c.CommonHeaders(req, a) + // Accept 用客户端值(CommonHeaders 发的是收窄后的 application/json)。 + req.Header.Set("Accept", "application/json, text/plain, */*") + req.Header.Set("X-Refresh-Token", a.RefreshToken) + if a.EnterpriseID != "" { + req.Header.Set("X-Enterprise-Id", a.EnterpriseID) + } + // X-Auth-Refresh-Source 对齐官方客户端 refresh 渠道标识 "plugin"(D3)。 + req.Header.Set("X-Auth-Refresh-Source", "plugin") + // X-Product: SaaS —— 5.9.3 真机 refresh 实测必带。 + req.Header.Set("X-Product", "SaaS") + // Authorization:真机 refresh **同时**带旧的 access token 与 refresh token + // (idx 556 两行并存)。旧实现只发 X-Refresh-Token,漏了这个头。 + // 注意与 chat 相反——chat 绝不带 X-Refresh-Token,refresh 则双发。 + if at := a.AccessTokenValue(); at != "" { + req.Header.Set("Authorization", "Bearer "+at) + } else { + req.Header.Set("X-No-Authorization", "true") + } + // X-Request-ID / X-User-Id / X-Domain:真机三头齐全,旧实现全漏。 + req.Header.Set("X-Request-ID", session.NewTraceID()) + if a.UID != "" { + req.Header.Set("X-User-Id", a.UID) + } + if d := a.DomainValue(); d != "" { + req.Header.Set("X-Domain", d) + } else { + req.Header.Set("X-Domain", c.chatHost(a)) + } +} diff --git a/internal/upstream/headers_parity_test.go b/internal/upstream/headers_parity_test.go new file mode 100644 index 0000000000000000000000000000000000000000..377084358fcb6ac378b7e8d0059acada9c16748c --- /dev/null +++ b/internal/upstream/headers_parity_test.go @@ -0,0 +1,224 @@ +// headers_parity_test.go 2026-10-28 后续修复的回归:六项与 5.9.3 真机的头级偏差。 +// +// 前一批(cn_contract_test.go)钉的是「哪些头出现 / 关键值」;本文件钉的是**形态与 +// 条件分支**——派生 ID 必须是 UUIDv7、身份头按 id_source 条件触发、根请求头独立于 +// 轮级聚合键、X-Agent-Type 分场景、X-Private-Data 有 true 分支、baggage 带运行时键。 +package upstream + +import ( + "encoding/base64" + "encoding/json" + "net/http" + "net/http/httptest" + "strconv" + "strings" + "testing" + + "github.com/misakano7545/workbuddy2api-panel/internal/auth" +) + +// b64url JWT 段编码(无填充)。 +func b64url(s string) string { return base64.RawURLEncoding.EncodeToString([]byte(s)) } + +// decodeUserinfo 解 X-Userinfo 头为 map[string]string。 +func decodeUserinfo(t *testing.T, req *http.Request) map[string]string { + t.Helper() + raw := req.Header.Get("X-Userinfo") + if raw == "" { + t.Fatal("X-Userinfo 未发送") + } + dec, err := base64.StdEncoding.DecodeString(raw) + if err != nil { + t.Fatalf("X-Userinfo 不是标准 base64: %v", err) + } + var m map[string]string + if err := json.Unmarshal(dec, &m); err != nil { + t.Fatalf("X-Userinfo 不是 JSON 对象: %v (%s)", err, dec) + } + return m +} + +// TestDerivedConversationIDsAreV7 派生分支(有会话源)的两个会话头必须是时间有序 +// UUIDv7——真机恒 `01a1815d-dacf-75f1-…`,旧实现派生时摆 v4 位(第 13 位 4)。 +func TestDerivedConversationIDsAreV7(t *testing.T) { + c := &Client{} + a := &auth.Auth{UID: "85329a86-a3e7-448a-9666-ec34e0bdfb67", AccessToken: "at"} + meta := ChatMeta{CacheKeyID: "sess-v7"} + + first := httptest.NewRequest(http.MethodPost, "https://example.invalid/v2/chat/completions", nil) + c.ChatHeaders(first, a, "", meta) + second := httptest.NewRequest(http.MethodPost, "https://example.invalid/v2/chat/completions", nil) + c.ChatHeaders(second, a, "", meta) + + for _, h := range []string{"X-Conversation-ID", "acp-connection-id"} { + got := first.Header.Get(h) + if !uuidV7Re.MatchString(got) { + t.Errorf("%s=%q 不是 UUIDv7(派生分支也必须 48bit 时间位 + ver 7)", h, got) + } + if again := second.Header.Get(h); again != got { + t.Errorf("%s 跨请求不稳定:%q vs %q(同账号同会话必须同值,否则缓存槽每轮换)", h, got, again) + } + } + if first.Header.Get("X-Conversation-ID") == first.Header.Get("acp-connection-id") { + t.Error("会话 ID 与 acp-connection-id 不能同值(官方是两个独立值)") + } +} + +// TestBuildTimeOrderedUUID 派生函数本身:v7 形态 / 稳定 / 跨会话跨 purpose 互不相同 / +// 时间位落在合理窗口(不是 1974 或 5000 年那种一眼假的值)。 +func TestBuildTimeOrderedUUID(t *testing.T) { + const uid = "u-1" + got := buildTimeOrderedUUID(uid, "conv-1", "acp") + if !uuidV7Re.MatchString(got) { + t.Fatalf("形态: %q", got) + } + if again := buildTimeOrderedUUID(uid, "conv-1", "acp"); again != got { + t.Fatalf("不稳定: %q vs %q", got, again) + } + if other := buildTimeOrderedUUID(uid, "conv-2", "acp"); other == got { + t.Fatal("跨会话不该同值") + } + if other := buildTimeOrderedUUID(uid, "conv-1", ""); other == got { + t.Fatal("不同 purpose 不该同值") + } + if other := buildTimeOrderedUUID("u-2", "conv-1", "acp"); other == got { + t.Fatal("跨账号不该同值(隔离约束)") + } + // 时间位:48 bit = 前 8 hex + 第 10~13 位 4 hex,解出来必须落在锚点窗口内 + // (锚 2026-01-01 + 0..24 个月),否则就是越界到 1974 / 5000 年的假值。 + ms, err := strconv.ParseInt(got[0:8]+got[9:13], 16, 64) + if err != nil { + t.Fatalf("解时间位失败: %v (%q)", err, got) + } + const lo, hi = int64(1767225600000), int64(1767225600000) + int64(24*30*24*60*60*1000) + if ms < lo || ms > hi { + t.Fatalf("时间位 %d 越界(应在 %d..%d)", ms, lo, hi) + } +} + +// TestIdentityHeadersIdSource 带 id_source 声明的个人号:发 X-Id-Source,且 X-Userinfo +// 带 id_source 段(不带 owner_uin,因为个人号没有企业)。 +func TestIdentityHeadersIdSource(t *testing.T) { + payload := `{"id_source":"sso_login"}` + a := &auth.Auth{UID: "u1", AccessToken: "h." + b64url(payload) + ".s"} + req := httptest.NewRequest(http.MethodPost, "https://example.invalid/v2/chat/completions", nil) + New().injectIdentityHeaders(req, a) + + if got := req.Header.Get("X-Id-Source"); got != "sso_login" { + t.Fatalf("X-Id-Source=%q want sso_login", got) + } + m := decodeUserinfo(t, req) + if m["id_source"] != "sso_login" { + t.Errorf("X-Userinfo 缺 id_source 段: %v", m) + } + if m["uin"] != "u1" { + t.Errorf("uin=%q want u1", m["uin"]) + } + if _, ok := m["owner_uin"]; ok { + t.Errorf("个人号不该写 owner_uin: %v", m) + } + if _, ok := m["token_source"]; ok { + t.Errorf("个人号不该写 token_source: %v", m) + } +} + +// TestRootRequestIDSessionScoped X-Root-Request-ID 独立于轮级聚合键;缺省回落不丢头。 +func TestRootRequestIDSessionScoped(t *testing.T) { + c := &Client{} + a := &auth.Auth{UID: "u1", AccessToken: "at"} + + req := httptest.NewRequest(http.MethodPost, "https://example.invalid/v2/chat/completions", nil) + c.ChatHeaders(req, a, "", ChatMeta{ + ConversationID: "c1", ConversationRequestID: "turn-id", RootRequestID: "session-root", + }) + if got := req.Header.Get("X-Root-Request-ID"); got != "session-root" { + t.Errorf("X-Root-Request-ID=%q want session-root(会话根,不是轮级键)", got) + } + if req.Header.Get("X-Conversation-Request-ID") != "turn-id" { + t.Error("轮级聚合键被改了") + } + + // 无会话根 → 回落轮级值,头仍然在(真机 chat 7/7 都带)。 + req2 := httptest.NewRequest(http.MethodPost, "https://example.invalid/v2/chat/completions", nil) + c.ChatHeaders(req2, a, "", ChatMeta{ConversationID: "c1", ConversationRequestID: "turn-id"}) + if got := req2.Header.Get("X-Root-Request-ID"); got != "turn-id" { + t.Errorf("无会话根时应回落轮级值,got=%q", got) + } +} + +// TestAgentTypePerScene X-Agent-Type 分场景:缺省 main,辅助链 auxiliary,且 baggage +// 里的 x-agent-intent 与同名头同值。 +func TestAgentTypePerScene(t *testing.T) { + c := &Client{} + a := &auth.Auth{UID: "u1", AccessToken: "at"} + + main := httptest.NewRequest(http.MethodPost, "https://example.invalid/v2/chat/completions", nil) + c.ChatHeaders(main, a, "", ChatMeta{ConversationID: "c1"}) + if got := main.Header.Get("X-Agent-Type"); got != "main" { + t.Errorf("缺省 X-Agent-Type=%q want main", got) + } + + aux := httptest.NewRequest(http.MethodPost, "https://example.invalid/v2/chat/completions", nil) + c.ChatHeaders(aux, a, "", ChatMeta{ConversationID: "c1", AgentType: AgentTypeAuxiliary}) + if got := aux.Header.Get("X-Agent-Type"); got != "auxiliary" { + t.Errorf("辅助链 X-Agent-Type=%q want auxiliary", got) + } +} + +// TestPrivateDataTrueBranch X-Private-Data 按**发行版**取,不是按账号形态: +// 企业号恒 true;个人号看 realm(国际版默认关模型优化 → true;国内版 → false)。 +// 依据:productFeatures.DefaultModelOptimizationOff(GL 5.9.4=true / CN 5.9.3=false) +// + 2026-10-30 双版本真机 chat 逐条比对。 +func TestPrivateDataTrueBranch(t *testing.T) { + c := &Client{} + ent := &auth.Auth{UID: "u1", EnterpriseID: "ent-1", AccessToken: "at"} + req := httptest.NewRequest(http.MethodPost, "https://example.invalid/v2/chat/completions", nil) + c.ChatHeaders(req, ent, "", ChatMeta{ConversationID: "c1"}) + if got := req.Header.Get("X-Private-Data"); got != "true" { + t.Errorf("企业号 X-Private-Data=%q want true", got) + } + // 国内个人号:发行版默认开模型优化 → false。 + personal := httptest.NewRequest(http.MethodPost, "https://example.invalid/v2/chat/completions", nil) + c.ChatHeaders(personal, &auth.Auth{UID: "u2", AccessToken: "at"}, "", ChatMeta{ConversationID: "c1"}) + if got := personal.Header.Get("X-Private-Data"); got != "false" { + t.Errorf("国内个人号 X-Private-Data=%q want false", got) + } + // 国际个人号:发行版默认**关**模型优化 → true(真机 4/4 条实测)。 + gl := &auth.Auth{UID: "u3", AccessToken: "at", Domain: "workbuddy.ai"} + glReq := httptest.NewRequest(http.MethodPost, "https://example.invalid/v2/chat/completions", nil) + c.ChatHeaders(glReq, gl, "", ChatMeta{ConversationID: "c1"}) + if got := glReq.Header.Get("X-Private-Data"); got != "true" { + t.Errorf("国际个人号 X-Private-Data=%q want true", got) + } +} + +// TestBaggageHasOnlyFourMembers baggage 必须**恰好** 4 个成员: +// buddyId / buddyName / codebuddy.session_id / codebuddy.conversation_request_id。 +// 曾注入 x-agent-runtime / x-agent-intent 两个成员,真机报文里没有(成员集合本身 +// 就是可比对的形态)。 +func TestBaggageHasOnlyFourMembers(t *testing.T) { + c := &Client{} + req := httptest.NewRequest(http.MethodPost, "https://example.invalid/v2/chat/completions", nil) + c.ChatHeaders(req, &auth.Auth{UID: "u1", AccessToken: "at"}, "", ChatMeta{ConversationID: "c1", ConversationRequestID: "r1"}) + bg := req.Header.Get("baggage") + for _, want := range []string{ + "codebuddy.session_id=c1", "codebuddy.conversation_request_id=r1", + "buddyId=", "buddyName=", + } { + if !strings.Contains(bg, want) { + t.Errorf("baggage 缺 %q: %s", want, bg) + } + } + for _, banned := range []string{"x-agent-runtime", "x-agent-intent"} { + if strings.Contains(bg, banned) { + t.Errorf("baggage 不得含 %q(真机只有 4 键): %s", banned, bg) + } + } + if n := len(strings.Split(bg, ",")); n != 4 { + t.Errorf("baggage 成员数=%d want 4: %s", n, bg) + } + // 与同名头同值(头体一致的硬要求)。 + if req.Header.Get("X-Agent-Runtime") == "" || req.Header.Get("X-Agent-Intent") == "" { + t.Error("X-Agent-Runtime / X-Agent-Intent 头本身必须存在") + } +} diff --git a/internal/upstream/headorder.go b/internal/upstream/headorder.go new file mode 100644 index 0000000000000000000000000000000000000000..0aad5f67c62d0d470dae3e660a69a12e8c5e84bc --- /dev/null +++ b/internal/upstream/headorder.go @@ -0,0 +1,221 @@ +// headorder.go 出站请求头**发送顺序**对齐官方客户端。 +// +// 背景:Go 的 net/http 写头时按 map key 排序(Header.writeSubset 的 +// sortedKeyValues),而官方客户端是 Node/undici/axios,按**代码插入序**写出。 +// 头名的集合与拼写已由 headcase.go 对齐,本文件补最后一项差异:顺序。 +// +// 依据(真机夹具,逐字节原文): +// +// testdata/official_chat_head.txt 43 头,chat 链 +// testdata/official_report_cn_head.txt 11 头,/v2/report +// testdata/official_chat_busy_head.txt 8 头,/v2/chat/busy +// testdata/official_v3config_head.txt 4 头,/v3/config +// +// 顺序表按**路径**分族:官方不同链路由不同代码构造头对象,顺序本就不通用, +// 拿 chat 的顺序套 report 反而更假。表里没有的路径保持 Go 原生排序——不做 +// 无证据的猜测。 +package upstream + +import ( + "bytes" + "strings" +) + +// officialHeadOrder 各主链路的官方头顺序(原文大小写,抄自夹具)。 +// +// 末尾的 Host / Connection / Content-Length / Accept-Encoding 是 net/http +// 自己追加的,重排时一并纳入,位置按真机。 +var officialHeadOrder = map[string][]string{ + "/v2/chat/completions": { + "Accept", + "Content-Type", + "X-Requested-With", + "x-stainless-arch", + "x-stainless-lang", + "x-stainless-os", + "x-stainless-package-version", + "x-stainless-retry-count", + "x-stainless-runtime", + "x-stainless-runtime-version", + "X-Conversation-ID", + "X-Agent-Purpose", + "X-IDE-Type", + "X-IDE-Name", + "X-IDE-Version", + "X-Agent-Intent", + "X-Agent-Runtime", + "X-Private-Data", + "acp-connection-id", + "x-codebuddy-request", + "X-Request-ID", + "X-Conversation-Message-ID", + "X-Conversation-Request-ID", + "X-Root-Request-ID", + "X-Agent-Type", + "baggage", + "Content-Encoding", + "traceparent", + "b3", + "X-B3-TraceId", + "X-B3-ParentSpanId", + "X-B3-SpanId", + "X-B3-Sampled", + "X-Trace-ID", + "X-Product", + "User-Agent", + "Authorization", + "X-User-Id", + "X-Domain", + "Content-Length", + "Accept-Encoding", + "Host", + "Connection", + }, + "/v2/report": { + "Accept", + "Content-Type", + "X-Request-ID", + "X-Product", + "User-Agent", + "Authorization", + "X-User-Id", + "X-Domain", + "Content-Length", + "Accept-Encoding", + "Host", + "Connection", + }, + "/v2/chat/busy": { + "Accept", + "Content-Type", + "User-Agent", + "X-Request-ID", + "X-Product", + "Authorization", + "X-User-Id", + "X-Domain", + "Content-Length", + "Host", + "Connection", + }, + "/v3/config": { + "Accept", + "Connection", + "User-Agent", + "X-Request-ID", + "X-Product", + "Host", + }, +} + +// headRank 把顺序表压成「小写头名 → 名次」,比对时大小写不敏感 +// (Go transport 写出的 key 已是官方拼写,但 Host 之类仍是 canonical)。 +func headRank(path string) (map[string]int, bool) { + order, ok := officialHeadOrder[path] + if !ok { + return nil, false + } + rank := make(map[string]int, len(order)) + for i, k := range order { + rank[strings.ToLower(k)] = i + } + return rank, true +} + +// requestPathOf 从请求行取 path(去掉 query),用于查顺序表。 +func requestPathOf(line string) string { + // METHOD SP request-target SP HTTP/x.y + sp1 := bytes.IndexByte([]byte(line), ' ') + if sp1 <= 0 { + return "" + } + rest := line[sp1+1:] + sp2 := strings.IndexByte(rest, ' ') + if sp2 < 0 { + return "" + } + target := rest[:sp2] + if i := strings.IndexByte(target, '?'); i >= 0 { + target = target[:i] + } + // absolute-form(http://host/path)时只留 path + if strings.HasPrefix(target, "http://") || strings.HasPrefix(target, "https://") { + if i := strings.Index(target[8:], "/"); i >= 0 { + target = target[8+i:] + } + } + return target +} + +// reorderHeadBlock 按官方顺序重排一个完整的请求头块(含结尾空行)。 +// +// 行为: +// - 顺序表里有的头按表排; +// - 表里没有的头(上游新增、临时注入)保持**原有相对顺序**追加在末尾; +// - 重复头名(极少)保持各自出现顺序; +// - 无法识别的请求行 / 空表 → 原样返回,绝不抛错。 +// +// 纯函数,不依赖任何连接状态,是这套机制唯一需要精确正确的地方。 +func reorderHeadBlock(block []byte) []byte { + if len(block) == 0 || !bytes.HasSuffix(block, []byte("\r\n\r\n")) { + return block + } + body := block[:len(block)-4] // 去掉终止空行 + lines := strings.Split(string(body), "\r\n") + if len(lines) < 2 { + return block + } + path := requestPathOf(lines[0]) + rank, ok := headRank(path) + if !ok { + return block + } + + type entry struct { + name string + raw string + seq int + } + var entries []entry + for i, ln := range lines[1:] { + if ln == "" { + continue + } + colon := strings.IndexByte(ln, ':') + if colon <= 0 { + continue + } + entries = append(entries, entry{name: ln[:colon], raw: ln, seq: i}) + } + + // 稳定排序:有名次的按名次,没名次的排后面并保持原序 + ordered := make([]entry, 0, len(entries)) + used := make([]bool, len(entries)) + for want := 0; want < len(rank); want++ { + for i, e := range entries { + if used[i] { + continue + } + if r, ok := rank[strings.ToLower(e.name)]; ok && r == want { + ordered = append(ordered, e) + used[i] = true + } + } + } + for i, e := range entries { + if !used[i] { + ordered = append(ordered, e) + } + } + + var out bytes.Buffer + out.Grow(len(block)) + out.WriteString(lines[0]) + out.WriteString("\r\n") + for _, e := range ordered { + out.WriteString(e.raw) + out.WriteString("\r\n") + } + out.WriteString("\r\n") + return out.Bytes() +} diff --git a/internal/upstream/headorder_conn.go b/internal/upstream/headorder_conn.go new file mode 100644 index 0000000000000000000000000000000000000000..15749c50b15c47fe8089e000c3ba121c4a3fda7b --- /dev/null +++ b/internal/upstream/headorder_conn.go @@ -0,0 +1,293 @@ +// headorder_conn.go 把官方头顺序落到网络层。 +// +// 为什么必须在 conn 层做:Go 的 net/http 自己序列化请求头(Header.writeSubset +// 按 key 排序),RoundTripper 拿不到「按顺序写字节」的控制权,除非把整个 +// HTTP/1.1 客户端重写一遍。包一层 net.Conn、在 Write 里重排头块,是唯一 +// 既保留 Transport 全部能力(连接池 / TLS / 超时 / 半死连接清理)又能改顺序 +// 的位置。 +// +// **失败安全红线**:本文件所有解析都是 best-effort。任何一步判断不出来就原样 +// 透传——最坏结果只是「没重排」(退回字母序),绝不改变数据流本身。连接复用 +// 的状态机若判断失误,也只影响下一个请求的重排与否。 +package upstream + +import ( + "bytes" + "net" + "strconv" + "strings" + "sync" +) + +// connPhase 一条连接上的当前位置。 +type connPhase int + +const ( + phaseAwaitRequest connPhase = iota // 下一个字节开始是请求头 + phaseInBody // 请求体/响应体流动中 +) + +// headOrderConn 在 Write 侧按官方顺序重排请求头块,Read 侧只做解析不改数据。 +type headOrderConn struct { + net.Conn + + mu sync.Mutex + phase connPhase + pending []byte // 请求头累积(仅在 phaseAwaitRequest 有意义) + + // Read 侧响应解析状态(只用于判断「响应体何时结束」→ 回到 phaseAwaitRequest) + resp respTracker + respMu sync.Mutex +} + +// maxPendingHead 请求头累积上限:超过就放弃重排并原样放行。 +// 官方头块约 1.8 KB,正常远达不到;这是防「头异常大 / 判断不出边界」时 +// 无限缓冲吃内存。 +const maxPendingHead = 64 * 1024 + +func newHeadOrderConn(c net.Conn) net.Conn { + return &headOrderConn{Conn: c} +} + +// Write 在请求头块完整时重排,其余情况原样透传。 +func (c *headOrderConn) Write(p []byte) (int, error) { + c.mu.Lock() + defer c.mu.Unlock() + + if c.phase == phaseInBody { + return c.Conn.Write(p) + } + + c.pending = append(c.pending, p...) + + // 头块未完整,继续等(调用方会继续 Write 或进入读阶段) + if i := bytes.Index(c.pending, []byte("\r\n\r\n")); i < 0 { + if len(c.pending) > maxPendingHead { + // 降级:原样放行已缓冲的字节,后续不再尝试重排 + out := c.pending + c.pending = nil + c.phase = phaseInBody + _, err := c.Conn.Write(out) + if err != nil { + return 0, err + } + } + return len(p), nil + } else { + head := c.pending[:i+4] + rest := c.pending[i+4:] + c.pending = nil + c.phase = phaseInBody + + out := reorderHeadBlock(head) + if _, err := c.Conn.Write(out); err != nil { + return 0, err + } + if len(rest) > 0 { + if _, err := c.Conn.Write(rest); err != nil { + return 0, err + } + } + return len(p), nil + } +} + +// Read 只透传,同时把字节喂给响应解析器判断响应体边界。 +func (c *headOrderConn) Read(p []byte) (int, error) { + n, err := c.Conn.Read(p) + if n > 0 { + c.respMu.Lock() + done := c.resp.feed(p[:n]) + c.respMu.Unlock() + if done { + c.mu.Lock() + if c.phase == phaseInBody { + c.phase = phaseAwaitRequest + c.pending = nil + } + c.mu.Unlock() + } + } + return n, err +} + +// respTracker 跟踪一条 HTTP/1.1 响应,判断响应体何时读完。 +// +// 只关心「边界」,不解析内容:响应头 → 依据 Content-Length / chunked / +// Connection: close 三种情形计数。任何不确定(字段畸形、多段编码)一律 +// 当作「无法判断」→ 保持 phaseInBody(该连接后续不再重排,安全降级)。 +type respTracker struct { + inHead bool // true = 正在收响应头 + headBuf []byte + remain int64 // Content-Length 剩余 + chunked bool + chunkRem int64 // 当前 chunk 剩余 + chunkSt int // 0=等大小行 1=收数据 2=等 chunk 尾 CRLF 3=收 trailer + unknown bool // 无法判断边界 → 永不回到 awaitRequest + started bool +} + +// feed 喂入刚读到的字节,返回 true 表示「本响应已完整结束」。 +func (t *respTracker) feed(b []byte) bool { + if t.unknown { + return false + } + if !t.started { + t.started = true + t.inHead = true + } + if t.inHead { + t.headBuf = append(t.headBuf, b...) + i := bytes.Index(t.headBuf, []byte("\r\n\r\n")) + if i < 0 { + if len(t.headBuf) > maxPendingHead { + t.unknown = true + } + return false + } + headBytes := t.headBuf[:i] + over := t.headBuf[i+4:] // 响应头之后已经读到的 body 字节 + t.headBuf = nil + t.inHead = false + + lines := bytes.Split(headBytes, []byte("\r\n")) + var clen int64 = -1 + closeDelimited := true + for _, ln := range lines[1:] { + l := string(ln) + low := toLowerASCII(l) + switch { + case hasPrefixFold(low, "content-length:"): + clen = parseInt64(trimSpace(l[len("content-length:"):])) + if clen < 0 { + t.unknown = true + return false + } + closeDelimited = false + case hasPrefixFold(low, "transfer-encoding:") && bytesContainsFold(low, "chunked"): + t.chunked = true + closeDelimited = false + case hasPrefixFold(low, "connection:") && bytesContainsFold(low, "close"): + closeDelimited = true + } + } + switch { + case t.chunked: + t.chunkSt = 0 + case clen >= 0: + t.remain = clen + default: + // 无长度且非 chunked:以连接关闭为界,无法给出结束点 + _ = closeDelimited + t.unknown = true + return false + } + if len(over) == 0 { + return t.complete() + } + return t.feedBody(over) + } + return t.feedBody(b) +} + +// feedBody 按已确定的分帧方式消费 body 字节。 +func (t *respTracker) feedBody(b []byte) bool { + if t.chunked { + return t.feedChunked(b) + } + if int64(len(b)) >= t.remain { + t.remain = 0 + return true + } + t.remain -= int64(len(b)) + return false +} + +// feedChunked 解析 chunked 分帧直到结束块。 +func (t *respTracker) feedChunked(b []byte) bool { + i := 0 + for i < len(b) { + switch t.chunkSt { + case 0: // 等 chunk 大小行 + j := bytes.Index(b[i:], []byte("\r\n")) + if j < 0 { + return false // 半行,下次继续(不缓存,行很短且极少跨包) + } + line := string(b[i : i+j]) + if k := bytes.IndexByte([]byte(line), ';'); k >= 0 { + line = line[:k] + } + n := parseInt64Hex(trimSpace(line)) + if n < 0 { + t.unknown = true + return false + } + i += j + 2 + if n == 0 { + t.chunkSt = 3 // 末尾 trailer + continue + } + t.chunkRem = n + t.chunkSt = 1 + case 1: // 收 chunk 数据 + if int64(len(b)-i) < t.chunkRem { + t.chunkRem -= int64(len(b) - i) + return false + } + i += int(t.chunkRem) + t.chunkRem = 0 + t.chunkSt = 2 + case 2: // 等 chunk 后 CRLF + if len(b)-i < 2 { + return false + } + i += 2 + t.chunkSt = 0 + case 3: // trailer 直到空行 + j := bytes.Index(b[i:], []byte("\r\n")) + if j < 0 { + return false + } + if j == 0 { // 空行 = 结束 + return true + } + i += j + 2 + } + } + return false +} + +// complete 头到手但 body 为空时的判定。 +func (t *respTracker) complete() bool { + if t.chunked { + return false // chunked 至少要有 0\r\n\r\n + } + return t.remain == 0 +} + +// 以下解析全用标准库:这是每响应的解析路径,用 strings/strconv 换来的是 +// 「不会自己写错」,比省几纳秒的分配更值。开销实测在噪声内。 + +func toLowerASCII(s string) string { return strings.ToLower(s) } + +func hasPrefixFold(low, prefix string) bool { return strings.HasPrefix(low, prefix) } + +func bytesContainsFold(low, sub string) bool { return strings.Contains(low, sub) } + +func trimSpace(s string) string { return strings.TrimSpace(s) } + +func parseInt64(s string) int64 { + n, err := strconv.ParseInt(strings.TrimSpace(s), 10, 64) + if err != nil || n < 0 { + return -1 + } + return n +} + +func parseInt64Hex(s string) int64 { + n, err := strconv.ParseInt(strings.TrimSpace(s), 16, 64) + if err != nil || n < 0 { + return -1 + } + return n +} diff --git a/internal/upstream/headorder_e2e_test.go b/internal/upstream/headorder_e2e_test.go new file mode 100644 index 0000000000000000000000000000000000000000..c0e6333f7ea2fafcd67e2d32d5798b7f17359478 --- /dev/null +++ b/internal/upstream/headorder_e2e_test.go @@ -0,0 +1,156 @@ +// headorder_e2e_test.go 端到端验证:真实 TLS 连接上,Transport 写出的请求头 +// 是否已按官方顺序排列。 +// +// 为什么必须端到端:headorder_test.go 验的是纯函数和 conn 包装,但「Transport +// 到底有没有用我们替换的 DialTLSContext」只有真跑一遍才能确认——这一层如果 +// 没接上,前面所有测试全绿而线上毫无变化。 +package upstream + +import ( + "bufio" + "crypto/rand" + "crypto/rsa" + "crypto/tls" + "crypto/x509" + "crypto/x509/pkix" + "math/big" + "net" + "net/http" + "strings" + "sync" + "testing" + "time" + + "github.com/misakano7545/workbuddy2api-panel/internal/auth" +) + +// selfSignedServerTLS 造一张 127.0.0.1 自签证书(测试专用,不落盘)。 +func selfSignedServerTLS(t *testing.T) *tls.Config { + t.Helper() + priv, err := rsa.GenerateKey(rand.Reader, 2048) + if err != nil { + t.Fatalf("rsa: %v", err) + } + tmpl := &x509.Certificate{ + SerialNumber: big.NewInt(1), + Subject: pkix.Name{CommonName: "127.0.0.1"}, + NotBefore: time.Now().Add(-time.Hour), + NotAfter: time.Now().Add(time.Hour), + IPAddresses: []net.IP{net.ParseIP("127.0.0.1")}, + KeyUsage: x509.KeyUsageDigitalSignature | x509.KeyUsageKeyEncipherment, + ExtKeyUsage: []x509.ExtKeyUsage{x509.ExtKeyUsageServerAuth}, + } + der, err := x509.CreateCertificate(rand.Reader, tmpl, tmpl, &priv.PublicKey, priv) + if err != nil { + t.Fatalf("cert: %v", err) + } + return &tls.Config{Certificates: []tls.Certificate{{Certificate: [][]byte{der}, PrivateKey: priv}}} +} + +// TestTransportUsesHeadOrderConn 确认真实 TLS 路径上出现官方头顺序。 +// +// 手段:自签 TLS 服务器 + 注入 InsecureSkipVerify 的 newTLSDialer, +// 让 Transport 走我们那条 DialTLSContext;服务端侧用 hijack 拿原始字节。 +func TestTransportUsesHeadOrderConn(t *testing.T) { + srvTLS := selfSignedServerTLS(t) + ln, err := net.Listen("tcp", "127.0.0.1:0") + if err != nil { + t.Fatalf("listen: %v", err) + } + t.Cleanup(func() { ln.Close() }) + tlsLn := tls.NewListener(ln, srvTLS) + + var mu sync.Mutex + var rawHead strings.Builder + go func() { + for { + conn, aerr := tlsLn.Accept() + if aerr != nil { + return + } + go func(c net.Conn) { + defer c.Close() + br := bufio.NewReader(c) + var head []byte + for { + ln, rerr := br.ReadBytes('\n') + head = append(head, ln...) + if rerr != nil { + break + } + if string(ln) == "\r\n" { + break + } + } + mu.Lock() + rawHead.Write(head) + mu.Unlock() + c.Write([]byte("HTTP/1.1 200 OK\r\nContent-Length: 2\r\nContent-Type: application/json\r\n\r\n{}")) + }(conn) + } + }() + + tr := &http.Transport{ + DialTLSContext: newTLSDialer(newDialer(), &tls.Config{InsecureSkipVerify: true}, TLSFingerprintGo), + } + httpClient := &http.Client{Transport: tr} + c := &Client{HTTP: httpClient, ChatHTTP: httpClient, ChatBaseCN: "https://" + ln.Addr().String()} + a := &auth.Auth{UID: "uid-e2e", AccessToken: "AT", Nickname: "e2e"} + meta := ChatMeta{ + ConversationID: "f7c6c392-e016-43bb-beca-ab918b436668", + ConversationRequestID: "01a194ad31c27d81804ee9915cf954fb", + } + + req, _ := http.NewRequest(http.MethodPost, "https://"+ln.Addr().String()+"/v2/chat/completions", + strings.NewReader(`{"model":"x","messages":[]}`)) + c.ChatHeaders(req, a, "", meta) + resp, derr := c.do(req, a, true) + if derr != nil { + t.Fatalf("do: %v", derr) + } + resp.Body.Close() + + mu.Lock() + got := rawHead.String() + mu.Unlock() + if got == "" { + t.Fatal("服务端没收到请求头") + } + + _, offHeaders := splitFixture(t, "official_chat_head.txt") + lines := strings.Split(got, "\r\n") + if len(lines) < 2 { + t.Fatalf("头块异常: %q", got) + } + var gotOrder []string + for _, ln := range lines[1:] { + if ln == "" { + continue + } + if i := strings.Index(ln, ":"); i > 0 { + gotOrder = append(gotOrder, ln[:i]) + } + } + + // 官方顺序里的头,在本项目出站里的相对次序必须与官方一致。 + rank := map[string]int{} + for i, h := range offHeaders { + if j := strings.Index(h, ":"); j > 0 { + rank[strings.ToLower(h[:j])] = i + } + } + lastRank := -1 + lastName := "" + for _, h := range gotOrder { + r, ok := rank[strings.ToLower(h)] + if !ok { + continue // 表外头(如 Host 之外的临时头)跳过 + } + if r < lastRank { + t.Fatalf("顺序偏离官方:%q(rank %d) 出现在 %q(rank %d) 之后\n实际顺序: %v", + h, r, lastName, lastRank, gotOrder) + } + lastRank, lastName = r, h + } + t.Logf("实际出站顺序: %v", gotOrder) +} diff --git a/internal/upstream/headorder_test.go b/internal/upstream/headorder_test.go new file mode 100644 index 0000000000000000000000000000000000000000..ff4fb793da6ff1188b141e11d8d9aa627b177f06 --- /dev/null +++ b/internal/upstream/headorder_test.go @@ -0,0 +1,297 @@ +// headorder_test.go 头顺序重排的回归测试。 +// +// 判据不用手写期望值,而是**直接拿官方夹具当 oracle**:把夹具的头顺序打乱 +// 再喂进 reorderHeadBlock,输出必须逐行等于夹具原文。夹具本身来自真机抓包 +// (见 testdata/official_*_head.txt),所以这条链路红 == 与官方顺序不符。 +package upstream + +import ( + "bytes" + "io" + "net" + "os" + "path/filepath" + "strings" + "sync" + "testing" +) + +// splitFixture 把夹具切成 (请求行, []头行)。 +func splitFixture(t *testing.T, name string) (string, []string) { + t.Helper() + raw, err := os.ReadFile(filepath.Join("testdata", name)) + if err != nil { + t.Fatalf("读夹具 %s: %v", name, err) + } + var first string + var rest []string + for i, ln := range strings.Split(string(raw), "\n") { + ln = strings.TrimRight(ln, "\r") + if ln == "" { + continue + } + if i == 0 { + first = ln + continue + } + rest = append(rest, ln) + } + return first, rest +} + +// shuffleHeaders 确定性反转(不用随机:测试必须可复现)。 +func shuffleHeaders(h []string) []string { + out := make([]string, len(h)) + for i := range h { + out[i] = h[len(h)-1-i] + } + return out +} + +func buildBlock(first string, headers []string) []byte { + var b bytes.Buffer + b.WriteString(first + "\r\n") + for _, h := range headers { + b.WriteString(h + "\r\n") + } + b.WriteString("\r\n") + return b.Bytes() +} + +// TestReorderHeadBlockMatchesOfficial 每张夹具:打乱 → 重排 → 必须等于原文。 +func TestReorderHeadBlockMatchesOfficial(t *testing.T) { + for _, f := range []string{ + "official_chat_head.txt", + "official_report_cn_head.txt", + "official_chat_busy_head.txt", + "official_v3config_head.txt", + } { + t.Run(strings.TrimSuffix(strings.TrimPrefix(f, "official_"), "_head.txt"), func(t *testing.T) { + first, want := splitFixture(t, f) + got := reorderHeadBlock(buildBlock(first, shuffleHeaders(want))) + wantBlock := buildBlock(first, want) + if string(got) != string(wantBlock) { + t.Errorf("重排结果与官方不一致\n--- got ---\n%s\n--- want ---\n%s", got, wantBlock) + } + }) + } +} + +// TestReorderHeadBlockUnknownPathUntouched 顺序表外的路径必须原样返回。 +func TestReorderHeadBlockUnknownPathUntouched(t *testing.T) { + in := buildBlock("GET /v9/nothing HTTP/1.1", []string{"Zeta: 1", "Alpha: 2"}) + if got := reorderHeadBlock(in); string(got) != string(in) { + t.Errorf("未知路径不该重排:\n%s", got) + } +} + +// TestReorderHeadBlockExtraHeadersAppended 表外头保持原序追加在末尾。 +func TestReorderHeadBlockExtraHeadersAppended(t *testing.T) { + first, headers := splitFixture(t, "official_v3config_head.txt") + // 表外头放在最前,打乱后仍应保持它们的相对顺序(表外头之间不排序) + withExtra := append([]string{"X-Brand-New: 1", "X-Another: 2"}, headers...) + shuffled := shuffleHeaders(withExtra) + got := string(reorderHeadBlock(buildBlock(first, shuffled))) + + if !strings.HasSuffix(got, "\r\n\r\n") { + t.Fatalf("头块结尾异常:\n%s", got) + } + // 反转输入后 X-Another 在前,输出应保持这个相对顺序(表外头之间不排序) + if tail := got[len(got)-len("X-Brand-New: 1\r\n\r\n"):]; tail != "X-Brand-New: 1\r\n\r\n" { + t.Errorf("表外头应追加在末尾,尾部=%q\n全文:\n%s", tail, got) + } + if !strings.Contains(got, "X-Another: 2\r\nX-Brand-New: 1") { + t.Errorf("表外俩头的相对顺序应与输入一致(输入反转后 X-Another 在前):\n%s", got) + } + // 表内头仍按官方序 + if !strings.HasPrefix(got, "GET /v3/config HTTP/1.1\r\nAccept: ") { + t.Errorf("表内头顺序被破坏:\n%s", got) + } +} + +// TestReorderHeadBlockMalformed 畸形输入不 panic、不破坏。 +func TestReorderHeadBlockMalformed(t *testing.T) { + cases := []string{ + "", + "POST /v2/chat/completions HTTP/1.1\r\n", // 无结尾空行 + "garbage", + "\r\n\r\n", + } + for _, in := range cases { + func() { + defer func() { + if r := recover(); r != nil { + t.Errorf("输入 %q panic: %v", in, r) + } + }() + _ = reorderHeadBlock([]byte(in)) + }() + } +} + +// pipeConn 用 net.Pipe 抽出 headOrderConn 的写侧行为(读侧另测)。 +func newTestPipe(t *testing.T) (*headOrderConn, net.Conn) { + t.Helper() + a, b := net.Pipe() + t.Cleanup(func() { a.Close(); b.Close() }) + return &headOrderConn{Conn: a}, b +} + +// TestHeadOrderConnWriteReorders 一次写完整头块:对端应收到官方顺序。 +func TestHeadOrderConnWriteReorders(t *testing.T) { + c, peer := newTestPipe(t) + first, headers := splitFixture(t, "official_v3config_head.txt") + in := buildBlock(first, shuffleHeaders(headers)) + + var wg sync.WaitGroup + wg.Add(1) + var got []byte + go func() { + defer wg.Done() + buf := make([]byte, 4096) + n, _ := peer.Read(buf) + got = buf[:n] + }() + if _, err := c.Write(in); err != nil { + t.Fatalf("write: %v", err) + } + wg.Wait() + if !strings.HasPrefix(string(got), "GET /v3/config HTTP/1.1\r\nAccept: ") { + t.Errorf("写侧未重排:\n%s", got) + } +} + +// TestHeadOrderConnWriteSplitAcrossCalls 头块分两次写也能重排(bufio 分块场景)。 +func TestHeadOrderConnWriteSplitAcrossCalls(t *testing.T) { + c, peer := newTestPipe(t) + first, headers := splitFixture(t, "official_v3config_head.txt") + in := buildBlock(first, shuffleHeaders(headers)) + cut := len(in) / 2 + + var wg sync.WaitGroup + wg.Add(1) + var got []byte + go func() { + defer wg.Done() + buf := make([]byte, 4096) + n, _ := peer.Read(buf) // 一次读够整块(写侧是整块 flush) + got = append(got, buf[:n]...) + }() + + // 两次写:第一次只有半截头,不应下发;第二次补齐后整块按官方序下发 + if _, err := c.Write(in[:cut]); err != nil { + t.Fatalf("write1: %v", err) + } + if _, err := c.Write(in[cut:]); err != nil { + t.Fatalf("write2: %v", err) + } + wg.Wait() + if !strings.HasPrefix(string(got), "GET /v3/config HTTP/1.1\r\nAccept: ") { + t.Errorf("分块写未重排:\n%s", got) + } +} + +// TestRespTrackerContentLength 有 Content-Length 时按字节数判断结束。 +func TestRespTrackerContentLength(t *testing.T) { + var tr respTracker + if tr.feed([]byte("HTTP/1.1 200 OK\r\nContent-Length: 5\r\n\r\n")) { + t.Fatal("body 未到不该结束") + } + if tr.feed([]byte("abc")) { + t.Fatal("body 未满不该结束") + } + if !tr.feed([]byte("de")) { + t.Fatal("body 满应结束") + } +} + +// TestRespTrackerChunked chunked 按分帧结束判定。 +func TestRespTrackerChunked(t *testing.T) { + var tr respTracker + head := "HTTP/1.1 200 OK\r\nTransfer-Encoding: chunked\r\n\r\n" + if tr.feed([]byte(head + "3\r\nabc\r\n")) { + t.Fatal("chunked 未完不该结束") + } + if !tr.feed([]byte("0\r\n\r\n")) { + t.Fatal("结束块应判定完成") + } +} + +// TestRespTrackerSSEChunked SSE 长流:多段数据、最后 0 块结束。 +func TestRespTrackerSSEChunked(t *testing.T) { + var tr respTracker + if tr.feed([]byte("HTTP/1.1 200 OK\r\nTransfer-Encoding: chunked\r\n\r\n")) { + t.Fatal("不该结束") + } + // 每段 payload = "data: {}\n\n" 共 10 字节 → chunk size a + for i := 0; i < 3; i++ { + if tr.feed([]byte("a\r\ndata: {}\n\n\r\n")) { + t.Fatalf("第 %d 段不该结束", i) + } + } + if !tr.feed([]byte("0\r\n\r\n")) { + t.Fatal("SSE 结束块应判定完成") + } +} + +// TestRespTrackerUnknownFallsBack 无长度无 chunked → 标记 unknown,永不误判完成。 +func TestRespTrackerUnknownFallsBack(t *testing.T) { + var tr respTracker + done := tr.feed([]byte("HTTP/1.1 200 OK\r\nConnection: close\r\n\r\nsome body")) + if done { + t.Fatal("无边界信息时不该判定完成") + } + if !tr.unknown { + t.Fatal("应标记 unknown 走安全降级") + } + if tr.feed([]byte("more")) { + t.Fatal("unknown 之后不该再判定完成") + } +} + +// TestResponseBoundaryResetsPhase 响应结束应把连接状态复位,下一个请求才能重排。 +func TestResponseBoundaryResetsPhase(t *testing.T) { + var tr respTracker + tr.feed([]byte("HTTP/1.1 200 OK\r\nContent-Length: 2\r\n\r\n")) + if !tr.feed([]byte("ok")) { + t.Fatal("应判定完成") + } + // 复位后能吃下一个响应(同一连接 keep-alive 场景) + tr2 := respTracker{} + if !tr2.feed([]byte("HTTP/1.1 200 OK\r\nContent-Length: 0\r\n\r\n")) { + t.Fatal("零长度响应应立即完成") + } +} + +// TestReorderPreservesBody 头块之后的数据必须原样透传(不能吞 body)。 +func TestReorderPreservesBody(t *testing.T) { + c, peer := newTestPipe(t) + first, headers := splitFixture(t, "official_v3config_head.txt") + head := buildBlock(first, shuffleHeaders(headers)) + body := []byte("{\"k\":\"v\"}") + in := append(append([]byte{}, head...), body...) + + var wg sync.WaitGroup + wg.Add(1) + var got []byte + go func() { + defer wg.Done() + buf := make([]byte, 8192) + for { + n, err := peer.Read(buf) + if n > 0 { + got = append(got, buf[:n]...) + } + if err != nil || bytes.Contains(got, body) { + return + } + } + }() + c.Write(in) + wg.Wait() + if !bytes.HasSuffix(got, body) { + t.Errorf("body 丢了或被改: %q", got) + } +} + +var _ = io.Discard diff --git a/internal/upstream/hint.go b/internal/upstream/hint.go index 4bcab9adbf8eafa65db220335ad017e354dbf1f0..5a490fb343578ce9a3f8928372c7efab39c6313e 100644 --- a/internal/upstream/hint.go +++ b/internal/upstream/hint.go @@ -1,149 +1,191 @@ -// hint.go 网关错误附加说明字段(error.gateway_hint)的单一事实来源。 -// -// 纪律(任务书 gateway-hint): -// - error.message 永远是上游 body 原文透传(5755fe3 透传原则不动); -// gateway_hint 只做与 message **并列**的网关视角补充说明,绝不替换/包装 message。 -// - 文案集中在本文件(一张 Kind 表 + 11133/11135 形态判定),按 ErrKind + 上下文 -// (请求带图/模型目录能力)映射,不散落 handler 的 if-else。 -// - 未覆盖形态返回空串 → 响应不带该字段(不编造)。 -// - hint 措辞是英文(错误响应面向客户端工具链,英文是通用口径)。 -package upstream - -import ( - "encoding/json" - "net/http" - "strings" -) - -// GatewayHint 按错误形态返回网关视角的补充说明(error.gateway_hint 字段值)。 -// msg 是上游错误 body 原文(或 SSE error 帧 payload);kind 是权威分类 -// (Classify / *Error 信封)。返回空串 = 未覆盖形态,调用方不带字段。 -// -// ctx 携带判定 hint 所需的请求侧上下文(零值合法,信息缺失时相关形态退为中性 -// hint 或无 hint): -// - HasImage:请求体是否携带 image_url part(11133 的「模型不支持图片」指向前提); -// - Model / ModelInCatalog / ModelSupportsImages:模型目录对该模型的 -// supports_images 声明(目录未收录 → 不做「不支持」判定,防查不到误判成不支持)。 -// -// 判定次序:11133/11135 上游业务码**先于** Kind 表——实测这两族归 ErrClient/ -// ErrBadParams 皆有可能(Classify 词表不含 11133),hint 层自带判定(hint 是补充 -// 说明非权威分类,误判代价只是多一条中性补充说明);其余走 Kind 一对一映射。 -func GatewayHint(kind ErrKind, msg string, ctx HintContext) string { - // 11133 model_param_invalid 家族(图片回归实测:不支持图片的模型传图,或任意 - // 参数被模型供应商拒绝)。只有请求确实带图、且目录能对该模型做出「不支持图片」 - // 的判定时才给「换模型」指向,否则退中性参数形态(可能是任意参数问题,不点名图片)。 - if isModelParamInvalid(msg) { - if ctx.HasImage && ctx.ModelInCatalog && !ctx.ModelSupportsImages { - return "model " + ctx.Model + " does not support images; pick one with supports_images=true from /v1/models" - } - return "request parameters were rejected by the model provider; check message format and model capabilities" - } - // 11135 invalid_image_data 家族(图片数据无效,Discussion #77 实测形态)。 - if isInvalidImageData(msg) { - return "image data rejected by upstream; use a real/valid image, may need a new conversation" - } - switch kind { - case ErrPromptTooLong: - return "request context exceeds the model's limit; reduce history/message size" - case ErrImageInvalid: - return "image request was rejected by upstream; check image_url format and image data" - case ErrWafBlock: - // 账号级 WAF 403 与 IP 级 fail-fast 同 hint:两者对客户端的动作一致 - // (等待窗口过去再试,换号/立刻重试无意义)。 - return "upstream WAF blocked the gateway; retry after the block window" - case ErrSoftRate: - return "rate limited by upstream; retry after reset" - case ErrAccountFault: - return "account-level fault at upstream (auth/quota state); the gateway will rotate or disable this account" - case ErrSessionDead: - return "account session expired at upstream; the account is disabled until re-login" - case ErrHardCredit: - return "account credits exhausted at upstream; waiting for daily check-in to restore" - case ErrModelBlocked: - return "upstream has no such model on this backend; switch model or retry on another account" - case ErrContentBlocked: - // 措辞不含 "upstream":content_blocked 响应有不含上游字样的既有口径 - // (handler_test 的泄漏守卫),hint 遵守同一口径。 - return "request content was rejected by content policy; adjust the prompt and retry" - default: - // ErrNone/ErrNotFound/ErrServer/ErrBadParams/ErrClient 等未覆盖形态:无 hint。 - return "" - } -} - -// HintContext gateway_hint 判定所需的请求侧上下文(handler 侧组装,见 -// Handler.hintContext)。零值合法。 -type HintContext struct { - Model string // 请求裸模型名(可空) - HasImage bool // 请求体是否携带 image_url part - ModelSupportsImages bool // 模型目录 supports_images 声明(仅 ModelInCatalog 时有意义) - ModelInCatalog bool // 模型目录是否收录该模型(「不支持」判定的前提) -} - -// noHealthyHint 本地调度类错误(池中无健康号可用/传输层抖动,无上游原文可透传) -// 的固定 hint。不进 GatewayHint:它没有 ErrKind,是网关自己的调度事实。 -const noHealthyHint = "no healthy account available in pool; check /status or retry later" - -// NoHealthyAccountHint 本地调度错误的 gateway_hint(与 no_healthy_account code 配套)。 -func NoHealthyAccountHint() string { return noHealthyHint } - -// FrameHintFunc 返回 SSE error 帧的 gateway_hint 判定函数(Stream 的可选参数)。 -// ctxFn 惰性求值:仅在实际撞到 error 帧才调用(正常流零开销,模型目录查询 -// 不会为每个成功请求触发)。 -func FrameHintFunc(ctxFn func() HintContext) func(string) string { - return func(payload string) string { - if payload == "" || payload == "[DONE]" { - return "" - } - return GatewayHint(FrameKind(payload), payload, ctxFn()) - } -} - -// FrameKind 从 SSE error 帧 payload 判定 ErrKind:6004 模型级限流的流式形态 -// (IsModelRateLimit 对帧 JSON 直接命中)优先;其余取帧内 error.message 走 -// Classify(请求级 400 口径)。判不出 → ErrNone(无 hint)。 -func FrameKind(payload string) ErrKind { - if IsModelRateLimit(payload) { - return ErrSoftRate - } - var f struct { - Error struct { - Message string `json:"message"` - } `json:"error"` - } - if json.Unmarshal([]byte(payload), &f) != nil || f.Error.Message == "" { - return ErrNone - } - return Classify(http.StatusBadRequest, f.Error.Message) -} - -// isModelParamInvalid 上游 11133 body 判定(code 11133 / extError.code= -// model_param_invalid / msg 文案家族)。子串口径:hint 是补充说明非权威分类, -// 宁宽勿漏。 -func isModelParamInvalid(body string) bool { - lower := strings.ToLower(body) - return codeMarker(lower, "11133") || - strings.Contains(lower, "model_param_invalid") || - strings.Contains(lower, "invalid request parameters") || - strings.Contains(lower, "request parameters do not meet the current model requirements") -} - -// isInvalidImageData 上游 11135 body 判定(code 11135 / invalid_image_data / -// "replace the image" msg 家族)。 -func isInvalidImageData(body string) bool { - lower := strings.ToLower(body) - return codeMarker(lower, "11135") || - strings.Contains(lower, "invalid_image_data") || - strings.Contains(lower, "replace the image") -} - -// codeMarker JSON code 字段命中(`"code":N` / `"code": N` / `"code":"N"` 形态, -// 与 IsModelBlocked 的 code 判定同容差口径)。lower 须为小写 body。 -func codeMarker(lower, code string) bool { - for _, v := range []string{`"code":` + code, `"code": ` + code, `"code":"` + code + `"`, `"code": "` + code + `"`, `"code":" ` + code + `"`, `"code": '` + code + `'`} { - if strings.Contains(lower, v) { - return true - } - } - return false -} +// hint.go 网关错误附加说明字段(error.gateway_hint)的单一事实来源。 +// +// 纪律(任务书 gateway-hint): +// - error.message 永远是上游 body 原文透传(5755fe3 透传原则不动); +// gateway_hint 只做与 message **并列**的网关视角补充说明,绝不替换/包装 message。 +// - 文案集中在本文件(一张 Kind 表 + 11133/11135 形态判定),按 ErrKind + 上下文 +// (请求带图/模型目录能力)映射,不散落 handler 的 if-else。 +// - 未覆盖形态返回空串 → 响应不带该字段(不编造)。 +// - hint 措辞是英文(错误响应面向客户端工具链,英文是通用口径)。 +package upstream + +import ( + "encoding/json" + "net/http" + "strings" +) + +// GatewayHint 按错误形态返回网关视角的补充说明(error.gateway_hint 字段值)。 +// msg 是上游错误 body 原文(或 SSE error 帧 payload);kind 是权威分类 +// (Classify / *Error 信封)。返回空串 = 未覆盖形态,调用方不带字段。 +// +// ctx 携带判定 hint 所需的请求侧上下文(零值合法,信息缺失时相关形态退为中性 +// hint 或无 hint): +// - HasImage:请求体是否携带 image_url part(11133 的「模型不支持图片」指向前提); +// - Model / ModelInCatalog / ModelSupportsImages:模型目录对该模型的 +// supports_images 声明(目录未收录 → 不做「不支持」判定,防查不到误判成不支持)。 +// +// 判定次序:11133/11135 上游业务码**先于** Kind 表——实测这两族归 ErrClient/ +// ErrBadParams 皆有可能(Classify 词表不含 11133),hint 层自带判定(hint 是补充 +// 说明非权威分类,误判代价只是多一条中性补充说明);其余走 Kind 一对一映射。 +func GatewayHint(kind ErrKind, msg string, ctx HintContext) string { + // 11133 model_param_invalid 家族(图片回归实测:不支持图片的模型传图,或任意 + // 参数被模型供应商拒绝)。只有请求确实带图、且目录**显式声明**该模型不支持图片 + // 时才给「换模型」指向——目录只收录而不声明该能力(缺键)时无从判断,退中性 + // 参数形态(断言「不支持」等于编造能力事实,客户端会照 hint 白换模型)。 + if isModelParamInvalid(msg) { + if ctx.HasImage && ctx.ModelInCatalog && ctx.ModelSupportsImagesKnown && !ctx.ModelSupportsImages { + return "model " + ctx.Model + " does not support images; pick one with supports_images=true from /v1/models" + } + return "request parameters were rejected by the model provider; check message format and model capabilities" + } + // 11135 invalid_image_data 家族(图片数据无效,Discussion #77 实测形态)。 + if isInvalidImageData(msg) { + return "image data rejected by upstream; use a real/valid image, may need a new conversation" + } + switch kind { + case ErrPromptTooLong: + return "request context exceeds the model's limit; reduce history/message size" + case ErrImageInvalid: + return "image request was rejected by upstream; check image_url format and image data" + case ErrWafBlock: + // 账号级 WAF 403 与 IP 级 fail-fast 同 hint:两者对客户端的动作一致 + // (等待窗口过去再试,换号/立刻重试无意义)。 + return "upstream WAF blocked the gateway; retry after the block window" + case ErrSoftRate: + return "rate limited by upstream; retry after reset" + case ErrAccountFault: + return "account-level fault at upstream (auth/quota state); the gateway will rotate or disable this account" + case ErrSessionDead: + return "account session expired at upstream; the account is disabled until re-login" + case ErrHardCredit: + // 不能说「等签到恢复」:国际版账号**没有签到活动**(本网关日志:国际版签到 + // 活动未开启,跳过),积分只能靠充值/订阅恢复。旧文案对 global 号的持有者 + // 是一个永远不会兑现的承诺(issue #191 的延伸)。 + return "account credits exhausted at upstream; CN accounts recover via the next daily check-in, global accounts need a top-up" + case ErrUpstreamBusy: + // 6021 queue.full:渠道级容量满载。措辞明确「不是账号问题、换号无意义」, + // 指引客户端短等待后重试(SDK 指数退避天然适配)。 + return "upstream admission queue is full (channel-level capacity, not an account problem); retry after a short wait" + case ErrToolMismatch: + // 11148 配对断裂:请求内容(会话历史里的 tool_calls / tool 结果)本身对不上, + // 上游明示「直接重试无效,请新建任务」。措辞指向「开新会话」而不是「换个账号 + // 重试」——换号/重试都必然同样失败。 + return "request tool-call history is broken (call/result mismatch); upstream rejects this request as-is — start a new conversation instead of retrying" + case ErrEmptyContent: + // 11151 空段:上游对「某条消息的 text 段是空串」判硬 400。出站前网关已补位, + // 客户端能做的是把那条空消息删掉或换新会话——重试必然复现。 + return "request history contains an empty text block; upstream rejects it as-is — drop that message or start a new conversation" + case ErrModelBlocked: + return "upstream has no such model on this backend; switch model or retry on another account" + case ErrContentBlocked: + // 措辞不含 "upstream":content_blocked 响应有不含上游字样的既有口径 + // (handler_test 的泄漏守卫),hint 遵守同一口径。 + return "request content was rejected by content policy; adjust the prompt and retry" + default: + // ErrNone/ErrNotFound/ErrServer/ErrBadParams/ErrClient 等未覆盖形态:无 hint。 + return "" + } +} + +// HintContext gateway_hint 判定所需的请求侧上下文(handler 侧组装,见 +// Handler.hintContext)。零值合法。 +type HintContext struct { + Model string // 请求裸模型名(可空) + HasImage bool // 请求体是否携带 image_url part + ModelSupportsImages bool // 模型目录 supports_images 声明(仅 ModelInCatalog 时有意义) + // ModelSupportsImagesKnown 目录是否**显式**声明过该能力。缺失时不得断言「不支持 + // 图片」(那是编造能力事实),只能退中性参数文案。 + ModelSupportsImagesKnown bool + ModelInCatalog bool // 模型目录是否收录该模型(「不支持」判定的前提) +} + +// noHealthyHint 本地调度类错误(池中无健康号可用/传输层抖动,无上游原文可透传) +// 的固定 hint。不进 GatewayHint:它没有 ErrKind,是网关自己的调度事实。 +const noHealthyHint = "no healthy account available in pool; check /status or retry later" + +// NoHealthyAccountHint 本地调度错误的 gateway_hint(与 no_healthy_account code 配套)。 +func NoHealthyAccountHint() string { return noHealthyHint } + +// NoHealthyAccountHintForModel 本地调度错误的 gateway_hint,带 realm 感知。 +// +// 为什么需要它:裸模型名一律按 cn 域路由(见 server.resolveModel)。池里若只有 +// 另一域的账号,选号必然失败,但固定文案 "check /status" 会把人指向一个永远健康的 +// 面板——池子没毛病,是请求落错了域,重试多少次结果都一样。此时直接把「该怎么写」 +// 告诉客户端,比让人去翻 issue 有用。 +// +// otherRealm 为空 = 另一域也没有该模型的健康号(或模型名为空),退回固定文案, +// 不对能力做任何断言。 +func NoHealthyAccountHintForModel(bareModel, otherRealm string) string { + if bareModel == "" || otherRealm == "" { + return noHealthyHint + } + return `model "` + bareModel + `" is only available in the ` + otherRealm + + ` realm; retry with "` + otherRealm + `:` + bareModel + `"` +} + +// FrameHintFunc 返回 SSE error 帧的 gateway_hint 判定函数(Stream 的可选参数)。 +// ctxFn 惰性求值:仅在实际撞到 error 帧才调用(正常流零开销,模型目录查询 +// 不会为每个成功请求触发)。 +func FrameHintFunc(ctxFn func() HintContext) func(string) string { + return func(payload string) string { + if payload == "" || payload == "[DONE]" { + return "" + } + return GatewayHint(FrameKind(payload), payload, ctxFn()) + } +} + +// FrameKind 从 SSE error 帧 payload 判定 ErrKind:6004 模型级限流的流式形态 +// (IsModelRateLimit 对帧 JSON 直接命中)优先;其余取帧内 error.message 走 +// Classify(请求级 400 口径)。判不出 → ErrNone(无 hint)。 +func FrameKind(payload string) ErrKind { + if IsModelRateLimit(payload) { + return ErrSoftRate + } + var f struct { + Error struct { + Message string `json:"message"` + } `json:"error"` + } + if json.Unmarshal([]byte(payload), &f) != nil || f.Error.Message == "" { + return ErrNone + } + return Classify(http.StatusBadRequest, f.Error.Message) +} + +// isModelParamInvalid 上游 11133 body 判定(code 11133 / extError.code= +// model_param_invalid / msg 文案家族)。子串口径:hint 是补充说明非权威分类, +// 宁宽勿漏。 +func isModelParamInvalid(body string) bool { + lower := strings.ToLower(body) + return codeMarker(lower, "11133") || + strings.Contains(lower, "model_param_invalid") || + strings.Contains(lower, "invalid request parameters") || + strings.Contains(lower, "request parameters do not meet the current model requirements") +} + +// isInvalidImageData 上游 11135 body 判定(code 11135 / invalid_image_data / +// "replace the image" msg 家族)。 +func isInvalidImageData(body string) bool { + lower := strings.ToLower(body) + return codeMarker(lower, "11135") || + strings.Contains(lower, "invalid_image_data") || + strings.Contains(lower, "replace the image") +} + +// codeMarker JSON code 字段命中(`"code":N` / `"code": N` / `"code":"N"` 形态, +// 与 IsModelBlocked 的 code 判定同容差口径)。lower 须为小写 body。 +// HasCodeMarker 包外判据入口(server 侧 applyErrorPolicy 分野用):按 codeMarker 的空白 +// 容差在原文里找业务码。同一条 msg 骑不同 code 的故障要靠它区分——例如 "request illegal" +// 既是 11140 授权风控,也是 "11-128" 渠道校验拦截(见 handler 的 ErrAccountFault 分支)。 +func HasCodeMarker(body, code string) bool { return codeMarker(strings.ToLower(body), code) } + +func codeMarker(lower, code string) bool { + for _, v := range []string{`"code":` + code, `"code": ` + code, `"code":"` + code + `"`, `"code": "` + code + `"`, `"code":" ` + code + `"`, `"code": '` + code + `'`} { + if strings.Contains(lower, v) { + return true + } + } + return false +} diff --git a/internal/upstream/hint_test.go b/internal/upstream/hint_test.go new file mode 100644 index 0000000000000000000000000000000000000000..8ea69bcb2d3df8d353bc9ff54f04052521500d60 --- /dev/null +++ b/internal/upstream/hint_test.go @@ -0,0 +1,127 @@ +package upstream + +import ( + "encoding/json" + "testing" +) + +// hint 层此前完全没有测试(这正是 supportsImages 丢 ok 的 bug 能活下来的原因)。 +// 这里守住两条:能力断言只在目录**显式声明**时才给,以及各 Kind 的中性回落。 + +func TestGatewayHintModelParamInvalidImageTriState(t *testing.T) { + const msg = `{"code":11133,"msg":"the request parameters were rejected by the model provider"}` + const neutral = "request parameters were rejected by the model provider; check message format and model capabilities" + + // 目录声明了 false(显式):才敢断言「不支持图片」。 + got := GatewayHint(ErrModelParamInvalid, msg, HintContext{ + Model: "glm-x", HasImage: true, ModelInCatalog: true, + ModelSupportsImagesKnown: true, ModelSupportsImages: false, + }) + if got != "model glm-x does not support images; pick one with supports_images=true from /v1/models" { + t.Errorf("显式 false 应给出换模型指向,got=%q", got) + } + + // 目录**没声明**该能力(缺键):无从判断 → 中性文案,不得断言不支持。 + got = GatewayHint(ErrModelParamInvalid, msg, HintContext{ + Model: "auto-chat", HasImage: true, ModelInCatalog: true, + ModelSupportsImagesKnown: false, ModelSupportsImages: false, + }) + if got != neutral { + t.Errorf("缺声明时必须退中性文案(不得编造能力事实),got=%q", got) + } + + // 声明支持图片、但请求确实带图且参数被拒 → 中性(问题不在图片)。 + got = GatewayHint(ErrModelParamInvalid, msg, HintContext{ + Model: "glm-x", HasImage: true, ModelInCatalog: true, + ModelSupportsImagesKnown: true, ModelSupportsImages: true, + }) + if got != neutral { + t.Errorf("支持图片的模型被拒参数时应中性,got=%q", got) + } + + // 未带图的 11133:中性(可能是任意参数问题,不点名图片)。 + if got = GatewayHint(ErrModelParamInvalid, msg, HintContext{Model: "glm-x", ModelInCatalog: true}); got != neutral { + t.Errorf("未带图应中性,got=%q", got) + } +} + +func TestGatewayHintKindsAndFallback(t *testing.T) { + if got := GatewayHint(ErrNone, "", HintContext{}); got != "" { + t.Errorf("未覆盖形态应返回空串(不带字段),got=%q", got) + } + if got := GatewayHint(ErrPromptTooLong, "too long", HintContext{}); got == "" { + t.Error("ErrPromptTooLong 应给 hint") + } + // 11135 先于 Kind 表判定(上游业务码优先)。 + if got := GatewayHint(ErrClient, `{"code":11135,"msg":"invalid_image_data"}`, HintContext{}); got == "" { + t.Error("11135 形态应给 hint(业务码先于 Kind 表)") + } +} + +// TestParseGlobalModelLooseSupportsImagesTriState 两个解析入口都必须把「缺键」与 +// 「显式 false」分开——否则 /v1/models 与 11133 的 hint 都无法区分「不支持」与「未知」。 +func TestParseGlobalModelLooseSupportsImagesTriState(t *testing.T) { + for _, tc := range []struct { + name string + raw string + wantVal, wantKnown bool + }{ + {"显式 true", `{"id":"m","supportsImages":true}`, true, true}, + {"显式 false", `{"id":"m","supportsImages":false}`, false, true}, + {"缺键", `{"id":"m"}`, false, false}, + } { + var obj map[string]any + if err := json.Unmarshal([]byte(tc.raw), &obj); err != nil { + t.Fatal(err) + } + mi, ok := parseGlobalModelLoose(obj) + if !ok { + t.Fatalf("%s: 解析失败", tc.name) + } + if mi.SupportsImages != tc.wantVal || mi.SupportsImagesSet != tc.wantKnown { + t.Errorf("%s: SupportsImages=%v(set=%v) want %v(set=%v)", + tc.name, mi.SupportsImages, mi.SupportsImagesSet, tc.wantVal, tc.wantKnown) + } + } +} + +// TestDynModelEntrySupportsImagesTriState CN 目录走 typed 解析(dynModelEntry), +// 缺键同样必须与显式 false 分开。 +func TestDynModelEntrySupportsImagesTriState(t *testing.T) { + for _, tc := range []struct { + name string + raw string + wantVal, wantKnown bool + }{ + {"显式 true", `{"id":"m","supportsImages":true}`, true, true}, + {"显式 false", `{"id":"m","supportsImages":false}`, false, true}, + {"缺键", `{"id":"m"}`, false, false}, + } { + var e dynModelEntry + if err := json.Unmarshal([]byte(tc.raw), &e); err != nil { + t.Fatal(err) + } + mi := e.modelInfo() + if mi.SupportsImages != tc.wantVal || mi.SupportsImagesSet != tc.wantKnown { + t.Errorf("%s: SupportsImages=%v(set=%v) want %v(set=%v)", + tc.name, mi.SupportsImages, mi.SupportsImagesSet, tc.wantVal, tc.wantKnown) + } + } +} + +// NoHealthyAccountHintForModel 只在「确认另一域能服务」时才改写文案;参数缺失一律 +// 退回固定文案,不对能力做任何断言。 +func TestNoHealthyAccountHintForModel(t *testing.T) { + want := `model "glm-5.3" is only available in the global realm; retry with "global:glm-5.3"` + if got := NoHealthyAccountHintForModel("glm-5.3", "global"); got != want { + t.Errorf("got %q want %q", got, want) + } + for _, c := range []struct{ bare, other string }{ + {"glm-5.3", ""}, + {"", "global"}, + } { + if got := NoHealthyAccountHintForModel(c.bare, c.other); got != noHealthyHint { + t.Errorf("NoHealthyAccountHintForModel(%q,%q) = %q, want fallback", c.bare, c.other, got) + } + } +} diff --git a/internal/upstream/hotpath_parse_count_test.go b/internal/upstream/hotpath_parse_count_test.go new file mode 100644 index 0000000000000000000000000000000000000000..2ff73f9314f285c10ac07d09f899234ff1a61e02 --- /dev/null +++ b/internal/upstream/hotpath_parse_count_test.go @@ -0,0 +1,92 @@ +package upstream + +import ( + "encoding/json" + "testing" + + "github.com/misakano7545/workbuddy2api-panel/internal/prompt" + "github.com/misakano7545/workbuddy2api-panel/internal/session" +) + +const hotPathBody = `{"model":"cn:deepseek-v4.1-flash","conversationId":"c-1","stream":true, + "messages":[{"role":"system","content":"sys"},{"role":"user","content":"hi"}], + "tools":[{"type":"function","function":{"name":"read_file","parameters":{"type":"object"}}}]}` + +// TestHotPathParseCount 守住「一个 chat 请求把同一个 body 整树解析几次」。 +// +// 线上「并发一高就降速」的根因就是这里:同一个 100~500KB body 被 5~6 条互不 +// 相干的代码路径各解析一遍(每条只读一两个字段)。解析次数不是审美问题—— +// 170K token 的请求体单次整树解析约 30ms,10 请求/秒就是 0.3 个核。 +// +// 用计数器而不是「返回值是不是同一块内存」来断言:EnsureSystemFirst 命中 +// system 分支时本来就原样返回 body,指针相同并不代表没解析过(第一版测试就 +// 因此漏检,变异测试没变红)。 +func TestHotPathParseCount(t *testing.T) { + body := []byte(hotPathBody) + + prompt.ResetParseCount() + if out := prompt.EnsureSystemFirst(body, "fallback"); string(out) != hotPathBody { + t.Fatalf("EnsureSystemFirst 改动了已是 system 首条的 body") + } + if n := prompt.ParseCount(); n != 0 { + t.Errorf("EnsureSystemFirst 首条已是 system 时解析 %d 次,应为 0", n) + } + + session.ResetParseCount() + if got := session.ExtractKey(body); got != "c-1" { + t.Errorf("ExtractKey = %q want c-1", got) + } + if got := session.ResolveConversationID(body); got != "c-1" { + t.Errorf("ResolveConversationID = %q want c-1", got) + } + if n := session.ParseCount(); n != 0 { + t.Errorf("显式会话键路径解析 %d 次,应为 0", n) + } + + ResetKimiToolsParseCount() + if out := prepareKimiTools(body, "cn"); string(out) != hotPathBody { + t.Fatalf("prepareKimiTools 改动/重构了非 kimi 请求") + } + if n := KimiToolsParseCount(); n != 0 { + t.Errorf("非 kimi 模型下 prepareKimiTools 解析 %d 次,应为 0", n) + } + + // 归一化本身必须改结构,这一次解析无法避免;但会话字段注入必须搭它同一趟车。 + ResetPrepareBodyParseCount() + out, _, _ := prepareBodyOpt(body, false, true, nil, nil, nil, "cn", nil, "uid", "c-1", true, 0, "conv-turn-1") + if n := PrepareBodyParseCount(); n != 1 { + t.Errorf("prepareBodyOpt 解析 %d 次,应为 1(会话字段注入已并入)", n) + } + var got struct { + Messages []struct { + Role string `json:"role"` + ConversationRequestID string `json:"conversationRequestId"` + } `json:"messages"` + } + if err := json.Unmarshal(out, &got); err != nil { + t.Fatalf("unmarshal: %v", err) + } + if len(got.Messages) < 2 || got.Messages[1].ConversationRequestID != "conv-turn-1" { + t.Fatalf("会话字段注入丢失: %s", out) + } +} + +// TestHotPathFallbacksStillParse 快路径的回落分支必须真的存在(扫描器认不出时 +// 仍走整树解析,行为不退化)。 +func TestHotPathFallbacksStillParse(t *testing.T) { + weird := []byte(`not-json`) + prompt.ResetParseCount() + if out := prompt.EnsureSystemFirst(weird, "fallback"); string(out) != "not-json" { + t.Fatalf("坏 body 应原样返回") + } + if n := prompt.ParseCount(); n != 1 { + t.Errorf("坏 body 应回落整树解析 1 次,实际 %d", n) + } + + kimi := []byte(`{"model":"cn:kimi-k2","tools":[]}`) + ResetKimiToolsParseCount() + prepareKimiTools(kimi, "cn") + if n := KimiToolsParseCount(); n != 1 { + t.Errorf("kimi 模型应解析 1 次,实际 %d", n) + } +} diff --git a/internal/upstream/idle.go b/internal/upstream/idle.go index bed254563f53a6ce292d98ab1903985dec7ad610..21a189ac2a135e95cd4ad12dfa246c105dda0ee6 100644 --- a/internal/upstream/idle.go +++ b/internal/upstream/idle.go @@ -1,87 +1,121 @@ -// idle.go 聊天 SSE 流中空闲监控:活跃吐数据续命不掐,静默超过阈值才断流(释放租约)。 -package upstream - -import ( - "context" - "io" - "sync" - "time" -) - -// idleMonitoringBody 包在聊天 SSE body 外层: -// 每次读到底层数据(n>0)就刷新 lastRead;后台 goroutine 周期检查, -// 静默超过 idle 就 cancel 请求 context,中断阻塞中的 Read。 -type idleMonitoringBody struct { - rc io.ReadCloser - mu sync.Mutex - lastRead time.Time - stopOnce sync.Once - stopCh chan struct{} - cancel context.CancelFunc -} - -func (b *idleMonitoringBody) Read(p []byte) (int, error) { - n, err := b.rc.Read(p) - if n > 0 { - b.mu.Lock() - b.lastRead = time.Now() - b.mu.Unlock() - } - return n, err -} - -// Close 停掉后台 goroutine、取消请求 context、关闭底流,保证无泄漏。 -func (b *idleMonitoringBody) Close() error { - b.stopOnce.Do(func() { close(b.stopCh) }) - b.cancel() - return b.rc.Close() -} - -func (b *idleMonitoringBody) idleFor() time.Duration { - b.mu.Lock() - defer b.mu.Unlock() - return time.Since(b.lastRead) -} - -// monitorBody 若 idle<=0 直接返回原底流(禁用空闲监控); -// 否则包上流中空闲监控。计时从返回 body 之后开始——首字节阶段由 -// Transport.ResponseHeaderTimeout 管,这里不抢跑。 -func monitorBody(rc io.ReadCloser, idle time.Duration, cancel context.CancelFunc) io.ReadCloser { - if idle <= 0 { - return rc - } - b := &idleMonitoringBody{ - rc: rc, - lastRead: time.Now(), - stopCh: make(chan struct{}), - cancel: cancel, - } - go func() { - t := time.NewTicker(idleTick(idle)) - defer t.Stop() - for { - select { - case <-b.stopCh: - return - case <-t.C: - if b.idleFor() > idle { - cancel() - return - } - } - } - }() - return b -} - -// idleTick 返回监控周期:idle/4,钳在 [10ms, 1s]。小 idle 也能快速发现,大小值避免空转。 -func idleTick(idle time.Duration) time.Duration { - d := idle / 4 - if d > time.Second { - d = time.Second - } - if d < 10*time.Millisecond { - d = 10 * time.Millisecond - } - return d -} +// idle.go 聊天 SSE 流中空闲监控:活跃吐数据续命不掐,静默超过阈值才断流(释放租约)。 +package upstream + +import ( + "context" + "io" + "sync" + "time" +) + +// idleMonitoringBody 包在聊天 SSE body 外层: +// 每次读到底层数据(n>0)就刷新 lastRead;后台 goroutine 周期检查, +// 静默超过 idle 就 cancel 请求 context,中断阻塞中的 Read。 +type idleMonitoringBody struct { + rc io.ReadCloser + mu sync.Mutex + lastRead time.Time + stopCh chan struct{} + cancel context.CancelFunc + + closeOnce sync.Once + closeErr error +} + +func (b *idleMonitoringBody) Read(p []byte) (int, error) { + n, err := b.rc.Read(p) + if n > 0 { + b.mu.Lock() + b.lastRead = time.Now() + b.mu.Unlock() + } + return n, err +} + +// tailDrainMax / tailDrainWait Close 前读掉流尾的上限:读到 EOF 连接才回连接池。 +// 读者在 [DONE] 处就停了,上游随后才发 chunked 结束块(几个字节,实测晚到十几毫秒); +// 直接取消 context 会让 Transport 丢弃连接,流式请求每次都要重新 TCP+TLS(经代理时 +// 还要再建一次隧道,首字节多出几百毫秒)。流没结束(客户端中途断开、换号)时最多多读 +// 4KB、多等 100ms 就照旧取消、关闭。 +const ( + tailDrainMax = 4 << 10 + tailDrainWait = 100 * time.Millisecond +) + +// Close 停掉后台 goroutine,读掉流尾让连接可复用,再取消请求 context、关闭底流,保证无泄漏。 +// 读尾放在独立 goroutine 里限时等:Close 不能指望底流的 Read 一定会被取消打断;超时后 +// 取消与关闭照常进行,HTTP body 被关闭时阻塞的 Read 随即返回,读尾 goroutine 退出。 +// +// 幂等:只有第一次真正执行,之后原样返回第一次的结果。调用链里常有两层各关一次(续写读取器 +// 在 [DONE] 处关一次,处理函数结束时外层再关一次);第二次若再去读流尾,读到的是「body 已 +// 关闭」,经代理时会被当成代理故障、清掉节点的空闲连接。 +func (b *idleMonitoringBody) Close() error { + b.closeOnce.Do(func() { b.closeErr = b.close() }) + return b.closeErr +} + +func (b *idleMonitoringBody) close() error { + close(b.stopCh) + drained := make(chan struct{}) + go func() { + _, _ = io.CopyN(io.Discard, b.rc, tailDrainMax) + close(drained) + }() + t := time.NewTimer(tailDrainWait) + select { + case <-drained: + case <-t.C: + } + t.Stop() + b.cancel() + return b.rc.Close() +} + +func (b *idleMonitoringBody) idleFor() time.Duration { + b.mu.Lock() + defer b.mu.Unlock() + return time.Since(b.lastRead) +} + +// monitorBody 若 idle<=0 直接返回原底流(禁用空闲监控); +// 否则包上流中空闲监控。计时从返回 body 之后开始——首字节阶段由 +// Transport.ResponseHeaderTimeout 管,这里不抢跑。 +func monitorBody(rc io.ReadCloser, idle time.Duration, cancel context.CancelFunc) io.ReadCloser { + if idle <= 0 { + return rc + } + b := &idleMonitoringBody{ + rc: rc, + lastRead: time.Now(), + stopCh: make(chan struct{}), + cancel: cancel, + } + go func() { + t := time.NewTicker(idleTick(idle)) + defer t.Stop() + for { + select { + case <-b.stopCh: + return + case <-t.C: + if b.idleFor() > idle { + cancel() + return + } + } + } + }() + return b +} + +// idleTick 返回监控周期:idle/4,钳在 [10ms, 1s]。小 idle 也能快速发现,大小值避免空转。 +func idleTick(idle time.Duration) time.Duration { + d := idle / 4 + if d > time.Second { + d = time.Second + } + if d < 10*time.Millisecond { + d = 10 * time.Millisecond + } + return d +} diff --git a/internal/upstream/idle_test.go b/internal/upstream/idle_test.go index 35250f6910b7b0126250b90b7ef9c402f07551b5..3e31eb5338ceb7f593790b554a92162427ebf614 100644 --- a/internal/upstream/idle_test.go +++ b/internal/upstream/idle_test.go @@ -1,115 +1,197 @@ -package upstream - -import ( - "context" - "io" - "testing" - "time" -) - -// TestMonitorBodyIdleCutoff 静默超过 idle(配小值)→ Read 返回错误(context canceled)。 -func TestMonitorBodyIdleCutoff(t *testing.T) { - ctx, cancel := context.WithCancel(context.Background()) - defer cancel() - // 模拟真实 resp.Body:阻塞直到请求 context 被 cancel 才返回 error。 - body := monitorBody(&ctxBoundReader{ctx: ctx}, 50*time.Millisecond, cancel) - defer body.Close() - if _, err := body.Read(make([]byte, 16)); err == nil { - t.Fatal("expect read error after idle cutoff") - } -} - -// TestMonitorBodyRenewsOnActivity 持续活跃(周期吐数据,总时长 > idle)→ 流不被掐。 -func TestMonitorBodyRenewsOnActivity(t *testing.T) { - _, cancel := context.WithCancel(context.Background()) - defer cancel() - // 每 30ms 吐 1 字节;idle=80ms。总读 10 字节耗时 300ms > idle: - // 若空闲续命失效(绝对 deadline 语义)早在 80ms 就被掐断。 - body := monitorBody(nopCloserBody{Reader: periodicReader{period: 30 * time.Millisecond}}, 80*time.Millisecond, cancel) - defer body.Close() - buf := make([]byte, 1) - for i := 0; i < 10; i++ { - if _, err := io.ReadFull(body, buf); err != nil { - t.Fatalf("read %d: %v (active stream must not be cut)", i, err) - } - } -} - -// TestMonitorBodyDisabledWhenIdleZero idle<=0 直接返回原底流。 -func TestMonitorBodyDisabledWhenIdleZero(t *testing.T) { - _, cancel := context.WithCancel(context.Background()) - defer cancel() - rc := nopCloserBody{Reader: &oneByteReader{}} - out := monitorBody(rc, 0, cancel) - if _, ok := out.(nopCloserBody); !ok { - t.Fatalf("idle<=0 should return underlying body verbatim, got %T", out) - } - buf := make([]byte, 1) - if _, err := out.Read(buf); err != nil || buf[0] != 'a' { - t.Fatalf("read=%q err=%v", buf, err) - } -} - -// TestMonitorBodyCloseStopsGoroutine Close 停掉 goroutine,无泄漏(等效监控循环 + 短周期)。 -func TestMonitorBodyCloseStopsGoroutine(t *testing.T) { - m := &idleMonitoringBody{ - rc: &ctxBoundReader{ctx: context.Background()}, - lastRead: time.Now(), - stopCh: make(chan struct{}), - cancel: func() {}, - } - stopped := make(chan struct{}) - go func() { - tk := time.NewTicker(idleTick(40 * time.Millisecond)) - defer tk.Stop() - for { - select { - case <-m.stopCh: - close(stopped) - return - case <-tk.C: - } - } - }() - m.Close() - select { - case <-stopped: - case <-time.After(time.Second): - t.Fatal("goroutine not stopped after Close") - } -} - -// —— helpers —— - -// ctxBoundReader 模拟 net/http resp.Body:Read 阻塞在 ctx.Done() 上,ctx cancel 后返回错误。 -type ctxBoundReader struct{ ctx context.Context } - -func (r *ctxBoundReader) Read([]byte) (int, error) { - <-r.ctx.Done() - return 0, r.ctx.Err() -} - -func (r *ctxBoundReader) Close() error { return nil } - -type periodicReader struct{ period time.Duration } - -func (r periodicReader) Read(p []byte) (int, error) { - time.Sleep(r.period) - p[0] = 'x' - return 1, nil -} - -type oneByteReader struct{ done bool } - -func (r *oneByteReader) Read(p []byte) (int, error) { - if r.done { - return 0, io.EOF - } - r.done = true - p[0] = 'a' - return 1, nil -} - -type nopCloserBody struct{ io.Reader } - -func (nopCloserBody) Close() error { return nil } +package upstream + +import ( + "bufio" + "context" + "errors" + "io" + "net/http" + "net/http/httptest" + "net/http/httptrace" + "strings" + "testing" + "time" +) + +// TestMonitorBodyIdleCutoff 静默超过 idle(配小值)→ Read 返回错误(context canceled)。 +func TestMonitorBodyIdleCutoff(t *testing.T) { + ctx, cancel := context.WithCancel(context.Background()) + defer cancel() + // 模拟真实 resp.Body:阻塞直到请求 context 被 cancel 才返回 error。 + body := monitorBody(&ctxBoundReader{ctx: ctx}, 50*time.Millisecond, cancel) + defer body.Close() + if _, err := body.Read(make([]byte, 16)); err == nil { + t.Fatal("expect read error after idle cutoff") + } +} + +// TestMonitorBodyRenewsOnActivity 持续活跃(周期吐数据,总时长 > idle)→ 流不被掐。 +func TestMonitorBodyRenewsOnActivity(t *testing.T) { + _, cancel := context.WithCancel(context.Background()) + defer cancel() + // 每 30ms 吐 1 字节;idle=80ms。总读 10 字节耗时 300ms > idle: + // 若空闲续命失效(绝对 deadline 语义)早在 80ms 就被掐断。 + body := monitorBody(nopCloserBody{Reader: periodicReader{period: 30 * time.Millisecond}}, 80*time.Millisecond, cancel) + defer body.Close() + buf := make([]byte, 1) + for i := 0; i < 10; i++ { + if _, err := io.ReadFull(body, buf); err != nil { + t.Fatalf("read %d: %v (active stream must not be cut)", i, err) + } + } +} + +// TestMonitorBodyDisabledWhenIdleZero idle<=0 直接返回原底流。 +func TestMonitorBodyDisabledWhenIdleZero(t *testing.T) { + _, cancel := context.WithCancel(context.Background()) + defer cancel() + rc := nopCloserBody{Reader: &oneByteReader{}} + out := monitorBody(rc, 0, cancel) + if _, ok := out.(nopCloserBody); !ok { + t.Fatalf("idle<=0 should return underlying body verbatim, got %T", out) + } + buf := make([]byte, 1) + if _, err := out.Read(buf); err != nil || buf[0] != 'a' { + t.Fatalf("read=%q err=%v", buf, err) + } +} + +// TestMonitorBodyCloseStopsGoroutine Close 停掉 goroutine,无泄漏(等效监控循环 + 短周期)。 +func TestMonitorBodyCloseStopsGoroutine(t *testing.T) { + m := &idleMonitoringBody{ + rc: &ctxBoundReader{ctx: context.Background()}, + lastRead: time.Now(), + stopCh: make(chan struct{}), + cancel: func() {}, + } + stopped := make(chan struct{}) + go func() { + tk := time.NewTicker(idleTick(40 * time.Millisecond)) + defer tk.Stop() + for { + select { + case <-m.stopCh: + close(stopped) + return + case <-tk.C: + } + } + }() + m.Close() + select { + case <-stopped: + case <-time.After(time.Second): + t.Fatal("goroutine not stopped after Close") + } +} + +// —— helpers —— + +// ctxBoundReader 模拟 net/http resp.Body:Read 阻塞在 ctx.Done() 上,ctx cancel 后返回错误。 +type ctxBoundReader struct{ ctx context.Context } + +func (r *ctxBoundReader) Read([]byte) (int, error) { + <-r.ctx.Done() + return 0, r.ctx.Err() +} + +func (r *ctxBoundReader) Close() error { return nil } + +type periodicReader struct{ period time.Duration } + +func (r periodicReader) Read(p []byte) (int, error) { + time.Sleep(r.period) + p[0] = 'x' + return 1, nil +} + +type oneByteReader struct{ done bool } + +func (r *oneByteReader) Read(p []byte) (int, error) { + if r.done { + return 0, io.EOF + } + r.done = true + p[0] = 'a' + return 1, nil +} + +type nopCloserBody struct{ io.Reader } + +func (nopCloserBody) Close() error { return nil } + +// 流读到 [DONE] 就关闭(StreamHint 的读法,不会再读到 EOF)后,连接必须回到池里: +// Close 先取消请求 context、chunked 结束块还没读,Transport 只能丢弃连接,流式请求每次都新建连接。 +func TestStreamConnReusedAfterDone(t *testing.T) { + srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { + w.Header().Set("Content-Type", "text/event-stream") + for _, f := range []string{`data: {"choices":[{"delta":{"content":"hi"}}]}`, "data: [DONE]"} { + _, _ = io.WriteString(w, f+"\n\n") + w.(http.Flusher).Flush() + } + // 上游在 [DONE] 之后过一会儿才发 chunked 结束块:读者在这之前就已关闭。 + time.Sleep(20 * time.Millisecond) + })) + defer srv.Close() + cl := &http.Client{Transport: newTransport()} + defer cl.CloseIdleConnections() + + stream := func() (reused bool) { + ctx, cancel := context.WithCancel(context.Background()) + ctx = httptrace.WithClientTrace(ctx, &httptrace.ClientTrace{GotConn: func(i httptrace.GotConnInfo) { reused = i.Reused }}) + req, _ := http.NewRequestWithContext(ctx, http.MethodPost, srv.URL, nil) + resp, err := cl.Do(req) + if err != nil { + t.Fatal(err) + } + body := monitorBody(resp.Body, time.Minute, cancel) + br := bufio.NewReader(body) + for { + line, err := br.ReadString('\n') + if err != nil { + t.Fatalf("没读到 [DONE]:%v", err) + } + if strings.TrimSpace(line) == "data: [DONE]" { + break + } + } + body.Close() + return reused + } + stream() + for i := 0; i < 5; i++ { + if !stream() { + t.Fatalf("第 %d 次流式请求没有复用连接", i+2) + } + } +} + +// closeCounter 记 Close 次数与 Close 之后的 Read:幂等的 Close 只关一次底流,之后也不再读它。 +type closeCounter struct { + closes, readsAfterClose int +} + +func (c *closeCounter) Read(p []byte) (int, error) { + if c.closes > 0 { + c.readsAfterClose++ + return 0, errors.New("read on closed body") + } + return 0, io.EOF +} + +func (c *closeCounter) Close() error { c.closes++; return nil } + +// Close 幂等:调用链里两层各关一次是常态,第二次不能再读流尾、再关底流。 +func TestIdleBodyCloseIsIdempotent(t *testing.T) { + under := &closeCounter{} + canceled := 0 + b := monitorBody(under, time.Minute, func() { canceled++ }) + for range 3 { + if err := b.Close(); err != nil { + t.Fatal(err) + } + } + if under.closes != 1 || under.readsAfterClose != 0 || canceled != 1 { + t.Fatalf("closes=%d readsAfterClose=%d canceled=%d, want 1/0/1", under.closes, under.readsAfterClose, canceled) + } +} diff --git a/internal/upstream/imagecharge_test.go b/internal/upstream/imagecharge_test.go new file mode 100644 index 0000000000000000000000000000000000000000..b0ca50cadc7ccc4f79ae41c1655b2c855614c92e --- /dev/null +++ b/internal/upstream/imagecharge_test.go @@ -0,0 +1,58 @@ +// imagecharge_test.go 出图实扣分档观测(ImageChargeAgg)的回归。 +package upstream + +import "testing" + +// TestRecordImageChargeBuckets 分档聚合:同一档累计,不同档分桶,样本多的排前。 +// +// 为什么必须分档:global 按输出图像 token 计费(实测 1024² low = 0.55 / 3997 tokens, +// high = 4.84 / 35333 tokens),CN 每张固定 5.71——把两档混成一个均值,面板上就再也 +// 对不上任何一档真实价格(issue:面板显示 0.55/张,用户选 high 后均值漂移)。 +func TestRecordImageChargeBuckets(t *testing.T) { + c := New() + c.RecordImageCharge("global", "gpt-image-2.5-sunburst", "1024x1024", "low", 0.55, 3997, 0) + c.RecordImageCharge("global", "gpt-image-2.5-sunburst", "1024x1024", "low", 0.55, 3997, 0) + c.RecordImageCharge("global", "gpt-image-2.5-sunburst", "1024x1024", "high", 4.84, 35333, 0) + // 另一个模型 / 另一个域不串档。 + c.RecordImageCharge("cn", "hunyuan-image-alpha", "512x512", "", 5.71, 0, 0) + // credit<=0(上游省略 usage)不入账,也不改已有样本。 + c.RecordImageCharge("global", "gpt-image-2.5-sunburst", "1024x1024", "low", 0, 0, 0) + + got := c.ImageCharges("global", "gpt-image-2.5-sunburst") + if len(got) != 2 { + t.Fatalf("分档数=%d want 2: %+v", len(got), got) + } + // 样本多的在前:low 2 次、high 1 次。 + if got[0].Quality != "low" || got[0].Samples != 2 { + t.Fatalf("第一档应是 low×2,得到 %+v", got[0]) + } + if got[0].Avg != 0.55 || got[0].LastTokens != 3997 { + t.Errorf("low 档 avg=%v tokens=%d want 0.55 / 3997", got[0].Avg, got[0].LastTokens) + } + if got[1].Quality != "high" || got[1].Avg != 4.84 || got[1].LastTokens != 35333 { + t.Errorf("high 档 %+v want avg 4.84 tokens 35333", got[1]) + } + // 跨域不串:CN 只有自己那一档,且不带画质维(CN 回执没有 quality)。 + if cn := c.ImageCharges("cn", "hunyuan-image-alpha"); len(cn) != 1 || cn[0].Avg != 5.71 || cn[0].Quality != "" { + t.Errorf("CN 档 %+v want 单档 5.71 且无画质", cn) + } + // 没出过图的模型返回空。 + if none := c.ImageCharges("global", "no-such-model"); len(none) != 0 { + t.Errorf("未出图模型应返回空,得到 %+v", none) + } +} + +// TestImageChargeKeyDistinguishesMissingFields 缺省尺寸/画质要落到同一个 "-" 桶, +// 不能因为空串互相覆盖或分裂成多个桶。 +func TestImageChargeKeyDistinguishesMissingFields(t *testing.T) { + c := New() + c.RecordImageCharge("cn", "hunyuan-image-alpha", "", "", 5.71, 0, 0) + c.RecordImageCharge("cn", "hunyuan-image-alpha", "", "", 5.71, 0, 0) + got := c.ImageCharges("cn", "hunyuan-image-alpha") + if len(got) != 1 || got[0].Samples != 2 { + t.Fatalf("空尺寸/画质应落同一桶,得到 %+v", got) + } + if got[0].Last != 5.71 || got[0].Avg != 5.71 { + t.Errorf("avg/last=%v/%v want 5.71", got[0].Avg, got[0].Last) + } +} diff --git a/internal/upstream/images.go b/internal/upstream/images.go new file mode 100644 index 0000000000000000000000000000000000000000..73ff4e86e243a679d16b33c58fe4821a82292013 --- /dev/null +++ b/internal/upstream/images.go @@ -0,0 +1,276 @@ +// images.go 文生图 / 图生图:POST {chatBase}/v2/images/generations 与 /v2/images/edits。 +// +// 实测(带池内真实 token):上游只有这两条图像路由——/v1/images/generations、 +// /v2/image/generations、/v2/plugin/images/generations、/v2/chat/images/generations 全 +// `{"error_msg":"404 Route Not Found"}`。请求 {model,prompt,n,size}:size 生效(默认 +// 1536x1536)、n 被忽略(恒 1 张)、未知键被忽略;回程信封 data 已是 OpenAI 形状 +// {created,data:[{url}],usage{...,credit}},图是签名 COS 直链(约 24h 有效)——网关只拆 +// 信封,不转存字节。edits 多一个 image(data URL 数组)。 +// +// 模型名按 realm 不同,**计费模型也完全不同**(2026-10-22 复测,两个个人号直连上游): +// +// cn hunyuan-image-alpha 每张固定 5.71 credit。512/1024/1536 三档尺寸、n=1/2 +// 四次回执全为 5.71(output_tokens 却在 693–1118 间跳), +// 说明与尺寸/token/张数都无关;回执带 +// output_image_coefficient:1。目录 2026-10-18 曾报牌价 +// x5.00(比实扣低 14%),2026-10-22 复测已不再报 credits。 +// global hy-image-3.5 每张固定 0.27 credit。low/medium/high × 512/1024/1536 +// 六档实测同价,回执恒 output_image_tokens:15000 却**不带** +// coefficient——token 数不代表单价,按 token 反推价格会算错。 +// global gpt-image-2.5-sunburst **已下架**:400 code=14401 route config not found。 +// 当年按输出图像 token 计费(credit = tokens/7300:1024² +// low 0.55/3997、high 4.84/35333),该口径仅作存档。 +package upstream + +import ( + "encoding/json" + "net/http" + "sort" + "time" + + "github.com/misakano7545/workbuddy2api-panel/internal/auth" +) + +// 图像通道(chatBase 域,与 growth/report 同 base 同头)。 +const ( + imagesPath = "/v2/images/generations" + editsPath = "/v2/images/edits" +) + +// ImageGenerations 文生图,返回上游 data 对象(OpenAI 形状,可直接透出)。 +// 复用 growthJSON:同 chatBase、同 BillingHeaders、同信封解码与 *Error 语义。 +func (c *Client) ImageGenerations(a *auth.Auth, body any) (json.RawMessage, error) { + return c.growthJSON(a, http.MethodPost, imagesPath, body) +} + +// ImageEdits 图生图(image 为 data URL 数组),同样返回 OpenAI 形状的 data。 +func (c *Client) ImageEdits(a *auth.Auth, body any) (json.RawMessage, error) { + return c.growthJSON(a, http.MethodPost, editsPath, body) +} + +// ImageChargeAgg 出图实扣按「尺寸 × 画质」分档的聚合(见 RecordImageCharge)。 +// +// 为什么需要分档:不同(或不同代)图片模型的计费口径可能完全不同,混成一个均值会骗人: +// +// cn hunyuan-image-alpha:**每张固定 5.71**,与尺寸/画质/n 全无关,回执带 +// output_image_coefficient:1(2026-10-22 复测 1024/768/512 三档 + n=2 恒等); +// global hy-image-3.5:**每张固定 0.27**,回执恒为 output_image_tokens:15000, +// 回执不带 coefficient;low/medium/high 与 512/1024/1536 六档实测全部 0.27; +// global gpt-image-2.5-sunburst(**已下架**,14401 route config not found): +// 当年按输出图像 token 计费(credit = tokens/7300,low 0.55/3997、high 4.84/35333)。 +// +// 分档仍然保留:它是「这价是哪一档」的唯一凭据,且一旦上游改回按档计价就能直接读出。 +// +// 所以面板必须知道某个均值是「哪一档」的平均,否则 0.55 一旦参进 high 样本就再也 +// 对不上任何一档真实价格。 +type ImageChargeAgg struct { + Realm string `json:"realm"` + Model string `json:"model"` + Size string `json:"size,omitempty"` + Quality string `json:"quality,omitempty"` + // Samples 该档累计次数;Credits 累计实扣;Avg 平均每张。 + Samples int `json:"samples"` + Credits float64 `json:"credits"` + Avg float64 `json:"avg"` + // Last 最近一次的实扣与输出图像 token(反推单价用)。 + Last float64 `json:"last"` + LastTokens int64 `json:"last_output_image_tokens,omitempty"` + // LastCoefficient 最近一次的 usage.output_image_coefficient(上游给的「倍率」 + // 原值,CN 恒 1、global 不回该字段)。只展示:它是上游自己的口径,本网关 + // 不拿它重算价格——重算出来的数跟回执 credit 对不上就是二次编数。 + LastCoefficient float64 `json:"last_output_image_coefficient,omitempty"` + LastAt string `json:"last_at,omitempty"` +} + +// imageChargeKey 分档键:域:模型@尺寸/画质(缺项记 "-",保证桶不串)。 +func imageChargeKey(realm, model, size, quality string) string { + if size == "" { + size = "-" + } + if quality == "" { + quality = "-" + } + return realm + ":" + model + "@" + size + "/" + quality +} + +// RecordImageCharge 记录一次出图实扣(数量取上游回执 usage.credit)。 +// tokens 为 usage.output_image_tokens(CN 侧不回该字段,记 0)。 +// 只在 credit > 0 时调用(上游省略 usage 时不编数)。 +func (c *Client) RecordImageCharge(realm, model, size, quality string, credit float64, tokens int64, coefficient float64) { + if c == nil || model == "" || credit <= 0 { + return + } + key := imageChargeKey(realm, model, size, quality) + c.imageChargeMu.Lock() + defer c.imageChargeMu.Unlock() + if c.imageCharges == nil { + c.imageCharges = make(map[string]ImageChargeAgg) + } + agg := c.imageCharges[key] + agg.Realm, agg.Model = realm, model + if size != "" { + agg.Size = size + } + if quality != "" { + agg.Quality = quality + } + agg.Samples++ + agg.Credits += credit + agg.Avg = agg.Credits / float64(agg.Samples) + agg.Last = credit + if tokens > 0 { + agg.LastTokens = tokens + } + if coefficient > 0 { + agg.LastCoefficient = coefficient + } + agg.LastAt = time.Now().Format(time.RFC3339) + c.imageCharges[key] = agg +} + +// ImageCharges 返回某域某模型的全部分档(样本多的在前)。空结果 = 本次运行还没出过图。 +// +// 内存态、重启清零:它是「最近实扣观测」,不是账单;长期口径仍由 usage.Recorder +// (credit_by_model,落盘)负责。刻意不并入 Recorder——那边的桶按 日/小时 分, +// 再加一维尺寸×画质会让整条落盘链路(含旧文件兼容)复杂化,收益不成正比。 +func (c *Client) ImageCharges(realm, model string) []ImageChargeAgg { + if c == nil { + return nil + } + c.imageChargeMu.Lock() + defer c.imageChargeMu.Unlock() + out := make([]ImageChargeAgg, 0, 4) + for _, agg := range c.imageCharges { + if agg.Realm == realm && agg.Model == model { + out = append(out, agg) + } + } + sort.Slice(out, func(i, j int) bool { + if out[i].Samples != out[j].Samples { + return out[i].Samples > out[j].Samples + } + return out[i].Avg > out[j].Avg + }) + return out +} + +// stashGenerationModels 从一次目录解析里留存媒体生成模型(在 nonChatModel 过滤**前** +// 调用,零额外请求),按 GenerationKind 标 image/video。存 Client 上(不是包级全局): +// 测试各建各的 Client,互不串味。 +// +// **按 ID 合并而非覆盖**:global 目录是多 UA 并发探测的,宽目录(WorkBuddy 产品身份, +// 29 个模型)与窄目录(13 个)都会来这里落一笔——覆盖式留存会让结果取决于哪个探测先 +// 返回,表现为「这次面板有 gpt-image-2.5-sunburst、下次变成 hunyuan-image-alpha」。 +// ponytail: 只增不减,上游下架的模型要等重启才消失;出现真实误报再加版本比对。 +func (c *Client) stashGenerationModels(realm string, entries []ModelInfo) { + media := make([]ModelInfo, 0, len(entries)) + for _, m := range entries { + if kind := generationKind(m.Tags); kind != "" { + m.GenerationKind = kind + media = append(media, m) + } + } + if len(media) == 0 { + return + } + c.imageMu.Lock() + defer c.imageMu.Unlock() + if c.imageModels == nil { + c.imageModels = map[string][]ModelInfo{} + } + merged := map[string]ModelInfo{} + for _, m := range c.imageModels[realm] { + merged[m.ID] = m + } + for _, m := range media { + merged[m.ID] = m + } + ids := make([]string, 0, len(merged)) + for id := range merged { + ids = append(ids, id) + } + sort.Strings(ids) + out := make([]ModelInfo, 0, len(ids)) + for _, id := range ids { + out = append(out, merged[id]) + } + c.imageModels[realm] = out +} + +// sortedInfos 把模型 map 摊成稳定顺序的切片(map 迭代序随机,留存顺序不该抖动)。 +func sortedInfos(byID map[string]ModelInfo) []ModelInfo { + ids := make([]string, 0, len(byID)) + for id := range byID { + ids = append(ids, id) + } + sort.Strings(ids) + out := make([]ModelInfo, 0, len(ids)) + for _, id := range ids { + out = append(out, byID[id]) + } + return out +} + +// imageRouteRealm 已实测的「图像模型 → 有路由的域」。 +// +// 为什么需要:目录里出现的媒体模型不一定在本域有出图路由——实测 global 目录同样列着 +// hunyuan-image-alpha,但国际侧调它必回 400 code=14401「route config not found」。列进 +// /v1/models 等于引诱客户端选一个必然失败的模型(客户端枚举列表即踩)。 +// +// 2026-10-22 复测(两个个人号,直连上游): +// cn:hunyuan-image-alpha 200 → usage{output_image_coefficient:1, credit:5.71} +// global:hy-image-3.5 200 → usage{output_image_tokens:15000, credit:0.27} +// global:gpt-image-2.5-sunburst → **400 code=14401 route config not found** +// (已下架;两个域的目录里都不再有它,global 目录把可用出图模型只放在 +// modelPromotions 里,见 fetchV3ConfigModelMap 的补入逻辑) +// 所以 sunburst 这条映射已作废:留着只会把一个必失败的模型列给客户端。 +// +// ponytail: 只写实测过的组合,未知模型照旧列出(不猜);图像模型变多时改成探测一次路由 +// 并缓存——现在只有这几个模型,加探测是白花钱。 +var imageRouteRealm = map[string]string{ + "hunyuan-image-alpha": "cn", + "hunyuan-image-alpha-edit": "cn", + "hy-image-3.5": "global", +} + +// imageDeadModels 上游已下架、两个域都没有路由的出图模型:列出来只会让客户端 +// 选到一个必然 400 的模型。实测 2026-10-22:global:gpt-image-2.5-sunburst +// → 400 code=14401「route config not found」,且两域目录里都已不再出现它。 +// 只写实测下架的;模型回来时删一行即可(未知模型照旧列出,见 GenerationModels)。 +var imageDeadModels = map[string]bool{ + "gpt-image-2.5-sunburst": true, +} + +// GenerationModels 最近一次目录解析留存的出图/出视频模型(空 = 尚未探测过该域)。 +// 目录把这些模型从**对话**列表剔掉(客户端拿它发对话会 11102),留存供 /v1/models +// 与面板以 image_generation / video_generation 标记单列。 +func (c *Client) GenerationModels(realm string) []ModelInfo { + c.imageMu.Lock() + defer c.imageMu.Unlock() + src := c.imageModels[realm] + out := make([]ModelInfo, 0, len(src)) + for _, m := range src { + if m.GenerationKind == "video" { + // 视频:与图片同一套「只写实测路由」口径(videoRouteRealm/videoDeadModels + // 在 videos.go,视频有独立端点 /v1/videos/generations)。 + if videoDeadModels[m.ID] { + continue + } + if r, known := videoRouteRealm[m.ID]; known && r != realm { + continue + } + out = append(out, m) + continue + } + // 已下架的模型不列(见 imageDeadModels)。 + if imageDeadModels[m.ID] { + continue + } + // 已知在别的域才有路由的模型不列(见 imageRouteRealm)。 + if r, known := imageRouteRealm[m.ID]; known && r != realm { + continue + } + out = append(out, m) + } + return out +} diff --git a/internal/upstream/images_test.go b/internal/upstream/images_test.go new file mode 100644 index 0000000000000000000000000000000000000000..d91d7e779155117a5086ff49c9712b948fa3852c --- /dev/null +++ b/internal/upstream/images_test.go @@ -0,0 +1,109 @@ +package upstream + +import "testing" + +// TestNonChatModelAndGenerationKind 非对话模型判定必须覆盖媒体生成标签: +// 出图(text-to-image / image-to-image)与出视频(text-to-video / image-to-video)。 +// 视频这两条以前漏了 —— seedance-2.5 因此被当成对话模型列进 global 名单,面板里还 +// 显示成"不支持思考";客户端选它发对话只会拿到 11102/14407。 +func TestNonChatModelAndGenerationKind(t *testing.T) { + cases := []struct { + name string + id string + maxOut int64 + tags []string + nonChat bool + kindWant string + }{ + {"出图", "hunyuan-image-alpha", 0, []string{"text-to-image"}, true, "image"}, + {"改图", "hunyuan-image-alpha-edit", 0, []string{"image-to-image"}, true, "image"}, + {"出视频", "seedance-2.5", 0, []string{"text-to-video", "image-to-video"}, true, "video"}, + {"改视频(大写/空白容错)", "x", 0, []string{" Text-To-Video "}, true, "video"}, + {"普通对话模型", "glm-5.2", 32000, []string{"craft"}, false, ""}, + {"craft + 视频标签仍算出视频", "y", 32000, []string{"craft", "text-to-video"}, true, "video"}, + {"前缀过滤仍生效", "codewise-jump", 0, nil, true, ""}, + {"tiny 输出仍过滤", "z", 256, nil, true, ""}, + } + for _, c := range cases { + if got := nonChatModel(c.id, c.maxOut, c.tags); got != c.nonChat { + t.Errorf("%s: nonChatModel=%v want %v", c.name, got, c.nonChat) + } + if got := generationKind(c.tags); got != c.kindWant { + t.Errorf("%s: generationKind=%q want %q", c.name, got, c.kindWant) + } + } +} + +// TestStashGenerationModelsMergesPerID 留存按 ID 合并而非覆盖:global 目录是多 UA 并发 +// 探测的,宽/窄两份目录都会落一笔——覆盖式留存会让结果取决于谁先返回(实测表现为 +// 「这次有 hy-image-3.5、下次变成 hunyuan-image-alpha」,seedance-2.5 时有时无)。 +// +// 另:hunyuan-image-alpha 虽可能被 global 目录列出,但国际侧**没有出图路由**(实测 +// 400 code=14401 route config not found),故列表侧按 imageRouteRealm 过滤掉——这正是 +// 「模型列出来却必失败」的修复点,故 global 侧同样只剩 2 条。 +func TestStashGenerationModelsMergesPerID(t *testing.T) { + c := &Client{} + c.stashGenerationModels("global", []ModelInfo{ + {ID: "hy-image-3.5", Tags: []string{"text-to-image"}}, + }) + c.stashGenerationModels("global", []ModelInfo{ + {ID: "hunyuan-image-alpha", Tags: []string{"text-to-image"}}, + {ID: "seedance-2.5", Tags: []string{"text-to-video", "image-to-video"}}, + {ID: "glm-5.2", Tags: []string{"craft"}}, // 非媒体模型不入留存 + }) + got := c.GenerationModels("global") + if len(got) != 2 { + t.Fatalf("global 留存应合并成 2 条(窄目录不能顶掉宽目录;hunyuan 无本域路由须剔除),实际 %d:%+v", len(got), got) + } + kinds := map[string]string{} + for _, m := range got { + kinds[m.ID] = m.GenerationKind + } + if kinds["hy-image-3.5"] != "image" || kinds["seedance-2.5"] != "video" { + t.Fatalf("kind 标记不对:%+v", kinds) + } + if _, bad := kinds["hunyuan-image-alpha"]; bad { + t.Fatalf("国际侧无路由的 hunyuan-image-alpha 不得出现在 global 列表:%+v", got) + } + // 顺序稳定(按 ID 排序),重复留存不抖 + again := c.GenerationModels("global") + for i := range got { + if got[i].ID != again[i].ID { + t.Fatalf("留存顺序不稳定:%v vs %v", got, again) + } + } +} + +// TestGenerationModelsRouteFilter 列表只列本域真有路由的图像模型: +// 目录里出现 ≠ 本域能调。实测(2026-10-22 两个个人号直连上游): +// - hunyuan-image-alpha 只有国内路由;hy-image-3.5 只有国际路由; +// - gpt-image-2.5-sunburst 已下架(14401 route config not found),两域都不列; +// - 未知模型不在表里,照旧列出(不猜、不隐藏未实测的能力)。 +func TestGenerationModelsRouteFilter(t *testing.T) { + c := &Client{} + for _, realm := range []string{"cn", "global"} { + c.stashGenerationModels(realm, []ModelInfo{ + {ID: "hunyuan-image-alpha", Tags: []string{"text-to-image"}}, + {ID: "hy-image-3.5", Tags: []string{"text-to-image"}}, + {ID: "gpt-image-2.5-sunburst", Tags: []string{"text-to-image"}}, // 已下架 + {ID: "brand-new-image-v9", Tags: []string{"text-to-image"}}, // 表里没有 → 照列 + }) + } + ids := func(realm string) map[string]bool { + out := map[string]bool{} + for _, m := range c.GenerationModels(realm) { + out[m.ID] = true + } + return out + } + cn, gl := ids("cn"), ids("global") + if !cn["hunyuan-image-alpha"] || cn["hy-image-3.5"] || cn["gpt-image-2.5-sunburst"] { + t.Fatalf("cn 列表应含 hunyuan、不含 hy-image-3.5 与已下架的 sunburst:%v", cn) + } + if !gl["hy-image-3.5"] || gl["hunyuan-image-alpha"] || gl["gpt-image-2.5-sunburst"] { + t.Fatalf("global 列表应含 hy-image-3.5、不含 hunyuan 与已下架的 sunburst:%v", gl) + } + if !cn["brand-new-image-v9"] || !gl["brand-new-image-v9"] { + t.Fatalf("未实测的模型应照旧列出(不隐藏能力):cn=%v global=%v", cn, gl) + } +} diff --git a/internal/upstream/keep_rounds_wire_test.go b/internal/upstream/keep_rounds_wire_test.go new file mode 100644 index 0000000000000000000000000000000000000000..7a0f022fc084546ad7810cfca845f60e8b44dd2f --- /dev/null +++ b/internal/upstream/keep_rounds_wire_test.go @@ -0,0 +1,57 @@ +package upstream + +import ( + "encoding/json" + "testing" +) + +// TestClientKeepRecentRoundsReachesPipeline KeepRecentRounds 必须真的从 Client +// 走到出站 body(issue #99):只测 trimHistory 而不测接线,开关写了不生效也照样绿。 +func TestClientKeepRecentRoundsReachesPipeline(t *testing.T) { + c := New() + body := []byte(`{"model":"deepseek-v4.1-flash","messages":[ + {"role":"system","content":"s"}, + {"role":"user","content":"一"}, + {"role":"assistant","content":"a1"}, + {"role":"user","content":"二"}, + {"role":"assistant","content":"a2"}, + {"role":"user","content":"三"}]}`) + + // 关闭时全量透传(默认行为,与没有这个功能一致)。 + out, _, _ := c.prepareBody(body, "cn", "uid", "conv", "") + if n := countMessages(t, out); n != 6 { + t.Fatalf("keep_recent_rounds=0 不该裁历史,实际 %d 条", n) + } + + c.KeepRecentRounds.Store(2) + out, _, _ = c.prepareBody(body, "cn", "uid", "conv", "") + roles := messageRoles(t, out) + if got := len(roles); got != 4 { + t.Fatalf("保留 2 轮应为 system+user+assistant+user 共 4 条,实际 %d 条: %v", got, roles) + } + if roles[0] != "system" || roles[1] != "user" { + t.Fatalf("裁完必须 system 开头、user 接续,实际 %v", roles) + } +} + +func countMessages(t *testing.T, body []byte) int { + t.Helper() + return len(messageRoles(t, body)) +} + +func messageRoles(t *testing.T, body []byte) []string { + t.Helper() + var obj struct { + Messages []struct { + Role string `json:"role"` + } `json:"messages"` + } + if err := json.Unmarshal(body, &obj); err != nil { + t.Fatalf("decode body: %v", err) + } + out := make([]string, 0, len(obj.Messages)) + for _, m := range obj.Messages { + out = append(out, m.Role) + } + return out +} diff --git a/internal/upstream/kimi_tools.go b/internal/upstream/kimi_tools.go new file mode 100644 index 0000000000000000000000000000000000000000..3479e0c20573ee66d5fbd2bf560ee29bc506e1eb --- /dev/null +++ b/internal/upstream/kimi_tools.go @@ -0,0 +1,132 @@ +package upstream + +import ( + "encoding/json" + "strings" + "sync/atomic" + + "github.com/misakano7545/workbuddy2api-panel/internal/jsonscan" +) + +// kimiToolsParses prepareKimiTools 做整树解析的次数(观测/回归用)。 +// 非 kimi 模型必须 0 次:那一路只需读一个 model 字段。 +var kimiToolsParses atomic.Int64 + +// KimiToolsParseCount 返回 prepareKimiTools 累计的整树解析次数(供测试)。 +func KimiToolsParseCount() int64 { return kimiToolsParses.Load() } + +// ResetKimiToolsParseCount 归零计数(供测试)。 +func ResetKimiToolsParseCount() { kimiToolsParses.Store(0) } + +// prepareKimiTools 把 CN Kimi 出站请求里工具 schema 的本地 $ref 展开成内联定义 +// (Kimi 不接受 parameters 里的 $ref/#/$defs),其余模型、其余域原样返回字节。 +// +// 只做 $ref 展开,**不裁剪任何工具**:本网关是通用中转,按工具名前缀裁剪是把某个 +// 部署的绕行手段写进了共享路径,其它用户的 MCP 工具会静默消失。 +func prepareKimiTools(body []byte, realm string) []byte { + if realmKey(realm) != "cn" { + return body + } + // 快路径:先用零分配的扫描读 model;非 kimi 直接返回,不做整树解析。 + // 线上绝大多数请求走这里——此前每个 CN 请求都要为了一句前缀判断把整个 + // body 解析成 map[string]json.RawMessage(100~500KB,全部值都复制一遍)。 + model, ok := jsonscan.TopLevelString(body, "model") + if !ok || !strings.HasPrefix(strings.TrimPrefix(model, "cn:"), "kimi") { + return body + } + kimiToolsParses.Add(1) + var obj map[string]json.RawMessage + if json.Unmarshal(body, &obj) != nil { + return body + } + var tools []map[string]any + if json.Unmarshal(obj["tools"], &tools) != nil || len(tools) == 0 { + return body + } + kept := make([]map[string]any, 0, len(tools)) + budget := 10000 + for _, tool := range tools { + fn, ok := tool["function"].(map[string]any) + if !ok { + // Preserve non-function tools rather than converting their protocol. + kept = append(kept, tool) + continue + } + if params, ok := fn["parameters"].(map[string]any); ok { + defs, _ := params["$defs"].(map[string]any) + fn["parameters"] = inlineKimiSchemaBudget(params, defs, map[string]bool{}, 0, &budget) + if budget <= 0 { + return body + } + } + kept = append(kept, tool) + } + encoded, err := json.Marshal(kept) + if err != nil { + return body + } + obj["tools"] = encoded + out, err := json.Marshal(obj) + if err != nil { + return body + } + return out +} + +// Cyclic schemas cannot be inlined; retain the local proxy's empty-schema +// fallback. Depth is bounded so an adversarial schema cannot exhaust the stack. +func inlineKimiSchema(node any, defs map[string]any, seen map[string]bool, depth int) any { + budget := 10000 + return inlineKimiSchemaBudget(node, defs, seen, depth, &budget) +} + +func inlineKimiSchemaBudget(node any, defs map[string]any, seen map[string]bool, depth int, budget *int) any { + if *budget <= 0 { + return nil + } + *budget-- + if depth > 64 { + return map[string]any{} + } + switch v := node.(type) { + case []any: + out := make([]any, len(v)) + for i, x := range v { + if *budget <= 0 { + break + } + out[i] = inlineKimiSchemaBudget(x, defs, seen, depth+1, budget) + } + return out + case map[string]any: + if ref, ok := v["$ref"].(string); ok && strings.HasPrefix(ref, "#/$defs/") { + name := strings.TrimPrefix(ref, "#/$defs/") + name = strings.ReplaceAll(strings.ReplaceAll(name, "~1", "/"), "~0", "~") + if seen[name] { + return map[string]any{} + } + target, ok := defs[name] + if !ok { + return map[string]any{"type": "object"} + } + next := make(map[string]bool, len(seen)+1) + for k, x := range seen { + next[k] = x + } + next[name] = true + return inlineKimiSchemaBudget(target, defs, next, depth+1, budget) + } + out := make(map[string]any, len(v)) + for k, x := range v { + if *budget <= 0 { + break + } + if k != "$defs" && k != "$schema" { + out[k] = inlineKimiSchemaBudget(x, defs, seen, depth+1, budget) + } + } + return out + default: + return node + } +} diff --git a/internal/upstream/kimi_tools_test.go b/internal/upstream/kimi_tools_test.go new file mode 100644 index 0000000000000000000000000000000000000000..e9d139a0cbcc8c7ee93d444cadb1b0529be6ecd0 --- /dev/null +++ b/internal/upstream/kimi_tools_test.go @@ -0,0 +1,111 @@ +package upstream + +import ( + "encoding/json" + "io" + "net/http" + "strings" + "testing" + + "github.com/misakano7545/workbuddy2api-panel/internal/auth" +) + +const kimiToolBody = `{"model":"kimi-k3.1-pro","messages":[{"role":"user","content":"test"}],"tools":[{"type":"function","function":{"name":"lookup","strict":true,"parameters":{"type":"object","$schema":"schema","$defs":{"Item":{"type":"string","enum":["a","b"]}},"properties":{"x":{"$ref":"#/$defs/Item"},"y":{"$ref":"#/$defs/Item"}}}}},{"type":"function","function":{"name":"mcp__rea__inspect","parameters":{"type":"object"}}},{"type":"function","function":{"name":"mcp__tencent_docs__read","parameters":{"type":"object"}}}],"metadata":{"keep":1234567890123456789}}` + +func TestKimiToolsCompatibility(t *testing.T) { + out := prepareKimiTools([]byte(kimiToolBody), "cn") + var got map[string]any + if err := json.Unmarshal(out, &got); err != nil { + t.Fatal(err) + } + tools := got["tools"].([]any) + if len(tools) != 3 { + t.Fatalf("tools=%v", tools) // 只展开 $ref,不裁剪任何工具 + } + fn := tools[0].(map[string]any)["function"].(map[string]any) + if fn["strict"] != true { + t.Fatal("lost function metadata") + } + params := fn["parameters"].(map[string]any) + if _, ok := params["$defs"]; ok { + t.Fatal("definitions remain") + } + if _, ok := params["$schema"]; ok { + t.Fatal("schema marker remains") + } + props := params["properties"].(map[string]any) + for _, key := range []string{"x", "y"} { + v := props[key].(map[string]any) + if v["type"] != "string" || len(v["enum"].([]any)) != 2 { + t.Fatalf("ref %s=%v", key, v) + } + } + if !strings.Contains(string(out), "1234567890123456789") { + t.Fatal("unrelated number changed") + } +} + +func TestKimiToolsScopeAndForcedChoice(t *testing.T) { + for _, tc := range []struct{ body, realm string }{ + {strings.ReplaceAll(kimiToolBody, "kimi-k3.1-pro", "deepseek-v4.1-flash"), "cn"}, + {kimiToolBody, "global"}, {`invalid`, "cn"}, {`{"model":"kimi","tools":[]}`, "cn"}, + } { + if got := string(prepareKimiTools([]byte(tc.body), tc.realm)); got != tc.body { + t.Fatalf("changed passthrough body: %s", got) + } + } + body := strings.Replace(kimiToolBody, `"messages":`, `"tool_choice":{"type":"function","function":{"name":"mcp__rea__inspect"}},"messages":`, 1) + body = strings.Replace(body, `"model":"kimi`, `"model":"cn:kimi`, 1) + var got map[string]any + _ = json.Unmarshal(prepareKimiTools([]byte(body), "cn"), &got) + if len(got["tools"].([]any)) != 3 { + t.Fatal("forced tool must remain declared") // 三个都该在:不裁剪 + } +} + +func TestKimiSchemaRecursiveAndMissingRefs(t *testing.T) { + defs := map[string]any{"Loop": map[string]any{"$ref": "#/$defs/Loop"}} + for _, ref := range []string{"Loop", "Missing"} { + out := inlineKimiSchema(map[string]any{"$ref": "#/$defs/" + ref}, defs, map[string]bool{}, 0) + b, err := json.Marshal(out) + if err != nil || strings.Contains(string(b), "$ref") { + t.Fatalf("unresolved ref: %s %v", b, err) + } + } +} + +func TestChatStreamKimiToolsOnWire(t *testing.T) { + var outbound []byte + c := testClient(func(r *http.Request) (*http.Response, error) { + outbound, _ = io.ReadAll(r.Body) + return &http.Response{StatusCode: 200, Header: http.Header{"Content-Type": []string{"text/event-stream"}}, Body: io.NopCloser(strings.NewReader("data: [DONE]\n\n"))}, nil + }) + rc, status, _, err := c.ChatStream(&auth.Auth{AccessToken: "test", UID: "test"}, []byte(kimiToolBody), "", ChatMeta{}) + if err != nil || status != 200 { + t.Fatalf("status=%d err=%v", status, err) + } + rc.Close() + if strings.Contains(string(outbound), "$ref") || !strings.Contains(string(outbound), `"name":"lookup"`) || + !strings.Contains(string(outbound), "mcp__rea__inspect") || !strings.Contains(string(outbound), "mcp__tencent_docs__read") { + t.Fatalf("bad wire body: %s", outbound) + } +} + +func TestKimiSchemaExpansionBudget(t *testing.T) { + // A tiny input can expand exponentially when each definition references the + // preceding one twice. Abort the rewrite instead of allocating that tree. + defs := map[string]any{"Leaf": map[string]any{"type": "string"}} + last := "Leaf" + for i := 0; i < 20; i++ { + name := last + "x" + defs[name] = map[string]any{"allOf": []any{map[string]any{"$ref": "#/$defs/" + last}, map[string]any{"$ref": "#/$defs/" + last}}} + last = name + } + body, err := json.Marshal(map[string]any{"model": "kimi-k3.1-pro", "tools": []any{map[string]any{"type": "function", "function": map[string]any{"name": "test", "parameters": map[string]any{"$defs": defs, "properties": map[string]any{"x": map[string]any{"$ref": "#/$defs/" + last}}}}}}}) + if err != nil { + t.Fatal(err) + } + if got := prepareKimiTools(body, "cn"); string(got) != string(body) { + t.Fatal("expansion budget should leave original request intact") + } +} diff --git a/internal/upstream/model.json b/internal/upstream/model.json index 3886fe00c746c28bbd5aea882fa2a4c010930a7f..68e8c3b54b4d9cbb1d92b81fe8341afb50d1a652 100644 --- a/internal/upstream/model.json +++ b/internal/upstream/model.json @@ -1,135 +1,135 @@ -{ - "glm-5.2": { - "context_length": 1000000, - "max_output_tokens": 131072, - "source": "seed" - }, - "glm-5.1": { - "context_length": 200000, - "max_output_tokens": 131072, - "source": "seed" - }, - "glm-5.3": { - "context_length": 1000000, - "max_output_tokens": 131072, - "source": "seed" - }, - "glm-5.3-flash": { - "context_length": 1000000, - "max_output_tokens": 131072, - "source": "seed" - }, - "glm-5v-turbo": { - "context_length": 200000, - "max_output_tokens": 131072, - "source": "seed" - }, - "kimi-k2.7": { - "context_length": 256000, - "max_output_tokens": 65536, - "source": "seed" - }, - "kimi-k2.6": { - "context_length": 256000, - "max_output_tokens": 262144, - "source": "seed" - }, - "kimi-k2.5": { - "context_length": 164000, - "max_output_tokens": 262144, - "source": "seed" - }, - "kimi-k3": { - "context_length": 1048576, - "max_output_tokens": 131072, - "source": "seed" - }, - "kimi-k2.8-preview": { - "context_length": 1048576, - "source": "seed" - }, - "minimax-m3": { - "context_length": 512000, - "max_output_tokens": 512000, - "source": "seed" - }, - "hy3": { - "context_length": 192000, - "max_output_tokens": 64000, - "source": "seed" - }, - "hy3-preview": { - "context_length": 262144, - "max_output_tokens": 64000, - "source": "seed" - }, - "hy4-preview": { - "context_length": 1000000, - "max_output_tokens": 64000, - "source": "seed" - }, - "hy4-preview-x": { - "context_length": 1000000, - "max_output_tokens": 64000, - "source": "seed" - }, - "deepseek-v4-pro": { - "context_length": 1000000, - "max_output_tokens": 384000, - "source": "seed" - }, - "deepseek-v4-flash": { - "context_length": 1000000, - "max_output_tokens": 384000, - "source": "seed" - }, - "deepseek-v4.1-flash": { - "context_length": 1000000, - "max_output_tokens": 384000, - "source": "seed" - }, - "gpt-6-astra": { - "context_length": 1050000, - "max_output_tokens": 128000, - "source": "seed" - }, - "gpt-5.6-sol": { - "context_length": 1050000, - "max_output_tokens": 128000, - "source": "seed" - }, - "gpt-5.6-terra": { - "context_length": 1050000, - "max_output_tokens": 128000, - "source": "seed" - }, - "gpt-5.6-luna": { - "context_length": 1050000, - "max_output_tokens": 128000, - "source": "seed" - }, - "gpt-5.5": { - "context_length": 1050000, - "max_output_tokens": 128000, - "source": "seed" - }, - "gpt-5.4": { - "context_length": 1050000, - "max_output_tokens": 128000, - "source": "seed" - }, - "gpt-5.3-codex": { - "context_length": 400000, - "max_output_tokens": 128000, - "source": "seed" - }, - "gemini-3.5-flash": { - "context_length": 1048576, - "max_output_tokens": 65536, - "source": "seed" - }, - "auto": { - "context_length": 168000, - "source": "seed" - } -} +{ + "glm-5.2": { + "context_length": 1000000, + "max_output_tokens": 131072, + "source": "seed" + }, + "glm-5.1": { + "context_length": 200000, + "max_output_tokens": 131072, + "source": "seed" + }, + "glm-5.3": { + "context_length": 1000000, + "max_output_tokens": 131072, + "source": "seed" + }, + "glm-5.3-flash": { + "context_length": 1000000, + "max_output_tokens": 131072, + "source": "seed" + }, + "glm-5v-turbo": { + "context_length": 200000, + "max_output_tokens": 131072, + "source": "seed" + }, + "kimi-k2.7": { + "context_length": 256000, + "max_output_tokens": 65536, + "source": "seed" + }, + "kimi-k2.6": { + "context_length": 256000, + "max_output_tokens": 262144, + "source": "seed" + }, + "kimi-k2.5": { + "context_length": 164000, + "max_output_tokens": 262144, + "source": "seed" + }, + "kimi-k3": { + "context_length": 1048576, + "max_output_tokens": 131072, + "source": "seed" + }, + "kimi-k2.8-preview": { + "context_length": 1048576, + "source": "seed" + }, + "minimax-m3": { + "context_length": 512000, + "max_output_tokens": 512000, + "source": "seed" + }, + "hy3": { + "context_length": 192000, + "max_output_tokens": 64000, + "source": "seed" + }, + "hy3-preview": { + "context_length": 262144, + "max_output_tokens": 64000, + "source": "seed" + }, + "hy4-preview": { + "context_length": 1000000, + "max_output_tokens": 64000, + "source": "seed" + }, + "hy4-preview-x": { + "context_length": 1000000, + "max_output_tokens": 64000, + "source": "seed" + }, + "deepseek-v4-pro": { + "context_length": 1000000, + "max_output_tokens": 384000, + "source": "seed" + }, + "deepseek-v4-flash": { + "context_length": 1000000, + "max_output_tokens": 384000, + "source": "seed" + }, + "deepseek-v4.1-flash": { + "context_length": 1000000, + "max_output_tokens": 384000, + "source": "seed" + }, + "gpt-6-astra": { + "context_length": 1050000, + "max_output_tokens": 128000, + "source": "seed" + }, + "gpt-5.6-sol": { + "context_length": 1050000, + "max_output_tokens": 128000, + "source": "seed" + }, + "gpt-5.6-terra": { + "context_length": 1050000, + "max_output_tokens": 128000, + "source": "seed" + }, + "gpt-5.6-luna": { + "context_length": 1050000, + "max_output_tokens": 128000, + "source": "seed" + }, + "gpt-5.5": { + "context_length": 1050000, + "max_output_tokens": 128000, + "source": "seed" + }, + "gpt-5.4": { + "context_length": 1050000, + "max_output_tokens": 128000, + "source": "seed" + }, + "gpt-5.3-codex": { + "context_length": 400000, + "max_output_tokens": 128000, + "source": "seed" + }, + "gemini-3.5-flash": { + "context_length": 1048576, + "max_output_tokens": 65536, + "source": "seed" + }, + "auto": { + "context_length": 168000, + "source": "seed" + } +} diff --git a/internal/upstream/model_catalog.go b/internal/upstream/model_catalog.go index 309d221b5ffcb93b8cee2e5c0bf4601e062e0f34..3d21ca5318573fdd1809021b99dc4586e0f6321d 100644 --- a/internal/upstream/model_catalog.go +++ b/internal/upstream/model_catalog.go @@ -1,320 +1,317 @@ -// model_catalog.go context_length / max_output_tokens 四级查找链 + model.json -// 本地缓存(任务书 model-json-dynamic)。 -// -// 查找链(32a3c13 三级 → 四级,上游动态值永远权威不变): -// 1. 上游动态值(ModelInfo.ContextWindow/MaxTokens)——权威,永远压过 model.json -// (即使后者更新:上游才是权威,任务书 §清理); -// 2. 静态种子表(context_catalog.go 的 contextCapFallback,编译期兜底); -// 3. model.json 本地缓存(数据目录,含运行时从 models.dev 补的值 + 仓库种子 -// embed 的初值);损坏 → 降级种子并 WARN 不崩溃(手动维护入口的容错); -// 4. 触发 models.dev 按需拉取(异步,不阻塞本次响应)→ 值写入 model.json → -// 本次先落 1M/省略,下次命中缓存;负缓存 24h。 -// -// model.json 读写并发安全(单 sync.Mutex 全程持锁 + 原子落盘 tmp+rename, -// 多请求同时 miss 同一模型只写一次);文件损坏/不可写均静默降级(种子表→1M)。 -// -// 状态归属:包级 catalogState 单例(与 modelsDev fetcher 同模式,进程一份)。 -// 测试用 resetModelCatalog / loadModelCatalogAt 隔离。 -package upstream - -import ( - "embed" - "encoding/json" - "log" - "net/http" - "os" - "path/filepath" - "sync" - "time" -) - -// modelSeedFS 仓库种子版 model.json(context_catalog 静态表 27 值迁移,source=seed)。 -// 只作 model.json 缺失时的初值来源;运行目录的 model.json 一旦存在则以它为准 -// (用户手动维护入口——直接编辑文件,格式容错由 loadModelCatalog 的校验兜底)。 -// -//go:embed model.json -var modelSeedFS embed.FS - -// ModelCapEntry model.json 单条目(与静态表同字段口径 + 来源与抓取时间)。 -// Source:seed(仓库种子迁移)/ modelsdev(运行时按需拉取)/ manual(用户手编 -// ——无法区分手编与 seed,手编条目保留其原 source 字符串,语义等同「非拉取」)。 -// Context 必须 >0(零/负条目校验拒绝);MaxOutput 0 = 输出上限未知 → 省略字段。 -type ModelCapEntry struct { - ContextLength int64 `json:"context_length"` - MaxOutputTokens int64 `json:"max_output_tokens,omitempty"` - FetchedAt string `json:"fetched_at,omitempty"` // RFC3339;seed 条目为空 - Source string `json:"source"` -} - -// modelCatalog model.json 缓存状态机(包级 catalogState 单例的字段载体)。 -type modelCatalog struct { - mu sync.Mutex - - path string // 落盘路径(空 = 禁用持久化:纯内存 + 种子) - entries map[string]ModelCapEntry - loaded bool // entries 已初始化(含损坏降级形态) -} - -// catalogState 包级单例:全进程一份 model.json 状态。 -var catalogState = &modelCatalog{} - -// initModelCatalogLocked 确保 entries 已加载(持锁调用): -// - 运行目录 model.json 存在且合法 → 全量加载(校验失败的条目剔除并 WARN); -// - 文件不存在 / 整体损坏(非法 JSON)→ 种子 embed 初值(不落盘:保持「用户 -// 尚无缓存」状态,首次拉取成功后再落盘); -// - path 为空(未接线,如测试/工具进程)→ 种子初值。 -func (c *modelCatalog) initLocked() { - if c.loaded { - return - } - c.entries = map[string]ModelCapEntry{} - c.loaded = true - if c.path == "" { - c.loadSeedLocked() - return - } - raw, err := os.ReadFile(c.path) - if err != nil { - // 不存在 / 不可读 → 种子(首次启动形态)。 - c.loadSeedLocked() - return - } - var file map[string]ModelCapEntry - if err := json.Unmarshal(raw, &file); err != nil { - // 整体损坏:降级种子 + WARN 不崩溃(任务书 §手动维护入口容错)。 - log.Printf("WARN: [upstream] model.json 损坏(降级内置种子表): path=%s err=%v", c.path, err) - c.loadSeedLocked() - return - } - for id, e := range file { - if !validCapEntry(e) { - log.Printf("WARN: [upstream] model.json 条目非法剔除: model=%s entry=%+v", id, e) - continue - } - c.entries[id] = e - } -} - -// loadSeedLocked 把仓库种子 model.json 灌入 entries(持锁调用)。 -func (c *modelCatalog) loadSeedLocked() { - raw, err := modelSeedFS.ReadFile("model.json") - if err != nil { - // embed 编译期保证存在,理论不可达;防御性兜底走静态表(initLocked 调用方 - // 查找链第 2 级本来就会兜,这里只需保持 entries 为空)。 - return - } - var seed map[string]ModelCapEntry - if err := json.Unmarshal(raw, &seed); err != nil { - return - } - for id, e := range seed { - if validCapEntry(e) { - c.entries[id] = e - } - } -} - -// validCapEntry 条目级校验:context 正数 + 输出非负(任务书 §值校验的写入侧)。 -func validCapEntry(e ModelCapEntry) bool { - return e.ContextLength > 0 && e.MaxOutputTokens >= 0 -} - -// get 查 model.json 缓存(第 3 级)。返回条目与是否命中。 -// 只读内存,不发网络;加载与网络动作由 ensure/触发侧负责。 -func (c *modelCatalog) get(model string) (ModelCapEntry, bool) { - c.mu.Lock() - defer c.mu.Unlock() - c.initLocked() - e, ok := c.entries[model] - if !ok || !validCapEntry(e) { - return ModelCapEntry{}, false - } - return e, true -} - -// put 写一条缓存(第 4 级拉取成功后调用)并落盘。同模型已存在(用户手动维护过) -// 仍覆盖——运行时拉取值采信 models.dev 官方源优先口径,比手编更可信; -// 若不希望覆盖,删掉 model.json 里对应条目即可(加载后手编值只在本次进程生效)。 -func (c *modelCatalog) put(model string, e ModelCapEntry) { - if model == "" || !validCapEntry(e) { - return - } - c.mu.Lock() - defer c.mu.Unlock() - c.initLocked() - c.entries[model] = e - c.saveLocked() -} - -// saveLocked 原子落盘(tmp + rename,pool state.json 同模式)。持锁调用。 -// path 为空 / 目录不可写 / 序列化失败 → 静默(内存缓存仍生效,下次进程重拉)。 -func (c *modelCatalog) saveLocked() { - if c.path == "" { - return - } - raw, err := json.MarshalIndent(c.entries, "", " ") - if err != nil { - return - } - if dir := filepath.Dir(c.path); dir != "" { - _ = os.MkdirAll(dir, 0o755) - } - tmp := c.path + ".tmp" - if err := os.WriteFile(tmp, raw, 0o600); err != nil { - log.Printf("WARN: [upstream] model.json 落盘失败(内存缓存仍生效): path=%s err=%v", c.path, err) - return - } - if err := os.Rename(tmp, c.path); err != nil { - log.Printf("WARN: [upstream] model.json 落盘改名失败: path=%s err=%v", c.path, err) - } -} - -// ---- 包级 API(查找链 3/4 级 + 接线)---- - -// SetModelCatalogPath 接线 model.json 落盘路径(cmd/server 启动时调用, -// 数据目录与 state.json 同风格)。首次调用生效;后续调用在已加载后仅更新路径 -// (不重载——进程内以内存 entries 为准)。 -func SetModelCatalogPath(path string) { - c := catalogState - c.mu.Lock() - defer c.mu.Unlock() - c.path = path -} - -// modelCatalogGet 第 3 级:model.json 缓存命中(内含种子初值与损坏降级)。 -func modelCatalogGet(model string) (ModelCapEntry, bool) { - return catalogState.get(model) -} - -// modelCatalogPut 第 4 级写入:models.dev 拉到的值落缓存(含落盘)。 -func modelCatalogPut(model string, context, maxOutput int64) { - modelCatalogPutSourced(model, context, maxOutput, "modelsdev") -} - -// modelCatalogPutSourced 写入指定来源的条目(测试可注入 fetched_at 检查落盘格式)。 -func modelCatalogPutSourced(model string, context, maxOutput int64, source string) { - catalogState.put(model, ModelCapEntry{ - ContextLength: context, - MaxOutputTokens: maxOutput, - FetchedAt: time.Now().UTC().Format(time.RFC3339), - Source: source, - }) -} - -// resetModelCatalog 测试隔离:清空单例状态(entries/path/loaded)。 -func resetModelCatalog() { - c := catalogState - c.mu.Lock() - defer c.mu.Unlock() - c.entries = nil - c.path = "" - c.loaded = false -} - -// loadModelCatalogAt 测试接线:指向指定路径后立即触发一次加载(同步,可断言文件 -// 解析行为)。生产路径用 SetModelCatalogPath(惰性首次 get 触发加载)。 -func loadModelCatalogAt(path string) { - SetModelCatalogPath(path) - catalogState.mu.Lock() - defer catalogState.mu.Unlock() - catalogState.initLocked() -} - -// ResetLookupChainForTest 跨包测试钩子:清空 model.json 缓存与 models.dev fetcher -// 的全部包级单例状态(含在途拉取冷却——防 server 包测试末尾的异步 goroutine 打 -// 真网、防跨测试缓存污染)。仅测试引用(upstream 包内用 resetModelsDev / -// resetModelCatalog 等价内联)。 -func ResetLookupChainForTest() { - resetModelCatalog() - resetModelsDev() -} - -// ---- 四级查找链(对 handler 暴露的入口,签名与 32a3c13 三级版兼容)---- - -// ContextWindowListingV4 四级查找链的 context_length 决策: -// 1. remote>0 权威透出(上游动态值永远压过 model.json,任务书 §清理); -// 2. 静态种子表(contextCapFallback); -// 3. model.json 缓存(内含种子初值 / models.dev 运行时补充值); -// 4. 全链 miss 且非负缓存 → 异步触发 models.dev 拉取(本次返回 DefaultContextWindow -// 1M,不阻塞;拉到后写 model.json 供下次命中)。 -func ContextWindowListingV4(model string, remote int64, client *http.Client) int64 { - if remote > 0 { - return remote - } - if model == "" { - return DefaultContextWindow - } - if cap, ok := contextCapFallback[model]; ok && cap.context > 0 { - return cap.context // 第 2 级:静态种子表(编译期兜底,永远可用) - } - if e, ok := modelCatalogGet(model); ok { - return e.ContextLength // 第 3 级:model.json - } - if !modelsDev.negativeFresh(model) { - // 第 4 级触发:先查进程内文档索引(拉过一次即常驻),命中直接入缓存 - // 返回(不等待异步拉取);未命中 → 记负缓存 + 异步拉取(本次先回 1M)。 - if e, ok := modelsDev.lookup(model); ok { - modelCatalogPut(model, e.Context, e.Output) - return e.Context - } - modelsDev.ensureDocAsync(client, "") - } - return DefaultContextWindow // 第 4 级兜底:1M(本次先回,拉到后下次命中) -} - -// MaxOutputTokensListingV4 四级查找链的 max_output_tokens 决策(与 context 口径 -// 刻意不同:未知 → 省略,无「宁可高估」安全侧)。 -func MaxOutputTokensListingV4(model string, remote int64, client *http.Client) (int64, bool) { - if remote > 0 { - return remote, true - } - if model == "" { - return 0, false - } - if cap, ok := contextCapFallback[model]; ok && cap.maxOutput > 0 { - return cap.maxOutput, true // 第 2 级 - } - if e, ok := modelCatalogGet(model); ok && e.MaxOutputTokens > 0 { - return e.MaxOutputTokens, true // 第 3 级 - } - if !modelsDev.negativeFresh(model) { - // 与 ContextWindowListingV4 同触发:lookup 命中先入缓存再返回 - // (两条查找链并发 miss 同一模型时,第二调用方直接拿到刚写入的值)。 - if e, ok := modelsDev.lookup(model); ok { - modelCatalogPut(model, e.Context, e.Output) - return e.Output, e.Output > 0 - } - modelsDev.ensureDocAsync(client, "") - } - return 0, false // 第 4 级兜底:省略(输出上限不编造) -} - -// ---- 第 4 级拉取值的回流(fetchDoc 成功后调用,写 model.json)---- - -// noteModelsDevMiss 查询未命中 models.dev 索引 → 负缓存已由 lookup 记录。 -// 本函数是 lookup + 写缓存的粘合层:fetchDoc 拉到文档后对「曾 miss 过的模型」 -// 重查一次并写入 model.json(下次 /v1/models 直接命中第 3 级)。 -func (f *modelsDevFetcher) backfillMisses() { - f.mu.Lock() - doc := f.doc - missed := make([]string, 0, len(f.negatives)) - for m := range f.negatives { - missed = append(missed, m) - } - f.mu.Unlock() - if doc == nil { - return - } - for _, m := range missed { - e, ok := doc[m] - if !ok { - continue // 仍查不到:负缓存 24h 生效,不写 - } - modelCatalogPut(m, e.Context, e.Output) - // 回流成功:清除负缓存条目(该模型已有值,后续走第 3 级缓存, - // 不再进本清单)。 - f.mu.Lock() - delete(f.negatives, m) - f.mu.Unlock() - } -} +// model_catalog.go context_length / max_output_tokens 四级查找链 + model.json +// 本地缓存(任务书 model-json-dynamic)。 +// +// 查找链(32a3c13 三级 → 四级,上游动态值永远权威不变): +// 1. 上游动态值(ModelInfo.ContextWindow/MaxTokens)——权威,永远压过 model.json +// (即使后者更新:上游才是权威,任务书 §清理); +// 2. 静态种子表(context_catalog.go 的 contextCapFallback,编译期兜底); +// 3. model.json 本地缓存(数据目录,含运行时从 models.dev 补的值 + 仓库种子 +// embed 的初值);损坏 → 降级种子并 WARN 不崩溃(手动维护入口的容错); +// 4. 触发 models.dev 按需拉取(异步,不阻塞本次响应)→ 值写入 model.json → +// 本次先落 1M/省略,下次命中缓存;负缓存 24h。 +// +// model.json 读写并发安全(单 sync.Mutex 全程持锁 + 原子落盘 tmp+rename, +// 多请求同时 miss 同一模型只写一次);文件损坏/不可写均静默降级(种子表→1M)。 +// +// 状态归属:包级 catalogState 单例(与 modelsDev fetcher 同模式,进程一份)。 +// 测试用 resetModelCatalog / loadModelCatalogAt 隔离。 +package upstream + +import ( + "embed" + "encoding/json" + "log" + "net/http" + "os" + "path/filepath" + "sync" + "time" + + "github.com/misakano7545/workbuddy2api-panel/internal/safefile" +) + +// modelSeedFS 仓库种子版 model.json(context_catalog 静态表 27 值迁移,source=seed)。 +// 只作 model.json 缺失时的初值来源;运行目录的 model.json 一旦存在则以它为准 +// (用户手动维护入口——直接编辑文件,格式容错由 loadModelCatalog 的校验兜底)。 +// +//go:embed model.json +var modelSeedFS embed.FS + +// ModelCapEntry model.json 单条目(与静态表同字段口径 + 来源与抓取时间)。 +// Source:seed(仓库种子迁移)/ modelsdev(运行时按需拉取)/ manual(用户手编 +// ——无法区分手编与 seed,手编条目保留其原 source 字符串,语义等同「非拉取」)。 +// Context 必须 >0(零/负条目校验拒绝);MaxOutput 0 = 输出上限未知 → 省略字段。 +type ModelCapEntry struct { + ContextLength int64 `json:"context_length"` + MaxOutputTokens int64 `json:"max_output_tokens,omitempty"` + FetchedAt string `json:"fetched_at,omitempty"` // RFC3339;seed 条目为空 + Source string `json:"source"` +} + +// modelCatalog model.json 缓存状态机(包级 catalogState 单例的字段载体)。 +type modelCatalog struct { + mu sync.Mutex + + path string // 落盘路径(空 = 禁用持久化:纯内存 + 种子) + entries map[string]ModelCapEntry + loaded bool // entries 已初始化(含损坏降级形态) +} + +// catalogState 包级单例:全进程一份 model.json 状态。 +var catalogState = &modelCatalog{} + +// initModelCatalogLocked 确保 entries 已加载(持锁调用): +// - 运行目录 model.json 存在且合法 → 全量加载(校验失败的条目剔除并 WARN); +// - 文件不存在 / 整体损坏(非法 JSON)→ 种子 embed 初值(不落盘:保持「用户 +// 尚无缓存」状态,首次拉取成功后再落盘); +// - path 为空(未接线,如测试/工具进程)→ 种子初值。 +func (c *modelCatalog) initLocked() { + if c.loaded { + return + } + c.entries = map[string]ModelCapEntry{} + c.loaded = true + if c.path == "" { + c.loadSeedLocked() + return + } + raw, err := safefile.Read(c.path, nil) + if err != nil { + // 不存在 / 不可读(两边都坏)→ 种子(首次启动形态)。 + c.loadSeedLocked() + return + } + var file map[string]ModelCapEntry + if err := json.Unmarshal(raw, &file); err != nil { + // 整体损坏:降级种子 + WARN 不崩溃(任务书 §手动维护入口容错)。 + log.Printf("WARN: [upstream] model.json 损坏(降级内置种子表): path=%s err=%v", c.path, err) + c.loadSeedLocked() + return + } + for id, e := range file { + if !validCapEntry(e) { + log.Printf("WARN: [upstream] model.json 条目非法剔除: model=%s entry=%+v", id, e) + continue + } + c.entries[id] = e + } +} + +// loadSeedLocked 把仓库种子 model.json 灌入 entries(持锁调用)。 +func (c *modelCatalog) loadSeedLocked() { + raw, err := modelSeedFS.ReadFile("model.json") + if err != nil { + // embed 编译期保证存在,理论不可达;防御性兜底走静态表(initLocked 调用方 + // 查找链第 2 级本来就会兜,这里只需保持 entries 为空)。 + return + } + var seed map[string]ModelCapEntry + if err := json.Unmarshal(raw, &seed); err != nil { + return + } + for id, e := range seed { + if validCapEntry(e) { + c.entries[id] = e + } + } +} + +// validCapEntry 条目级校验:context 正数 + 输出非负(任务书 §值校验的写入侧)。 +func validCapEntry(e ModelCapEntry) bool { + return e.ContextLength > 0 && e.MaxOutputTokens >= 0 +} + +// get 查 model.json 缓存(第 3 级)。返回条目与是否命中。 +// 只读内存,不发网络;加载与网络动作由 ensure/触发侧负责。 +func (c *modelCatalog) get(model string) (ModelCapEntry, bool) { + c.mu.Lock() + defer c.mu.Unlock() + c.initLocked() + e, ok := c.entries[model] + if !ok || !validCapEntry(e) { + return ModelCapEntry{}, false + } + return e, true +} + +// put 写一条缓存(第 4 级拉取成功后调用)并落盘。同模型已存在(用户手动维护过) +// 仍覆盖——运行时拉取值采信 models.dev 官方源优先口径,比手编更可信; +// 若不希望覆盖,删掉 model.json 里对应条目即可(加载后手编值只在本次进程生效)。 +func (c *modelCatalog) put(model string, e ModelCapEntry) { + if model == "" || !validCapEntry(e) { + return + } + c.mu.Lock() + defer c.mu.Unlock() + c.initLocked() + c.entries[model] = e + c.saveLocked() +} + +// saveLocked 原子落盘(tmp + rename,pool state.json 同模式)。持锁调用。 +// path 为空 / 目录不可写 / 序列化失败 → 静默(内存缓存仍生效,下次进程重拉)。 +func (c *modelCatalog) saveLocked() { + if c.path == "" { + return + } + raw, err := json.MarshalIndent(c.entries, "", " ") + if err != nil { + return + } + if dir := filepath.Dir(c.path); dir != "" { + _ = os.MkdirAll(dir, 0o755) + } + if err := safefile.Write(c.path, raw, 0o600); err != nil { + log.Printf("WARN: [upstream] model.json 落盘失败(内存缓存仍生效): path=%s err=%v", c.path, err) + } +} + +// ---- 包级 API(查找链 3/4 级 + 接线)---- + +// SetModelCatalogPath 接线 model.json 落盘路径(cmd/server 启动时调用, +// 数据目录与 state.json 同风格)。首次调用生效;后续调用在已加载后仅更新路径 +// (不重载——进程内以内存 entries 为准)。 +func SetModelCatalogPath(path string) { + c := catalogState + c.mu.Lock() + defer c.mu.Unlock() + c.path = path +} + +// modelCatalogGet 第 3 级:model.json 缓存命中(内含种子初值与损坏降级)。 +func modelCatalogGet(model string) (ModelCapEntry, bool) { + return catalogState.get(model) +} + +// modelCatalogPut 第 4 级写入:models.dev 拉到的值落缓存(含落盘)。 +func modelCatalogPut(model string, context, maxOutput int64) { + modelCatalogPutSourced(model, context, maxOutput, "modelsdev") +} + +// modelCatalogPutSourced 写入指定来源的条目(测试可注入 fetched_at 检查落盘格式)。 +func modelCatalogPutSourced(model string, context, maxOutput int64, source string) { + catalogState.put(model, ModelCapEntry{ + ContextLength: context, + MaxOutputTokens: maxOutput, + FetchedAt: time.Now().UTC().Format(time.RFC3339), + Source: source, + }) +} + +// resetModelCatalog 测试隔离:清空单例状态(entries/path/loaded)。 +func resetModelCatalog() { + c := catalogState + c.mu.Lock() + defer c.mu.Unlock() + c.entries = nil + c.path = "" + c.loaded = false +} + +// loadModelCatalogAt 测试接线:指向指定路径后立即触发一次加载(同步,可断言文件 +// 解析行为)。生产路径用 SetModelCatalogPath(惰性首次 get 触发加载)。 +func loadModelCatalogAt(path string) { + SetModelCatalogPath(path) + catalogState.mu.Lock() + defer catalogState.mu.Unlock() + catalogState.initLocked() +} + +// ResetLookupChainForTest 跨包测试钩子:清空 model.json 缓存与 models.dev fetcher +// 的全部包级单例状态(含在途拉取冷却——防 server 包测试末尾的异步 goroutine 打 +// 真网、防跨测试缓存污染)。仅测试引用(upstream 包内用 resetModelsDev / +// resetModelCatalog 等价内联)。 +func ResetLookupChainForTest() { + resetModelCatalog() + resetModelsDev() +} + +// ---- 四级查找链(对 handler 暴露的入口,签名与 32a3c13 三级版兼容)---- + +// ContextWindowListingV4 四级查找链的 context_length 决策: +// 1. remote>0 权威透出(上游动态值永远压过 model.json,任务书 §清理); +// 2. 静态种子表(contextCapFallback); +// 3. model.json 缓存(内含种子初值 / models.dev 运行时补充值); +// 4. 全链 miss 且非负缓存 → 异步触发 models.dev 拉取(本次返回 DefaultContextWindow +// 1M,不阻塞;拉到后写 model.json 供下次命中)。 +func ContextWindowListingV4(model string, remote int64, client *http.Client) int64 { + if remote > 0 { + return remote + } + if model == "" { + return DefaultContextWindow + } + if cap, ok := contextCapFallback[model]; ok && cap.context > 0 { + return cap.context // 第 2 级:静态种子表(编译期兜底,永远可用) + } + if e, ok := modelCatalogGet(model); ok { + return e.ContextLength // 第 3 级:model.json + } + if !modelsDev.negativeFresh(model) { + // 第 4 级触发:先查进程内文档索引(拉过一次即常驻),命中直接入缓存 + // 返回(不等待异步拉取);未命中 → 记负缓存 + 异步拉取(本次先回 1M)。 + if e, ok := modelsDev.lookup(model); ok { + modelCatalogPut(model, e.Context, e.Output) + return e.Context + } + modelsDev.ensureDocAsync(client, "") + } + return DefaultContextWindow // 第 4 级兜底:1M(本次先回,拉到后下次命中) +} + +// MaxOutputTokensListingV4 四级查找链的 max_output_tokens 决策(与 context 口径 +// 刻意不同:未知 → 省略,无「宁可高估」安全侧)。 +func MaxOutputTokensListingV4(model string, remote int64, client *http.Client) (int64, bool) { + if remote > 0 { + return remote, true + } + if model == "" { + return 0, false + } + if cap, ok := contextCapFallback[model]; ok && cap.maxOutput > 0 { + return cap.maxOutput, true // 第 2 级 + } + if e, ok := modelCatalogGet(model); ok && e.MaxOutputTokens > 0 { + return e.MaxOutputTokens, true // 第 3 级 + } + if !modelsDev.negativeFresh(model) { + // 与 ContextWindowListingV4 同触发:lookup 命中先入缓存再返回 + // (两条查找链并发 miss 同一模型时,第二调用方直接拿到刚写入的值)。 + if e, ok := modelsDev.lookup(model); ok { + modelCatalogPut(model, e.Context, e.Output) + return e.Output, e.Output > 0 + } + modelsDev.ensureDocAsync(client, "") + } + return 0, false // 第 4 级兜底:省略(输出上限不编造) +} + +// ---- 第 4 级拉取值的回流(fetchDoc 成功后调用,写 model.json)---- + +// noteModelsDevMiss 查询未命中 models.dev 索引 → 负缓存已由 lookup 记录。 +// 本函数是 lookup + 写缓存的粘合层:fetchDoc 拉到文档后对「曾 miss 过的模型」 +// 重查一次并写入 model.json(下次 /v1/models 直接命中第 3 级)。 +func (f *modelsDevFetcher) backfillMisses() { + f.mu.Lock() + doc := f.doc + missed := make([]string, 0, len(f.negatives)) + for m := range f.negatives { + missed = append(missed, m) + } + f.mu.Unlock() + if doc == nil { + return + } + for _, m := range missed { + e, ok := doc[m] + if !ok { + continue // 仍查不到:负缓存 24h 生效,不写 + } + modelCatalogPut(m, e.Context, e.Output) + // 回流成功:清除负缓存条目(该模型已有值,后续走第 3 级缓存, + // 不再进本清单)。 + f.mu.Lock() + delete(f.negatives, m) + f.mu.Unlock() + } +} diff --git a/internal/upstream/modelblocked_test.go b/internal/upstream/modelblocked_test.go new file mode 100644 index 0000000000000000000000000000000000000000..bb3804bc1141119b2d2cb93342686fecffc9689f --- /dev/null +++ b/internal/upstream/modelblocked_test.go @@ -0,0 +1,143 @@ +// modelblocked_test.go 11102/11158/14401 确定性模型拒绝的判据回归。 +// +// 这两条 code 都会让 handler 写 (账号, 模型) 负缓存(BlockModelBackoff): +// - 11102「该后端无此模型」(含图像域 14401 route config not found)→ 该模型在本域 +// 根本不存在,换号也没用; +// - 11158「该账号类型无权使用该模型」→ 同一模型在个人 / 企业 / 静态 API Key 上权限 +// 不同,换有权限的号仍可能成功。 +// +// 判据错误的两个方向代价不对称:漏判(11158 落 ErrClient)→ 该号留在池内被反复选中、 +// 每轮都撞同一堵墙且不避让;误判(把限流/普通 400 当模型拒绝)→ 一个健康模型被冷却 +// 6h 起跳。故这里既钉命中,也钉**不该命中**的形态。 +package upstream + +import ( + "net/http" + "testing" +) + +func TestIsModelBlockedCodes(t *testing.T) { + cases := []struct { + name string + body string + want bool + }{ + { + name: "11102_数字code", + body: `{"code":11102,"msg":"model [glm-5.3] service info not found","requestId":"r1"}`, + want: true, + }, + { + name: "11102_字符串code", + body: `{"code":"11102","msg":"model service info not found"}`, + want: true, + }, + { + name: "11102_error子对象", + body: `{"error":{"code":11102,"message":"service info not found"}}`, + want: true, + }, + { + name: "11158_账号类型无权限", + body: `{"code":11158,"msg":"model [claude-opus-4-1] is not allowed for user type","requestId":"r1"}`, + want: true, + }, + { + name: "11158_仅文案命中", + body: `{"code":0,"msg":"This model is not allowed for user type: free"}`, + want: true, + }, + { + name: "14401_图像域同族答复", + body: `{"code":14401,"msg":"route config not found"}`, + want: true, + }, + { + // 11102 出现在 requestId 等无关字段里,不得据此避让一个能用的模型。 + name: "code撞在requestId上不命中", + body: `{"code":11101,"msg":"bad params","requestId":"req-11102-abc"}`, + want: false, + }, + { + // 11140 request illegal 是账号级风控(ErrAccountFault),不是模型级拒绝: + // 换模型也不解决,误判成模型拒绝会把该号所有模型逐个冷却一遍。 + name: "11140_request_illegal不命中", + body: `{"code":11140,"msg":"request illegal"}`, + want: false, + }, + { + name: "6004模型级限流不命中", + body: `{"code":6004,"msg":"The model provider is rate-limiting requests"}`, + want: false, + }, + { + name: "普通400不命中", + body: `{"code":11101,"msg":"Unmarshal chat params failed"}`, + want: false, + }, + { + name: "空body", + body: "", + want: false, + }, + } + for _, c := range cases { + t.Run(c.name, func(t *testing.T) { + if got := IsModelBlocked(http.StatusBadRequest, c.body); got != c.want { + t.Fatalf("IsModelBlocked(%q)=%v want %v", c.body, got, c.want) + } + }) + } +} + +// 429 带 11158 仍属限流语义(上游在限流时也可能回带模型的 code):只看 400/404, +// 否则一个本来能用的模型会因为一次限流被负缓存 6 小时。 +func TestIsModelBlockedIgnoresNon400Statuses(t *testing.T) { + body := `{"code":11158,"msg":"model is not allowed for user type"}` + for _, status := range []int{http.StatusTooManyRequests, http.StatusForbidden, http.StatusOK, http.StatusInternalServerError} { + if IsModelBlocked(status, body) { + t.Fatalf("status=%d 不应判为模型拒绝", status) + } + } + // 400/404 才判。 + for _, status := range []int{http.StatusBadRequest, http.StatusNotFound} { + if !IsModelBlocked(status, body) { + t.Fatalf("status=%d 应判为模型拒绝", status) + } + } +} + +// ModelBlockReasonFor 决定负缓存条目的 reason 前缀,pool 侧按此前缀分域 +// (BlockModelClear 清 11102/11158、台账 kind 区分限流与不可用)。11158 必须与 +// 11102 分列,否则运维在台账上看不出「模型不存在」与「这个号没权限」。 +func TestModelBlockReasonFor(t *testing.T) { + cases := []struct { + name string + body string + want string + }{ + {"11158数字", `{"code":11158,"msg":"model is not allowed for user type"}`, ModelForbiddenReason}, + {"11158字符串", `{"code":"11158","msg":"x"}`, ModelForbiddenReason}, + {"11158仅文案", `{"code":0,"msg":"This model is not allowed for user type"}`, ModelForbiddenReason}, + {"11102数字", `{"code":11102,"msg":"service info not found"}`, ModelBlockReason}, + {"14401图像域", `{"code":14401,"msg":"route config not found"}`, ModelBlockReason}, + {"非JSON", `not json at all`, ModelBlockReason}, + } + for _, c := range cases { + t.Run(c.name, func(t *testing.T) { + if got := ModelBlockReasonFor(c.body); got != c.want { + t.Fatalf("ModelBlockReasonFor(%q)=%q want %q", c.body, got, c.want) + } + }) + } +} + +// reason 前缀必须能被 pool 的正则表识别("11102"/"11158")——两处字面量分属不同包, +// 漂移会让 BlockModelClear 静默失效(该模型重新跑通也永远不清缓存)。 +func TestModelBlockReasonPrefixesAreRecognizable(t *testing.T) { + for _, reason := range []string{ModelBlockReason, ModelForbiddenReason} { + if len(reason) < 5 || (reason[:5] != "11102" && reason[:5] != "11158") { + t.Fatalf("reason %q 不以 11102/11158 开头,pool.BlockModelClear 将无法识别", reason) + } + } +} diff --git a/internal/upstream/modelbusy.go b/internal/upstream/modelbusy.go new file mode 100644 index 0000000000000000000000000000000000000000..de82c5819434a1a20af63c4cc3d599e79fe955e6 --- /dev/null +++ b/internal/upstream/modelbusy.go @@ -0,0 +1,115 @@ +// modelbusy.go 上游「模型繁忙度」观测(官方桌面端 POST /v2/chat/busy)。 +// +// 逆向来源:syan-anan/wb-syan 的 internal/upstream/modelbusy.go(其文件头注明形状来自 +// xiaofan6ya/workbuddy2api 的 admin/model_busy.py);线上实测(2026-10-16,CN): +// +// POST {chatBase}/v2/chat/busy ← 与 /v2/chat/completions 同 base,路径必须带 /v2 +// 请求: {"models": ["glm-5.3-flash", "deepseek-v4-pro"]} ← 单次上限 50 个(超出分批) +// 响应: {"code":0,"data":[{"model":"glm-5.3-flash","busy_level":"idle"}, ...]} +// +// busy_level ∈ idle | normal | busy | congested | unavailable(实测还会出 unknown)。实测发现该结果**单次请求可降级**:同一批模型重查三次分别得 idle/unknown/idle, +// n=21 的一次得 9 idle + 1 congested + 10 unknown —— unknown 是服务端当次无数据(不是模型不合法),故 +// 不得把 unknown 当成「不可用」展示,也不能据此改选号。这是**观测数据**,不是 +// 路由依据:真正决定选号的是 pool 的冷却/熔断状态,本文件不参与任何选号决策,只给面板看(当次取不到就不填) +// ——它恰好解释了 chat 侧偶发的 429 / 6021 queue.full(同一上游容量现象的事前面)。 +package upstream + +import ( + "bytes" + "encoding/json" + "errors" + "log" + "net/http" + + "github.com/misakano7545/workbuddy2api-panel/internal/auth" + "github.com/misakano7545/workbuddy2api-panel/internal/session" +) + +const ( + modelBusyPath = "/v2/chat/busy" + // modelBusyBatch 单批模型数上限。上游硬限制,超限整批被拒,故必须分批。 + modelBusyBatch = 50 +) + +// ModelBusy 查一批模型的繁忙度,返回 model → busy_level(上游未返回的模型不在 map 里)。 +// 只读、无副作用;失败原样返回错误(调用方不填即可,不得据此改变选号)。 +func (c *Client) ModelBusy(a *auth.Auth, models []string) (map[string]string, error) { + out := map[string]string{} + // 国际版没有这条端点:2026-10-29 5.9.3 真机抓包(www.workbuddy.ai)10 次 POST /v2/chat/busy + // 全部 404,同一 token 直连复验也是 404 {"error_msg":"404 Route Not Found"},而国内版同路径 200。 + // 官方客户端自己也在打这条不存在的路径(说明是服务端没部署,不是我们路径写错)。 + // + // 一旦探到 404 就记住,本进程后续调用直接返回空表:繁忙度是**纯观测**数据(见文件头), + // 拿到 404 既不值得每轮刷新重试一次、也不该让上层把「观测失败」记成错误(面板会把 + // busy 失败并进目录错误列表,进而拒绝写目录缓存)。 + // + // 自愈口子:上游若补上该端点,重启进程即重新探测(不做持久化),不需要改代码。 + if c.globalOn(a) && c.modelBusyUnsupported.Load() { + return out, nil + } + for i := 0; i < len(models); i += modelBusyBatch { + end := i + modelBusyBatch + if end > len(models) { + end = len(models) + } + raw, err := json.Marshal(map[string]any{"models": models[i:end]}) + if err != nil { + return out, err + } + req, err := http.NewRequest(http.MethodPost, c.chatBase(a)+modelBusyPath, bytes.NewReader(raw)) + if err != nil { + return out, err + } + // 头族按真机 /v2/chat/busy 逐头对齐——**不是** chat 那套重头族: + // + // Accept: application/json, text/plain, */* + // Content-Type: application/json + // User-Agent: CN WorkBuddy/5.9.3 WorkBuddy/5.9.3 CLI/2.165.0 + // GL workbuddy-ai/5.9.4 workbuddy-ai/5.9.4 CLI/2.165.0 + // X-Request-ID / X-Product: SaaS / Authorization / X-User-Id / X-Domain + // + // 真机这条路径**不发** X-Conversation-* / acp-connection-id / baggage / b3 / + // x-stainless-* / x-codebuddy-request,也没有 X-Requested-With。旧实现直接复用 + // ChatHeaders,等于给一个官方轻请求套上 20 多个它从不发的头。 + // + // UA 取 rpcUAFor(首段即品牌 slug),不是 userAgent(chat 的 SDK 形态): + // 2026-10-30 国际版 5.9.4 真机 /v2/chat/busy = `workbuddy-ai/5.9.4 workbuddy-ai/ + // 5.9.4 CLI/2.165.0`,而同一会话的 /v2/chat/completions 首段是驼峰 WorkBuddy。 + // CN 下两者同值(品牌段本来就是驼峰),故只有 GL 会分叉。 + req.Header.Set("Accept", "application/json, text/plain, */*") + req.Header.Set("Content-Type", "application/json") + req.Header.Set("User-Agent", c.rpcUAFor(a)) + req.Header.Set("X-Request-ID", session.NewTraceID()) // 真机为纯随机 32 hex(无时间前缀) + req.Header.Set("X-Product", "SaaS") + if at := a.AccessTokenValue(); at != "" { + req.Header.Set("Authorization", "Bearer "+at) + } + if a.UID != "" { + req.Header.Set("X-User-Id", a.UID) + } + req.Header.Set("X-Domain", c.chatHost(a)) + data, err := c.doJSON(req, a) + if err != nil { + var ue *Error + if c.globalOn(a) && errors.As(err, &ue) && ue.Kind == ErrNotFound { + c.modelBusyUnsupported.Store(true) + log.Printf("model busy: global realm 无 /v2/chat/busy(404),本进程后续跳过繁忙度探测") + return out, nil + } + return out, err + } + var rows []struct { + Model string `json:"model"` + Level string `json:"busy_level"` + } + if err := json.Unmarshal(data, &rows); err != nil { + return out, err + } + for _, r := range rows { + if r.Model != "" && r.Level != "" { + out[r.Model] = r.Level + } + } + } + return out, nil +} diff --git a/internal/upstream/modelbusy_global_test.go b/internal/upstream/modelbusy_global_test.go new file mode 100644 index 0000000000000000000000000000000000000000..7ad5a47e7340b7a8345d209e3dac40d87fff5b83 --- /dev/null +++ b/internal/upstream/modelbusy_global_test.go @@ -0,0 +1,122 @@ +package upstream + +import ( + "io" + "net/http" + "strings" + "testing" + + "github.com/misakano7545/workbuddy2api-panel/internal/auth" +) + +// globalBusyStub 模拟两域繁忙度端点:host 匹配 www.workbuddy.ai 时一律回 404 +// {"error_msg":"404 Route Not Found"}(2026-10-29 真机形态),其余 host 正常回一条 normal。 +// hits 记录被打过的总次数,globalHits 记录其中打到国际域的次数。 +type globalBusyStub struct { + hits int + globalHits int +} + +func (g *globalBusyStub) client() *Client { + return &Client{ + HTTP: &http.Client{Transport: rtFunc(func(r *http.Request) (*http.Response, error) { + g.hits++ + if r.URL.Host == "www.workbuddy.ai" { + g.globalHits++ + return &http.Response{StatusCode: http.StatusNotFound, + Header: http.Header{"Content-Type": []string{"application/json"}}, + Body: io.NopCloser(strings.NewReader( + `{"error_msg":"404 Route Not Found"}`))}, nil + } + return &http.Response{StatusCode: http.StatusOK, + Header: http.Header{"Content-Type": []string{"application/json"}}, + Body: io.NopCloser(strings.NewReader( + `{"code":0,"msg":"OK","data":[{"model":"hy3","busy_level":"idle"}]}`))}, nil + })}, + ChatBaseCN: "https://cn.example", + BillingBaseCN: "https://cn.example", + ChatBaseGlobal: "https://www.workbuddy.ai", + GlobalEnabled: true, + } +} + +// busyGlobalAuth 判为 global realm 的账号(Domain 后缀决定,见 auth.Realm)。 +func busyGlobalAuth() *auth.Auth { + return &auth.Auth{UID: "g1", AccessToken: "at", Domain: "www.workbuddy.ai"} +} + +// busyCNAuth 判为 cn realm 的账号。 +func busyCNAuth() *auth.Auth { + return &auth.Auth{UID: "u1", AccessToken: "at"} +} + +// TestModelBusyGlobal404IsNotAnError 国际版无 /v2/chat/busy(实测 404): +// 必须当成「该域没有这个观测能力」返回空表 + nil error,而不是把 404 抛给上层。 +// +// 反例代价(本测试存在的原因):面板把 busy 失败并进目录错误列表,于是只要池里有 +// global 账号,`len(fetchErrs)==0` 的写缓存条件永远不成立,模型目录缓存整份失效。 +func TestModelBusyGlobal404IsNotAnError(t *testing.T) { + g := &globalBusyStub{} + got, err := g.client().ModelBusy(busyGlobalAuth(), []string{"fast-model", "gpt-6-astra"}) + if err != nil { + t.Fatalf("global 404 必须吞掉(返回 nil error),实际 err=%v", err) + } + if len(got) != 0 { + t.Fatalf("404 时不得编造繁忙度,实际 %v", got) + } + if g.globalHits != 1 { + t.Fatalf("首次调用应真打国际域 1 次,实际 %d", g.globalHits) + } +} + +// TestModelBusyGlobal404Memoized 探到 404 后本进程不再重试:繁忙度是纯观测数据, +// 每轮刷新重打一次不存在的端点只刷日志、白等 RTT。 +func TestModelBusyGlobal404Memoized(t *testing.T) { + g := &globalBusyStub{} + c := g.client() + for i := 0; i < 3; i++ { + if _, err := c.ModelBusy(busyGlobalAuth(), []string{"fast-model"}); err != nil { + t.Fatalf("第 %d 次 err=%v", i+1, err) + } + } + if g.globalHits != 1 { + t.Fatalf("404 记住后应只打过国际域 1 次,实际 %d", g.globalHits) + } +} + +// TestModelBusyGlobal404NotAppliedToCN 记忆只作用于 global:CN 端点实测 200, +// 不能因为国际域探到 404 就把国内版的繁忙度也一并关掉。 +func TestModelBusyGlobal404NotAppliedToCN(t *testing.T) { + g := &globalBusyStub{} + c := g.client() + if _, err := c.ModelBusy(busyGlobalAuth(), []string{"fast-model"}); err != nil { + t.Fatal(err) + } + got, err := c.ModelBusy(busyCNAuth(), []string{"hy3"}) + if err != nil { + t.Fatal(err) + } + if got["hy3"] != "idle" { + t.Fatalf("CN 繁忙度必须照常,实际 %v", got) + } +} + +// TestModelBusyGlobalNon404StillErrors 非 404(如 401/500)不属于「端点不存在」, +// 必须原样返回错误——否则运维看不到凭证失效这类真故障。 +func TestModelBusyGlobalNon404StillErrors(t *testing.T) { + c := &Client{ + HTTP: &http.Client{Transport: rtFunc(func(r *http.Request) (*http.Response, error) { + return &http.Response{StatusCode: http.StatusUnauthorized, + Header: http.Header{"Content-Type": []string{"application/json"}}, + Body: io.NopCloser(strings.NewReader(`{"code":12153,"msg":"invalid token"}`))}, nil + })}, + ChatBaseGlobal: "https://www.workbuddy.ai", + GlobalEnabled: true, + } + if _, err := c.ModelBusy(busyGlobalAuth(), []string{"fast-model"}); err == nil { + t.Fatal("401 必须报错") + } + if c.modelBusyUnsupported.Load() { + t.Fatal("非 404 不得置位「端点不存在」记忆") + } +} diff --git a/internal/upstream/modelbusy_test.go b/internal/upstream/modelbusy_test.go new file mode 100644 index 0000000000000000000000000000000000000000..eee32947f655d4d9bf583d20fbc2c1fa72cbb7a9 --- /dev/null +++ b/internal/upstream/modelbusy_test.go @@ -0,0 +1,98 @@ +package upstream + +import ( + "encoding/json" + "io" + "net/http" + "strings" + "testing" + + "github.com/misakano7545/workbuddy2api-panel/internal/auth" +) + +// busyStub 记录落点与请求体,按批回对应结果。 +type busyStub struct { + paths []string + hosts []string + bodies []string + levels map[string]string // model → busy_level(其余回 normal) +} + +func (b *busyStub) client() *Client { + return &Client{ + HTTP: &http.Client{Transport: rtFunc(func(r *http.Request) (*http.Response, error) { + raw, _ := io.ReadAll(r.Body) + b.paths = append(b.paths, r.URL.Path) + b.hosts = append(b.hosts, r.URL.Host) + b.bodies = append(b.bodies, string(raw)) + var req struct { + Models []string `json:"models"` + } + _ = json.Unmarshal(raw, &req) + rows := make([]string, 0, len(req.Models)) + for _, m := range req.Models { + lv := "normal" + if v, ok := b.levels[m]; ok { + lv = v + } + rows = append(rows, `{"model":"`+m+`","busy_level":"`+lv+`"}`) + } + body := `{"code":0,"msg":"OK","data":[` + strings.Join(rows, ",") + `]}` + return &http.Response{StatusCode: 200, + Header: http.Header{"Content-Type": []string{"application/json"}}, + Body: io.NopCloser(strings.NewReader(body))}, nil + })}, + ChatBaseCN: "https://cn.example", + BillingBaseCN: "https://cn.example", + } +} + +// TestModelBusyPathBodyAndParse 落点与体:必须 /v2/chat/busy(chat base),"models" 数组。 +func TestModelBusyPathBodyAndParse(t *testing.T) { + b := &busyStub{levels: map[string]string{"glm-5.3-flash": "idle", "deepseek-v4-pro": "congested"}} + got, err := b.client().ModelBusy(&auth.Auth{UID: "u1", AccessToken: "at"}, []string{"glm-5.3-flash", "deepseek-v4-pro"}) + if err != nil { + t.Fatal(err) + } + if b.paths[0] != "/v2/chat/busy" || b.hosts[0] != "cn.example" { + t.Fatalf("落点 %s%s want /v2/chat/busy @ cn.example", b.hosts[0], b.paths[0]) + } + var sent struct { + Models []string `json:"models"` + } + _ = json.Unmarshal([]byte(b.bodies[0]), &sent) + if len(sent.Models) != 2 { + t.Fatalf("请求体 models=%v", sent.Models) + } + if got["glm-5.3-flash"] != "idle" || got["deepseek-v4-pro"] != "congested" { + t.Fatalf("解析不符: %v", got) + } +} + +// TestModelBusyBatchesOver50 单次上限 50:超出的模型必须分批(超限整批被上游拒)。 +func TestModelBusyBatchesOver50(t *testing.T) { + var models []string + for i := 0; i < 120; i++ { + models = append(models, "m"+string(rune('a'+i%26))+string(rune('0'+i/26))) + } + b := &busyStub{levels: map[string]string{}} + got, err := b.client().ModelBusy(&auth.Auth{UID: "u1", AccessToken: "at"}, models) + if err != nil { + t.Fatal(err) + } + if len(b.paths) != 3 { + t.Fatalf("批次=%d want 3(120 个模型 / 每批 50)", len(b.paths)) + } + for i, body := range b.bodies { + var sent struct { + Models []string `json:"models"` + } + _ = json.Unmarshal([]byte(body), &sent) + if len(sent.Models) > 50 { + t.Fatalf("第 %d 批 %d 个模型,超过上游上限 50", i+1, len(sent.Models)) + } + } + if len(got) != 120 { + t.Fatalf("结果数=%d want 120", len(got)) + } +} diff --git a/internal/upstream/modelsdev.go b/internal/upstream/modelsdev.go index 23d09ab1d051d443381e3c793c24cadf8eabca08..273f4eb2b318b1c79a06926b02fde9567fbd4014 100644 --- a/internal/upstream/modelsdev.go +++ b/internal/upstream/modelsdev.go @@ -1,358 +1,358 @@ -// modelsdev.go models.dev 按需兜底(context_length 四级查找链的第 4 级)。 -// -// 定位:只对「上游动态值缺失 + 静态种子表未收录 + model.json 未缓存」的模型查 -// models.dev,是兜底的兜底——超时短(默认 5s)、失败静默降级(context_length 落 -// DefaultContextWindow=1M),绝不阻塞 /v1/models 主路径(查找异步化,本次请求 -// 直接返回兜底值,拉到后写 model.json 供下次命中)。 -// -// 数据源(2026-09-16 逆向,结论详见 .claude/reports/model-json-dynamic.md): -// - 官方聚合 JSON 端点 https://models.dev/api.json:~4.7MB 单文档、217 provider、 -// 免鉴权、Cloudflare 托管静态站; -// - 无按模型/按 provider 子端点(/z-ai.json 等 302 回 /),「按需」的实现是 -// 单次拉全量文档 + 建裸 id 索引(拉一次只发生一次,此后进程内复用索引); -// - schema:{ "": { "models": { "": { "limit": {"context": N, -// "output": N} } } } },模型 id 有裸名(glm-5.2)与带命名空间(openai/gpt-5.5) -// 两种形态,均取尾段做索引 key; -// - 多 provider 同名值会分歧(聚合网关常自报改动):vendor 官方源(zai/ -// moonshotai/openai/google/deepseek/minimax)优先,其余取众数(共识值)。 -package upstream - -import ( - "context" - "encoding/json" - "fmt" - "io" - "log" - "net/http" - "sort" - "strings" - "sync" - "time" -) - -// ModelsDevURL models.dev 官方聚合 JSON 端点(唯一端点,见文件头逆向结论)。 -const ModelsDevURL = "https://models.dev/api.json" - -// modelsDevTimeout 单次拉取超时:兜底的兜底,不值得等(任务书 §2:如 5s)。 -const modelsDevTimeout = 5 * time.Second - -// modelsDevFetchCooldown 拉取节流(进程级):文档是全量聚合体,5min 内不重拉 -// (同模型 24h 负缓存之外的整体节流,防短窗反复打 models.dev)。 -const modelsDevFetchCooldown = 5 * time.Minute - -// modelsDevNegativeTTL 同模型负缓存:查不到的模型 24h 内不重查 -// (任务书 §2:如同模型 24h 内不重查,查不到的模型负缓存防反复打)。 -const modelsDevNegativeTTL = 24 * time.Hour - -// modelsDevNegativesSoftCap 负缓存 map 的软上限:规模超过它时才做一次过期条目淘汰 -// 扫描。分批摊销是为避免每次 lookup 都做 O(n) 全扫——第 4 级触发点在 /v1/models 里 -// 每个模型各调一次(handler 遍历模型列表逐条 V4),n 大时全扫会被请求数放大成 CPU -// 开销。淘汰只针对 TTL 已过期的条目,故低于上限时不扫也不会让任何有效条目过期失效。 -// -// 注意「只扫过期条目」不足以保证有界:TTL 从**首次未命中**起算(见 lookup 的写回 -// 判断),若模型名持续出现在 /v1/models 名单里,一个 TTL 窗口内所有条目都会被反复 -// 盖章成 fresh,扫描一条也删不掉,规模只增不减。因此超过**硬上限**(两倍软上限) -// 时额外丢弃最旧的条目——负缓存是纯性能优化(miss 时多查一次进程内索引),丢条目 -// 只可能让某个模型重新进一次扫描,不改变任何对外语义。 -const modelsDevNegativesSoftCap = 1024 - -// modelsDevNegativesHardCap 负缓存 map 的硬上限:超过即按时间序丢弃最旧条目 -// (见 modelsDevNegativesSoftCap 注释)。取两倍软上限,给「一轮 /v1/models 新增」 -// 留出余量,正常规模远达不到。 -const modelsDevNegativesHardCap = 2 * modelsDevNegativesSoftCap - -// modelsDevMaxBody 拉取响应体上限(文档实测 ~4.7MB,留余量;防异常大响应拖死)。 -const modelsDevMaxBody = 32 << 20 - -// modelsDevValueMax 值校验上限:context/output 超过 1e9 视为脏数据拒绝 -// (量级上限校验,任务书 §2 值校验;正数下界在 catalog 写入侧兜底)。 -const modelsDevValueMax = int64(1e9) - -// modelsDevVendorSources 官方 vendor provider 优先名单:models.dev 收录 217 个 -// provider,聚合网关(merge-gateway/nano-gpt 等)自报的 limit 常与官方源分歧, -// 采值优先级 = 本名单命中 > 众数共识。 -var modelsDevVendorSources = map[string]bool{ - "zai": true, // Z.AI(glm 家族官方) - "moonshotai": true, // Moonshot AI(kimi 家族官方,国际版) - "moonshotai-cn": true, // Moonshot AI 中国版 - "openai": true, - "google": true, - "deepseek": true, - "minimax": true, -} - -// modelsDevEntry models.dev 单模型采值结果(modelsdev json 的 limit 子集)。 -type modelsDevEntry struct { - Context int64 - Output int64 -} - -// modelsDevFetcher models.dev 按需拉取器:进程级单例语义(包级变量 modelsDev), -// 拉取节流 + 裸 id 索引缓存 + 同模型负缓存。测试用 resetModelsDev / 独立 base URL -// 注入隔离(newModelsDevForTest)。 -type modelsDevFetcher struct { - mu sync.Mutex - - // doc 文档解析后的裸 id 索引(多 provider 同名合并采值:vendor 优先/众数)。 - // nil = 未拉取;空 map(非 nil)= 拉取过但索引为空(视作失败冷却)。 - doc map[string]modelsDevEntry - - lastFetch time.Time // 最近一次拉取尝试(成功与失败都算,冷却节流) - fetched bool // 是否已拉取过(doc 字段区分成败) - - negatives map[string]time.Time // 查询未命中的模型 → 记录时间(24h 负缓存) -} - -// modelsDev 包级拉取器实例(单例:全进程共享一份文档索引与节流状态)。 -var modelsDev = &modelsDevFetcher{} - -// resetModelsDev 测试隔离:清空单例状态(doc/fetched/lastFetch/negatives)。 -func resetModelsDev() { - modelsDev.mu.Lock() - modelsDev.doc = nil - modelsDev.fetched = false - modelsDev.lastFetch = time.Time{} - modelsDev.negatives = nil - modelsDev.mu.Unlock() -} - -// lookup 查询一个模型的 (context, output, found): -// - 索引命中且值合法 → found=true; -// - 索引未命中(含索引尚未就绪)→ 记入 negatives(既是 24h 负缓存,也是 -// fetchDoc 成功后 backfillMisses 的回流清单——「曾 miss 过的模型」),found=false。 -// -// 只读内存索引,不发网络请求;网络动作由 ensureDocAsync(goroutine 内)负责。 -// 注意:doc 就绪前的 miss 也记 negatives——backfillMisses 回流时查到即写 -// model.json 并清除负缓存条目(freshLookup),查不到的保持 24h 负缓存。 -func (f *modelsDevFetcher) lookup(model string) (modelsDevEntry, bool) { - f.mu.Lock() - defer f.mu.Unlock() - if f.doc != nil { - if e, ok := f.doc[model]; ok { - return e, true - } - } - // 未命中(索引在但模型不在,或索引尚未就绪):记 miss。 - if f.negatives == nil { - f.negatives = make(map[string]time.Time) - } - now := time.Now() - // 未命中「重复查询」不再刷新记录时刻:TTL 只从**首次未命中**起算。 - // 否则覆盖写等于每次查询都把条目续期——一个持续出现在 /v1/models 名单里的 - // 未知模型(每条 listing 经 ContextWindowListingV4 + MaxOutputTokensListingV4 - // 各查一次,即每请求 2 次写回)其条目永远 fresh,下面的惰性淘汰一条也扫不掉; - // 又因淘汰只在超软上限时才扫,规模超限后只增不减(进程生命周期内无界增长)。 - // 续期对行为零影响:negativeFresh 只判是否存在 + within TTL,未过 TTL 的条目 - // 无论是否续期都同样短路第 4 级触发。 - if _, seen := f.negatives[model]; !seen { - f.negatives[model] = now - } - // 惰性淘汰已过期的负缓存条目:TTL 到期后 negativeFresh 本就判 false(等效不存在), - // 条目继续留着只是内存泄漏——models.dev 永不收录的模型名(model 由客户端任意指定) - // 查一次就永久驻留,而全库唯一的删除点 backfillMisses 只删「文档里查到」的模型, - // 永远不会回收这些条目,map 在进程生命周期内无界增长。 - // 仅在规模超软上限时才扫一遍(摊销 O(1),理由见 modelsDevNegativesSoftCap 注释)。 - if len(f.negatives) > modelsDevNegativesSoftCap { - for m, t := range f.negatives { - if now.Sub(t) >= modelsDevNegativeTTL { - delete(f.negatives, m) - } - } - } - // 硬上限兜底:TTL 未到期的条目本就无可淘汰(上一轮扫描已删净过期项),若规模 - // 仍超硬上限说明输入模型名太多,按时间序丢弃最旧条目、削回软上限 - // (纯性能优化:负缓存 miss 只会多查一次进程内索引,丢条目无语义影响)。 - if len(f.negatives) > modelsDevNegativesHardCap { - cut := len(f.negatives) - modelsDevNegativesSoftCap - oldest := make([]string, 0, len(f.negatives)) - for m := range f.negatives { - oldest = append(oldest, m) - } - sort.Slice(oldest, func(i, j int) bool { return f.negatives[oldest[i]].Before(f.negatives[oldest[j]]) }) - for _, m := range oldest[:cut] { - delete(f.negatives, m) - } - } - return modelsDevEntry{}, false -} - -// negativeFresh 模型是否在负缓存有效期内(供查找链短路第 4 级触发)。 -func (f *modelsDevFetcher) negativeFresh(model string) bool { - f.mu.Lock() - defer f.mu.Unlock() - t, ok := f.negatives[model] - return ok && time.Since(t) < modelsDevNegativeTTL -} - -// ensureDocAsync 确保 models.dev 文档索引可用(异步,不阻塞调用方): -// 已有索引 / 拉取冷却期内 / 已有人在拉(in-flight 去重)→ 直接返回。 -// 否则起 goroutine 拉取解析,完成后落 f.doc(失败静默:只刷新 lastFetch 冷却, -// 下次查找仍走 1M 兜底,不重试风暴)。 -func (f *modelsDevFetcher) ensureDocAsync(client *http.Client, baseOverride string) { - f.mu.Lock() - if f.doc != nil { - f.mu.Unlock() - return - } - if f.fetched && time.Since(f.lastFetch) < modelsDevFetchCooldown { - // 拉取过(成功或失败)且冷却期内:不再打 models.dev。 - f.mu.Unlock() - return - } - // in-flight 去重:把 fetched/lastFetch 先置为「本次进行中」, - // 后续并发调用在冷却窗口内直接返回,不重复起拉取。 - f.fetched = true - f.lastFetch = time.Now() - f.mu.Unlock() - - go f.fetchDoc(client, baseOverride) -} - -// fetchDoc 拉取并解析 models.dev 文档,建裸 id 索引(goroutine 内执行,永不 panic -// 上抛:任何失败只静默冷却)。 -// 拒绝 nil client(不回落 http.DefaultClient):生产调用方恒传非 nil,nil 只意味着 -// 测试疏漏——DefaultClient 无超时(挂起隐患)且会打真网(测试污染 + 不确定延迟), -// 静默 WARN + 返回(与 fetch 失败同语义,降级 1M 兜底)让疏漏显式化。 -func (f *modelsDevFetcher) fetchDoc(client *http.Client, baseOverride string) { - if client == nil { - log.Printf("WARN: [upstream] models.dev fetch: nil client rejected (no DefaultClient fallback, silent fallback to 1M)") - return - } - url := ModelsDevURL - if baseOverride != "" { - url = baseOverride - } - ctx, cancel := context.WithTimeout(context.Background(), modelsDevTimeout) - defer cancel() - req, err := http.NewRequestWithContext(ctx, http.MethodGet, url, nil) - if err != nil { - log.Printf("WARN: [upstream] models.dev fetch: build request: %v", err) - return - } - resp, err := client.Do(req) - if err != nil { - log.Printf("WARN: [upstream] models.dev fetch failed (silent fallback to 1M): %v", err) - return - } - defer resp.Body.Close() - if resp.StatusCode != http.StatusOK { - log.Printf("WARN: [upstream] models.dev fetch status %d (silent fallback to 1M)", resp.StatusCode) - return - } - raw, err := io.ReadAll(io.LimitReader(resp.Body, modelsDevMaxBody)) - if err != nil { - log.Printf("WARN: [upstream] models.dev fetch read: %v", err) - return - } - doc, err := parseModelsDevDoc(raw) - if err != nil { - log.Printf("WARN: [upstream] models.dev parse failed (silent fallback to 1M): %v", err) - return - } - f.mu.Lock() - f.doc = doc - f.mu.Unlock() - // 文档就绪后把「曾 miss 过的模型」回流 model.json(第 4 级 → 第 3 级, - // 下次 /v1/models 直接命中缓存)。仍查不到的保持负缓存。 - f.backfillMisses() -} - -// parseModelsDevDoc 解析 models.dev api.json:{provider:{models:{id:{limit:{context, -// output}}}}} → 裸 id 索引。同名多 provider 采值优先级四级:官方 vendor 源 -// (modelsDevVendorSources)> 票数众数 > provider 字典序 > 先出现。 -// 第 3 级 provider 字典序是确定性 tie-break:聚合时维护候选的最小 provider 名 -// (minProvider,同 doc 稳定的选择器身份),消灭 map 迭代序随机化导致的 -// 「同票先到先得」值抖动(同 binary 两次拉取同一文档可能落不同的值进 model.json, -// /v1/models 的 context_length 不可复现)。不引入「值字典序」——那会把 -// 「选谁」变成「选什么值」的启发式,语义不如 provider 名干净。 -func parseModelsDevDoc(raw []byte) (map[string]modelsDevEntry, error) { - var doc map[string]struct { - Models map[string]struct { - Limit *struct { - Context int64 `json:"context"` - Output int64 `json:"output"` - } `json:"limit"` - } `json:"models"` - } - if err := json.Unmarshal(raw, &doc); err != nil { - return nil, fmt.Errorf("models.dev doc: %w", err) - } - // 同名 id 的候选值收集:vendorOfficial 标记官方源,votes 计众数, - // minProvider 维护该候选已见的最小 provider 名(tie-break 用)。 - type candidate struct { - entry modelsDevEntry - vendor bool - votes int - aggKey string // 去重聚合 key(同值多 provider 只计票不重复存) - minProvider string - } - byModel := map[string][]candidate{} - for provider, pv := range doc { - for fullID, mv := range pv.Models { - if mv.Limit == nil { - continue - } - id := fullID - if i := strings.LastIndex(fullID, "/"); i >= 0 { - id = fullID[i+1:] - } - if id == "" { - continue - } - // 值校验(任务书 §2):正数 + 量级上限,脏值不进索引。 - ctx, out := mv.Limit.Context, mv.Limit.Output - if ctx <= 0 || ctx > modelsDevValueMax { - continue - } - if out < 0 || out > modelsDevValueMax { - continue - } - key := fmt.Sprintf("%d/%d", ctx, out) - cs := byModel[id] - dup := false - for i := range cs { - if cs[i].aggKey == key { - cs[i].votes++ - if modelsDevVendorSources[provider] { - cs[i].vendor = true - } - if provider < cs[i].minProvider { - cs[i].minProvider = provider - } - dup = true - break - } - } - if !dup { - byModel[id] = append(cs, candidate{ - entry: modelsDevEntry{Context: ctx, Output: out}, - vendor: modelsDevVendorSources[provider], - votes: 1, - aggKey: key, - minProvider: provider, - }) - } - } - } - out := make(map[string]modelsDevEntry, len(byModel)) - for id, cs := range byModel { - best := 0 - for i, c := range cs { - // 优先级:官方 vendor 源 > 票数众数 > provider 字典序(tie-break 确定性)。 - cur := cs[best] - better := false - if c.vendor && !cur.vendor { - better = true - } else if c.vendor == cur.vendor && c.votes > cur.votes { - better = true - } else if c.vendor == cur.vendor && c.votes == cur.votes && c.minProvider < cur.minProvider { - better = true - } - if better { - best = i - } - } - out[id] = cs[best].entry - } - return out, nil -} +// modelsdev.go models.dev 按需兜底(context_length 四级查找链的第 4 级)。 +// +// 定位:只对「上游动态值缺失 + 静态种子表未收录 + model.json 未缓存」的模型查 +// models.dev,是兜底的兜底——超时短(默认 5s)、失败静默降级(context_length 落 +// DefaultContextWindow=1M),绝不阻塞 /v1/models 主路径(查找异步化,本次请求 +// 直接返回兜底值,拉到后写 model.json 供下次命中)。 +// +// 数据源(2026-09-16 逆向,结论详见 .claude/reports/model-json-dynamic.md): +// - 官方聚合 JSON 端点 https://models.dev/api.json:~4.7MB 单文档、217 provider、 +// 免鉴权、Cloudflare 托管静态站; +// - 无按模型/按 provider 子端点(/z-ai.json 等 302 回 /),「按需」的实现是 +// 单次拉全量文档 + 建裸 id 索引(拉一次只发生一次,此后进程内复用索引); +// - schema:{ "": { "models": { "": { "limit": {"context": N, +// "output": N} } } } },模型 id 有裸名(glm-5.2)与带命名空间(openai/gpt-5.5) +// 两种形态,均取尾段做索引 key; +// - 多 provider 同名值会分歧(聚合网关常自报改动):vendor 官方源(zai/ +// moonshotai/openai/google/deepseek/minimax)优先,其余取众数(共识值)。 +package upstream + +import ( + "context" + "encoding/json" + "fmt" + "io" + "log" + "net/http" + "sort" + "strings" + "sync" + "time" +) + +// ModelsDevURL models.dev 官方聚合 JSON 端点(唯一端点,见文件头逆向结论)。 +const ModelsDevURL = "https://models.dev/api.json" + +// modelsDevTimeout 单次拉取超时:兜底的兜底,不值得等(任务书 §2:如 5s)。 +const modelsDevTimeout = 5 * time.Second + +// modelsDevFetchCooldown 拉取节流(进程级):文档是全量聚合体,5min 内不重拉 +// (同模型 24h 负缓存之外的整体节流,防短窗反复打 models.dev)。 +const modelsDevFetchCooldown = 5 * time.Minute + +// modelsDevNegativeTTL 同模型负缓存:查不到的模型 24h 内不重查 +// (任务书 §2:如同模型 24h 内不重查,查不到的模型负缓存防反复打)。 +const modelsDevNegativeTTL = 24 * time.Hour + +// modelsDevNegativesSoftCap 负缓存 map 的软上限:规模超过它时才做一次过期条目淘汰 +// 扫描。分批摊销是为避免每次 lookup 都做 O(n) 全扫——第 4 级触发点在 /v1/models 里 +// 每个模型各调一次(handler 遍历模型列表逐条 V4),n 大时全扫会被请求数放大成 CPU +// 开销。淘汰只针对 TTL 已过期的条目,故低于上限时不扫也不会让任何有效条目过期失效。 +// +// 注意「只扫过期条目」不足以保证有界:TTL 从**首次未命中**起算(见 lookup 的写回 +// 判断),若模型名持续出现在 /v1/models 名单里,一个 TTL 窗口内所有条目都会被反复 +// 盖章成 fresh,扫描一条也删不掉,规模只增不减。因此超过**硬上限**(两倍软上限) +// 时额外丢弃最旧的条目——负缓存是纯性能优化(miss 时多查一次进程内索引),丢条目 +// 只可能让某个模型重新进一次扫描,不改变任何对外语义。 +const modelsDevNegativesSoftCap = 1024 + +// modelsDevNegativesHardCap 负缓存 map 的硬上限:超过即按时间序丢弃最旧条目 +// (见 modelsDevNegativesSoftCap 注释)。取两倍软上限,给「一轮 /v1/models 新增」 +// 留出余量,正常规模远达不到。 +const modelsDevNegativesHardCap = 2 * modelsDevNegativesSoftCap + +// modelsDevMaxBody 拉取响应体上限(文档实测 ~4.7MB,留余量;防异常大响应拖死)。 +const modelsDevMaxBody = 32 << 20 + +// modelsDevValueMax 值校验上限:context/output 超过 1e9 视为脏数据拒绝 +// (量级上限校验,任务书 §2 值校验;正数下界在 catalog 写入侧兜底)。 +const modelsDevValueMax = int64(1e9) + +// modelsDevVendorSources 官方 vendor provider 优先名单:models.dev 收录 217 个 +// provider,聚合网关(merge-gateway/nano-gpt 等)自报的 limit 常与官方源分歧, +// 采值优先级 = 本名单命中 > 众数共识。 +var modelsDevVendorSources = map[string]bool{ + "zai": true, // Z.AI(glm 家族官方) + "moonshotai": true, // Moonshot AI(kimi 家族官方,国际版) + "moonshotai-cn": true, // Moonshot AI 中国版 + "openai": true, + "google": true, + "deepseek": true, + "minimax": true, +} + +// modelsDevEntry models.dev 单模型采值结果(modelsdev json 的 limit 子集)。 +type modelsDevEntry struct { + Context int64 + Output int64 +} + +// modelsDevFetcher models.dev 按需拉取器:进程级单例语义(包级变量 modelsDev), +// 拉取节流 + 裸 id 索引缓存 + 同模型负缓存。测试用 resetModelsDev / 独立 base URL +// 注入隔离(newModelsDevForTest)。 +type modelsDevFetcher struct { + mu sync.Mutex + + // doc 文档解析后的裸 id 索引(多 provider 同名合并采值:vendor 优先/众数)。 + // nil = 未拉取;空 map(非 nil)= 拉取过但索引为空(视作失败冷却)。 + doc map[string]modelsDevEntry + + lastFetch time.Time // 最近一次拉取尝试(成功与失败都算,冷却节流) + fetched bool // 是否已拉取过(doc 字段区分成败) + + negatives map[string]time.Time // 查询未命中的模型 → 记录时间(24h 负缓存) +} + +// modelsDev 包级拉取器实例(单例:全进程共享一份文档索引与节流状态)。 +var modelsDev = &modelsDevFetcher{} + +// resetModelsDev 测试隔离:清空单例状态(doc/fetched/lastFetch/negatives)。 +func resetModelsDev() { + modelsDev.mu.Lock() + modelsDev.doc = nil + modelsDev.fetched = false + modelsDev.lastFetch = time.Time{} + modelsDev.negatives = nil + modelsDev.mu.Unlock() +} + +// lookup 查询一个模型的 (context, output, found): +// - 索引命中且值合法 → found=true; +// - 索引未命中(含索引尚未就绪)→ 记入 negatives(既是 24h 负缓存,也是 +// fetchDoc 成功后 backfillMisses 的回流清单——「曾 miss 过的模型」),found=false。 +// +// 只读内存索引,不发网络请求;网络动作由 ensureDocAsync(goroutine 内)负责。 +// 注意:doc 就绪前的 miss 也记 negatives——backfillMisses 回流时查到即写 +// model.json 并清除负缓存条目(freshLookup),查不到的保持 24h 负缓存。 +func (f *modelsDevFetcher) lookup(model string) (modelsDevEntry, bool) { + f.mu.Lock() + defer f.mu.Unlock() + if f.doc != nil { + if e, ok := f.doc[model]; ok { + return e, true + } + } + // 未命中(索引在但模型不在,或索引尚未就绪):记 miss。 + if f.negatives == nil { + f.negatives = make(map[string]time.Time) + } + now := time.Now() + // 未命中「重复查询」不再刷新记录时刻:TTL 只从**首次未命中**起算。 + // 否则覆盖写等于每次查询都把条目续期——一个持续出现在 /v1/models 名单里的 + // 未知模型(每条 listing 经 ContextWindowListingV4 + MaxOutputTokensListingV4 + // 各查一次,即每请求 2 次写回)其条目永远 fresh,下面的惰性淘汰一条也扫不掉; + // 又因淘汰只在超软上限时才扫,规模超限后只增不减(进程生命周期内无界增长)。 + // 续期对行为零影响:negativeFresh 只判是否存在 + within TTL,未过 TTL 的条目 + // 无论是否续期都同样短路第 4 级触发。 + if _, seen := f.negatives[model]; !seen { + f.negatives[model] = now + } + // 惰性淘汰已过期的负缓存条目:TTL 到期后 negativeFresh 本就判 false(等效不存在), + // 条目继续留着只是内存泄漏——models.dev 永不收录的模型名(model 由客户端任意指定) + // 查一次就永久驻留,而全库唯一的删除点 backfillMisses 只删「文档里查到」的模型, + // 永远不会回收这些条目,map 在进程生命周期内无界增长。 + // 仅在规模超软上限时才扫一遍(摊销 O(1),理由见 modelsDevNegativesSoftCap 注释)。 + if len(f.negatives) > modelsDevNegativesSoftCap { + for m, t := range f.negatives { + if now.Sub(t) >= modelsDevNegativeTTL { + delete(f.negatives, m) + } + } + } + // 硬上限兜底:TTL 未到期的条目本就无可淘汰(上一轮扫描已删净过期项),若规模 + // 仍超硬上限说明输入模型名太多,按时间序丢弃最旧条目、削回软上限 + // (纯性能优化:负缓存 miss 只会多查一次进程内索引,丢条目无语义影响)。 + if len(f.negatives) > modelsDevNegativesHardCap { + cut := len(f.negatives) - modelsDevNegativesSoftCap + oldest := make([]string, 0, len(f.negatives)) + for m := range f.negatives { + oldest = append(oldest, m) + } + sort.Slice(oldest, func(i, j int) bool { return f.negatives[oldest[i]].Before(f.negatives[oldest[j]]) }) + for _, m := range oldest[:cut] { + delete(f.negatives, m) + } + } + return modelsDevEntry{}, false +} + +// negativeFresh 模型是否在负缓存有效期内(供查找链短路第 4 级触发)。 +func (f *modelsDevFetcher) negativeFresh(model string) bool { + f.mu.Lock() + defer f.mu.Unlock() + t, ok := f.negatives[model] + return ok && time.Since(t) < modelsDevNegativeTTL +} + +// ensureDocAsync 确保 models.dev 文档索引可用(异步,不阻塞调用方): +// 已有索引 / 拉取冷却期内 / 已有人在拉(in-flight 去重)→ 直接返回。 +// 否则起 goroutine 拉取解析,完成后落 f.doc(失败静默:只刷新 lastFetch 冷却, +// 下次查找仍走 1M 兜底,不重试风暴)。 +func (f *modelsDevFetcher) ensureDocAsync(client *http.Client, baseOverride string) { + f.mu.Lock() + if f.doc != nil { + f.mu.Unlock() + return + } + if f.fetched && time.Since(f.lastFetch) < modelsDevFetchCooldown { + // 拉取过(成功或失败)且冷却期内:不再打 models.dev。 + f.mu.Unlock() + return + } + // in-flight 去重:把 fetched/lastFetch 先置为「本次进行中」, + // 后续并发调用在冷却窗口内直接返回,不重复起拉取。 + f.fetched = true + f.lastFetch = time.Now() + f.mu.Unlock() + + go f.fetchDoc(client, baseOverride) +} + +// fetchDoc 拉取并解析 models.dev 文档,建裸 id 索引(goroutine 内执行,永不 panic +// 上抛:任何失败只静默冷却)。 +// 拒绝 nil client(不回落 http.DefaultClient):生产调用方恒传非 nil,nil 只意味着 +// 测试疏漏——DefaultClient 无超时(挂起隐患)且会打真网(测试污染 + 不确定延迟), +// 静默 WARN + 返回(与 fetch 失败同语义,降级 1M 兜底)让疏漏显式化。 +func (f *modelsDevFetcher) fetchDoc(client *http.Client, baseOverride string) { + if client == nil { + log.Printf("WARN: [upstream] models.dev fetch: nil client rejected (no DefaultClient fallback, silent fallback to 1M)") + return + } + url := ModelsDevURL + if baseOverride != "" { + url = baseOverride + } + ctx, cancel := context.WithTimeout(context.Background(), modelsDevTimeout) + defer cancel() + req, err := http.NewRequestWithContext(ctx, http.MethodGet, url, nil) + if err != nil { + log.Printf("WARN: [upstream] models.dev fetch: build request: %v", err) + return + } + resp, err := client.Do(req) + if err != nil { + log.Printf("WARN: [upstream] models.dev fetch failed (silent fallback to 1M): %v", err) + return + } + defer resp.Body.Close() + if resp.StatusCode != http.StatusOK { + log.Printf("WARN: [upstream] models.dev fetch status %d (silent fallback to 1M)", resp.StatusCode) + return + } + raw, err := io.ReadAll(io.LimitReader(resp.Body, modelsDevMaxBody)) + if err != nil { + log.Printf("WARN: [upstream] models.dev fetch read: %v", err) + return + } + doc, err := parseModelsDevDoc(raw) + if err != nil { + log.Printf("WARN: [upstream] models.dev parse failed (silent fallback to 1M): %v", err) + return + } + f.mu.Lock() + f.doc = doc + f.mu.Unlock() + // 文档就绪后把「曾 miss 过的模型」回流 model.json(第 4 级 → 第 3 级, + // 下次 /v1/models 直接命中缓存)。仍查不到的保持负缓存。 + f.backfillMisses() +} + +// parseModelsDevDoc 解析 models.dev api.json:{provider:{models:{id:{limit:{context, +// output}}}}} → 裸 id 索引。同名多 provider 采值优先级四级:官方 vendor 源 +// (modelsDevVendorSources)> 票数众数 > provider 字典序 > 先出现。 +// 第 3 级 provider 字典序是确定性 tie-break:聚合时维护候选的最小 provider 名 +// (minProvider,同 doc 稳定的选择器身份),消灭 map 迭代序随机化导致的 +// 「同票先到先得」值抖动(同 binary 两次拉取同一文档可能落不同的值进 model.json, +// /v1/models 的 context_length 不可复现)。不引入「值字典序」——那会把 +// 「选谁」变成「选什么值」的启发式,语义不如 provider 名干净。 +func parseModelsDevDoc(raw []byte) (map[string]modelsDevEntry, error) { + var doc map[string]struct { + Models map[string]struct { + Limit *struct { + Context int64 `json:"context"` + Output int64 `json:"output"` + } `json:"limit"` + } `json:"models"` + } + if err := json.Unmarshal(raw, &doc); err != nil { + return nil, fmt.Errorf("models.dev doc: %w", err) + } + // 同名 id 的候选值收集:vendorOfficial 标记官方源,votes 计众数, + // minProvider 维护该候选已见的最小 provider 名(tie-break 用)。 + type candidate struct { + entry modelsDevEntry + vendor bool + votes int + aggKey string // 去重聚合 key(同值多 provider 只计票不重复存) + minProvider string + } + byModel := map[string][]candidate{} + for provider, pv := range doc { + for fullID, mv := range pv.Models { + if mv.Limit == nil { + continue + } + id := fullID + if i := strings.LastIndex(fullID, "/"); i >= 0 { + id = fullID[i+1:] + } + if id == "" { + continue + } + // 值校验(任务书 §2):正数 + 量级上限,脏值不进索引。 + ctx, out := mv.Limit.Context, mv.Limit.Output + if ctx <= 0 || ctx > modelsDevValueMax { + continue + } + if out < 0 || out > modelsDevValueMax { + continue + } + key := fmt.Sprintf("%d/%d", ctx, out) + cs := byModel[id] + dup := false + for i := range cs { + if cs[i].aggKey == key { + cs[i].votes++ + if modelsDevVendorSources[provider] { + cs[i].vendor = true + } + if provider < cs[i].minProvider { + cs[i].minProvider = provider + } + dup = true + break + } + } + if !dup { + byModel[id] = append(cs, candidate{ + entry: modelsDevEntry{Context: ctx, Output: out}, + vendor: modelsDevVendorSources[provider], + votes: 1, + aggKey: key, + minProvider: provider, + }) + } + } + } + out := make(map[string]modelsDevEntry, len(byModel)) + for id, cs := range byModel { + best := 0 + for i, c := range cs { + // 优先级:官方 vendor 源 > 票数众数 > provider 字典序(tie-break 确定性)。 + cur := cs[best] + better := false + if c.vendor && !cur.vendor { + better = true + } else if c.vendor == cur.vendor && c.votes > cur.votes { + better = true + } else if c.vendor == cur.vendor && c.votes == cur.votes && c.minProvider < cur.minProvider { + better = true + } + if better { + best = i + } + } + out[id] = cs[best].entry + } + return out, nil +} diff --git a/internal/upstream/modeltiers_exclusive_test.go b/internal/upstream/modeltiers_exclusive_test.go new file mode 100644 index 0000000000000000000000000000000000000000..2182646897b956ddabb3a012f92078248bddd2bf --- /dev/null +++ b/internal/upstream/modeltiers_exclusive_test.go @@ -0,0 +1,61 @@ +package upstream + +import "testing" + +// accessMode=exclusive 才是「免费号调不通」的机器可读口径;CN 那条「订阅优先」只有文案, +// 混成同一判据会把能用的国内模型错标成禁选(issue #235 的教训)。 +func TestApplyModelTiersExclusive(t *testing.T) { + badge := func(s string) *struct { + Label string `json:"label"` + } { + return &struct { + Label string `json:"label"` + }{Label: s} + } + out := map[string]ModelInfo{ + "pro-model": {ID: "pro-model"}, + "priority-model": {ID: "priority-model"}, + } + applyModelTiers(out, []v3ModelTier{ + {Enabled: true, Priority: 200, ModelIDs: []string{"pro-model"}, AccessMode: "exclusive", Badge: badge("Pro Only")}, + {Enabled: true, Priority: 100, ModelIDs: []string{"priority-model"}, Badge: badge("订阅优先")}, + }) + if !out["pro-model"].Exclusive { + t.Error("accessMode=exclusive 的模型应标 Exclusive") + } + if out["priority-model"].Exclusive { + t.Error("只有「订阅优先」文案、没有 accessMode 的不算门控(会误拒能用的请求)") + } +} + +// ModelExclusive 按域分桶:同一模型名在另一域没有门控时不能串味。 +func TestModelExclusivePerRealm(t *testing.T) { + c := &Client{} + c.storeModelRates("global", []ModelInfo{{ID: "pro-model", Exclusive: true}, {ID: "free-model"}}) + c.storeModelRates("cn", []ModelInfo{{ID: "pro-model"}}) + if !c.ModelExclusive("global", "pro-model") { + t.Error("global:pro-model 应被标为 exclusive") + } + if c.ModelExclusive("cn", "pro-model") { + t.Error("cn 域未标 exclusive,不该串味") + } + if c.ModelExclusive("global", "free-model") || c.ModelExclusive("global", "") { + t.Error("未标 exclusive 的模型 / 空模型名不该被拦") + } +} + +// 付费状态「没观测过」不等于免费:PaidUser 的第二个返回值必须能区分这两件事。 +func TestPaidUserUnknownVsFree(t *testing.T) { + c := &Client{} + if _, known := c.PaidUser("u1"); known { + t.Fatal("没记过就该是 unknown") + } + c.NotePaidUser("u1", false) + if paid, known := c.PaidUser("u1"); !known || paid { + t.Fatalf("PaidUser = %v,%v want false,true", paid, known) + } + c.NotePaidUser("u1", true) + if paid, _ := c.PaidUser("u1"); !paid { + t.Fatal("后一次观测应覆盖前一次") + } +} diff --git a/internal/upstream/modeltiers_test.go b/internal/upstream/modeltiers_test.go new file mode 100644 index 0000000000000000000000000000000000000000..2f8a6090d16ed0696b1ee4158f10929e63f5df68 --- /dev/null +++ b/internal/upstream/modeltiers_test.go @@ -0,0 +1,84 @@ +package upstream + +import "testing" + +// issue #235:/v3/config 的 data.modelTiers 要挂到目录条目上——海外「Pro Only」 +// 与国内「订阅优先」都只是官方文案,模型是否可调由账号决定,这里只负责标注。 +func TestApplyModelTiers(t *testing.T) { + out := map[string]ModelInfo{ + "gpt-6.1-sol": {ID: "gpt-6.1-sol"}, + "glm-5.3": {ID: "glm-5.3"}, + "unlisted-model": {ID: "unlisted-model"}, + } + tiers := []v3ModelTier{ + {Enabled: true, Priority: 200, ModelIDs: []string{"gpt-6.1-sol", "已下架"}, + Badge: &struct { + Label string `json:"label"` + }{Label: "Pro Only"}}, + {Enabled: false, Priority: 300, ModelIDs: []string{"glm-5.3"}, + Badge: &struct { + Label string `json:"label"` + }{Label: "停用的层级"}}, + {Enabled: true, Priority: 20, ModelIDs: []string{"glm-5.3"}, + Badge: &struct { + Label string `json:"label"` + }{Label: "订阅优先"}}, + } + applyModelTiers(out, tiers) + + if got := out["gpt-6.1-sol"].Tier; got != "Pro Only" { + t.Fatalf("gpt-6.1-sol tier = %q", got) + } + if got := out["glm-5.3"].Tier; got != "订阅优先" { + t.Fatalf("glm-5.3 tier = %q(enabled=false 的层级不该生效)", got) + } + if got := out["unlisted-model"].Tier; got != "" { + t.Fatalf("未被任何层级列出的模型不该有 tier,got %q", got) + } +} + +// primary-model 上游 modelTiers 漏标、但三个 global 号实测 11158 拒(2026-10-23): +// 空 tiers 也要挂上;上游给了文案时以上游为准。 +func TestApplyModelTiersProOnlyFallback(t *testing.T) { + out := map[string]ModelInfo{"primary-model": {ID: "primary-model"}} + applyModelTiers(out, nil) + if got := out["primary-model"].Tier; got != "Pro Only" { + t.Fatalf("空 tiers 时 primary-model tier = %q,want Pro Only", got) + } + + // 上游若收录了它,用上游文案,不被兜底覆盖。 + out2 := map[string]ModelInfo{"primary-model": {ID: "primary-model"}} + applyModelTiers(out2, []v3ModelTier{{Enabled: true, Priority: 1, ModelIDs: []string{"primary-model"}, + Badge: &struct { + Label string `json:"label"` + }{Label: "订阅优先"}}}) + if got := out2["primary-model"].Tier; got != "订阅优先" { + t.Fatalf("上游文案被兜底覆盖:tier = %q", got) + } + + // 目录里没有该模型时不凭空造条目。 + out3 := map[string]ModelInfo{"other": {ID: "other"}} + applyModelTiers(out3, nil) + if _, ok := out3["primary-model"]; ok { + t.Fatal("目录外模型不该被兜底补进来") + } +} + +// 同模型命中多条 enabled 层级时取 priority 最高那条的文案。 +func TestApplyModelTiersPriority(t *testing.T) { + out := map[string]ModelInfo{"m": {ID: "m"}} + badge := func(s string) *struct { + Label string `json:"label"` + } { + return &struct { + Label string `json:"label"` + }{Label: s} + } + applyModelTiers(out, []v3ModelTier{ + {Enabled: true, Priority: 10, ModelIDs: []string{"m"}, Badge: badge("低优先")}, + {Enabled: true, Priority: 90, ModelIDs: []string{"m"}, Badge: badge("高优先")}, + }) + if out["m"].Tier != "高优先" { + t.Fatalf("tier = %q", out["m"].Tier) + } +} diff --git a/internal/upstream/mp_events.go b/internal/upstream/mp_events.go new file mode 100644 index 0000000000000000000000000000000000000000..ebf55649cdbe56b36118755825f1d4e716f48565 --- /dev/null +++ b/internal/upstream/mp_events.go @@ -0,0 +1,153 @@ +// mp_events.go 小程序埋点指纹。Sequential_* 成长任务仍走这套上报。 +package upstream + +import ( + "bytes" + "encoding/json" + "fmt" + "net/http" + "time" + + "github.com/misakano7545/workbuddy2api-panel/internal/auth" + "github.com/misakano7545/workbuddy2api-panel/internal/session" +) + +const mpReportPath = "/v2/report" + +// mpEventBase 小程序埋点公共指纹(appservice wQ()+Ao() 对齐)。 +func mpEventBase(a *auth.Auth) map[string]any { + return map[string]any{ + "timestamp": time.Now().UnixMilli(), + "ideType": "WorkBuddy_MP", + "ideVersion": "2.4.0", + "extName": "workbuddy-mp", + "extVersion": "2.4.0", + "product": "SaaS", + "ideName": "wx_app_cloud", + "platform": "mini_program", + "os": "windows", + "osVersion": "11", + "arch": "x64", + "machineId": "0655736a-607f-4d9d-b430-58176ee9a090", + "timezone": "Asia/Shanghai", + "userId": a.UID, + "userNickname": a.Nickname, + } +} + +// ReportMPEvent 以小程序指纹向 www.codebuddy.cn/v2/report 批量上报事件。 +func (c *Client) ReportMPEvent(a *auth.Auth, events ...map[string]any) error { + if len(events) == 0 { + return fmt.Errorf("mp report: no events") + } + base := mpEventBase(a) + arr := make([]map[string]any, 0, len(events)) + for _, ev := range events { + m := map[string]any{} + for k, v := range base { + m[k] = v + } + for k, v := range ev { + m[k] = v + } + arr = append(arr, m) + } + raw, err := json.Marshal(arr) + if err != nil { + return err + } + req, err := http.NewRequest(http.MethodPost, c.BillingBaseCN+mpReportPath, bytes.NewReader(raw)) + if err != nil { + return err + } + req.Header.Set("Authorization", "Bearer "+a.AccessTokenValue()) + req.Header.Set("Content-Type", "application/json") + req.Header.Set("Accept", "application/json") + if a.UID != "" { + req.Header.Set("X-User-Id", a.UID) + } + req.Header.Set("X-Client-Product", "workbuddy-mp") + req.Header.Set("X-Client-Version", "2.4.0") + req.Header.Set("X-Client-Platform", "mp-weixin") + req.Header.Set("X-Platform", "wechatmp") + _, err = c.doJSON(req, a) + return err +} + +// MiniChatSendEvent 构造一条小程序 chat_request_send(Sequential 对话任务计数), +// 不带 activityId。 +func MiniChatSendEvent(conversationID string) map[string]any { + // rid 用官方形态(32 hex 时间前缀)。旧值 "wb2api-"+clientToken() 把项目缩写 + // 写进 traceId / rootRequestId / messageId 一起上报(issue #51)。 + rid := session.NewMessageID() + return map[string]any{ + "eventCode": "chat_request_send", + "inputLength": 14, "isPlan": false, "isAutoExecuteTerminal": false, + "isAutoModify": false, "codebaseEnable": false, "maxToken": 0, + "maxSteps": 500, "temperature": 0, "maxRetries": 0, + "mentionContexts": []any{}, "knowledgeId": []any{}, "knowledgeName": []any{}, + "codebaseId": "", "mentionContextCount": 0, "command": "", + "recommendId": "", "skillId": "", "skillCount": 0, "totalCount": 0, + "traceId": rid, "rootRequestId": rid, + "parentConversationId": conversationID, "conversationId": conversationID, + "messageId": "msg-" + rid[len(rid)-8:], + "agentName": "mp", "agentType": "main", + "codebuddy.session_id": conversationID, + "codebuddy.conversation_request_id": rid, + } +} + +// MiniExpertUseEvent 构造 Sequential_Tasks_2 的判据事件:mp 指纹 expert_actual_use。 +// 形状对齐小程序源码真实发射点(上报即 completed,claim +200c+5e)。 +// 不带 conversationId/activityId;extVersion 用小程序自身版本 2.2.8; +// source=mini_program + type 固定 "send_message"。 +// expertID 必须是专家市场真实 ex_ id,空 id 服务端不入账。 +func MiniExpertUseEvent(expertID, expertName, expertType string) map[string]any { + if expertType == "" { + expertType = "agent" + } + if expertName == "" { + expertName = expertID + } + return map[string]any{ + "eventCode": "expert_actual_use", "reportDelay": 0, + "extVersion": "2.2.8", "source": "mini_program", + "id": expertID, "name": expertID, + "expertTitle": expertName, "type": "send_message", + "characterCount": 12, "expertType": expertType, + } +} + +// MiniChatModelEvent mp 对话事件 + 模型字段(Sequential_Tasks_5 判据载体)。 +func MiniChatModelEvent(conversationID, modelID, modelName string) map[string]any { + ev := MiniChatSendEvent(conversationID) + ev["requestModelId"] = modelID + ev["requestModelName"] = modelName + return ev +} + +// MiniPlaybookEvents mp 指纹灵感事件组(Sequential_Tasks_7 判据载体)。 +func MiniPlaybookEvents(caseID, caseName string) []map[string]any { + base := map[string]any{ + "id": caseID, "name": caseName, "type": "document", + "categoryId": "", "categoryName": "", + "skills": "", "skillNames": "", + } + cta := map[string]any{ + "eventCode": "playbook_cta_click", "source": "discover", "position": 1, + "extVersion": "2.2.8", + } + for k, v := range base { + cta[k] = v + } + send := map[string]any{ + "eventCode": "playbook_prompt_send", "source": "discover", + "promptLength": 96, "isOfficial": 1, + "conversationId": session.NewConversationID(), + "extVersion": "2.2.8", + } + for k, v := range base { + send[k] = v + } + return []map[string]any{cta, send} +} diff --git a/internal/upstream/school_mp_test.go b/internal/upstream/mp_events_test.go similarity index 79% rename from internal/upstream/school_mp_test.go rename to internal/upstream/mp_events_test.go index e278696cca510e9dce2d8202e08b68b99e1ba88f..4ff24359d5383ea5d40133fb7403b17fc414c393 100644 --- a/internal/upstream/school_mp_test.go +++ b/internal/upstream/mp_events_test.go @@ -1,37 +1,39 @@ -package upstream - -import ( - "encoding/json" - "strings" - "testing" - - "github.com/linguo2625469/workbuddy2api-panel/internal/auth" -) - -func TestMPEventBase(t *testing.T) { - a := &auth.Auth{UID: "u-1", Nickname: "测试"} - base := mpEventBase(a) - for _, k := range []string{"ideType", "extName", "ideName", "platform", "userId"} { - if _, ok := base[k]; !ok { - t.Errorf("missing common field %s", k) - } - } - if base["ideType"] != "WorkBuddy_MP" || base["extName"] != "workbuddy-mp" { - t.Errorf("fingerprint ideType=%v extName=%v", base["ideType"], base["extName"]) - } -} - -func TestSchoolChatTimesEvents(t *testing.T) { - ev := SchoolChatTimesEvents("conv-1") - if ev["eventCode"] != "chat_request_send" { - t.Errorf("eventCode=%v", ev["eventCode"]) - } - if ev["conversationId"] != "conv-1" || ev["codebuddy.session_id"] != "conv-1" { - t.Errorf("conversation join fields missing: %v", ev) - } - b, _ := json.Marshal(ev) - if !strings.Contains(string(b), "agentName") { - t.Error("agentName missing") - } -} - +package upstream + +import ( + "encoding/json" + "strings" + "testing" + + "github.com/misakano7545/workbuddy2api-panel/internal/auth" +) + +func TestMPEventBase(t *testing.T) { + a := &auth.Auth{UID: "u-1", Nickname: "测试"} + base := mpEventBase(a) + for _, k := range []string{"ideType", "extName", "ideName", "platform", "userId"} { + if _, ok := base[k]; !ok { + t.Errorf("missing common field %s", k) + } + } + if base["ideType"] != "WorkBuddy_MP" || base["extName"] != "workbuddy-mp" { + t.Errorf("fingerprint ideType=%v extName=%v", base["ideType"], base["extName"]) + } +} + +func TestMiniChatSendEvent(t *testing.T) { + ev := MiniChatSendEvent("conv-1") + if ev["eventCode"] != "chat_request_send" { + t.Errorf("eventCode=%v", ev["eventCode"]) + } + if ev["conversationId"] != "conv-1" || ev["codebuddy.session_id"] != "conv-1" { + t.Errorf("conversation join fields missing: %v", ev) + } + if _, ok := ev["activityId"]; ok { + t.Fatal("activityId must stay unset") + } + b, _ := json.Marshal(ev) + if !strings.Contains(string(b), "agentName") { + t.Error("agentName missing") + } +} diff --git a/internal/upstream/official_fixture_test.go b/internal/upstream/official_fixture_test.go new file mode 100644 index 0000000000000000000000000000000000000000..3cc005a39c053a5b3207595c513f9c5203d6d963 --- /dev/null +++ b/internal/upstream/official_fixture_test.go @@ -0,0 +1,306 @@ +// official_fixture_test.go 官方客户端抓包夹具对拍(审计用,默认跳过)。 +// +// 跑法:WB2A_PARITY=1 go test ./internal/upstream -run TestOfficialParity -v +// +// 夹具 testdata/official_*_head.txt 是 **WorkBuddy 官方桌面端真机抓包**的 +// 原始请求头原文(保序、保大小写、已脱敏)。本测试做三件事: +// +// 1. 用生产代码构造同路径请求,经裸 TCP 抓真实出站字节; +// 2. 从字节里解析头名(Go 的 http.Header 拿不到原始大小写,必须看 wire); +// 3. 与夹具逐名比对:集合 / 大小写 / 静态值,输出差异表。 +// +// 它不做断言门禁——差异本身就是审计结论,由人决定改不改。 +// 默认跳过,不污染常规 CI。 +package upstream + +import ( + "bufio" + "net/http" + "os" + "path/filepath" + "strconv" + "strings" + "testing" + + "github.com/misakano7545/workbuddy2api-panel/internal/auth" +) + +// officialCase 一张夹具对应的生产代码调用方式。 +type officialCase struct { + fixture string // testdata/official_xxx_head.txt + path string // 对照的请求路径(夹具第一行里的) + chat bool // 走 chatHTTP(SSE 那条)而不是 HTTP + build func(c *Client, a *auth.Auth, base string) *http.Request +} + +// dynamicHeader 值每次不同、不能逐一比对(只比存在性与形态)。 +var dynamicHeader = map[string]bool{ + "x-request-id": true, "x-conversation-message-id": true, + "x-conversation-request-id": true, "x-root-request-id": true, + "x-conversation-id": true, "acp-connection-id": true, + "traceparent": true, "b3": true, "x-b3-traceid": true, + "x-b3-parentspanid": true, "x-b3-spanid": true, "x-trace-id": true, + "baggage": true, "authorization": true, "x-user-id": true, + "content-length": true, "host": true, + "content-encoding": true, "cookie": true, "x-device-token": true, + // x-domain 从上游 base 推出来,测试里 base 是 127.0.0.1 抓包监听, + // 生产环境才等于真实域;这条差异是脚手架造成的,不算产品缺陷。 + "x-domain": true, +} + +// transportHeader 传输层头,不进内容比对。 +// +// connection 不在此列:它的值由 path 决定(keep-alive / close),是官方固定发送的 +// 字段而非传输层动态产物,必须参与比对,否则「官方必发、我们从没发过」这类回归 +// 永远不会被门禁抓到。 +var transportHeader = map[string]bool{ + "host": true, "content-length": true, + "accept-encoding": true, "content-encoding": true, +} + +func loadFixture(t *testing.T, name string) (order []string, values map[string]string) { + t.Helper() + fp := filepath.Join("testdata", name) + raw, err := os.ReadFile(fp) + if err != nil { + t.Fatalf("读夹具失败 %s: %v", fp, err) + } + values = map[string]string{} + sc := bufio.NewScanner(strings.NewReader(string(raw))) + first := true + for sc.Scan() { + ln := strings.TrimRight(sc.Text(), "\r") + if ln == "" { + continue + } + if first { + first = false + continue // 请求行 + } + i := strings.Index(ln, ":") + if i <= 0 { + continue + } + k := ln[:i] + v := strings.TrimSpace(ln[i+1:]) + order = append(order, k) + values[k] = v + } + return +} + +// parseRawHeaderNames 从原始请求字节里取头名(保大小写、保顺序)。 +func parseRawHeaderNames(raw string) (order []string, values map[string]string) { + values = map[string]string{} + for _, ln := range strings.Split(raw, "\r\n") { + i := strings.Index(ln, ":") + if i <= 0 { + continue + } + k := ln[:i] + if strings.HasPrefix(strings.ToUpper(ln), "HTTP/") { + continue + } + order = append(order, k) + values[k] = strings.TrimSpace(ln[i+1:]) + } + return +} + +// lookupVal 大小写不敏感地取值(wire 上的大小写随发送方,不能假定)。 +func lookupVal(values map[string]string, key string) string { + for k, v := range values { + if strings.EqualFold(k, key) { + return v + } + } + return "" +} + +// TestOfficialParity 逐路径对拍官方真机头与本项目出站头。 +// +// 两种模式: +// +// WB2A_PARITY=report 只打印差异表,不判失败(审计用) +// WB2A_PARITY=1 打印 + **断言差异为零**(CI 门禁用) +// +// 默认跳过,不污染常规 go test。 +func TestOfficialParity(t *testing.T) { + mode := os.Getenv("WB2A_PARITY") + if mode == "" { + t.Skip("set WB2A_PARITY=1 (gate) 或 WB2A_PARITY=report (audit) to run") + } + strict := mode != "report" + + cn := &auth.Auth{UID: "uid-fixture", AccessToken: "AT", RefreshToken: "RT", + Nickname: "fixture", Domain: "www.workbuddy.cn"} + meta := ChatMeta{ + ConversationID: "f7c6c392-e016-43bb-beca-ab918b436668", + ConversationRequestID: "01a194ad31c27d81804ee9915cf954fb", + CacheKeyID: "sess-fixture", + } + + cases := []officialCase{ + { + fixture: "official_chat_head.txt", path: "/v2/chat/completions", chat: true, + build: func(c *Client, a *auth.Auth, base string) *http.Request { + req, _ := http.NewRequest(http.MethodPost, base+"/v2/chat/completions", + strings.NewReader(`{"model":"x","messages":[]}`)) + c.ChatHeaders(req, a, "", meta) + return req + }, + }, + { + fixture: "official_chat_busy_head.txt", path: "/v2/chat/busy", + build: func(c *Client, a *auth.Auth, base string) *http.Request { + // 真走生产函数 ModelBusy:手工拼头会漏掉它注入的身份头, + // 那是脚手架缺陷、会被误读成产品漏发。这里用 ChatBaseCN 把 + // 上游指到抓包监听上,由 ModelBusy 自己构造请求。 + c.ChatBaseCN = base + _, _ = c.ModelBusy(a, []string{"hy3"}) + return nil // ModelBusy 已经发过请求 + }, + }, + { + fixture: "official_v3config_head.txt", path: "/v3/config", + build: func(c *Client, a *auth.Auth, base string) *http.Request { + req, _ := http.NewRequest(http.MethodGet, base+"/v3/config", nil) + req.Header.Set("Accept", "application/json, text/plain, */*") + req.Header.Set("User-Agent", c.v3ProbeUA(a)) + req.Header.Set("X-Request-ID", "x") + req.Header.Set("X-Product", "SaaS") + return req + }, + }, + } + + for _, tc := range cases { + t.Run(strings.TrimSuffix(strings.TrimPrefix(tc.fixture, "official_"), "_head.txt"), func(t *testing.T) { + offOrder, offVals := loadFixture(t, tc.fixture) + + var raw string + c := probeClient() + raw = rawCaptured(t, false, func(base string) { + req := tc.build(c, cn, base) + if req == nil { + return // build 自己发了请求(如 ModelBusy) + } + // 必须经 do():它是唯一出站口,头名拼写纠正(normalizeHeaderSpelling) + // 就在里面。直接 c.HTTP.Do() 会绕过它,看到的不是生产真实字节。 + if tc.chat { + c.ChatBaseCN = base + } + resp, err := c.do(req, cn, tc.chat) + if err != nil { + return + } + resp.Body.Close() + }) + if i := strings.Index(raw, "\r\n\r\n"); i >= 0 { + raw = raw[:i] + } + gotOrder, gotVals := parseRawHeaderNames(raw) + if len(gotOrder) == 0 { + t.Fatalf("未抓到出站请求字节(raw=%q)", raw[:min(len(raw), 120)]) + } + + // 1) 集合差异(小写归并,跳过传输层头) + offSet, gotSet := map[string]string{}, map[string]string{} + for _, k := range offOrder { + if !transportHeader[strings.ToLower(k)] { + offSet[strings.ToLower(k)] = k + } + } + for _, k := range gotOrder { + if !transportHeader[strings.ToLower(k)] { + gotSet[strings.ToLower(k)] = k + } + } + var missing, extra []string + for k, orig := range offSet { + if _, ok := gotSet[k]; !ok { + missing = append(missing, orig) + } + } + for k, orig := range gotSet { + if _, ok := offSet[k]; !ok { + extra = append(extra, orig) + } + } + + // 2) 大小写差异 + var caseDiff []string + for k, orig := range offSet { + if g, ok := gotSet[k]; ok && g != orig { + caseDiff = append(caseDiff, orig+" ←项目 "+g) + } + } + + // 3) 静态值差异 + var valDiff []string + for k, orig := range offSet { + if dynamicHeader[k] { + continue + } + g, ok := gotSet[k] + if !ok { + continue + } + if offVals[orig] != gotVals[g] { + valDiff = append(valDiff, k+": 官方="+strconv.Quote(offVals[orig])+" 项目="+strconv.Quote(gotVals[g])) + } + } + + t.Logf("\n===== %s =====", tc.fixture) + t.Logf("官方 %d 头 / 项目 %d 头(不含传输层)", len(offSet), len(gotSet)) + if len(missing) > 0 { + t.Logf("【漏发】%v", missing) + } + if len(extra) > 0 { + t.Logf("【多发】%v", extra) + } + if len(caseDiff) > 0 { + t.Logf("【大小写不同 %d 项】", len(caseDiff)) + for _, d := range caseDiff { + t.Logf(" %s", d) + } + } + if len(valDiff) > 0 { + t.Logf("【值不同】") + for _, d := range valDiff { + t.Logf(" %s", d) + } + } + total := len(missing) + len(extra) + len(caseDiff) + len(valDiff) + if total == 0 { + t.Logf("完全一致") + } + + // Accept-Encoding 单独判定:它是可指纹化的头,但有两个已知边界—— + // 1. chat 链路有意保留 Go 自动 gzip(SSE 流解压风险,见 ChatHeaders); + // 2. 真机某些路径(chat/busy、v3/config)没有这个头,而 Go 一定会补 + // gzip,除非全局 DisableCompression——那会把所有链路的透明解压关掉。 + // 所以只对「真机有值」的路径做相等断言,chat 允许降级成 gzip。 + offAE := lookupVal(offVals, "Accept-Encoding") + gotAE := lookupVal(gotVals, "Accept-Encoding") + t.Logf("Accept-Encoding: 官方=%q 项目=%q", offAE, gotAE) + + if strict { + if total > 0 { + t.Errorf("%s:与官方真机存在 %d 处差异(漏发%d/多发%d/大小写%d/值%d)", + tc.fixture, total, len(missing), len(extra), len(caseDiff), len(valDiff)) + } + if offAE != "" { + wantAE := offAE + if tc.chat { + // 已知残留:chat 交回 net/http 自动 gzip。 + wantAE = "gzip" + } + if gotAE != wantAE { + t.Errorf("%s:Accept-Encoding=%q want %q", tc.fixture, gotAE, wantAE) + } + } + } + }) + } +} diff --git a/internal/upstream/outbound_probe_test.go b/internal/upstream/outbound_probe_test.go new file mode 100644 index 0000000000000000000000000000000000000000..a7e9ff91da8ec43ff972328e97b72981533c359d --- /dev/null +++ b/internal/upstream/outbound_probe_test.go @@ -0,0 +1,313 @@ +// outbound_probe_test.go 出站报文探针(手工审计用,默认跳过)。 +// +// 跑法:WB2A_PROBE=1 go test ./internal/upstream -run TestProbeOutbound -v +// +// 作用:把各出站路径**真实写出的字节**抓下来(裸 TCP 抓明文请求头 + 抓 TLS +// ClientHello),用于对照官方客户端抓包做「头顺序 / 自动补头 / JA3 输入」审计。 +// +// 必须经 c.do() 发请求:它是唯一出站口,头名拼写纠正(normalizeHeaderSpelling) +// 就在里面。直接用 c.HTTP.Do() 会绕过生产逻辑,看到的不是线上真实字节。 +// +// 常规 `go test ./...` 会跳过——它会 bind 本地端口并往 stdout 打印大段报文。 +package upstream + +import ( + "bytes" + "crypto/tls" + "encoding/binary" + "fmt" + "net" + "net/http" + "os" + "strings" + "testing" + "time" + + "github.com/misakano7545/workbuddy2api-panel/internal/auth" +) + +// requireProbe 未设置 WB2A_PROBE 时跳过(默认不进 CI 的安静测试集)。 +func requireProbe(t *testing.T) { + t.Helper() + if os.Getenv("WB2A_PROBE") == "" { + t.Skip("set WB2A_PROBE=1 to run outbound probe") + } +} + +// rawCaptured 起一个裸 TCP 监听,收回一次请求的原始字节,然后回一个正常响应。 +func rawCaptured(t *testing.T, https bool, build func(base string)) string { + t.Helper() + ln, err := net.Listen("tcp", "127.0.0.1:0") + if err != nil { + t.Fatalf("listen: %v", err) + } + defer ln.Close() + scheme := "http" + if https { + scheme = "https" + } + base := scheme + "://" + ln.Addr().String() + + got := make(chan []byte, 1) + go func() { + conn, aerr := ln.Accept() + if aerr != nil { + got <- nil + return + } + defer conn.Close() + if https { + // 抓 ClientHello 后就断开(不需要真握手)。 + conn.SetReadDeadline(time.Now().Add(2 * time.Second)) + buf := make([]byte, 4096) + n, _ := conn.Read(buf) + got <- buf[:n] + return + } + var all []byte + conn.SetReadDeadline(time.Now().Add(400 * time.Millisecond)) + tmp := make([]byte, 8192) + for { + n, rerr := conn.Read(tmp) + if n > 0 { + all = append(all, tmp[:n]...) + if i := bytes.Index(all, []byte("\r\n\r\n")); i >= 0 { + head := string(all[:i]) + var clen int + for _, line := range strings.Split(head, "\r\n") { + if strings.HasPrefix(strings.ToLower(line), "content-length:") { + fmt.Sscanf(strings.TrimSpace(line[len("content-length:"):]), "%d", &clen) + } + } + if len(all) >= i+4+clen { + break + } + } + } + if rerr != nil { + break + } + conn.SetReadDeadline(time.Now().Add(200 * time.Millisecond)) + } + got <- all + body := `{"code":0,"data":{}}` + fmt.Fprintf(conn, "HTTP/1.1 200 OK\r\nContent-Type: application/json\r\nContent-Length: %d\r\n\r\n%s", len(body), body) + }() + + build(base) + + select { + case b := <-got: + return string(b) + case <-time.After(6 * time.Second): + return "" + } +} + +func dumpBlock(title, raw string) { + fmt.Printf("\n===== %s =====\n", title) + if raw == "" { + fmt.Println("") + return + } + if i := strings.Index(raw, "\r\n\r\n"); i >= 0 { + raw = raw[:i] + } + fmt.Println(raw) +} + +func probeClient() *Client { + c := New() + c.UserAgent = "" + c.DeviceToken = "" + c.PassthroughIP = false + return c +} + +// TestProbeOutboundRequestBytes 抓六条出站链路的原始请求字节。 +func TestProbeOutboundRequestBytes(t *testing.T) { + requireProbe(t) + c := probeClient() + cn := &auth.Auth{UID: "uid-cn-0001", AccessToken: "AT-CN", RefreshToken: "RT-CN", Nickname: "cn", Domain: "www.workbuddy.cn"} + gl := &auth.Auth{UID: "uid-gl-0001", AccessToken: "AT-GL", RefreshToken: "RT-GL", Nickname: "gl", Domain: "www.workbuddy.ai"} + meta := ChatMeta{ConversationID: "01a1815d-dacf-75f1-9a00-3f6f00000001", ConversationRequestID: "01a1815ddacf75f19a003f6f00000002", CacheKeyID: "sess-1"} + + raw := rawCaptured(t, false, func(base string) { + req, _ := http.NewRequest(http.MethodPost, base+"/v2/chat/completions", bytes.NewReader([]byte(`{"model":"x","messages":[]}`))) + c.ChatHeaders(req, cn, "", meta) + resp, err := c.do(req, cn, true) + if err != nil { + fmt.Println("chat CN err:", err) + return + } + resp.Body.Close() + }) + dumpBlock("chat · CN 个人号(ChatHeaders)", raw) + + raw = rawCaptured(t, false, func(base string) { + req, _ := http.NewRequest(http.MethodPost, base+"/v2/chat/completions", bytes.NewReader([]byte(`{"model":"x","messages":[]}`))) + c.ChatHeaders(req, gl, "", meta) + resp, err := c.do(req, gl, true) + if err != nil { + fmt.Println("chat GL err:", err) + return + } + resp.Body.Close() + }) + dumpBlock("chat · global 个人号(ChatHeaders)", raw) + + raw = rawCaptured(t, false, func(base string) { + req, _ := http.NewRequest(http.MethodPost, base+"/v2/report", bytes.NewReader([]byte(`[]`))) + c.CommonHeaders(req, cn) + req.Header.Set("Authorization", "Bearer AT-CN") + resp, err := c.do(req, cn, false) + if err != nil { + fmt.Println("rpc err:", err) + return + } + resp.Body.Close() + }) + dumpBlock("RPC 层(CommonHeaders,/v2/report)", raw) + + raw = rawCaptured(t, false, func(base string) { + req, _ := http.NewRequest(http.MethodPost, base+"/v2/plugin/auth/token/refresh", strings.NewReader("{}")) + c.RefreshHeaders(req, cn) + resp, err := c.do(req, cn, false) + if err != nil { + fmt.Println("refresh err:", err) + return + } + resp.Body.Close() + }) + dumpBlock("refresh(RefreshHeaders)", raw) + + raw = rawCaptured(t, false, func(base string) { + req, _ := http.NewRequest(http.MethodPost, base+"/v2/billing/meter/get-user-resource", strings.NewReader("{}")) + c.BillingHeaders(req, cn) + resp, err := c.do(req, cn, false) + if err != nil { + fmt.Println("billing err:", err) + return + } + resp.Body.Close() + }) + dumpBlock("billing(BillingHeaders)", raw) + + c.ChatBaseCN = "http://127.0.0.1:1" // 占位,真值在 build 里覆盖 + raw = rawCaptured(t, false, func(base string) { + c2 := probeClient() + c2.ChatBaseCN = base + c2.WebBaseCN = base + _ = c2.ReportDesktopEvent(cn, DesktopEvent{"eventCode": "agent_task_created"}) + }) + dumpBlock("桌面 /v2/report(ReportDesktopEvent)", raw) + + raw = rawCaptured(t, false, func(base string) { + c3 := probeClient() + c3.WebBaseCN = base + _ = c3.ReportWebEvent(cn, "library_doc_intro_click", "https://www.workbuddy.cn/library", "intro", "简介") + }) + dumpBlock("Web /v2/report(ReportWebEvent)", raw) +} + +// TestZZProbeClientHello 抓 Go 出站 TLS ClientHello 的关键字段(JA3 的输入)。 +func TestProbeOutboundClientHello(t *testing.T) { + requireProbe(t) + tr := newTransport() + c := &Client{HTTP: &http.Client{Transport: tr, Timeout: 3 * time.Second}, ChatHTTP: &http.Client{Transport: tr, Timeout: 3 * time.Second}} + raw := rawCaptured(t, true, func(base string) { + req, _ := http.NewRequest(http.MethodGet, base+"/", nil) + if resp, err := c.HTTP.Do(req); err == nil { + resp.Body.Close() + } + }) + b := []byte(raw) + if len(b) < 44 { + t.Fatalf("ClientHello 太短: %d bytes", len(b)) + } + fmt.Printf("\n===== TLS ClientHello(newTransport,禁 h2) =====\n") + fmt.Printf("record: type=%d version=0x%04x len=%d\n", b[0], binary.BigEndian.Uint16(b[1:3]), binary.BigEndian.Uint16(b[3:5])) + p := 5 + if b[p] != 1 { + t.Fatalf("不是 ClientHello: %d", b[p]) + } + hsLen := int(b[p+1])<<16 | int(b[p+2])<<8 | int(b[p+3]) + p += 4 + legacyVer := binary.BigEndian.Uint16(b[p : p+2]) + p += 2 + p += 32 // random + sidLen := int(b[p]) + p++ + sid := b[p : p+sidLen] + fmt.Printf("session_id=%x\n", sid) + p += sidLen + csLen := int(binary.BigEndian.Uint16(b[p : p+2])) + p += 2 + cs := b[p : p+csLen] + p += csLen + cmLen := int(b[p]) + cm := b[p+1 : p+1+cmLen] + p += 1 + cmLen + fmt.Printf("handshake_len=%d legacy_version=0x%04x session_id_len=%d compression=%v\n", hsLen, legacyVer, sidLen, cm) + var csHex []string + for i := 0; i+1 < len(cs); i += 2 { + csHex = append(csHex, fmt.Sprintf("%04x", binary.BigEndian.Uint16(cs[i:i+2]))) + } + fmt.Printf("cipher_suites(%d)=%s\n", len(csHex), strings.Join(csHex, ",")) + if p+2 > len(b) { + return + } + extLen := int(binary.BigEndian.Uint16(b[p : p+2])) + p += 2 + end := p + extLen + var exts []string + for p+4 <= end && p+4 <= len(b) { + etype := binary.BigEndian.Uint16(b[p : p+2]) + elen := int(binary.BigEndian.Uint16(b[p+2 : p+4])) + data := b[p+4 : min(p+4+elen, len(b))] + exts = append(exts, fmt.Sprintf("%d", etype)) + switch etype { + case 16: // ALPN + var protos []string + q := 2 + for q+1 < len(data) { + l := int(data[q]) + if q+1+l > len(data) { + break + } + protos = append(protos, string(data[q+1:q+1+l])) + q += 1 + l + } + fmt.Printf(" ALPN(16) = %v\n", protos) + case 10: // supported_groups + var g []string + for i := 2; i+1 < len(data); i += 2 { + g = append(g, fmt.Sprintf("%04x", binary.BigEndian.Uint16(data[i:i+2]))) + } + fmt.Printf(" groups(10) = %s\n", strings.Join(g, ",")) + case 11: // ec_point_formats + fmt.Printf(" ec_point_formats(11) = %v\n", data[1:]) + case 43: // supported_versions + fmt.Printf(" supported_versions(43) = %v\n", data[1:]) + case 13: // signature_algorithms + var s []string + for i := 2; i+1 < len(data); i += 2 { + s = append(s, fmt.Sprintf("%04x", binary.BigEndian.Uint16(data[i:i+2]))) + } + fmt.Printf(" sigalgs(13) = %s\n", strings.Join(s, ",")) + } + p += 4 + elen + } + fmt.Printf("extensions(%d) = %s\n", len(exts), strings.Join(exts, ",")) +} + +// TestProbeOutboundTransport 确认 Go 出厂 Transport 的 TLS 配置面(ServerName/NextProtos)。 +func TestProbeOutboundTransport(t *testing.T) { + requireProbe(t) + _ = tls.VersionTLS13 + tr := newTransport() + fmt.Printf("\n===== Transport 面 =====\n") + fmt.Printf("TLSNextProto len=%d (0=允许 h2 / >0=禁 h2)\n", len(tr.TLSNextProto)) + fmt.Printf("ForceAttemptHTTP2=%v DisableCompression=%v DisableKeepAlives=%v\n", tr.ForceAttemptHTTP2, tr.DisableCompression, tr.DisableKeepAlives) + var _ = net.IPv4len +} diff --git a/internal/upstream/outbound_repair_test.go b/internal/upstream/outbound_repair_test.go new file mode 100644 index 0000000000000000000000000000000000000000..b11db16b051b014663eb40c26d61cf562b611ecf --- /dev/null +++ b/internal/upstream/outbound_repair_test.go @@ -0,0 +1,198 @@ +package upstream + +import ( + "encoding/json" + "reflect" + "strings" + "testing" +) + +// TestGuardEmptyTextPartsShapes 逐形态钉住「哪些 text 段会被补、哪些不动」。 +// +// 形态矩阵来自上游实测(2026-11-08,kimi-k3.1-pro + cn 号池;见 empty_text_part.go +// 文件头):只有「空串 / null / 缺失」三种会被判 11151,`" "` 与未识别 type 放行。 +// 因此补位的**边界**和补位本身一样重要——多补一格就是在改上游本来接受的报文。 +func TestGuardEmptyTextPartsShapes(t *testing.T) { + cases := []struct { + name string + in string // 单条消息的 content + want string // 期望的 content(JSON 字面量) + }{ + {"空串补位", `[{"type":"text","text":""}]`, `[{"type":"text","text":" "}]`}, + {"null 补位", `[{"type":"text","text":null}]`, `[{"type":"text","text":" "}]`}, + {"缺失补位", `[{"type":"text"}]`, `[{"type":"text","text":" "}]`}, + {"纯空白不动", `[{"type":"text","text":" "}]`, `[{"type":"text","text":" "}]`}, + {"未识别 type 不动", `[{"type":"textarea","text":""}]`, `[{"type":"textarea","text":""}]`}, + {"非数组对象不动", `{"type":"text","text":""}`, `{"type":"text","text":""}`}, + {"普通字符串不动", `"hello"`, `"hello"`}, + } + for _, c := range cases { + t.Run(c.name, func(t *testing.T) { + body := `{"model":"m","messages":[{"role":"user","content":` + c.in + `}]}` + out := PrepareBodyOpt([]byte(body), false) + var obj map[string]any + if err := json.Unmarshal(out, &obj); err != nil { + t.Fatalf("输出不是合法 JSON: %v (%s)", err, out) + } + got, err := json.Marshal(obj["messages"].([]any)[0].(map[string]any)["content"]) + if err != nil { + t.Fatal(err) + } + // 期望值也要归一化(对象键序无关) + var want, gotAny any + if err := json.Unmarshal([]byte(c.want), &want); err != nil { + t.Fatalf("want 不是合法 JSON: %v", err) + } + if err := json.Unmarshal(got, &gotAny); err != nil { + t.Fatal(err) + } + wb, _ := json.Marshal(want) + gb, _ := json.Marshal(gotAny) + if string(gb) != string(wb) { + t.Fatalf("content 变成 %s,期望 %s", gb, wb) + } + }) + } +} + +// TestGuardEmptyTextPartsSniffedString 字符串信封信封被上游当 parts 嗅探: +// 工具结果里抓到的表单/按钮数组(`[{"type":"text","text":""},…]`)正是这个形态, +// 它会变成一个空文本段 → 11151。这里钉住「补位并重新序列化」,同时钉住反例: +// 普通文本、解析失败、空数组、非对象数组都必须一字不动(否则正常工具结果会被 +// 无谓地重写,下游按原文比对的逻辑会漂)。 +func TestGuardEmptyTextPartsSniffedString(t *testing.T) { + msg := func(content any) map[string]any { + return map[string]any{"role": "tool", "content": content} + } + + // 命中:补位后重新序列化 + hit := `[{"type":"text","text":""},{"type":"text","text":"ok"}]` + msgs := []any{msg(hit)} + guardEmptyTextParts(msgs) + got, _ := msgs[0].(map[string]any)["content"].(string) + if got == hit { + t.Fatalf("嗅探命中的字符串应被补位,实际原样:%q", got) + } + var parts []map[string]any + if err := json.Unmarshal([]byte(got), &parts); err != nil { + t.Fatalf("补位后不是合法 JSON: %v (%q)", err, got) + } + if parts[0]["text"] != " " || parts[1]["text"] != "ok" { + t.Fatalf("补位结果不对:%+v", parts) + } + + // 反例:都不该被改写 + for _, c := range []string{ + "普通工具结果文本", + "[1,2,3]", // 非对象数组 + "[]", // 空数组 + `[{"type":"text"`, // 解析失败 + `{"type":"text","text":""}`, // 对象(不是数组) + `[{"type":"text","text":"x"}]`, // 没有空段 + } { + msgs := []any{msg(c)} + guardEmptyTextParts(msgs) + if got := msgs[0].(map[string]any)["content"]; got != c { + t.Errorf("不该改写 %q,实际变成 %q", c, got) + } + } +} + +// TestGuardEmptyTextPartsKeepsNonTextParts 多模态:图片等非 text 段必须原引用保留 +// (只克隆要改的 text 段)。同时钉住「同一消息里 text 与 image 混排时下标不变」—— +// 删段派生的实现会在这里红。 +func TestGuardEmptyTextPartsKeepsNonTextParts(t *testing.T) { + img := map[string]any{"type": "image_url", "image_url": map[string]any{"url": "data:image/png;base64,AA"}} + msgs := []any{map[string]any{ + "role": "user", + "content": []any{ + map[string]any{"type": "text", "text": ""}, + img, + }, + }} + guardEmptyTextParts(msgs) + parts := msgs[0].(map[string]any)["content"].([]any) + if len(parts) != 2 { + t.Fatalf("段数变了:%d,删段会改段落下标", len(parts)) + } + if reflect.ValueOf(parts[1]).Pointer() != reflect.ValueOf(img).Pointer() { + t.Fatalf("image 段应保持原引用(未被克隆/改写),实际 %#v", parts[1]) + } + if parts[0].(map[string]any)["text"] != " " { + t.Fatalf("空 text 段未补位:%#v", parts[0]) + } +} + +// TestMirrorUpstreamReasoning 镜像只对「按 reasoning 读历史」的家族生效,且只抄不造。 +func TestMirrorUpstreamReasoning(t *testing.T) { + body := func(model string, msgs string) []byte { + return []byte(`{"model":"` + model + `","messages":[` + msgs + `]}`) + } + asst := func(extra string) string { + return `{"role":"assistant","content":"答"` + extra + `}` + } + + // 命中:六个家族各来一发(含 realm 前缀与大小写) + for _, model := range []string{"kimi-k3.1-pro", "cn:glm-5.3", "minimax-m3", "MiMo-7B", "step-5", "space-bunny-x"} { + out := PrepareBodyOpt(body(model, asst(`,"reasoning_content":"想过了"`)), false) + if !strings.Contains(string(out), `"reasoning":"想过了"`) { + t.Errorf("%s:reasoning_content 未镜像进 reasoning,输出 %s", model, out) + } + } + + // 反例一:不在名单里的模型一字不加(凭空多键会让原模型看到陌生字段) + for _, model := range []string{"gpt-5", "qwen3-max"} { + out := PrepareBodyOpt(body(model, asst(`,"reasoning_content":"想过了"`)), false) + if strings.Contains(string(out), `"reasoning":"`) { + t.Errorf("%s:不该镜像,输出 %s", model, out) + } + } + + // deepseek 不走这份:它的 reasoning 由 thinking.go 的 backfillReasoningContent + // 供给(含空值占位)。这里只钉「两条路径互不干扰」——deepseek 仍然有 reasoning, + // 但那是既有行为,不是本次新增。 + out := PrepareBodyOpt(body("deepseek-v4.1-flash", asst(`,"reasoning_content":"想过了"`)), false) + if !strings.Contains(string(out), `"reasoning":"想过了"`) { + t.Errorf("deepseek 的 reasoning 应仍由 backfillReasoningContent 提供:%s", out) + } + + // 反例二:reasoning 已有非空值时不得覆盖(上游自己的版本更权威) + out = PrepareBodyOpt(body("kimi-k3.1-pro", asst(`,"reasoning":"上游写的","reasoning_content":"客户端的"`)), false) + if !strings.Contains(string(out), `"reasoning":"上游写的"`) { + t.Errorf("已有的非空 reasoning 被覆盖了:%s", out) + } + + // 反例三:空/缺失的 reasoning_content 不制造字段(与 deepseek 那份的纪律相反) + for _, extra := range []string{``, `,"reasoning_content":""`, `,"reasoning_content":null`} { + out := PrepareBodyOpt(body("kimi-k3.1-pro", asst(extra)), false) + if strings.Contains(string(out), `"reasoning":`) { + t.Errorf("空 reasoning_content 不该产生 reasoning 字段(extra=%q):%s", extra, out) + } + } + + // 反例四:非 assistant 角色不镜像(工具结果里的同名字段是数据不是思考) + out = PrepareBodyOpt(body("kimi-k3.1-pro", `{"role":"tool","content":"x","reasoning_content":"别抄我"}`), false) + if strings.Contains(string(out), `"reasoning":"别抄我"`) { + t.Errorf("tool 消息不该被镜像:%s", out) + } +} + +// TestReadsUpstreamReasoning 判据本身:前缀命中表 + 空串/裸名的边界。 +// +// 前缀匹配是**故意宽松**的(与上游实现同口径):`step` 会同时命中 `steps`、`glm` +// 会命中 `glm-free`。收紧成精确模型名表会让新上架的 kimi/glm 型号静默漏掉,而多 +// 命中一个陌生名字的代价只是多发一个没人读的键。 +func TestReadsUpstreamReasoning(t *testing.T) { + yes := []string{"kimi", "kimi-k2", "glm-9.9", "glm-free", "minimax-m3", "mimo-7b", "step-5-preview", "steps", "space-bunny", "global:glm-5.2", " Kimi-K3 "} + no := []string{"", "deepseek-v4.1-flash", "gpt-5.6-sol", "qwen3-max", "claude-sonnet-4"} + for _, m := range yes { + if !readsUpstreamReasoning(m) { + t.Errorf("%q 应命中", m) + } + } + for _, m := range no { + if readsUpstreamReasoning(m) { + t.Errorf("%q 不该命中", m) + } + } +} diff --git a/internal/upstream/output_budget.go b/internal/upstream/output_budget.go new file mode 100644 index 0000000000000000000000000000000000000000..ed81ee6f6e36a250aec2604af6263efb0d9c9106 --- /dev/null +++ b/internal/upstream/output_budget.go @@ -0,0 +1,133 @@ +// output_budget.go 输出预算下限:客户端挡不住「高档位思考把自己那份额度吃光」的 +// 组合错误,网关兜住它。 +// +// 现象(2026-11-08 生产实测,cn:deepseek-v4.1-flash,要求写 3000+ 字长文档): +// +// effort=high + max_tokens=2048 → total=4096 think=2048 正文=2048 finish=length +// effort=max + max_tokens=2048 → total=4096 think=2048 正文=2048 finish=length +// effort=high + 不给额度 → total=16720 think=2998 正文=13722 finish=stop +// +// 即:思考与正文在**同一份额度**里结算时,客户端给的 2048 先被思考吃掉一半, +// 正文只剩 1024 个 token 就断在句子中间——用户看到的就是「回答写到一半停住」。 +// 客户端并不知道模型的思考要花多少,它只能给一个拍脑袋的数,这个组合错误只能由 +// 网关修:把 max_tokens 抬到「这一档思考起码要花的量」以上。 +// +// 抬的是**上限**不是目标长度:模型写完自然停(实测 high+大额度收尾在 13722 token, +// 不会因为上限 8192/16384 而多写一个字)。所以这既不改变答案长度,也不额外计费, +// 只是把「预算被思考偷走」这个 bug 修掉。 +// +// 与 starved.go / continue.go 的分工: +// - 这里在**出站前**兜住(最彻底,客户端根本看不到截断); +// - starved.go 兜「额度仍被吃光、正文 0B」的残留形态(关思考重发一次); +// - continue.go 兜「共用额度、思考占大头但已写出正文」的残留形态(关思考续写)。 +// 三者按「越早越省」排列,后者只是前者的保险。 +package upstream + +import ( + "log" + "strings" +) + +// minBudgetByEffort 各思考档位下「正文还能写得出来」的最小输出预算。 +// +// 取值依据(生产实测 think 用量,同一模型 cn:deepseek-v4.1-flash): +// +// low → think 1853~2722 +// high → think 2048~4068 +// max → think 7612~37110(同一个提示词能从 7.6k 波动到 37k) +// +// 下限按「该档思考的上界」再留一倍给正文,所以是 4k/8k/16k:低于它,思考必然 +// 先把预算吃掉一半以上;高于它,思考与正文都够用,模型自然收尾。 +var minBudgetByEffort = map[string]int64{ + "minimal": 4096, + "low": 4096, + "medium": 6144, + "high": 8192, + "xhigh": 12288, + "max": 16384, +} + +// minOutputBudgetProbe 低于这个额度的请求一律不动:官方客户端用 max_tokens=1 做 +// key 探活("Reply with OK."),抬上去没有意义,还会让探活变慢。与 starved.go 的 +// minStarvedBudget 同口径。 +const minOutputBudgetProbe = 16 + +// MinOutputBudget 该思考档位下「正文还能写得出来」的最小输出预算;档位未知返回 0。 +// +// 供续写/救援段复用:那些段是从**客户端原始 body** 重建的(不含首段被抬过的 +// max_tokens),而它们往往关掉思考,prepareBody 的下限逻辑会跳过(没有思考就不 +// 存在「思考吃光预算」)。若不显式带上,救援段会继续用客户端那个装不下正文的小额度 +// ——线上实测正是这样:首段 8192 全被思考吃掉 → 救援段只拿到 1024 → 正文 1946 字 +// 就断。所以续写层必须自己把下限写进去。 +func MinOutputBudget(effort string) int64 { + return minBudgetByEffort[strings.ToLower(strings.TrimSpace(effort))] +} + +// EnsureMinBudget 把 obj 的 max_tokens 抬到不低于 floor(floor<=0 或当前额度是探活级 +// 时不动)。返回是否改动。 +func EnsureMinBudget(obj map[string]any, floor int64) bool { + if floor <= 0 { + return false + } + v, ok := explicitOutputBudget(obj) + if !ok || v <= 0 || v < minOutputBudgetProbe || v >= floor { + return false + } + obj["max_tokens"] = floor + return true +} + +// ensureMinOutputBudget 在「客户端显式给了 max_tokens」且「低于该档下限」时抬到下限。 +// +// 不动的四种情形(都不猜): +// - 没有显式额度:injectCatalogMaxTokens 已按目录补了真实上限,无需再动; +// - 额度是探活级(< 16); +// - 档位为空或关闭思考(thinking.type=disabled / effort=off):没有思考要花钱; +// - 已经不低于下限。 +// +// 目录 maxOutputTokens 已知且更小时以目录为准——不把额度抬到模型物理上写不了的值。 +func ensureMinOutputBudget(obj map[string]any, effort string, maxOut map[string]int64) { + v, ok := explicitOutputBudget(obj) + if !ok || v <= 0 || v < minOutputBudgetProbe { + return + } + floor, has := minBudgetByEffort[strings.ToLower(strings.TrimSpace(effort))] + if !has { + return + } + if thinkingDisabled(obj) { + return + } + if model, _ := obj["model"].(string); len(maxOut) > 0 { + if cap, ok := maxOut[model]; ok && cap > 0 && floor > cap { + floor = cap + } + } + if v >= floor { + return + } + obj["max_tokens"] = floor + log.Printf("INFO: [budget] max_tokens %d -> %d(effort=%s 的输出预算下限:低于它时思考会先吃掉一半以上,正文被截断在句子中间;抬的是上限不是目标长度)", + v, floor, effort) +} + +// explicitOutputBudget 读客户端显式给的输出额度(三个别名,translateMaxCompletionTokens +// 已把别名折进 max_tokens,这里仍按三个键判「有没有显式给」)。 +func explicitOutputBudget(obj map[string]any) (int64, bool) { + for _, k := range []string{"max_tokens", "max_completion_tokens", "max_output_tokens"} { + switch v := obj[k].(type) { + case float64: + return int64(v), true + case int: + return int64(v), true + case int64: + return v, true + case string: + // 个别客户端把额度写成字符串;解析失败按「没给」处理,交给目录兜底。 + if n := parseInt64(v); n > 0 { + return n, true + } + } + } + return 0, false +} diff --git a/internal/upstream/output_budget_test.go b/internal/upstream/output_budget_test.go new file mode 100644 index 0000000000000000000000000000000000000000..6fd6005354975b47a7523ce4a4dc2320e4c27e7b --- /dev/null +++ b/internal/upstream/output_budget_test.go @@ -0,0 +1,137 @@ +package upstream + +import ( + "encoding/json" + "testing" +) + +func budgetObj(t *testing.T, raw string) map[string]any { + t.Helper() + var obj map[string]any + if err := json.Unmarshal([]byte(raw), &obj); err != nil { + t.Fatalf("decode %s: %v", raw, err) + } + return obj +} + +func budgetOf(obj map[string]any) int64 { + switch v := obj["max_tokens"].(type) { + case float64: + return int64(v) + case int64: + return v + case int: + return int64(v) + } + return 0 +} + +// TestEnsureMinOutputBudgetRaises 低额度的请求按档位抬到下限。 +// +// 依据(2026-11-08 生产实测,cn:deepseek-v4.1-flash):effort=high + max_tokens=2048 +// 时上游把 2048 里的 2048 花在思考上、正文再占 2048 就 finish=length;同一提示词 +// 不限额度时正文写到 13722 token 才自然收尾。所以 2048 这种额度是「装不下思考」的 +// 组合错误,不是客户端真要的答案长度。 +func TestEnsureMinOutputBudgetRaises(t *testing.T) { + cases := []struct { + name string + body string + effort string + want int64 + }{ + {"high+2048", `{"model":"m","max_tokens":2048}`, "high", 8192}, + {"max+1024", `{"model":"m","max_tokens":1024}`, "max", 16384}, + {"low+512", `{"model":"m","max_tokens":512}`, "low", 4096}, + {"medium+2048", `{"model":"m","max_tokens":2048}`, "medium", 6144}, + {"xhigh+2048", `{"model":"m","max_tokens":2048}`, "xhigh", 12288}, + {"字符串额度+high", `{"model":"m","max_tokens":"2048"}`, "high", 8192}, + {"英文大写档位", `{"model":"m","max_tokens":2048}`, "HIGH", 8192}, + // 已经够大:不动。 + {"high+16384", `{"model":"m","max_tokens":16384}`, "high", 16384}, + {"high+8192(等于下限)", `{"model":"m","max_tokens":8192}`, "high", 8192}, + } + for _, c := range cases { + obj := budgetObj(t, c.body) + ensureMinOutputBudget(obj, c.effort, nil) + if got := budgetOf(obj); got != c.want { + t.Errorf("%s: max_tokens=%d want %d", c.name, got, c.want) + } + } +} + +// TestEnsureMinOutputBudgetLeavesAlone 不猜的四种情形:没给额度、探活级额度、 +// 关闭思考、档位未知。 +func TestEnsureMinOutputBudgetLeavesAlone(t *testing.T) { + cases := []struct { + name string + body string + effort string + }{ + {"没给额度(交给目录)", `{"model":"m"}`, "high"}, + {"探活 max_tokens=1", `{"model":"m","max_tokens":1}`, "max"}, + {"关闭思考", `{"model":"m","max_tokens":512,"thinking":{"type":"disabled"}}`, "high"}, + {"档位未知", `{"model":"m","max_tokens":512}`, ""}, + {"档位是 off", `{"model":"m","max_tokens":512}`, "off"}, + } + for _, c := range cases { + obj := budgetObj(t, c.body) + before := budgetOf(obj) + ensureMinOutputBudget(obj, c.effort, nil) + if got := budgetOf(obj); got != before { + t.Errorf("%s: max_tokens 被改成了 %d(want 原值 %d)", c.name, got, before) + } + } +} + +// TestEnsureMinOutputBudgetRespectsCatalogCap 目录声明的输出上限更小时以目录为准: +// 抬到模型物理上写不了的值没有意义。 +func TestEnsureMinOutputBudgetRespectsCatalogCap(t *testing.T) { + obj := budgetObj(t, `{"model":"small-model","max_tokens":1024}`) + ensureMinOutputBudget(obj, "max", map[string]int64{"small-model": 6000}) + if got := budgetOf(obj); got != 6000 { + t.Fatalf("max_tokens=%d want 6000(目录上限封顶)", got) + } +} + +// TestPrepareBodyAppliesMinOutputBudget 端到端接线:真实管线里 max_tokens 被抬升, +// 且档位仍是客户端要的那一档(不因为抬额度改档位)。 +func TestPrepareBodyAppliesMinOutputBudget(t *testing.T) { + src := []byte(`{"model":"deepseek-v4.1-flash","reasoning_effort":"max","max_tokens":1024, + "messages":[{"role":"user","content":"hi"}]}`) + out, eff := PrepareBodyOptWithEffortPolicy(src, false, + map[string][]string{"deepseek-v4.1-flash": {"low", "high", "max"}}, + map[string]string{"deepseek-v4.1-flash": "high"}, + map[string]int64{"deepseek-v4.1-flash": 131072}, + "cn", &EffortPolicy{Enabled: true, DefaultEffort: "high", ClientPriority: true}) + var obj map[string]any + if err := json.Unmarshal(out, &obj); err != nil { + t.Fatalf("decode out: %v", err) + } + if got := budgetOf(obj); got != 16384 { + t.Fatalf("max_tokens=%d want 16384(max 档下限)", got) + } + if eff != "max" { + t.Fatalf("effective effort=%q want max(抬额度不得改档位)", eff) + } + if obj["reasoning_effort"] != "max" { + t.Fatalf("reasoning_effort=%v want max", obj["reasoning_effort"]) + } +} + +// TestPrepareBodyKeepsLargeClientBudget 客户端给的额度已经够大时一个字节都不动。 +func TestPrepareBodyKeepsLargeClientBudget(t *testing.T) { + src := []byte(`{"model":"deepseek-v4.1-flash","reasoning_effort":"high","max_tokens":65536, + "messages":[{"role":"user","content":"hi"}]}`) + out, _ := PrepareBodyOptWithEffortPolicy(src, false, + map[string][]string{"deepseek-v4.1-flash": {"low", "high", "max"}}, + map[string]string{"deepseek-v4.1-flash": "high"}, + map[string]int64{"deepseek-v4.1-flash": 131072}, + "cn", &EffortPolicy{Enabled: true, DefaultEffort: "high", ClientPriority: true}) + var obj map[string]any + if err := json.Unmarshal(out, &obj); err != nil { + t.Fatalf("decode out: %v", err) + } + if got := budgetOf(obj); got != 65536 { + t.Fatalf("max_tokens=%d want 65536(不动)", got) + } +} diff --git a/internal/upstream/payload.go b/internal/upstream/payload.go index 635f62e0c0d105f22ef53cedf7000eb53e6503cf..d974d1f5b272b204a1bcd4d48322490186c348a9 100644 --- a/internal/upstream/payload.go +++ b/internal/upstream/payload.go @@ -1,439 +1,790 @@ -// payload.go 改写发往上游的 chat 请求体: -// 1. 强制 stream:true(上游拒绝非流式) -// 2. tool_choice 归一化(上游该字段是 string,对象形式会 400 code=11101) -// 3. image_url 归一化(上游只认 OpenAI 对象形态,字符串会 400 code=11101) -package upstream - -import ( - "encoding/json" - "log" - "strings" -) - -// PrepareBodyOpt 单 pass 改写;sanitize=false 时行为完全还原(仅强制 stream + 归一化 tool_choice)。 -func PrepareBodyOpt(src []byte, sanitize bool) []byte { - return PrepareBodyOptWithEffortsAndDefault(src, sanitize, nil, nil) -} - -// PrepareBodyOptWithEfforts 在 PrepareBodyOpt 基础上按模型 supportedEfforts 降级 reasoning_effort: -// 仅当请求显式携带且模型不支持该档位时,改为 ≤请求档位的最高支持档;支持档全部高于请求档时取最低档; -// 未知模型/未知档位/未携带该字段一律透传。efforts 为 nil 表示未知(不降级)。 -// -// 向后兼容封装:不传 defaultEfforts(无模型声明默认档),thinking.go 回退硬编码 high。 -func PrepareBodyOptWithEfforts(src []byte, sanitize bool, efforts map[string][]string) []byte { - return PrepareBodyOptWithEffortsAndDefault(src, sanitize, efforts, nil) -} - -// PrepareBodyOptWithEffortsAndDefault 完整管线:efforts 降级 + thinking.go 按 -// defaultEfforts(模型声明默认档)补档。defaultEfforts 为 nil 时与旧行为一致 -// (deepseek 缺档回退硬编码 high)。 -func PrepareBodyOptWithEffortsAndDefault(src []byte, sanitize bool, efforts map[string][]string, defaultEfforts map[string]string) []byte { - if len(src) == 0 { - return src - } - var obj map[string]any - if err := json.Unmarshal(src, &obj); err != nil { - return src - } - obj["stream"] = true - // max_completion_tokens → max_tokens 翻译(吸收上游 PR #116,Closes #117): - // OpenAI 规范里 max_tokens 已 deprecated、max_completion_tokens 是新字段; - // DeepSeek Harness 等新客户端只发别名。WorkBuddy 上游(CN /v2 与 global - // /console 同源)只认 max_tokens——别名透传会被上游忽略后回落默认输出上限 - // (实测 32000),长流任务被截。 - translateMaxCompletionTokens(obj) - clampGPTMinMaxTokens(obj) - // stream_options 仅当 body 未显式带时补 {include_usage: true}(D7): - // 官方 CLI 流式必发该字段,上游据此在末帧返回 usage 用量;显式带则不覆盖。 - if _, has := obj["stream_options"]; !has { - obj["stream_options"] = map[string]any{"include_usage": true} - } - normalizeToolChoice(obj) - normalizeToolPatterns(obj) - normalizeRoles(obj) - normalizeImageURL(obj) - // tool 配对三步(见 tool_pairing.go):先合并再重排再清理。所有模型一律执行(独立于 - // deepseek-only 的 sanitize 开关)。这是「让请求通过」的安全网——不完整配对的 - // tool_calls/tool 结果会让上游对之后每条消息都返 400,必须先行剔除; - // 插在结果中间的非 tool 消息(Codex image_resize_notice)同样判配对断裂, - // 先 repack 挪后,再 cleanup 删孤儿,两侧同口径。 - // - // 顺序不能换:mergeAdjacentToolCalls 必须最先跑——它把「背靠背的两条 - // assistant.tool_calls」合成一条(部分 agent 客户端回放并行调用的报文形状),是上游 - // deepseek 系模型 11148 的正面修复;先合并再 repack,repack 才看得到完整的一批调用。 - if msgs, ok := obj["messages"].([]any); ok { - msgs, _ = mergeAdjacentToolCalls(msgs) - msgs, _ = repackToolResultBlocks(msgs) - msgs, _ = cleanupOrphanToolCalls(msgs) - // 无改动时两步都返回原 slice,这里回写等于零操作;任一步重排/删除 - // (哪怕后续步骤零改动)也必须落到 obj——不能只在「最后一步改动」时回写, - // 否则 repack 单独生效的结果会被原 slice 覆盖丢失。 - obj["messages"] = msgs - } - // DeepSeek 思维链开关(见 thinking.go):注入 thinking.type=enabled + 缺档补默认档。 - // 先于 normalizeReasoningEffort 执行:补入的默认档也要走既有降级管线, - // 模型不支持默认档时自动落到 ≤ 默认档的最高支持档(不出站不合规档位)。 - modelName, _ := obj["model"].(string) - injectThinking(obj, lookupDefaultEffort(defaultEfforts, modelName)) - normalizeReasoningEffort(obj, efforts) - // DeepSeek 多轮一致性:assistant 消息带 reasoning 痕迹时回填 reasoning_content - // (requiresReasoningContentOnAssistantMessages,见 thinking.go)。 - backfillReasoningContent(obj) - if sanitize { - if msgs, ok := obj["messages"].([]any); ok { - sanitizeMessages(msgs) - } - } - out, err := json.Marshal(obj) - if err != nil { - return src - } - return out -} - -// translateMaxCompletionTokens 把 OpenAI 别名 max_completion_tokens 翻译为上游 -// 认的 max_tokens(吸收上游 PR #116)。规则:显式 max_tokens 优先(别名只删); -// 别名非正数值(0/null/负数)不翻译(0/null 语义是「未设置」,负数是非法值, -// 翻译等于把垃圾搬进 max_tokens);非数值别名(字符串等畸形)不翻译(原样 -// 透传由上游报 11101 参数错)。两域同口径:CN /v2 与 global /console 是同一套 -// API,翻译不分 realm。 -func translateMaxCompletionTokens(obj map[string]any) { - alias, has := obj["max_completion_tokens"] - delete(obj, "max_completion_tokens") // 无论翻译与否,别名一律删(减少 body 体积与排障噪音) - if !has { - return - } - if _, explicit := obj["max_tokens"]; explicit { - return // 显式 max_tokens 优先:别名只删不译 - } - // json.Unmarshal 数字 → float64(整数去整后回写,避免 1.28e5 科学计数法/小数 - // 尾巴进上游 body);其他数值类型防御性兼容(int 家族——手构造 map 的调用方)。 - switch v := alias.(type) { - case float64: - if v > 0 && v == float64(int64(v)) { - obj["max_tokens"] = int64(v) - } - case int64: - if v > 0 { - obj["max_tokens"] = v - } - case int: - if v > 0 { - obj["max_tokens"] = int64(v) - } - } -} - -// gptMinMaxTokens GPT 系上游接受的 max_tokens 下限。 -const gptMinMaxTokens = 16 - -// clampGPTMinMaxTokens 把 GPT 系模型过小的 max_tokens 抬到下限。 -// -// 背景:上游 GPT 系(实测 gpt-6-sol / gpt-6-luna / gpt-5.6-sol)对 max_tokens < 16 -// 一律 400 code=11133 model_param_invalid(15 拒、16 过,同号同 body 对照);hy4 等 -// 非 GPT 模型无此限制。Claude Code 切模型时发 max_tokens 极小的探针,全号轮转同样 -// 被拒 → 客户端 503,模型永远切不过去。账号与 body 其余部分无关,换号无用,只能 -// 在发送前修。抬到下限只放宽输出上限、不改语义;未携带字段 / 非数值 / 已达下限一律不动。 -func clampGPTMinMaxTokens(obj map[string]any) { - model, _ := obj["model"].(string) - if !strings.Contains(strings.ToLower(model), "gpt-") { - return - } - var v int64 - switch n := obj["max_tokens"].(type) { - case float64: - v = int64(n) - case int64: - v = n - case int: - v = int64(n) - default: - return - } - if v < gptMinMaxTokens { - obj["max_tokens"] = int64(gptMinMaxTokens) - log.Printf("max_tokens clamped model=%s %d -> %d", model, v, gptMinMaxTokens) - } -} - -// effortRank 档位从低到高。 -var effortRank = map[string]int{"off": 0, "minimal": 1, "low": 2, "medium": 3, "high": 4, "xhigh": 5, "max": 6} - -// normalizeReasoningEffort 按模型 supportedEfforts 降级 reasoning_effort(snake/camel 双字段兼容)。 -// - 请求档位模型支持 → 原样透传 -// - 请求档位不支持 → 改为 ≤请求档位的最高支持档(降级) -// - 支持档全部高于请求档 → 取最低支持档(偏离最小) -// - 未知模型/未知档位/未携带字段/模型未缓存 → 一律透传 -func normalizeReasoningEffort(obj map[string]any, efforts map[string][]string) { - if len(efforts) == 0 { - return - } - model, _ := obj["model"].(string) - if model == "" { - return - } - supported, ok := efforts[model] - if !ok || len(supported) == 0 { - return - } - key := "" - if _, present := obj["reasoning_effort"]; present { - key = "reasoning_effort" - } else if _, present := obj["reasoningEffort"]; present { - key = "reasoningEffort" - } else { - return - } - reqStr, ok := obj[key].(string) - if !ok { - return - } - reqStr = strings.TrimSpace(strings.ToLower(reqStr)) - reqIdx, known := effortRank[reqStr] - if !known { - return - } - // 在 ≤请求档位的支持档里选最高档;命中且与请求不同才改写。 - best, bestIdx := "", -1 - for _, s := range supported { - idx, k := effortRank[strings.TrimSpace(strings.ToLower(s))] - if k && idx <= reqIdx && idx > bestIdx { - best, bestIdx = s, idx - } - } - if best != "" { - if !strings.EqualFold(best, reqStr) { - obj[key] = best - log.Printf("reasoning_effort downgraded model=%s %s -> %s", model, reqStr, best) - } - return - } - // 支持档全部高于请求档:取最低支持档。 - lowest, lowestIdx := "", 1<<30 - for _, s := range supported { - idx, k := effortRank[strings.TrimSpace(strings.ToLower(s))] - if k && idx < lowestIdx { - lowest, lowestIdx = s, idx - } - } - if lowest != "" { - obj[key] = lowest - log.Printf("reasoning_effort floored model=%s %s -> %s", model, reqStr, lowest) - } -} - -// normalizeRoles 把 messages 里的 developer 角色归一为 system。 -// -// 背景:上游对 messages 的 role 字段做白名单校验,developer 不在白名单内, -// 命中即 HTTP 400 code=11128。developer 是 OpenAI 新规范里 system 的别名 -// (Codex / Cursor 等新客户端用它承载 system 级指令),改写为 system 不丢语义。 -// -// 此归一化是「协议兼容」(补上游 role 白名单),不是「内容脱敏」, -// 因此有意与 SanitizeFingerprints / sanitize 参数解耦:即使 sanitize=false 也照常归一。 -// -// 只认 developer 这一个值:其余 role(system/user/assistant/tool/任意未知值)一律原样保留, -// 不合并、不重排、不删除任何消息(上游对多 system 的行为尚未实测,合并会引入新变量)。 -func normalizeRoles(obj map[string]any) { - msgs, ok := obj["messages"].([]any) - if !ok { - return - } - for i, m := range msgs { - msg, ok := m.(map[string]any) - if !ok { - continue - } - role, ok := msg["role"].(string) - if !ok { - continue - } - if strings.EqualFold(strings.TrimSpace(role), "developer") { - msg["role"] = "system" - log.Printf("role normalized developer->system idx=%d", i) - } - } -} - -// normalizeImageURL 兼容 OpenAI chat 多模态内容的两种 image_url 写法。 -// -// OpenAI Chat Completions 规范使用对象形态 {"url":"...","detail":"..."}, -// 部分客户端(以及 Responses -> Chat 转换器)会发送字符串形态 "data:..." 或 -// "https://..."。WorkBuddy 上游只接受对象形态,字符串会返回 400 code=11101 -// "cannot unmarshal string into ... ImageContent"。 -// -// 这里只做形状转换:字符串转 {"url": 原值};已有对象及其中 url/detail/mime_type -// 原样保留;空字符串、缺失值、对象内非法 url 一律不补默认值,让上游返回真实错误。 -func normalizeImageURL(obj map[string]any) { - msgs, ok := obj["messages"].([]any) - if !ok { - return - } - for _, rawMsg := range msgs { - msg, ok := rawMsg.(map[string]any) - if !ok { - continue - } - parts, ok := msg["content"].([]any) - if !ok { - continue - } - for _, rawPart := range parts { - part, ok := rawPart.(map[string]any) - if !ok || part["type"] != "image_url" { - continue - } - imageURL, ok := part["image_url"].(string) - if !ok || imageURL == "" { - continue - } - part["image_url"] = map[string]any{"url": imageURL} - } - } -} - -// ensureConsoleSystem global realm 兜底 system 注入(吸收 PR #45,防 console 域上游 code 11-128): -// 首条消息非 system 时在 messages 最前补一条 fallback system("You are a helpful assistant.")。 -// 仅对 global 请求调用(CN 现状不动;即使首条就是 system 也不重复注入)。 -// body 不可解析时原样返回(与 prepareBody 语义一致:坏 body 不在这里二次错误化)。 -func ensureConsoleSystem(body []byte) []byte { - if len(body) == 0 { - return body - } - var obj map[string]any - if err := json.Unmarshal(body, &obj); err != nil { - return body - } - msgs, ok := obj["messages"].([]any) - if !ok || len(msgs) == 0 { - return body - } - first, ok := msgs[0].(map[string]any) - if ok { - if role, _ := first["role"].(string); strings.EqualFold(strings.TrimSpace(role), "system") { - return body // 首条已是 system:不注入 - } - } - obj["messages"] = append([]any{map[string]any{"role": "system", "content": "You are a helpful assistant."}}, msgs...) - out, err := json.Marshal(obj) - if err != nil { - return body - } - return out -} - -// normalizeToolChoice 按上游 Go struct(string 类型)改写 OpenAI tool_choice。 -// - "none" → 删 tool_choice + 删 tools/functions -// - {"type":"none"} → 同上 -// - {"type":"auto"/"required"} → 字符串 "auto"/"required" -// - {"type":"function","function":{"name":"x"}} → 字符串 "x" -// - 其他对象/非标量 → 删 tool_choice -func normalizeToolChoice(obj map[string]any) { - suppress := func() { - delete(obj, "tools") - delete(obj, "functions") - } - tc, present := obj["tool_choice"] - if !present { - return - } - switch v := tc.(type) { - case string: - if strings.EqualFold(strings.TrimSpace(v), "none") { - delete(obj, "tool_choice") - suppress() - } - case map[string]any: - typ, _ := v["type"].(string) - typ = strings.ToLower(strings.TrimSpace(typ)) - switch typ { - case "none": - delete(obj, "tool_choice") - suppress() - case "auto", "required": - obj["tool_choice"] = typ - case "function": - name := "" - if fn, ok := v["function"].(map[string]any); ok { - name, _ = fn["name"].(string) - } - if name == "" { - name, _ = v["name"].(string) - } - if name = strings.TrimSpace(name); name != "" { - obj["tool_choice"] = name - } else { - obj["tool_choice"] = "auto" - } - default: - delete(obj, "tool_choice") - } - default: - delete(obj, "tool_choice") - } -} - -// normalizeToolPatterns 归一化 tools 子树里 pattern 的非标准转义 `\_`(→ `_`)。 -// -// 上游对 tools[].function.parameters 做严格 JSON Schema/正则文法校验,pattern 含 -// `\_`(转义的字面量下划线)会整体拒收:400 code=11129 invalid_function_call_ -// parameters(displayMsg「工具定义不合规」)。`\_` 不是任何正则文法的合法转义, -// 但所有主流引擎(RE2/PCRE/JS Annex B)都宽容地视为 `_` 本身——上游校验器比它们 -// 全部更严(对照 V8 严格文法 u 标志,唯一同样拒绝的实现)。实案:ZCode 的 exa 插件 -// agent_run 工具 runId/previousRunId 带 `^agent\_run\_`,deepseek 系全家确定性 400 -// → 网关侧归 ErrClient 只换号不罚但喂连败计数 → 轮转烧满 5 连败触发连败降权、 -// 客户端 503(2026-09-29/30 两次实案)。schema 级拒绝换账号无用,只能在发送前修。 -// -// 归一无损:`\_` 与 `_` 在所有引擎匹配语义相同(各引擎实测 + 上游对照探针:归一后 -// 200),工具方功能不变。只动 tools 子树(pattern 值 + patternProperties 键); -// 消息正文里的 `\_`(如 Windows 路径 C:\_x)不碰。其余非标转义(`\:` 等)未证实 -// 触发,不扩面——有实案再议。独立于 sanitize 开关:这是「让请求通过」,不是脱敏。 -func normalizeToolPatterns(obj map[string]any) { - rawTools, ok := obj["tools"].([]any) - if !ok { - return - } - for _, raw := range rawTools { - tool, ok := raw.(map[string]any) - if !ok { - continue - } - // OpenAI 形态 tools[].function.parameters;裸 tools[].parameters 兼容。 - if fn, ok := tool["function"].(map[string]any); ok { - unescapePatternLiteralEscapes(fn["parameters"]) - } - unescapePatternLiteralEscapes(tool["parameters"]) - } -} - -// unescapePatternLiteralEscapes 递归改写 schema 树里 pattern 值与 patternProperties -// 键中的 `\_` → `_`(patternProperties 的键也是正则;map 键不可原地改,命中时重建 -// 该层)。 -func unescapePatternLiteralEscapes(node any) { - switch n := node.(type) { - case map[string]any: - if p, ok := n["pattern"].(string); ok && strings.Contains(p, `\_`) { - n["pattern"] = strings.ReplaceAll(p, `\_`, `_`) - } - if props, ok := n["patternProperties"].(map[string]any); ok { - rebuilt := false - fixed := make(map[string]any, len(props)) - for k, v := range props { - if strings.Contains(k, `\_`) { - k = strings.ReplaceAll(k, `\_`, `_`) - rebuilt = true - } - fixed[k] = v - } - if rebuilt { - n["patternProperties"] = fixed - } - } - for _, v := range n { - unescapePatternLiteralEscapes(v) - } - case []any: - for _, v := range n { - unescapePatternLiteralEscapes(v) - } - } -} +// payload.go 改写发往上游的 chat 请求体: +// 1. 强制 stream:true(上游拒绝非流式) +// 2. tool_choice 归一化(上游该字段是 string,对象形式会 400 code=11101) +// 3. image_url 归一化(上游只认 OpenAI 对象形态,字符串会 400 code=11101) +package upstream + +import ( + "encoding/json" + "log" + "math" + "strings" + "sync/atomic" +) + +// PrepareBodyOpt 单 pass 改写;sanitize=false 时行为完全还原(仅强制 stream + 归一化 tool_choice)。 +func PrepareBodyOpt(src []byte, sanitize bool) []byte { + return PrepareBodyOptWithEffortsAndDefault(src, sanitize, nil, nil) +} + +// PrepareBodyOptWithEfforts 在 PrepareBodyOpt 基础上把 reasoning_effort 对齐到模型支持的档位: +// 仅当请求显式携带且模型不支持该档位时,改为**最近**的支持档(同距优先模型默认档,其次偏高); +// 未知模型/未知档位/未携带该字段一律透传。efforts 为 nil 表示未知(不改写)。 +// +// 向后兼容封装:不传 defaultEfforts(无模型声明默认档),thinking.go 回退硬编码 high。 +func PrepareBodyOptWithEfforts(src []byte, sanitize bool, efforts map[string][]string) []byte { + return PrepareBodyOptWithEffortsAndDefault(src, sanitize, efforts, nil) +} + +// PrepareBodyOptWithEffortsAndDefault 完整管线:efforts 降级 + thinking.go 按 +// defaultEfforts(模型声明默认档)补档。defaultEfforts 为 nil 时与旧行为一致 +// (deepseek 缺档回退硬编码 high)。 +func PrepareBodyOptWithEffortsAndDefault(src []byte, sanitize bool, efforts map[string][]string, defaultEfforts map[string]string) []byte { + body, _ := PrepareBodyOptWithEffortsDefaultAndCaps(src, sanitize, efforts, defaultEfforts, nil) + return body +} + +// prepareBodyParses 记录 prepareBodyOpt 对请求体的整树解析次数(观测/回归用)。 +// 每个 chat 请求在这里只应解析一次:会话键、首条 role、kimi 工具、会话字段 +// 注入都已各自走零分配扫描或并入本次解析。 +var prepareBodyParses atomic.Int64 + +// PrepareBodyParseCount 返回累计整树解析次数(供测试与面板观测)。 +func PrepareBodyParseCount() int64 { return prepareBodyParses.Load() } + +// ResetPrepareBodyParseCount 归零计数(供测试)。 +func ResetPrepareBodyParseCount() { prepareBodyParses.Store(0) } + +// SplitRealmPrefix 解析网关的 realm 前缀协议("[realm:]model"): +// 取第一个 ":",前段恰为 "cn"/"global" 才剥离;否则视为裸名,realm 回落 "cn"。 +// 大小写敏感(前缀必须是精确的小写枚举)。server.resolveModel 委托本函数, +// 保证选号、粘性、出站重写三处口径一致。 +func SplitRealmPrefix(model string) (realm, bare string) { + if i := strings.IndexByte(model, ':'); i >= 0 { + switch model[:i] { + case "cn", "global": + return model[:i], model[i+1:] + } + } + return "cn", model +} + +// normalizeModelName 把出站 model 剥成裸名:上游只认裸名,realm 前缀是网关侧 +// 路由协议。model 缺失或非字符串时保持原样(不二次错误化坏 body)。 +func normalizeModelName(obj map[string]any) { + cur, ok := obj["model"].(string) + if !ok { + return + } + if _, bare := SplitRealmPrefix(cur); bare != cur { + obj["model"] = bare + } +} + +// PrepareBodyOptWithEffortsDefaultAndCaps 在 …AndDefault 之上接入模型输出上限快照: +// 无显式限额的请求按目录动态值补 max_tokens(见 injectCatalogMaxTokens)。 +// maxOut 为 nil 时行为与 …AndDefault 完全一致。 +// 返回改写后的请求体与本次**实际生效**的思考档位(未携带该字段/未知模型/未知档位 → "")。 +// +// 导出入口不注入 prompt_cache_key(保持既有公开语义);生产路径由 +// client.prepareBody 调用 prepareBodyOpt 并传入 cache 参数。 +func PrepareBodyOptWithEffortsDefaultAndCaps(src []byte, sanitize bool, efforts map[string][]string, defaultEfforts map[string]string, maxOut map[string]int64) ([]byte, string) { + body, _, eff := prepareBodyOpt(src, sanitize, true, efforts, defaultEfforts, maxOut, "", nil, "", "", false, 0, "") + return body, eff +} + +// PrepareBodyOptWithEffortPolicy 在 …Caps 之上接入网关思考档位策略(config +// thinking 节):客户端缺档补网关默认档;client_priority=false 时按网关档位 +// 改写客户端显式档(override_scope 控制是否连「关闭思考」一起改写)。 +// realm 用于 thinking.model_defaults 的 "realm:model" 精确匹配;policy 为 nil +// 或未启用时与 …Caps 完全一致。 +func PrepareBodyOptWithEffortPolicy(src []byte, sanitize bool, efforts map[string][]string, defaultEfforts map[string]string, maxOut map[string]int64, realm string, policy *EffortPolicy) ([]byte, string) { + body, _, eff := prepareBodyOpt(src, sanitize, true, efforts, defaultEfforts, maxOut, realm, policy, "", "", false, 0, "") + return body, eff +} + +// prepareBodyOpt 是完整管线:injectCache=true 时在同一次 map 解析里注入 +// prompt_cache_key(优先级见 promptCacheKeyFor),避免二次 Unmarshal/Marshal。 +// +// 返回 (改写后请求体, 客户端原始请求档位, 本次实际生效档位): +// - requested 在 injectThinking 之前抓取,因此不含网关补的默认档——它回答 +// 「客户端到底发没发、发的哪一档」(issue #43/#18 的判别依据); +// - effective 是降级后的出站档位,未携带/未知模型/未知档位 → ""。 +func prepareBodyOpt(src []byte, sanitize, brandGlobal bool, efforts map[string][]string, defaultEfforts map[string]string, maxOut map[string]int64, realm string, policy *EffortPolicy, cacheUID, cacheConversation string, injectCache bool, keepRounds int, convReqID string) ([]byte, string, string) { + if len(src) == 0 { + return src, "", "" + } + prepareBodyParses.Add(1) + var obj map[string]any + if err := json.Unmarshal(src, &obj); err != nil { + return src, "", "" + } + // 先剥 realm 前缀:后续 injectCatalogMaxTokens / clampGPTMinMaxTokens / + // injectThinking / normalizeReasoningEffort 都按裸模型名查表,晚一步就会查空。 + normalizeModelName(obj) + obj["stream"] = true + // max_completion_tokens → max_tokens 翻译(吸收上游 PR #116,Closes #117): + // OpenAI 规范里 max_tokens 已 deprecated、max_completion_tokens 是新字段; + // DeepSeek Harness 等新客户端只发别名。WorkBuddy 上游(CN /v2 与 global + // /console 同源)只认 max_tokens——别名透传会被上游忽略后回落默认输出上限 + // (实测 32000),长流任务被截。 + translateMaxCompletionTokens(obj) + // GPT 系过小的 max_tokens 抬到上游下限(吸收上游 fd3e142): + // Claude Code 切模型时发的探针 max_tokens 极小,上游 GPT 系对 <16 一律 + // 400 code=11133,全号轮转同样被拒 → 客户端永远切不过去。 + clampGPTMinMaxTokens(obj) + // 目录动态值补默认输出上限(同 PR #116 的另一个缺口:多数客户端连别名都 + // 不发——Codex 实测不带任何限额字段,被上游默认 32000 截断)。 + injectCatalogMaxTokens(obj, maxOut) + // stream_options 仅当 body 未显式带时补 {include_usage: true}(D7): + // 官方 CLI 流式必发该字段,上游据此在末帧返回 usage 用量;显式带则不覆盖。 + if _, has := obj["stream_options"]; !has { + obj["stream_options"] = map[string]any{"include_usage": true} + } + normalizeToolChoice(obj) + normalizeToolPatterns(obj) + normalizeRoles(obj) + normalizeImageURL(obj) + normalizeStop(obj) + dropReasoningContentParts(obj) + // 历史裁剪先于 tool 配对:cut 落在整轮边界上,不会切出半个 tool 配对; + // 万一客户端自己的历史本来就断了,后面两步照样兜底。 + trimHistory(obj, keepRounds) + // tool 配对两步(见 tool_pairing.go):先重排再清理。所有模型一律执行(独立于 + // deepseek-only 的 sanitize 开关)。这是「让请求通过」的安全网——不完整配对的 + // tool_calls/tool 结果会让上游对之后每条消息都返 400,必须先行剔除; + // 插在结果中间的非 tool 消息(Codex image_resize_notice)同样判配对断裂, + // 先 repack 挪后,再 cleanup 删孤儿,两侧同口径。 + if msgs, ok := obj["messages"].([]any); ok { + msgs, _ = repackToolResultBlocks(msgs) + msgs, _ = cleanupOrphanToolCalls(msgs) + // 无改动时两步都返回原 slice,这里回写等于零操作;任一步重排/删除 + // (哪怕后续步骤零改动)也必须落到 obj——不能只在「最后一步改动」时回写, + // 否则 repack 单独生效的结果会被原 slice 覆盖丢失。 + obj["messages"] = msgs + } + // DeepSeek 思维链开关(见 thinking.go):注入 thinking.type=enabled + 缺档补默认档。 + // requested 必须在 injectThinking 之前抓:它要回答的是「客户端发了什么」, + // 而 injectThinking 会给缺档的请求补默认档——补完之后两者就再也分不开了 + // (issue #43:客户端设 max、日志显示 high,读者无法判断是「没收到 max」 + // 还是「收到了但降级」,这一列必须能自证)。 + requested := requestedEffort(obj) + modelName, _ := obj["model"].(string) + // 网关思考档位策略(见 effort_policy.go)同样先于 injectThinking: + // override_scope=all 要把客户端的 off/disabled 改写成「开启 + 目标档」, + // 晚一步就会被 injectThinking 写成 thinking.type=disabled 并删掉档位。 + // client_priority=true 时这里只在「客户端没发档位」时补默认档。 + policyEffort := applyEffortPolicy(obj, modelName, efforts[modelName], policy, realm) + // DeepSeek 思维链开关(见 thinking.go):注入 thinking.type=enabled + 缺档补默认档。 + // 先于 normalizeReasoningEffort 执行:补入的默认档也要走既有降级管线, + // 模型不支持默认档时自动落到 ≤ 默认档的最高支持档(不出站不合规档位)。 + injectThinking(obj, lookupDefaultEffort(defaultEfforts, modelName)) + effort := normalizeReasoningEffort(obj, efforts, defaultEfforts) + if policyEffort != "" { + // 网关写入的目标档已是「解析到支持列表」的结果;降级管线不会再改它, + // 但 effective 以实际写入值为准(off/disabled 被改写的场景 normalize + // 也可能返回空)。 + effort = policyEffort + } + // 输出预算下限(见 output_budget.go):客户端既要高档位思考、又把 max_tokens + // 给得比「这一档的思考都装不下」还小的时候,抬到该档的下限。抬的是上限不是 + // 目标长度——模型写完了照样停,只是不再被思考挤掉正文。 + ensureMinOutputBudget(obj, effort, maxOut) + // DeepSeek 多轮一致性:assistant 消息带 reasoning 痕迹时回填 reasoning_content + // (requiresReasoningContentOnAssistantMessages,见 thinking.go)。 + backfillReasoningContent(obj) + // 出站前最后一道形状检查,两条都是「不可自愈的 400」: + // - 空 text 段(11151):客户端重试只会重放同一段历史,换号也救不回来; + // - reasoning 镜像:Kimi/GLM/MiniMax 等按 `reasoning` 读历史,只看 + // reasoning_content 的话它们的多轮一致性校验会挂。 + // 位置必须在 repack/cleanup 之后:那两步会把字符串 content 挪到别的消息上, + // 先补位再挪动等于漏掉被挪过去的那一段。 + if msgs, ok := obj["messages"].([]any); ok { + guardEmptyTextParts(msgs) + } + mirrorUpstreamReasoning(obj) + if sanitize { + if msgs, ok := obj["messages"].([]any); ok { + sanitizeMessages(msgs, brandGlobal) + } + // tools 是客户端自带的能力声明,描述由客户端作者撰写,同样会带身份句 + // (上游 issue:只洗 messages 时整段工具描述原样出站)。issue #395 同类。 + sanitizeTools(obj["tools"], brandGlobal) + } + // 会话轮级字段(issue #51):本轮已解析好的 map 就地补,与本函数的序列化合并; + // 旧实现是在 prepared body 上再 Unmarshal+Marshal 一次(100~500KB 的整树往返)。 + injectConversationFieldsObj(obj, convReqID) + // prompt_cache_key:与 body 改写共用同一次 map,避免再 Unmarshal/Marshal 一遍。 + if injectCache { + if key, ok := promptCacheKeyFor(obj, cacheUID, cacheConversation); ok { + obj["prompt_cache_key"] = key + } + } + out, err := json.Marshal(obj) + if err != nil { + return src, requested, effort + } + return out, requested, effort +} + +// trimHistory 只保留最近 keep 轮对话(issue #99):一轮 = 一条 user 消息,连同其后 +// 的 assistant/tool 回复。更早的整轮丢弃——长会话的输入 token 几乎全在这里。 +// +// 三条约束: +// - system 消息一条不删。它们是协议与人格,删了上游要么 400 11-128 要么人格丢失; +// cut 之前出现的 system 也提到前面保留(客户端把 system 插在中间的情况)。 +// - cut 只落在 user 下标上,所以保留段开头永远不是 tool 结果——不会切出半个 +// tool 配对(配不成对的上游直接 400)。客户端自己断掉的历史仍由后面的 +// repack/cleanup 兜底。 +// - keep <= 0 时不动 body(默认关闭,与没有这个功能完全一致)。 +func trimHistory(obj map[string]any, keep int) { + if keep <= 0 { + return + } + msgs, ok := obj["messages"].([]any) + if !ok { + return + } + users := make([]int, 0, 8) + for i, m := range msgs { + if mm, ok := m.(map[string]any); ok && mm["role"] == "user" { + users = append(users, i) + } + } + if len(users) <= keep { + return + } + cut := users[len(users)-keep] + kept := make([]any, 0, len(msgs)-cut+4) + for _, m := range msgs[:cut] { + if mm, ok := m.(map[string]any); ok && mm["role"] == "system" { + kept = append(kept, m) + } + } + obj["messages"] = append(kept, msgs[cut:]...) +} + +// translateMaxCompletionTokens 把 OpenAI 别名 max_completion_tokens 翻译为上游 +// 认的 max_tokens(吸收上游 PR #116)。规则:显式 max_tokens 优先(别名只删); +// 别名非正数值(0/null/负数)不翻译(0/null 语义是「未设置」,负数是非法值, +// 翻译等于把垃圾搬进 max_tokens);非数值别名(字符串等畸形)不翻译(原样 +// 透传由上游报 11101 参数错)。两域同口径:CN /v2 与 global /console 是同一套 +// API,翻译不分 realm。 +func translateMaxCompletionTokens(obj map[string]any) { + alias, has := obj["max_completion_tokens"] + delete(obj, "max_completion_tokens") // 无论翻译与否,别名一律删(减少 body 体积与排障噪音) + if !has { + return + } + if _, explicit := obj["max_tokens"]; explicit { + return // 显式 max_tokens 优先:别名只删不译 + } + // json.Unmarshal 数字 → float64(整数去整后回写,避免 1.28e5 科学计数法/小数 + // 尾巴进上游 body);其他数值类型防御性兼容(int 家族——手构造 map 的调用方)。 + switch v := alias.(type) { + case float64: + if v > 0 && v == float64(int64(v)) { + obj["max_tokens"] = int64(v) + } + case int64: + if v > 0 { + obj["max_tokens"] = v + } + case int: + if v > 0 { + obj["max_tokens"] = int64(v) + } + } +} + +// gptMinMaxTokens GPT 系上游接受的 max_tokens 下限。 +const gptMinMaxTokens = 16 + +// clampGPTMinMaxTokens 把 GPT 系模型过小的 max_tokens 抬到下限(吸收上游 fd3e142)。 +// +// 背景:上游 GPT 系(实测 gpt-6-sol / gpt-6-luna / gpt-5.6-sol)对 max_tokens < 16 +// 一律 400 code=11133 model_param_invalid(15 拒、16 过,同号同 body 对照);hy4 等 +// 非 GPT 模型无此限制。Claude Code 切模型时发 max_tokens 极小的探针,全号轮转同样 +// 被拒 → 客户端 503,模型永远切不过去。账号与 body 其余部分无关,换号无用,只能 +// 在发送前修。抬到下限只放宽输出上限、不改语义;未携带字段 / 非数值 / 已达下限一律 +// 不动。判据用 id 含 "gpt-"(realm 前缀 global:gpt-… 同时命中)。 +func clampGPTMinMaxTokens(obj map[string]any) { + model, _ := obj["model"].(string) + if !strings.Contains(strings.ToLower(model), "gpt-") { + return + } + var v int64 + switch n := obj["max_tokens"].(type) { + case float64: + v = int64(n) + case int64: + v = n + case int: + v = int64(n) + default: + return + } + if v < gptMinMaxTokens { + obj["max_tokens"] = int64(gptMinMaxTokens) + log.Printf("max_tokens clamped model=%s %d -> %d", model, v, gptMinMaxTokens) + } +} + +// injectCatalogMaxTokens 无显式输出限额时,按模型目录动态声明的 maxOutputTokens +// 补 max_tokens。上游对缺失限额的请求套保守默认(实测 32000),而目录声明值才是 +// 模型真实预算(如 cn:deepseek-v4.1-flash 393216)——Codex 这类不发限额字段的 +// 客户端写大文件会在 32000 处被无声截断(长流任务被切)。显式限额(含别名翻译 +// 产物)优先,不覆盖;模型未知/目录无值不补(不编造)。 +func injectCatalogMaxTokens(obj map[string]any, maxOut map[string]int64) { + if len(maxOut) == 0 { + return + } + if _, has := obj["max_tokens"]; has { + return + } + model, _ := obj["model"].(string) + if v, ok := maxOut[model]; ok && v > 0 { + obj["max_tokens"] = v + } +} + +// effortRank 档位从低到高。 +var effortRank = map[string]int{"off": 0, "minimal": 1, "low": 2, "medium": 3, "high": 4, "xhigh": 5, "max": 6} + +// requestedEffort 读取客户端原始请求的思考档位(snake 优先,camel 兜底), +// 未携带或非字符串 → ""。与 normalizeReasoningEffort 的取值口径一致, +// 但**不**做降级、不补默认档:它只回答「客户端发了什么」。 +// +// 为什么单独留一列:网关对 deepseek 缺档请求会补默认档(thinking.go), +// 之后 requested 与 effective 就再也分不开——日志只报 effective 时, +// 「客户端设了 max、日志却是 high」无法判断是客户端没发出去,还是被降级了 +// (issue #43 / #18)。 +func requestedEffort(obj map[string]any) string { + for _, k := range []string{"reasoning_effort", "reasoningEffort"} { + if v, ok := obj[k].(string); ok { + if s := strings.TrimSpace(strings.ToLower(v)); s != "" { + return s + } + } + } + return "" +} + +// normalizeReasoningEffort 把请求档位对齐到模型支持的档位(snake/camel 双字段兼容), +// 返回本次最终生效的档位(未携带字段/未知模型/未知档位/模型未缓存 → "")。 +// - 请求档位模型支持 → 原样透传 +// - 不支持 → 取**最近**的支持档;距离相同优先模型声明的默认档,其次偏高的一档 +// - 未知模型/未知档位/未携带字段/模型未缓存 → 一律透传 +// +// 为什么不一律降级:Codex 等客户端默认发 medium,而 CN 模型常见档位是 low/high/max +// (没有 medium)——一律取「≤ 请求档的最高档」会降到 low,比**不携带该字段**时的模型 +// 默认档 high 还弱,客户端完全无感(issue #175)。 +func normalizeReasoningEffort(obj map[string]any, efforts map[string][]string, defaultEfforts map[string]string) string { + if len(efforts) == 0 { + return "" + } + model, _ := obj["model"].(string) + if model == "" { + return "" + } + // off/none 是「关闭思考」的表达,不是可降级的档位。没有模型声明 off 档位 + // (effortRank 里 rank 0 的 off 只是排序占位),不截住就会被就近降级成最弱 + // 正档——客户端要关闭,网关却给它开了最弱的思考(实测 glm 变 low)。 + // deepseek 的关闭形态由 injectThinking 写成 thinking.type=disabled。 + if effortValueOff(obj) { + delete(obj, "reasoning_effort") + delete(obj, "reasoningEffort") + return "" + } + supported, ok := efforts[model] + if !ok || len(supported) == 0 { + return "" + } + key := "" + if _, present := obj["reasoning_effort"]; present { + key = "reasoning_effort" + } else if _, present := obj["reasoningEffort"]; present { + key = "reasoningEffort" + } else { + return "" + } + reqStr, ok := obj[key].(string) + if !ok { + return "" + } + reqStr = strings.TrimSpace(strings.ToLower(reqStr)) + reqIdx, known := effortRank[reqStr] + if !known { + return "" + } + // 取最近档:距离最小;同距优先模型默认档,其次偏高的一档。 + def := strings.ToLower(strings.TrimSpace(lookupDefaultEffort(defaultEfforts, model))) + best, bestIdx, bestDist := "", -1, 1<<30 + for _, s := range supported { + idx, k := effortRank[strings.TrimSpace(strings.ToLower(s))] + if !k { + continue + } + dist := idx - reqIdx + if dist < 0 { + dist = -dist + } + if dist > bestDist { + continue + } + if dist == bestDist { + curDef := def != "" && strings.EqualFold(strings.TrimSpace(s), def) + bestDef := def != "" && strings.EqualFold(best, def) + switch { + case curDef && !bestDef: // 默认档优先 + case curDef == bestDef && idx > bestIdx: // 同距宁高 + default: + continue + } + } + best, bestIdx, bestDist = s, idx, dist + } + if best == "" { + return reqStr + } + if !strings.EqualFold(best, reqStr) { + obj[key] = best + log.Printf("reasoning_effort adjusted model=%s %s -> %s(模型支持 %s)", + model, reqStr, best, strings.Join(supported, ",")) + } + return best +} + +// normalizeRoles 把 messages 里的 developer 角色归一为 system。 +// +// 背景:上游对 messages 的 role 字段做白名单校验,developer 不在白名单内, +// 命中即 HTTP 400 code=11128。developer 是 OpenAI 新规范里 system 的别名 +// (Codex / Cursor 等新客户端用它承载 system 级指令),改写为 system 不丢语义。 +// +// 此归一化是「协议兼容」(补上游 role 白名单),不是「内容脱敏」, +// 因此有意与 SanitizeFingerprints / sanitize 参数解耦:即使 sanitize=false 也照常归一。 +// +// 只认 developer 这一个值:其余 role(system/user/assistant/tool/任意未知值)一律原样保留, +// 不合并、不重排、不删除任何消息(上游对多 system 的行为尚未实测,合并会引入新变量)。 +func normalizeRoles(obj map[string]any) { + msgs, ok := obj["messages"].([]any) + if !ok { + return + } + for i, m := range msgs { + msg, ok := m.(map[string]any) + if !ok { + continue + } + role, ok := msg["role"].(string) + if !ok { + continue + } + if strings.EqualFold(strings.TrimSpace(role), "developer") { + msg["role"] = "system" + log.Printf("role normalized developer->system idx=%d", i) + } + } +} + +// normalizeImageURL 兼容 OpenAI chat 多模态内容的两种 image_url 写法。 +// +// OpenAI Chat Completions 规范使用对象形态 {"url":"...","detail":"..."}, +// 部分客户端(以及 Responses -> Chat 转换器)会发送字符串形态 "data:..." 或 +// "https://..."。WorkBuddy 上游只接受对象形态,字符串会返回 400 code=11101 +// "cannot unmarshal string into ... ImageContent"。 +// +// 这里只做形状转换:字符串转 {"url": 原值};已有对象及其中 url/detail/mime_type +// 原样保留;空字符串、缺失值、对象内非法 url 一律不补默认值,让上游返回真实错误。 +func normalizeImageURL(obj map[string]any) { + msgs, ok := obj["messages"].([]any) + if !ok { + return + } + for _, rawMsg := range msgs { + msg, ok := rawMsg.(map[string]any) + if !ok { + continue + } + parts, ok := msg["content"].([]any) + if !ok { + continue + } + for _, rawPart := range parts { + part, ok := rawPart.(map[string]any) + if !ok || part["type"] != "image_url" { + continue + } + imageURL, ok := part["image_url"].(string) + if !ok || imageURL == "" { + continue + } + part["image_url"] = map[string]any{"url": imageURL} + } + } +} + +// normalizeStop 兼容 OpenAI chat 请求 stop 字段的两种合法写法。 +// +// OpenAI 规范允许 stop 为字符串或字符串数组(≤4 个停止词),部分客户端(SillyTavern +// 等)只发字符串形态;但上游 Go struct 把 stop 定义成 []string,字符串形态直接解码 +// 失败:400 code=11101 "cannot unmarshal string into Go struct field ***.stop of type +// []string"。网关把 11101 归 ErrBadParams(不罚号但**仍轮换**),同一 body 换任何号都 +// 必然同样 400——全池试完走末端透传,客户端看到「所有账号不可用」,与账号健康无关。 +// +// 只做形状转换:字符串 → 单元素数组。**不 TrimSpace**——停止词的前后空白是匹配语义 +// 本身("\n\nHuman:"、"\n\n" 靠前导换行触发),裁剪等于静默改写客户端意图。空串同样 +// 转 [""] 保留(不替客户端判定什么是无效值);数组 / null / 其他类型 / 字段缺失一律不动。 +func normalizeStop(obj map[string]any) { + s, ok := obj["stop"].(string) + if !ok { + return + } + obj["stop"] = []string{s} +} + +// dropReasoningContentParts 剔除 chat content 数组里的 reasoning_text / reasoning 片段 +// (吸收上游 PR #159)。 +// +// 场景:Codex 只走 /v1/responses,第三方中转的 responses→chat 转换器(如 new-api 的 +// openai_responses_to_openai_chat_completions)会把助手历史里的思考片段原样透传进 +// /v1/chat/completions;上游 content 类型白名单不含它,命中即 HTTP 400 code=11101 +// 「unsupported content type at index 0: reasoning_text」。本仓自己的 responses 入站 +// 不产这种片段(客户端回传的 reasoning item 在 convertInputItems 里就丢弃了),这条 +// 是给「链路上游还有别的转换器」兜底。 +// +// 思考片段只是模型私有推理,下游续写不需要,剔除无副作用: +// - 删除 type 为 reasoning_text / reasoning 的片段(TrimSpace 后比较) +// - 删除后 content 为空且该消息无 tool_calls → 整条消息一并删除;有 tool_calls 则保留 +// (留空数组,避免破坏工具调用配对) +func dropReasoningContentParts(obj map[string]any) { + msgs, ok := obj["messages"].([]any) + if !ok { + return + } + out := make([]any, 0, len(msgs)) + for _, rawMsg := range msgs { + msg, ok := rawMsg.(map[string]any) + if !ok { + out = append(out, rawMsg) + continue + } + parts, ok := msg["content"].([]any) + if !ok { + out = append(out, rawMsg) // 字符串 content(或字段缺失)不受影响 + continue + } + kept := make([]any, 0, len(parts)) + for _, rawPart := range parts { + part, ok := rawPart.(map[string]any) + if !ok { + kept = append(kept, rawPart) + continue + } + ptype, _ := part["type"].(string) + switch strings.TrimSpace(ptype) { + case "reasoning_text", "reasoning": + continue + } + kept = append(kept, rawPart) + } + if len(kept) == 0 { + if _, hasToolCalls := msg["tool_calls"]; !hasToolCalls { + continue // 整条只剩思考片段:删掉,否则上游会为这条空 content 报错 + } + } + msg["content"] = kept + out = append(out, rawMsg) + } + obj["messages"] = out +} + +// consoleSystemFallback 兜底 system 正文:只写行为约定,不写身份(issue #187)。 +const consoleSystemFallback = "Follow the user's instructions and respond in the user's language." + +// ensureConsoleSystem global realm 兜底 system 注入(吸收 PR #45,防 console 域上游 code 11-128): +// 首条消息非 system 时在 messages 最前补一条 fallback system。仅对 global 请求调用 +// (CN 现状不动;即使首条就是 system 也不重复注入)。 +// +// 兜底文本**不声明身份**(issue #187):上游的判据只是「首条必须是 system」,正文不参与 +// 校验;写成「You are a helpful assistant.」等于网关自己往对话里插一句身份声明,与客户端 +// harness 自带的人设并列时,模型会把它当成外部注入而拒绝执行。这里只声明行为约定, +// 不碰身份。 +// +// body 不可解析时原样返回(与 prepareBody 语义一致:坏 body 不在这里二次错误化)。 +func ensureConsoleSystem(body []byte) []byte { + if len(body) == 0 { + return body + } + var obj map[string]any + if err := json.Unmarshal(body, &obj); err != nil { + return body + } + msgs, ok := obj["messages"].([]any) + if !ok || len(msgs) == 0 { + return body + } + first, ok := msgs[0].(map[string]any) + if ok { + if role, _ := first["role"].(string); strings.EqualFold(strings.TrimSpace(role), "system") { + return body // 首条已是 system:不注入 + } + } + obj["messages"] = append([]any{map[string]any{"role": "system", "content": consoleSystemFallback}}, msgs...) + out, err := json.Marshal(obj) + if err != nil { + return body + } + return out +} + +// normalizeToolChoice 按上游 Go struct(string 类型)改写 OpenAI tool_choice。 +// - "none" → 删 tool_choice + 删 tools/functions +// - {"type":"none"} → 同上 +// - {"type":"auto"/"required"} → 字符串 "auto"/"required" +// - {"type":"function","function":{"name":"x"}} → 字符串 "x" +// - 其他对象/非标量 → 删 tool_choice +func normalizeToolChoice(obj map[string]any) { + suppress := func() { + delete(obj, "tools") + delete(obj, "functions") + } + tc, present := obj["tool_choice"] + if !present { + return + } + switch v := tc.(type) { + case string: + if strings.EqualFold(strings.TrimSpace(v), "none") { + delete(obj, "tool_choice") + suppress() + } + case map[string]any: + typ, _ := v["type"].(string) + typ = strings.ToLower(strings.TrimSpace(typ)) + switch typ { + case "none": + delete(obj, "tool_choice") + suppress() + case "auto", "required": + obj["tool_choice"] = typ + case "function": + name := "" + if fn, ok := v["function"].(map[string]any); ok { + name, _ = fn["name"].(string) + } + if name == "" { + name, _ = v["name"].(string) + } + if name = strings.TrimSpace(name); name != "" { + obj["tool_choice"] = name + } else { + obj["tool_choice"] = "auto" + } + default: + delete(obj, "tool_choice") + } + default: + delete(obj, "tool_choice") + } +} + +// normalizeToolPatterns 归一化 tools 子树里 pattern 的非标准转义 `\_`(→ `_`)。 +// +// 上游对 tools[].function.parameters 做严格 JSON Schema/正则文法校验,pattern 含 +// `\_`(转义的字面量下划线)会整体拒收:400 code=11129 invalid_function_call_ +// parameters(displayMsg「工具定义不合规」)。`\_` 不是任何正则文法的合法转义, +// 但所有主流引擎(RE2/PCRE/JS Annex B)都宽容地视为 `_` 本身——上游校验器比它们 +// 全部更严(对照 V8 严格文法 u 标志,唯一同样拒绝的实现)。实案:ZCode 的 exa 插件 +// agent_run 工具 runId/previousRunId 带 `^agent\_run\_`,deepseek 系全家确定性 400 +// → 网关侧归 ErrClient 只换号不罚但喂连败计数 → 轮转烧满 5 连败触发连败降权、 +// 客户端 503(2026-09-29/30 两次实案)。schema 级拒绝换账号无用,只能在发送前修。 +// +// 归一无损:`\_` 与 `_` 在所有引擎匹配语义相同(各引擎实测 + 上游对照探针:归一后 +// 200),工具方功能不变。只动 tools 子树(pattern 值 + patternProperties 键); +// 消息正文里的 `\_`(如 Windows 路径 C:\_x)不碰。其余非标转义(`\:` 等)未证实 +// 触发,不扩面——有实案再议。独立于 sanitize 开关:这是「让请求通过」,不是脱敏。 +func normalizeToolPatterns(obj map[string]any) { + rawTools, ok := obj["tools"].([]any) + if !ok { + return + } + for _, raw := range rawTools { + tool, ok := raw.(map[string]any) + if !ok { + continue + } + // OpenAI 形态 tools[].function.parameters;裸 tools[].parameters 兼容。 + if fn, ok := tool["function"].(map[string]any); ok { + normalizeSchemaTree(fn["parameters"]) + } + normalizeSchemaTree(tool["parameters"]) + } +} + +// normalizeSchemaTree 递归归一化工具参数 schema 树: +// - pattern 值与 patternProperties 键里的 `\_` → `_`(patternProperties 的键也是正则; +// map 键不可原地改,命中时重建该层); +// - 只有 enum、没有 type 的属性补上可无损推断的类型(见 inferEnumType)。 +func normalizeSchemaTree(node any) { + switch n := node.(type) { + case map[string]any: + if p, ok := n["pattern"].(string); ok && strings.Contains(p, `\_`) { + n["pattern"] = strings.ReplaceAll(p, `\_`, `_`) + } + if props, ok := n["patternProperties"].(map[string]any); ok { + rebuilt := false + fixed := make(map[string]any, len(props)) + for k, v := range props { + if strings.Contains(k, `\_`) { + k = strings.ReplaceAll(k, `\_`, `_`) + rebuilt = true + } + fixed[k] = v + } + if rebuilt { + n["patternProperties"] = fixed + } + } + // enum 缺 type:Kimi 系对参数 schema 严格校验,直接 400 11133「Invalid request + // parameters」——同一个模型对带这类 schema 的客户端等于全废。类型能无损推断就补上, + // 推断不出来(混合标量/含 null)保持原样,让上游按原语义报错,不猜。 + if _, hasType := n["type"]; !hasType { + if e, ok := n["enum"].([]any); ok && len(e) > 0 { + if t := inferEnumType(e); t != "" { + n["type"] = t + } + } + } + for _, v := range n { + normalizeSchemaTree(v) + } + case []any: + for _, v := range n { + normalizeSchemaTree(v) + } + } +} + +// inferEnumType 从 enum 取值推断 JSON Schema 类型;推不出唯一类型时返回空(不改写)。 +// 数字经 encoding/json 解出来一律是 float64,故按「全为整数值」区分 integer / number。 +func inferEnumType(values []any) string { + var strs, nums, ints, bools int + for _, v := range values { + switch x := v.(type) { + case string: + strs++ + case bool: + bools++ + case float64: + nums++ + if x == math.Trunc(x) { + ints++ + } + default: + return "" // null / 对象 / 数组:类型不唯一,不猜 + } + } + n := len(values) + switch { + case strs == n: + return "string" + case bools == n: + return "boolean" + case nums == n && ints == n: + return "integer" + case nums == n: + return "number" + } + return "" +} diff --git a/internal/upstream/payload_test.go b/internal/upstream/payload_test.go index b02033df533a5b59810fffaacb6e85469b0cd3e7..1de1b181118ac3b2a2204472a604b2203ff2c0b1 100644 --- a/internal/upstream/payload_test.go +++ b/internal/upstream/payload_test.go @@ -1,467 +1,777 @@ -package upstream - -import ( - "encoding/json" - "reflect" - "strings" - "testing" -) - -// TestNormalizeRoles 验证出站请求体把 developer 角色归一为 system。 -// 上游 role 白名单不含 developer(OpenAI 新规范的 system 别名), -// 命中即 HTTP 400 code=11128;此处走 PrepareBodyOptWithEfforts 全链路断言。 -func TestNormalizeRoles(t *testing.T) { - cases := []struct { - name string - body string - wantRoles []string // 与输出 messages 逐条对应的期望 role;len 即消息数 - }{ - {"developer 改写为 system", - `{"messages":[{"role":"developer","content":"x"}]}`, []string{"system"}}, - {"Developer 首字母大写改写", - `{"messages":[{"role":"Developer","content":"x"}]}`, []string{"system"}}, - {"DEVELOPER 全大写改写", - `{"messages":[{"role":"DEVELOPER","content":"x"}]}`, []string{"system"}}, - {"前后空白 TrimSpace 后改写", - `{"messages":[{"role":" developer ","content":"x"}]}`, []string{"system"}}, - {"system 原样保留", - `{"messages":[{"role":"system","content":"x"}]}`, []string{"system"}}, - {"user 原样保留", - `{"messages":[{"role":"user","content":"x"}]}`, []string{"user"}}, - {"assistant 原样保留", - `{"messages":[{"role":"assistant","content":"x"}]}`, []string{"assistant"}}, - {"tool 原样保留(不因未知而改写)", - `{"messages":[{"role":"tool","content":"x"}]}`, []string{"tool"}}, - {"messages 缺失不 panic 且其余字段不变", - `{"model":"glm-5.2"}`, []string{}}, - {"messages 为空数组不 panic", - `{"messages":[]}`, []string{}}, - {"混合消息仅 developer 被改写", - `{"messages":[{"role":"developer","content":"a"},{"role":"user","content":"b"},{"role":"developer","content":"c"}]}`, - []string{"system", "user", "system"}}, - {"sanitize=false 时仍归一(与脱敏解耦)", - `{"messages":[{"role":"developer","content":"x"}]}`, []string{"system"}}, - {"非对象消息元素跳过、其余正常处理", - `{"messages":["str",{"role":"developer","content":"x"},42]}`, []string{"system"}}, - } - - for _, c := range cases { - t.Run(c.name, func(t *testing.T) { - // 全程 sanitize=false:验证 role 归一与内容脱敏开关无关(D4)。 - out := PrepareBodyOptWithEfforts([]byte(c.body), false, nil) - var obj map[string]any - if err := json.Unmarshal(out, &obj); err != nil { - t.Fatalf("unmarshal: %v (out=%s)", err, out) - } - - // 提取输出 messages 里的 role(非对象元素跳过,不 panic)。 - var got []string - if msgs, ok := obj["messages"].([]any); ok { - for _, m := range msgs { - msg, ok := m.(map[string]any) - if !ok { - continue - } - if role, ok := msg["role"].(string); ok { - got = append(got, role) - } - } - } - - if len(got) != len(c.wantRoles) { - t.Fatalf("role 数量不符: got %v (%d) want %v (%d)", got, len(got), c.wantRoles, len(c.wantRoles)) - } - for i := range got { - if got[i] != c.wantRoles[i] { - t.Errorf("role[%d] = %q want %q", i, got[i], c.wantRoles[i]) - } - } - }) - } - - // messages 缺失时,其余字段必须原样保留(除强制 stream)。 - t.Run("messages 缺失时其余字段不变", func(t *testing.T) { - out := PrepareBodyOptWithEfforts([]byte(`{"model":"glm-5.2","temperature":0.7}`), false, nil) - var obj map[string]any - if err := json.Unmarshal(out, &obj); err != nil { - t.Fatalf("unmarshal: %v", err) - } - if obj["model"] != "glm-5.2" || obj["temperature"] != 0.7 { - t.Errorf("其余字段被改动: %v", obj) - } - }) -} - -func TestPrepareBodyOptWithEfforts(t *testing.T) { - efforts := map[string][]string{ - "glm-5.2": {"off", "low", "high"}, - "glm-5.2-mini": {"low", "medium"}, - "glm-5.2-max": {"high", "xhigh"}, - } - cases := []struct { - name string - body string - efforts map[string][]string - wantKey string // 输出应带有的 effort 字段名;空表示该字段应不存在 - wantVal string // 期望值 - }{ - {"downgrade to highest supported at or below request", - `{"model":"glm-5.2-mini","reasoning_effort":"high"}`, efforts, "reasoning_effort", "medium"}, - {"floor to lowest when all supported above request", - `{"model":"glm-5.2-max","reasoning_effort":"low"}`, efforts, "reasoning_effort", "high"}, - {"supported effort passes through unchanged", - `{"model":"glm-5.2","reasoning_effort":"low"}`, efforts, "reasoning_effort", "low"}, - {"camelCase field name downgrades and keeps key", - `{"model":"glm-5.2-mini","reasoningEffort":"high"}`, efforts, "reasoningEffort", "medium"}, - {"unknown model passes through", - `{"model":"unknown","reasoning_effort":"max"}`, efforts, "reasoning_effort", "max"}, - {"unknown effort value passes through", - `{"model":"glm-5.2","reasoning_effort":"ultra"}`, efforts, "reasoning_effort", "ultra"}, - {"empty cache passes through", - `{"model":"glm-5.2","reasoning_effort":"max"}`, map[string][]string{}, "reasoning_effort", "max"}, - {"no effort field untouched", - `{"model":"glm-5.2-mini","messages":[]}`, efforts, "", ""}, - {"nil efforts map passes through", - `{"model":"glm-5.2","reasoning_effort":"max"}`, nil, "reasoning_effort", "max"}, - } - for _, c := range cases { - t.Run(c.name, func(t *testing.T) { - out := PrepareBodyOptWithEfforts([]byte(c.body), false, c.efforts) - var m map[string]any - if err := json.Unmarshal(out, &m); err != nil { - t.Fatalf("unmarshal: %v (body=%s)", err, out) - } - if c.wantKey == "" { - if _, ok := m["reasoning_effort"]; ok { - t.Errorf("reasoning_effort should be absent, got %v", m["reasoning_effort"]) - } - if _, ok := m["reasoningEffort"]; ok { - t.Errorf("reasoningEffort should be absent, got %v", m["reasoningEffort"]) - } - return - } - got, ok := m[c.wantKey].(string) - if !ok || got != c.wantVal { - t.Errorf("%s: got %v (%T) want %q", c.wantKey, m[c.wantKey], m[c.wantKey], c.wantVal) - } - }) - } -} - -// TestPrepareBodyStreamOptions body 未显式带 stream_options 时注入 -// {include_usage: true}(D7,官方 CLI 流式必发);body 已带则不覆盖。 -func TestPrepareBodyStreamOptions(t *testing.T) { - out := PrepareBodyOptWithEfforts([]byte(`{"model":"glm-5.2","messages":[]}`), false, nil) - var obj map[string]any - if err := json.Unmarshal(out, &obj); err != nil { - t.Fatalf("unmarshal: %v (out=%s)", err, out) - } - so, ok := obj["stream_options"].(map[string]any) - if !ok { - t.Fatalf("stream_options not injected: %v", obj["stream_options"]) - } - if so["include_usage"] != true { - t.Errorf("stream_options.include_usage = %v want true", so["include_usage"]) - } - - out2 := PrepareBodyOptWithEffertsPreserve(t, `{"model":"glm-5.2","messages":[],"stream_options":{"include_usage":false}}`) - obj2, err := decodeBody(out2) - if err != nil { - t.Fatalf("unmarshal: %v", err) - } - so2, ok := obj2["stream_options"].(map[string]any) - if !ok { - t.Fatalf("stream_options lost: %v", obj2["stream_options"]) - } - if so2["include_usage"] != false { - t.Errorf("stream_options.include_usage = %v want false (not overwritten)", so2["include_usage"]) - } -} - -// PrepareBodyOptWithEffertsPreserve helper:PrepareBodyOptWithEfforts 包装。 -func PrepareBodyOptWithEffertsPreserve(t *testing.T, body string) []byte { - t.Helper() - return PrepareBodyOptWithEfforts([]byte(body), false, nil) -} - -// decodeBody helper:解析 body JSON。 -func decodeBody(b []byte) (map[string]any, error) { - var obj map[string]any - err := json.Unmarshal(b, &obj) - return obj, err -} - -// TestPrepareBodyDeterministic 序列化稳定性:同输入跑多遍出站字节级一致 -// (prompt_cache_key 前缀命中的前提——链中不得注入时间/随机/ID 类不确定源)。 -func TestPrepareBodyDeterministic(t *testing.T) { - inputs := []string{ - `{"model":"glm-5.2","messages":[{"role":"system","content":"你是助手"},{"role":"user","content":"你好"}],"reasoning_effort":"high"}`, - `{"model":"deepseek-v4","messages":[{"role":"user","content":"写个函数"}],"tool_choice":{"type":"auto"},"tools":[{"type":"function","function":{"name":"f"}}]}`, - `{"model":"glm-5.3","messages":[{"role":"developer","content":"sys"},{"role":"user","content":[{"type":"text","text":"hi"}]}]}`, - } - for i, in := range inputs { - var first []byte - for round := 0; round < 5; round++ { - out := PrepareBodyOptWithEfforts([]byte(in), true, map[string][]string{"glm-5.2": {"off", "low", "high"}}) - if round == 0 { - first = out - continue - } - if string(out) != string(first) { - t.Fatalf("input #%d round %d differs from round 0:\n%s\n%s", i, round, first, out) - } - } - } -} - -// TestNormalizeImageURL 覆盖 OpenAI chat 多模态内容的 image_url 兼容: -// 字符串形态必须转为上游需要的对象形态;对象形态及其中字段必须原样保留; -// 无效输入不补默认值,继续交给上游返回真实错误。 -func TestNormalizeImageURL(t *testing.T) { - tests := []struct { - name string - body string - want any - }{ - { - name: "data url string to object", - body: `{"messages":[{"role":"user","content":[{"type":"text","text":"look"},{"type":"image_url","image_url":"data:image/png;base64,QUJD"}]}]}`, - want: map[string]any{"url": "data:image/png;base64,QUJD"}, - }, - { - name: "http url string to object", - body: `{"messages":[{"role":"user","content":[{"type":"image_url","image_url":"https://example.test/a.png"}]}]}`, - want: map[string]any{"url": "https://example.test/a.png"}, - }, - { - name: "object with detail preserved", - body: `{"messages":[{"role":"user","content":[{"type":"image_url","image_url":{"url":"data:image/png;base64,QUJD","detail":"low","mime_type":"image/png"}}]}]}`, - want: map[string]any{"url": "data:image/png;base64,QUJD", "detail": "low", "mime_type": "image/png"}, - }, - { - name: "invalid object url type preserved", - body: `{"messages":[{"role":"user","content":[{"type":"image_url","image_url":{"url":123}}]}]}`, - want: map[string]any{"url": float64(123)}, - }, - { - name: "missing image url preserved", - body: `{"messages":[{"role":"user","content":[{"type":"image_url"}]}]}`, - want: nil, - }, - { - name: "empty string preserved", - body: `{"messages":[{"role":"user","content":[{"type":"image_url","image_url":""}]}]}`, - want: "", - }, - } - - for _, tc := range tests { - t.Run(tc.name, func(t *testing.T) { - for _, sanitize := range []bool{false, true} { - out := PrepareBodyOptWithEfforts([]byte(tc.body), sanitize, nil) - obj, err := decodeBody(out) - if err != nil { - t.Fatalf("sanitize=%v unmarshal: %v (out=%s)", sanitize, err, out) - } - msgs := obj["messages"].([]any) - content := msgs[0].(map[string]any)["content"].([]any) - var part map[string]any - for _, rawPart := range content { - candidate, ok := rawPart.(map[string]any) - if ok && candidate["type"] == "image_url" { - part = candidate - break - } - } - if part == nil { - t.Fatal("image_url part not found") - } - if tc.want == nil { - if _, exists := part["image_url"]; exists { - t.Fatalf("sanitize=%v: missing image_url should stay missing, got %#v", sanitize, part) - } - continue - } - if got := part["image_url"]; !reflect.DeepEqual(got, tc.want) { - t.Errorf("sanitize=%v: image_url=%#v want %#v", sanitize, got, tc.want) - } - } - }) - } -} - -// TestNormalizeToolPatterns 工具 schema pattern 的 `\_` 转义归一(11129 实案: -// exa agent_run 的 `^agent\_run\_` 被 deepseek 系确定性拒收,归一后上游 200)。 -// 覆盖:function.parameters 与裸 parameters 两形态、嵌套 schema、patternProperties -// 键、消息正文不碰、无 tools no-op、sanitize 开关两态一致。 -func TestNormalizeToolPatterns(t *testing.T) { - lookupPattern := func(t *testing.T, body string, path ...any) string { - t.Helper() - var obj map[string]any - if err := json.Unmarshal([]byte(body), &obj); err != nil { - t.Fatalf("out not json: %v", err) - } - cur := any(obj) - for _, p := range path { - switch k := p.(type) { - case string: - m, ok := cur.(map[string]any) - if !ok { - t.Fatalf("path %v: want object, got %T", path, cur) - } - cur = m[k] - case int: - l, ok := cur.([]any) - if !ok || k >= len(l) { - t.Fatalf("path %v: bad array at %T", path, cur) - } - cur = l[k] - } - } - s, _ := cur.(string) - return s - } - - t.Run("exa agent_run pattern normalized", func(t *testing.T) { - bs := string(byte(92)) // 反斜杠,测试体经工具链多层转义易被吞,运行时拼装保真 - body := `{"model":"deepseek-v4.1-flash","messages":[{"role":"user","content":"hi"}],"tools":[{"type":"function","function":{"name":"agent_run","parameters":{"type":"object","properties":{"runId":{"type":"string","pattern":"^agent` + bs + bs + `_run` + bs + bs + `_"}` + `,"query":{"type":"string"}},"required":["query"]}}}]}` //nolint:lll // 实案 body 原样 - out := string(PrepareBodyOptWithEfforts([]byte(body), false, nil)) - if got := lookupPattern(t, out, "tools", 0, "function", "parameters", "properties", "runId", "pattern"); got != `^agent_run_` { - t.Fatalf("pattern = %q, want %q", got, `^agent_run_`) - } - // 同 schema 的兄弟字段不受影响 - if got := lookupPattern(t, out, "tools", 0, "function", "parameters", "properties", "query", "type"); got != "string" { - t.Fatalf("sibling field disturbed: %q", got) - } - }) - - t.Run("nested anyOf items pattern normalized", func(t *testing.T) { - bs := string(byte(92)) - body := `{"messages":[],"tools":[{"type":"function","function":{"name":"t","parameters":{"anyOf":[{"properties":{"code":{"pattern":"x` + bs + bs + `_y"}}},{"type":"string"}]}}}]}` //nolint:lll - out := string(PrepareBodyOptWithEfforts([]byte(body), false, nil)) - if got := lookupPattern(t, out, "tools", 0, "function", "parameters", "anyOf", 0, "properties", "code", "pattern"); got != "x_y" { - t.Fatalf("nested pattern = %q, want %q", got, "x_y") - } - }) - - t.Run("bare tool parameters form normalized", func(t *testing.T) { - bs := string(byte(92)) - body := `{"messages":[],"tools":[{"name":"t","parameters":{"properties":{"id":{"pattern":"p` + bs + bs + `_q"}}}}]}` - out := string(PrepareBodyOptWithEfforts([]byte(body), false, nil)) - if got := lookupPattern(t, out, "tools", 0, "parameters", "properties", "id", "pattern"); got != "p_q" { - t.Fatalf("bare parameters pattern = %q, want %q", got, "p_q") - } - }) - - t.Run("patternProperties key normalized", func(t *testing.T) { - bs := string(byte(92)) - body := `{"messages":[],"tools":[{"type":"function","function":{"name":"t","parameters":{"patternProperties":{"^a` + bs + bs + `_b` + bs + bs + `_":{"type":"string"}}}}}]}` //nolint:lll - var obj map[string]any - out := PrepareBodyOptWithEfforts([]byte(body), false, nil) - if err := json.Unmarshal(out, &obj); err != nil { - t.Fatalf("out not json: %v", err) - } - tool := obj["tools"].([]any)[0].(map[string]any)["function"].(map[string]any)["parameters"].(map[string]any) - props := tool["patternProperties"].(map[string]any) - if _, ok := props["^a_b_"]; !ok { - t.Fatalf("normalized key missing: %v", props) - } - for k := range props { - if strings.Contains(k, string(byte(92))) { - t.Fatalf("patternProperties key not normalized: %q", k) - } - } - }) - - t.Run("message content backslash untouched", func(t *testing.T) { - bs := string(byte(92)) - raw := `{"messages":[{"role":"user","content":"path C:` + bs + bs + `_dir and regex a` + bs + bs + `_b"}],"tools":[{"type":"function","function":{"name":"t","parameters":{"properties":{"p":{"pattern":"q` + bs + bs + `_r"}}}}}]}` //nolint:lll - out := string(PrepareBodyOptWithEfforts([]byte(raw), false, nil)) - var obj map[string]any - if err := json.Unmarshal([]byte(out), &obj); err != nil { - t.Fatalf("out not json: %v", err) - } - msg := obj["messages"].([]any)[0].(map[string]any) - if got := msg["content"]; got != `path C:\_dir and regex a\_b` { - t.Fatalf("message content mutated: %q", got) - } - }) - - t.Run("clean pattern untouched", func(t *testing.T) { - bs := string(byte(92)) - body := `{"messages":[],"tools":[{"type":"function","function":{"name":"t","parameters":{"properties":{"p":{"pattern":"^[a-z]+` + bs + bs + `d_$"}}}}}]}` //nolint:lll - out := string(PrepareBodyOptWithEfforts([]byte(body), false, nil)) - if got := lookupPattern(t, out, "tools", 0, "function", "parameters", "properties", "p", "pattern"); got != `^[a-z]+\d_$` { - t.Fatalf("clean pattern mutated: %q", got) - } - }) - - t.Run("no tools is no-op", func(t *testing.T) { - bs := string(byte(92)) - body := `{"model":"m","messages":[{"role":"user","content":"a` + bs + bs + `_b"}]}` - var inObj, outObj map[string]any - if err := json.Unmarshal([]byte(body), &inObj); err != nil { - t.Fatal(err) - } - out := PrepareBodyOptWithEfforts([]byte(body), false, nil) - if err := json.Unmarshal(out, &outObj); err != nil { - t.Fatalf("out not json: %v", err) - } - inMsg, _ := json.Marshal(inObj["messages"]) - outMsg, _ := json.Marshal(outObj["messages"]) - if string(inMsg) != string(outMsg) { - t.Fatalf("messages changed without tools: %s -> %s", inMsg, outMsg) - } - if _, has := outObj["tools"]; has { - t.Fatal("tools appeared out of nowhere") - } - }) - - t.Run("sanitize on and off behave the same", func(t *testing.T) { - bs := string(byte(92)) - body := `{"messages":[],"tools":[{"type":"function","function":{"name":"t","parameters":{"properties":{"p":{"pattern":"a` + bs + bs + `_b"}}}}}]}` //nolint:lll - for _, sanitize := range []bool{false, true} { - out := string(PrepareBodyOptWithEfforts([]byte(body), sanitize, nil)) - if got := lookupPattern(t, out, "tools", 0, "function", "parameters", "properties", "p", "pattern"); got != "a_b" { - t.Fatalf("sanitize=%v: pattern = %q, want %q", sanitize, got, "a_b") - } - } - }) -} - -// TestClampGPTMinMaxTokens GPT 系上游要求 max_tokens ≥ 16(实测 gpt-6-sol/gpt-6-luna/ -// gpt-5.6-sol:15 → 400 code=11133 model_param_invalid,16 → 200)。Claude Code 切 -// 模型时的探针请求 max_tokens 极小,全号轮转同样被拒 → 客户端 503。非 GPT 模型不动。 -func TestClampGPTMinMaxTokens(t *testing.T) { - cases := []struct { - name string - body string - want any // nil 表示字段不存在 - }{ - {"gpt below floor", `{"model":"gpt-6-sol","max_tokens":1,"messages":[]}`, float64(16)}, - {"gpt global prefix", `{"model":"global:gpt-5.6-sol","max_tokens":15,"messages":[]}`, float64(16)}, - {"gpt at floor", `{"model":"gpt-6-luna","max_tokens":16,"messages":[]}`, float64(16)}, - {"gpt above floor", `{"model":"gpt-6-sol","max_tokens":32000,"messages":[]}`, float64(32000)}, - {"gpt alias translated then clamped", `{"model":"gpt-6-sol","max_completion_tokens":1,"messages":[]}`, float64(16)}, - {"gpt absent untouched", `{"model":"gpt-6-sol","messages":[]}`, nil}, - {"non-gpt untouched", `{"model":"hy4-preview-f","max_tokens":1,"messages":[]}`, float64(1)}, - } - for _, c := range cases { - t.Run(c.name, func(t *testing.T) { - obj, err := decodeBody(PrepareBodyOptWithEffertsPreserve(t, c.body)) - if err != nil { - t.Fatalf("unmarshal: %v", err) - } - got, has := obj["max_tokens"] - if c.want == nil { - if has { - t.Fatalf("max_tokens = %v, want absent", got) - } - return - } - if got != c.want { - t.Fatalf("max_tokens = %v, want %v", got, c.want) - } - }) - } -} +package upstream + +import ( + "encoding/json" + "reflect" + "strings" + "testing" +) + +// TestNormalizeRoles 验证出站请求体把 developer 角色归一为 system。 +// 上游 role 白名单不含 developer(OpenAI 新规范的 system 别名), +// 命中即 HTTP 400 code=11128;此处走 PrepareBodyOptWithEfforts 全链路断言。 +func TestNormalizeRoles(t *testing.T) { + cases := []struct { + name string + body string + wantRoles []string // 与输出 messages 逐条对应的期望 role;len 即消息数 + }{ + {"developer 改写为 system", + `{"messages":[{"role":"developer","content":"x"}]}`, []string{"system"}}, + {"Developer 首字母大写改写", + `{"messages":[{"role":"Developer","content":"x"}]}`, []string{"system"}}, + {"DEVELOPER 全大写改写", + `{"messages":[{"role":"DEVELOPER","content":"x"}]}`, []string{"system"}}, + {"前后空白 TrimSpace 后改写", + `{"messages":[{"role":" developer ","content":"x"}]}`, []string{"system"}}, + {"system 原样保留", + `{"messages":[{"role":"system","content":"x"}]}`, []string{"system"}}, + {"user 原样保留", + `{"messages":[{"role":"user","content":"x"}]}`, []string{"user"}}, + {"assistant 原样保留", + `{"messages":[{"role":"assistant","content":"x"}]}`, []string{"assistant"}}, + {"tool 原样保留(不因未知而改写)", + `{"messages":[{"role":"tool","content":"x"}]}`, []string{"tool"}}, + {"messages 缺失不 panic 且其余字段不变", + `{"model":"glm-5.2"}`, []string{}}, + {"messages 为空数组不 panic", + `{"messages":[]}`, []string{}}, + {"混合消息仅 developer 被改写", + `{"messages":[{"role":"developer","content":"a"},{"role":"user","content":"b"},{"role":"developer","content":"c"}]}`, + []string{"system", "user", "system"}}, + {"sanitize=false 时仍归一(与脱敏解耦)", + `{"messages":[{"role":"developer","content":"x"}]}`, []string{"system"}}, + {"非对象消息元素跳过、其余正常处理", + `{"messages":["str",{"role":"developer","content":"x"},42]}`, []string{"system"}}, + } + + for _, c := range cases { + t.Run(c.name, func(t *testing.T) { + // 全程 sanitize=false:验证 role 归一与内容脱敏开关无关(D4)。 + out := PrepareBodyOptWithEfforts([]byte(c.body), false, nil) + var obj map[string]any + if err := json.Unmarshal(out, &obj); err != nil { + t.Fatalf("unmarshal: %v (out=%s)", err, out) + } + + // 提取输出 messages 里的 role(非对象元素跳过,不 panic)。 + var got []string + if msgs, ok := obj["messages"].([]any); ok { + for _, m := range msgs { + msg, ok := m.(map[string]any) + if !ok { + continue + } + if role, ok := msg["role"].(string); ok { + got = append(got, role) + } + } + } + + if len(got) != len(c.wantRoles) { + t.Fatalf("role 数量不符: got %v (%d) want %v (%d)", got, len(got), c.wantRoles, len(c.wantRoles)) + } + for i := range got { + if got[i] != c.wantRoles[i] { + t.Errorf("role[%d] = %q want %q", i, got[i], c.wantRoles[i]) + } + } + }) + } + + // messages 缺失时,其余字段必须原样保留(除强制 stream)。 + t.Run("messages 缺失时其余字段不变", func(t *testing.T) { + out := PrepareBodyOptWithEfforts([]byte(`{"model":"glm-5.2","temperature":0.7}`), false, nil) + var obj map[string]any + if err := json.Unmarshal(out, &obj); err != nil { + t.Fatalf("unmarshal: %v", err) + } + if obj["model"] != "glm-5.2" || obj["temperature"] != 0.7 { + t.Errorf("其余字段被改动: %v", obj) + } + }) +} + +// 档位不在模型支持列表里时取「最近档」,不再一律降级(issue #175):Codex 等客户端 +// 默认发 medium,而 CN 模型常见档位是 low/high/max(无 medium)——旧逻辑取「≤ medium +// 的最高支持档」会降到 low,比**不携带该字段**时的模型默认档 high 还弱且客户端无感。 +// 同距时优先模型声明的默认档,其次偏高的一档。返回值即日志行里显示的生效档位。 +// 上游 PR #159:chat content 里的思考片段(reasoning_text / reasoning)必须剔除—— +// 上游 content 类型白名单不含它,命中即 400 code=11101(第三方 responses→chat 转换器 +// 会把助手历史里的思考片段原样透传进来)。 +func TestDropReasoningContentParts(t *testing.T) { + cases := []struct{ name, body, want string }{ + {"reasoning_text 剥离、text 保留", + `{"messages":[{"role":"assistant","content":[{"type":"reasoning_text","text":"think"},{"type":"text","text":"ans"}]}]}`, + `[{"role":"assistant","content":[{"type":"text","text":"ans"}]}]`}, + {"reasoning 别名同样剥离", + `{"messages":[{"role":"assistant","content":[{"type":"reasoning","text":"think"},{"type":"output_text","text":"ans"}]}]}`, + `[{"role":"assistant","content":[{"type":"output_text","text":"ans"}]}]`}, + {"type 前后空白同样命中", + `{"messages":[{"role":"assistant","content":[{"type":" reasoning_text ","text":"think"},{"type":"text","text":"ans"}]}]}`, + `[{"role":"assistant","content":[{"type":"text","text":"ans"}]}]`}, + {"剥空且无 tool_calls:整条消息删除", + `{"messages":[{"role":"assistant","content":[{"type":"reasoning_text","text":"think"}]},{"role":"user","content":"hi"}]}`, + `[{"role":"user","content":"hi"}]`}, + {"剥空但有 tool_calls:保留空数组 content(不破坏配对)", + `{"messages":[{"role":"assistant","content":[{"type":"reasoning_text","text":"t"}],"tool_calls":[{"id":"c1","type":"function","function":{"name":"f","arguments":"{}"}}]}]}`, + `[{"role":"assistant","content":[],"tool_calls":[{"id":"c1","type":"function","function":{"name":"f","arguments":"{}"}}]}]`}, + {"字符串 content 不受影响", + `{"messages":[{"role":"assistant","content":"plain"},{"role":"user","content":"hi"}]}`, + `[{"role":"assistant","content":"plain"},{"role":"user","content":"hi"}]`}, + {"非对象片段原样保留", + `{"messages":[{"role":"assistant","content":["raw",{"type":"text","text":"ans"}]}]}`, + `[{"role":"assistant","content":["raw",{"type":"text","text":"ans"}]}]`}, + {"messages 缺失", `{}`, `null`}, + {"messages 非数组", `{"messages":"oops"}`, `"oops"`}, + } + for _, c := range cases { + t.Run(c.name, func(t *testing.T) { + var obj map[string]any + if err := json.Unmarshal([]byte(c.body), &obj); err != nil { + t.Fatal(err) + } + dropReasoningContentParts(obj) // 不得 panic + got, err := json.Marshal(obj["messages"]) + if err != nil { + t.Fatal(err) + } + // 期望值也过一遍序列化:Go 的 map 按键排序输出,直接比字符串会被键序绊住。 + var want any + if err := json.Unmarshal([]byte(c.want), &want); err != nil { + t.Fatal(err) + } + wantOut, err := json.Marshal(want) + if err != nil { + t.Fatal(err) + } + if string(got) != string(wantOut) { + t.Errorf("messages=%s want %s", got, wantOut) + } + }) + } +} + +// 管线必须挂上剥离,且与 sanitize 开关无关(同 normalizeRoles / 工具配对的口径)。 +func TestPrepareBodyDropsReasoningTextParts(t *testing.T) { + body := []byte(`{"model":"deepseek-v4.1-flash","messages":[{"role":"assistant","content":[{"type":"reasoning_text","text":"think"},{"type":"text","text":"ans"}]}]}`) + for _, sanitize := range []bool{false, true} { + out := PrepareBodyOpt(body, sanitize) + if strings.Contains(string(out), "reasoning_text") { + t.Errorf("sanitize=%v 时管线未剥离思考片段: %s", sanitize, out) + } + if !strings.Contains(string(out), `"ans"`) { + t.Errorf("sanitize=%v 时正文被误删: %s", sanitize, out) + } + } +} + +func TestPrepareBodyOptNormalizeStop(t *testing.T) { + cases := []struct { + name, in, wantStop string // wantStop 为期望的 stop 字段 JSON 片段 + }{ + {"字符串形态转数组", `{"model":"m","stop":"\n\nHuman:"}`, `"stop":["\n\nHuman:"]`}, + // 前后空白是停止词语义本身,不得 TrimSpace(首版裁剪被此用例抓到)。 + {"保留空白", `{"model":"m","stop":" END "}`, `"stop":[" END "]`}, + {"空串保留", `{"model":"m","stop":""}`, `"stop":[""]`}, + {"数组形态原样", `{"model":"m","stop":["a","b"]}`, `"stop":["a","b"]`}, + } + for _, c := range cases { + out := string(PrepareBodyOpt([]byte(c.in), false)) + if !strings.Contains(out, c.wantStop) { + t.Errorf("%s: out=%s want 含 %s", c.name, out, c.wantStop) + } + } + // null / 字段缺失不动:null 保持 null(不替客户端造值)。 + if out := string(PrepareBodyOpt([]byte(`{"model":"m","stop":null}`), false)); !strings.Contains(out, `"stop":null`) { + t.Errorf("null 形态应原样保留: %s", out) + } + if out := string(PrepareBodyOpt([]byte(`{"model":"m"}`), false)); strings.Contains(out, "stop") { + t.Errorf("缺失 stop 不应被补出: %s", out) + } +} + +func TestPrepareBodyOptEffortNearestPick(t *testing.T) { + efforts := map[string][]string{ + "deepseek-v4.1-flash": {"low", "high", "max"}, // 无 medium(线上实测的真实形状) + "tie-default-low": {"low", "high"}, // medium 与 low/high 同距,默认档 low + "tie-no-default": {"low", "high"}, // 同距且模型未声明默认档 → 宁高 + "gap-only": {"low", "medium"}, + } + defaults := map[string]string{ + "deepseek-v4.1-flash": "high", + "tie-default-low": "low", + "gap-only": "high", + } + cases := []struct{ name, body, want string }{ + {"无 medium 时取最近档 high(不再降到 low)", + `{"model":"deepseek-v4.1-flash","reasoning_effort":"medium"}`, "high"}, + {"同距优先模型默认档", + `{"model":"tie-default-low","reasoning_effort":"medium"}`, "low"}, + {"同距且无默认档 → 宁高", + `{"model":"tie-no-default","reasoning_effort":"medium"}`, "high"}, + {"xhigh 取最近档 medium", + `{"model":"gap-only","reasoning_effort":"xhigh"}`, "medium"}, + {"高于最高档取最高支持档", + `{"model":"gap-only","reasoning_effort":"max"}`, "medium"}, + {"低于最低档取最低支持档", + `{"model":"deepseek-v4.1-flash","reasoning_effort":"minimal"}`, "low"}, + {"支持则原样透传", + `{"model":"deepseek-v4.1-flash","reasoning_effort":"max"}`, "max"}, + } + for _, c := range cases { + t.Run(c.name, func(t *testing.T) { + out, eff := PrepareBodyOptWithEffortsDefaultAndCaps([]byte(c.body), false, efforts, defaults, nil) + var m map[string]any + if err := json.Unmarshal(out, &m); err != nil { + t.Fatalf("unmarshal: %v (body=%s)", err, out) + } + if got := m["reasoning_effort"]; got != c.want { + t.Errorf("reasoning_effort=%v want %v", got, c.want) + } + if eff != c.want { + t.Errorf("生效档位回传=%q want %q(日志行显示的就是它)", eff, c.want) + } + }) + } +} + +func TestPrepareBodyOptRequestedVsEffectiveEffort(t *testing.T) { + // issue #43 / #18:日志里「客户端设了 max、显示却是 high」有两种完全不同的成因, + // 必须能靠一次日志分辨:客户端根本没发(网关补的默认档),还是发了被降级 + // (模型档位表里没有这一档)。requested 在 injectThinking 之前抓,就是为此。 + onlyHigh := map[string][]string{"deepseek-v4.1-flash": {"high"}} + full := map[string][]string{"deepseek-v4.1-flash": {"low", "high", "max"}} + defaults := map[string]string{"deepseek-v4.1-flash": "high"} + + cases := []struct { + name string + body string + efforts map[string][]string + wantReq, wantEff string + }{ + { + name: "客户端发 max 且模型支持 → 原样透传,日志 max->不显示降级", + body: `{"model":"deepseek-v4.1-flash","reasoning_effort":"max"}`, + efforts: full, + wantReq: "max", wantEff: "max", + }, + { + name: "客户端发 max 但只支持 high → 降级可见(max->high)", + body: `{"model":"deepseek-v4.1-flash","reasoning_effort":"max"}`, + efforts: onlyHigh, + wantReq: "max", wantEff: "high", + }, + { + name: "客户端没发 → requested 为空,日志不会误报成降级", + body: `{"model":"deepseek-v4.1-flash"}`, + efforts: onlyHigh, + wantReq: "", wantEff: "high", + }, + } + for _, c := range cases { + t.Run(c.name, func(t *testing.T) { + _, req, eff := prepareBodyOpt([]byte(c.body), false, true, c.efforts, defaults, nil, "", nil, "", "", false, 0, "") + if req != c.wantReq { + t.Errorf("requested=%q want %q(客户端原始档位)", req, c.wantReq) + } + if eff != c.wantEff { + t.Errorf("effective=%q want %q(出站档位)", eff, c.wantEff) + } + }) + } +} + +func TestPrepareBodyOptWithEfforts(t *testing.T) { + efforts := map[string][]string{ + "glm-5.2": {"off", "low", "high"}, + "glm-5.2-mini": {"low", "medium"}, + "glm-5.2-max": {"high", "xhigh"}, + } + cases := []struct { + name string + body string + efforts map[string][]string + wantKey string // 输出应带有的 effort 字段名;空表示该字段应不存在 + wantVal string // 期望值 + }{ + {"downgrade to highest supported at or below request", + `{"model":"glm-5.2-mini","reasoning_effort":"high"}`, efforts, "reasoning_effort", "medium"}, + {"floor to lowest when all supported above request", + `{"model":"glm-5.2-max","reasoning_effort":"low"}`, efforts, "reasoning_effort", "high"}, + {"supported effort passes through unchanged", + `{"model":"glm-5.2","reasoning_effort":"low"}`, efforts, "reasoning_effort", "low"}, + {"camelCase field name downgrades and keeps key", + `{"model":"glm-5.2-mini","reasoningEffort":"high"}`, efforts, "reasoningEffort", "medium"}, + {"unknown model passes through", + `{"model":"unknown","reasoning_effort":"max"}`, efforts, "reasoning_effort", "max"}, + {"unknown effort value passes through", + `{"model":"glm-5.2","reasoning_effort":"ultra"}`, efforts, "reasoning_effort", "ultra"}, + {"empty cache passes through", + `{"model":"glm-5.2","reasoning_effort":"max"}`, map[string][]string{}, "reasoning_effort", "max"}, + {"no effort field untouched", + `{"model":"glm-5.2-mini","messages":[]}`, efforts, "", ""}, + {"nil efforts map passes through", + `{"model":"glm-5.2","reasoning_effort":"max"}`, nil, "reasoning_effort", "max"}, + } + for _, c := range cases { + t.Run(c.name, func(t *testing.T) { + out := PrepareBodyOptWithEfforts([]byte(c.body), false, c.efforts) + var m map[string]any + if err := json.Unmarshal(out, &m); err != nil { + t.Fatalf("unmarshal: %v (body=%s)", err, out) + } + if c.wantKey == "" { + if _, ok := m["reasoning_effort"]; ok { + t.Errorf("reasoning_effort should be absent, got %v", m["reasoning_effort"]) + } + if _, ok := m["reasoningEffort"]; ok { + t.Errorf("reasoningEffort should be absent, got %v", m["reasoningEffort"]) + } + return + } + got, ok := m[c.wantKey].(string) + if !ok || got != c.wantVal { + t.Errorf("%s: got %v (%T) want %q", c.wantKey, m[c.wantKey], m[c.wantKey], c.wantVal) + } + }) + } +} + +// TestInjectCatalogMaxTokens 缺失输出限额时按目录动态值补 max_tokens: +// 上游对不带 max_tokens 的请求套保守默认 32000(Codex 实测被无声截断), +// 目录声明的 maxOutputTokens 才是真实预算;显式限额(含别名翻译产物)优先。 +func TestInjectCatalogMaxTokens(t *testing.T) { + maxOut := map[string]int64{"deepseek-v4.1-flash": 393216} + + assertMaxTokens := func(t *testing.T, body []byte, want any, absent bool) { + t.Helper() + var m map[string]any + if err := json.Unmarshal(body, &m); err != nil { + t.Fatalf("unmarshal: %v (body=%s)", err, body) + } + got, has := m["max_tokens"] + if absent { + if has { + t.Fatalf("max_tokens 不该存在, got %v", got) + } + return + } + if !has || got != want { + t.Fatalf("max_tokens=%v (%T) want %v", got, got, want) + } + } + + // 无限额 + 目录命中 → 补上(int64 落 JSON 后按 float64 读回)。 + body, _ := PrepareBodyOptWithEffortsDefaultAndCaps([]byte(`{"model":"deepseek-v4.1-flash","messages":[]}`), false, nil, nil, maxOut) + assertMaxTokens(t, body, float64(393216), false) + + // 显式 max_tokens 优先:不覆盖。 + body, _ = PrepareBodyOptWithEffortsDefaultAndCaps([]byte(`{"model":"deepseek-v4.1-flash","max_tokens":123,"messages":[]}`), false, nil, nil, maxOut) + assertMaxTokens(t, body, float64(123), false) + + // 别名 max_completion_tokens 翻译后同样算显式限额,不被目录值覆盖。 + body, _ = PrepareBodyOptWithEffortsDefaultAndCaps([]byte(`{"model":"deepseek-v4.1-flash","max_completion_tokens":456,"messages":[]}`), false, nil, nil, maxOut) + assertMaxTokens(t, body, float64(456), false) + + // 模型未知 → 不补。 + body, _ = PrepareBodyOptWithEffortsDefaultAndCaps([]byte(`{"model":"unknown","messages":[]}`), false, nil, nil, maxOut) + assertMaxTokens(t, body, nil, true) + + // 快照 nil → 不补(旧行为完全一致)。 + body, _ = PrepareBodyOptWithEffortsDefaultAndCaps([]byte(`{"model":"deepseek-v4.1-flash","messages":[]}`), false, nil, nil, nil) + assertMaxTokens(t, body, nil, true) +} + +// TestPrepareBodyStreamOptions body 未显式带 stream_options 时注入 +// {include_usage: true}(D7,官方 CLI 流式必发);body 已带则不覆盖。 +func TestPrepareBodyStreamOptions(t *testing.T) { + out := PrepareBodyOptWithEfforts([]byte(`{"model":"glm-5.2","messages":[]}`), false, nil) + var obj map[string]any + if err := json.Unmarshal(out, &obj); err != nil { + t.Fatalf("unmarshal: %v (out=%s)", err, out) + } + so, ok := obj["stream_options"].(map[string]any) + if !ok { + t.Fatalf("stream_options not injected: %v", obj["stream_options"]) + } + if so["include_usage"] != true { + t.Errorf("stream_options.include_usage = %v want true", so["include_usage"]) + } + + out2 := PrepareBodyOptWithEffertsPreserve(t, `{"model":"glm-5.2","messages":[],"stream_options":{"include_usage":false}}`) + obj2, err := decodeBody(out2) + if err != nil { + t.Fatalf("unmarshal: %v", err) + } + so2, ok := obj2["stream_options"].(map[string]any) + if !ok { + t.Fatalf("stream_options lost: %v", obj2["stream_options"]) + } + if so2["include_usage"] != false { + t.Errorf("stream_options.include_usage = %v want false (not overwritten)", so2["include_usage"]) + } +} + +// PrepareBodyOptWithEffertsPreserve helper:PrepareBodyOptWithEfforts 包装。 +func PrepareBodyOptWithEffertsPreserve(t *testing.T, body string) []byte { + t.Helper() + return PrepareBodyOptWithEfforts([]byte(body), false, nil) +} + +// decodeBody helper:解析 body JSON。 +func decodeBody(b []byte) (map[string]any, error) { + var obj map[string]any + err := json.Unmarshal(b, &obj) + return obj, err +} + +// TestPrepareBodyDeterministic 序列化稳定性:同输入跑多遍出站字节级一致 +// (prompt_cache_key 前缀命中的前提——链中不得注入时间/随机/ID 类不确定源)。 +func TestPrepareBodyDeterministic(t *testing.T) { + inputs := []string{ + `{"model":"glm-5.2","messages":[{"role":"system","content":"你是助手"},{"role":"user","content":"你好"}],"reasoning_effort":"high"}`, + `{"model":"deepseek-v4","messages":[{"role":"user","content":"写个函数"}],"tool_choice":{"type":"auto"},"tools":[{"type":"function","function":{"name":"f"}}]}`, + `{"model":"glm-5.3","messages":[{"role":"developer","content":"sys"},{"role":"user","content":[{"type":"text","text":"hi"}]}]}`, + } + for i, in := range inputs { + var first []byte + for round := 0; round < 5; round++ { + out := PrepareBodyOptWithEfforts([]byte(in), true, map[string][]string{"glm-5.2": {"off", "low", "high"}}) + if round == 0 { + first = out + continue + } + if string(out) != string(first) { + t.Fatalf("input #%d round %d differs from round 0:\n%s\n%s", i, round, first, out) + } + } + } +} + +// TestNormalizeImageURL 覆盖 OpenAI chat 多模态内容的 image_url 兼容: +// 字符串形态必须转为上游需要的对象形态;对象形态及其中字段必须原样保留; +// 无效输入不补默认值,继续交给上游返回真实错误。 +func TestNormalizeImageURL(t *testing.T) { + tests := []struct { + name string + body string + want any + }{ + { + name: "data url string to object", + body: `{"messages":[{"role":"user","content":[{"type":"text","text":"look"},{"type":"image_url","image_url":"data:image/png;base64,QUJD"}]}]}`, + want: map[string]any{"url": "data:image/png;base64,QUJD"}, + }, + { + name: "http url string to object", + body: `{"messages":[{"role":"user","content":[{"type":"image_url","image_url":"https://example.test/a.png"}]}]}`, + want: map[string]any{"url": "https://example.test/a.png"}, + }, + { + name: "object with detail preserved", + body: `{"messages":[{"role":"user","content":[{"type":"image_url","image_url":{"url":"data:image/png;base64,QUJD","detail":"low","mime_type":"image/png"}}]}]}`, + want: map[string]any{"url": "data:image/png;base64,QUJD", "detail": "low", "mime_type": "image/png"}, + }, + { + name: "invalid object url type preserved", + body: `{"messages":[{"role":"user","content":[{"type":"image_url","image_url":{"url":123}}]}]}`, + want: map[string]any{"url": float64(123)}, + }, + { + name: "missing image url preserved", + body: `{"messages":[{"role":"user","content":[{"type":"image_url"}]}]}`, + want: nil, + }, + { + name: "empty string preserved", + body: `{"messages":[{"role":"user","content":[{"type":"image_url","image_url":""}]}]}`, + want: "", + }, + } + + for _, tc := range tests { + t.Run(tc.name, func(t *testing.T) { + for _, sanitize := range []bool{false, true} { + out := PrepareBodyOptWithEfforts([]byte(tc.body), sanitize, nil) + obj, err := decodeBody(out) + if err != nil { + t.Fatalf("sanitize=%v unmarshal: %v (out=%s)", sanitize, err, out) + } + msgs := obj["messages"].([]any) + content := msgs[0].(map[string]any)["content"].([]any) + var part map[string]any + for _, rawPart := range content { + candidate, ok := rawPart.(map[string]any) + if ok && candidate["type"] == "image_url" { + part = candidate + break + } + } + if part == nil { + t.Fatal("image_url part not found") + } + if tc.want == nil { + if _, exists := part["image_url"]; exists { + t.Fatalf("sanitize=%v: missing image_url should stay missing, got %#v", sanitize, part) + } + continue + } + if got := part["image_url"]; !reflect.DeepEqual(got, tc.want) { + t.Errorf("sanitize=%v: image_url=%#v want %#v", sanitize, got, tc.want) + } + } + }) + } +} + +// TestNormalizeToolPatterns 工具 schema pattern 的 `\_` 转义归一(11129 实案: +// exa agent_run 的 `^agent\_run\_` 被 deepseek 系确定性拒收,归一后上游 200)。 +// 覆盖:function.parameters 与裸 parameters 两形态、嵌套 schema、patternProperties +// 键、消息正文不碰、无 tools no-op、sanitize 开关两态一致。 +func TestNormalizeToolPatterns(t *testing.T) { + lookupPattern := func(t *testing.T, body string, path ...any) string { + t.Helper() + var obj map[string]any + if err := json.Unmarshal([]byte(body), &obj); err != nil { + t.Fatalf("out not json: %v", err) + } + cur := any(obj) + for _, p := range path { + switch k := p.(type) { + case string: + m, ok := cur.(map[string]any) + if !ok { + t.Fatalf("path %v: want object, got %T", path, cur) + } + cur = m[k] + case int: + l, ok := cur.([]any) + if !ok || k >= len(l) { + t.Fatalf("path %v: bad array at %T", path, cur) + } + cur = l[k] + } + } + s, _ := cur.(string) + return s + } + + t.Run("exa agent_run pattern normalized", func(t *testing.T) { + bs := string(byte(92)) // 反斜杠,测试体经工具链多层转义易被吞,运行时拼装保真 + body := `{"model":"deepseek-v4.1-flash","messages":[{"role":"user","content":"hi"}],"tools":[{"type":"function","function":{"name":"agent_run","parameters":{"type":"object","properties":{"runId":{"type":"string","pattern":"^agent` + bs + bs + `_run` + bs + bs + `_"}` + `,"query":{"type":"string"}},"required":["query"]}}}]}` //nolint:lll // 实案 body 原样 + out := string(PrepareBodyOptWithEfforts([]byte(body), false, nil)) + if got := lookupPattern(t, out, "tools", 0, "function", "parameters", "properties", "runId", "pattern"); got != `^agent_run_` { + t.Fatalf("pattern = %q, want %q", got, `^agent_run_`) + } + // 同 schema 的兄弟字段不受影响 + if got := lookupPattern(t, out, "tools", 0, "function", "parameters", "properties", "query", "type"); got != "string" { + t.Fatalf("sibling field disturbed: %q", got) + } + }) + + t.Run("nested anyOf items pattern normalized", func(t *testing.T) { + bs := string(byte(92)) + body := `{"messages":[],"tools":[{"type":"function","function":{"name":"t","parameters":{"anyOf":[{"properties":{"code":{"pattern":"x` + bs + bs + `_y"}}},{"type":"string"}]}}}]}` //nolint:lll + out := string(PrepareBodyOptWithEfforts([]byte(body), false, nil)) + if got := lookupPattern(t, out, "tools", 0, "function", "parameters", "anyOf", 0, "properties", "code", "pattern"); got != "x_y" { + t.Fatalf("nested pattern = %q, want %q", got, "x_y") + } + }) + + t.Run("bare tool parameters form normalized", func(t *testing.T) { + bs := string(byte(92)) + body := `{"messages":[],"tools":[{"name":"t","parameters":{"properties":{"id":{"pattern":"p` + bs + bs + `_q"}}}}]}` + out := string(PrepareBodyOptWithEfforts([]byte(body), false, nil)) + if got := lookupPattern(t, out, "tools", 0, "parameters", "properties", "id", "pattern"); got != "p_q" { + t.Fatalf("bare parameters pattern = %q, want %q", got, "p_q") + } + }) + + t.Run("patternProperties key normalized", func(t *testing.T) { + bs := string(byte(92)) + body := `{"messages":[],"tools":[{"type":"function","function":{"name":"t","parameters":{"patternProperties":{"^a` + bs + bs + `_b` + bs + bs + `_":{"type":"string"}}}}}]}` //nolint:lll + var obj map[string]any + out := PrepareBodyOptWithEfforts([]byte(body), false, nil) + if err := json.Unmarshal(out, &obj); err != nil { + t.Fatalf("out not json: %v", err) + } + tool := obj["tools"].([]any)[0].(map[string]any)["function"].(map[string]any)["parameters"].(map[string]any) + props := tool["patternProperties"].(map[string]any) + if _, ok := props["^a_b_"]; !ok { + t.Fatalf("normalized key missing: %v", props) + } + for k := range props { + if strings.Contains(k, string(byte(92))) { + t.Fatalf("patternProperties key not normalized: %q", k) + } + } + }) + + t.Run("message content backslash untouched", func(t *testing.T) { + bs := string(byte(92)) + raw := `{"messages":[{"role":"user","content":"path C:` + bs + bs + `_dir and regex a` + bs + bs + `_b"}],"tools":[{"type":"function","function":{"name":"t","parameters":{"properties":{"p":{"pattern":"q` + bs + bs + `_r"}}}}}]}` //nolint:lll + out := string(PrepareBodyOptWithEfforts([]byte(raw), false, nil)) + var obj map[string]any + if err := json.Unmarshal([]byte(out), &obj); err != nil { + t.Fatalf("out not json: %v", err) + } + msg := obj["messages"].([]any)[0].(map[string]any) + if got := msg["content"]; got != `path C:\_dir and regex a\_b` { + t.Fatalf("message content mutated: %q", got) + } + }) + + t.Run("clean pattern untouched", func(t *testing.T) { + bs := string(byte(92)) + body := `{"messages":[],"tools":[{"type":"function","function":{"name":"t","parameters":{"properties":{"p":{"pattern":"^[a-z]+` + bs + bs + `d_$"}}}}}]}` //nolint:lll + out := string(PrepareBodyOptWithEfforts([]byte(body), false, nil)) + if got := lookupPattern(t, out, "tools", 0, "function", "parameters", "properties", "p", "pattern"); got != `^[a-z]+\d_$` { + t.Fatalf("clean pattern mutated: %q", got) + } + }) + + t.Run("no tools is no-op", func(t *testing.T) { + bs := string(byte(92)) + body := `{"model":"m","messages":[{"role":"user","content":"a` + bs + bs + `_b"}]}` + var inObj, outObj map[string]any + if err := json.Unmarshal([]byte(body), &inObj); err != nil { + t.Fatal(err) + } + out := PrepareBodyOptWithEfforts([]byte(body), false, nil) + if err := json.Unmarshal(out, &outObj); err != nil { + t.Fatalf("out not json: %v", err) + } + inMsg, _ := json.Marshal(inObj["messages"]) + outMsg, _ := json.Marshal(outObj["messages"]) + if string(inMsg) != string(outMsg) { + t.Fatalf("messages changed without tools: %s -> %s", inMsg, outMsg) + } + if _, has := outObj["tools"]; has { + t.Fatal("tools appeared out of nowhere") + } + }) + + t.Run("sanitize on and off behave the same", func(t *testing.T) { + bs := string(byte(92)) + body := `{"messages":[],"tools":[{"type":"function","function":{"name":"t","parameters":{"properties":{"p":{"pattern":"a` + bs + bs + `_b"}}}}}]}` //nolint:lll + for _, sanitize := range []bool{false, true} { + out := string(PrepareBodyOptWithEfforts([]byte(body), sanitize, nil)) + if got := lookupPattern(t, out, "tools", 0, "function", "parameters", "properties", "p", "pattern"); got != "a_b" { + t.Fatalf("sanitize=%v: pattern = %q, want %q", sanitize, got, "a_b") + } + } + }) +} + +// TestClampGPTMinMaxTokens GPT 系上游要求 max_tokens ≥ 16(实测 gpt-6-sol/gpt-6-luna/ +// gpt-5.6-sol:15 → 400 code=11133 model_param_invalid,16 → 200,吸收上游 fd3e142)。 +// Claude Code 切模型时的探针请求 max_tokens 极小,全号轮转同样被拒 → 客户端 503。 +// 非 GPT 模型与未携带字段一律不动。 +func TestClampGPTMinMaxTokens(t *testing.T) { + cases := []struct { + name string + body string + want any // nil 表示字段不存在 + }{ + {"gpt below floor", `{"model":"gpt-6-sol","max_tokens":1,"messages":[]}`, float64(16)}, + {"gpt global prefix", `{"model":"global:gpt-5.6-sol","max_tokens":15,"messages":[]}`, float64(16)}, + {"gpt at floor", `{"model":"gpt-6-luna","max_tokens":16,"messages":[]}`, float64(16)}, + {"gpt above floor", `{"model":"gpt-6-sol","max_tokens":32000,"messages":[]}`, float64(32000)}, + {"gpt alias translated then clamped", `{"model":"gpt-6-sol","max_completion_tokens":1,"messages":[]}`, float64(16)}, + {"gpt absent untouched", `{"model":"gpt-6-sol","messages":[]}`, nil}, + {"gpt zero clamped like unset", `{"model":"gpt-6-sol","max_tokens":0,"messages":[]}`, float64(16)}, + {"non-gpt untouched", `{"model":"hy4-preview-f","max_tokens":1,"messages":[]}`, float64(1)}, + } + for _, c := range cases { + t.Run(c.name, func(t *testing.T) { + out := PrepareBodyOptWithEfforts([]byte(c.body), false, nil) + var obj map[string]any + if err := json.Unmarshal(out, &obj); err != nil { + t.Fatalf("unmarshal: %v", err) + } + got, has := obj["max_tokens"] + if c.want == nil { + if has { + t.Fatalf("max_tokens = %v, want absent", got) + } + return + } + if got != c.want { + t.Fatalf("max_tokens = %v, want %v", got, c.want) + } + }) + } +} + +func TestSplitRealmPrefix(t *testing.T) { + cases := []struct { + in, realm, bare string + }{ + {"cn:hy3", "cn", "hy3"}, + {"global:gpt-x", "global", "gpt-x"}, + {"hy3", "cn", "hy3"}, + {"weird:model", "cn", "weird:model"}, + {"cn:", "cn", ""}, + {":", "cn", ":"}, + {"", "cn", ""}, + } + for _, c := range cases { + realm, bare := SplitRealmPrefix(c.in) + if realm != c.realm || bare != c.bare { + t.Errorf("SplitRealmPrefix(%q) = (%q,%q), want (%q,%q)", c.in, realm, bare, c.realm, c.bare) + } + } +} + +func TestPrepareBodyStripsRealmPrefix(t *testing.T) { + cases := []struct { + name, body, want string + }{ + {"cn prefix", `{"model":"cn:hy3","messages":[]}`, "hy3"}, + {"global prefix", `{"model":"global:gpt-x","messages":[]}`, "gpt-x"}, + {"bare name", `{"model":"hy3","messages":[]}`, "hy3"}, + {"unknown prefix", `{"model":"weird:model","messages":[]}`, "weird:model"}, + {"missing model", `{"messages":[]}`, ""}, + {"non-string model", `{"model":123,"messages":[]}`, ""}, + } + for _, c := range cases { + t.Run(c.name, func(t *testing.T) { + out := PrepareBodyOpt([]byte(c.body), false) + var obj map[string]any + if err := json.Unmarshal(out, &obj); err != nil { + t.Fatalf("unmarshal: %v", err) + } + got, _ := obj["model"].(string) + if got != c.want { + t.Fatalf("model = %q, want %q (body=%s)", got, c.want, out) + } + }) + } +} + +// 归一化必须发生在 catalog/efforts 查表之前:带前缀的 model 也要命中裸名条目。 +func TestPrepareBodyPrefixedModelUsesBareForCatalogAndEffort(t *testing.T) { + body := []byte(`{"model":"cn:hy3","reasoning_effort":"max","messages":[]}`) + out, effort := PrepareBodyOptWithEffortsDefaultAndCaps(body, false, + map[string][]string{"hy3": {"low", "high"}}, + map[string]string{"hy3": "high"}, + map[string]int64{"hy3": 123}, + ) + var obj map[string]any + if err := json.Unmarshal(out, &obj); err != nil { + t.Fatalf("unmarshal: %v", err) + } + if obj["model"] != "hy3" { + t.Fatalf("model = %v, want hy3", obj["model"]) + } + if obj["max_tokens"] != float64(123) { + t.Fatalf("max_tokens = %v, want 123 (catalog lookup used prefixed model?)", obj["max_tokens"]) + } + if obj["reasoning_effort"] != "high" { + t.Fatalf("reasoning_effort = %v, want high (efforts lookup used prefixed model?)", obj["reasoning_effort"]) + } + if effort != "high" { + t.Fatalf("effort = %q, want high", effort) + } +} diff --git a/internal/upstream/prepare_bench_test.go b/internal/upstream/prepare_bench_test.go new file mode 100644 index 0000000000000000000000000000000000000000..da5757862af8ee997d6499d773c2e437d2ea31c9 --- /dev/null +++ b/internal/upstream/prepare_bench_test.go @@ -0,0 +1,111 @@ +package upstream + +import ( + "encoding/json" + "testing" +) + +// benchAgenticBody 造一个「真实代理负载」形状的请求体:大上下文(≈170K token / +// 600KB 文本)+ 工具声明 + 长轮次历史。线上抓到的 /v1/responses 请求就是这个尺 +// 寸(request-logs 实测 prompt_tokens 15.7 万~17.1 万、tools 8~63 个)。 +// +// 用它量的是**网关自己的 CPU**(JSON 解析 + 各归一化步骤 + 脱敏 + 重新序列化), +// 与上游无关——所以基准里不发网络请求。 +func benchAgenticBody(rounds, payloadPerMsg int) []byte { + filler := make([]byte, payloadPerMsg) + for i := range filler { + filler[i] = byte('a' + i%26) + } + chunk := string(filler) + + msgs := []any{ + map[string]any{"role": "system", "content": "You are Claude Code, Anthropic's official CLI for Claude. " + + "Use the read tool to inspect files. Tokens prefixed with @ are paths the user explicitly referenced. " + + "Relative paths are resolved against the workspace root."}, + } + for i := 0; i < rounds; i++ { + msgs = append(msgs, + map[string]any{"role": "user", "content": "please inspect module " + chunk[:payloadPerMsg/2]}, + map[string]any{"role": "assistant", "content": "reading now", "reasoning_content": chunk[:payloadPerMsg/4], + "tool_calls": []any{map[string]any{ + "id": "call_" + chunk[:6], "type": "function", + "function": map[string]any{"name": "read_file", "arguments": `{"path":"internal/server/handler.go"}`}, + }}}, + map[string]any{"role": "tool", "tool_call_id": "call_" + chunk[:6], "content": chunk}, + ) + } + tools := []any{} + for _, name := range []string{"read_file", "write_file", "bash", "grep", "glob", "web_fetch", "todo_write", "task"} { + tools = append(tools, map[string]any{ + "type": "function", + "function": map[string]any{ + "name": name, + "description": "Tool " + name + " for the agent. Powered by Anthropic Claude. " + chunk[:200], + "parameters": map[string]any{ + "type": "object", + "properties": map[string]any{"path": map[string]any{"type": "string", "description": "path"}}, + "required": []any{"path"}, + }, + }, + }) + } + body := map[string]any{ + "model": "cn:deepseek-v4.1-flash", + "stream": true, + "max_tokens": 2048, + "reasoning_effort": "xhigh", + "messages": msgs, + "tools": tools, + } + raw, err := json.Marshal(body) + if err != nil { + panic(err) + } + return raw +} + +// BenchmarkPrepareBodyAgentic 量「一次请求的请求体预处理」成本。 +// +// 线上实测(2026-11-08,7863,170K token 上下文):prep 中位 99ms、p99 673ms, +// 10 请求/秒时这一项就要吃掉约 1 个核。基准给的是同一量级的输入,改动造成 +// 的放大/收敛都能在 ns/op 上直接看到。 +func BenchmarkPrepareBodyAgentic(b *testing.B) { + src := benchAgenticBody(30, 16*1024) // ≈30 轮 × 3 条 × 16KB ≈ 1.4MB/≈380K token + b.SetBytes(int64(len(src))) + b.ResetTimer() + for i := 0; i < b.N; i++ { + if out := PrepareBodyOpt(src, true); len(out) == 0 { + b.Fatal("empty output") + } + } +} + +// BenchmarkPrepareBodyAgenticNoSanitize 同一份请求体但关掉脱敏层: +// 两者的差值就是「脱敏(正则 walks 全历史)」的净成本。 +func BenchmarkPrepareBodyAgenticNoSanitize(b *testing.B) { + src := benchAgenticBody(30, 16*1024) + b.SetBytes(int64(len(src))) + b.ResetTimer() + for i := 0; i < b.N; i++ { + if out := PrepareBodyOpt(src, false); len(out) == 0 { + b.Fatal("empty output") + } + } +} + +// BenchmarkPrepareBodyUnmarshalOnly 只算一次 JSON 解析 + 序列化,作为下界: +// 任何「比这个贵很多」的步骤都是可优化的对象。 +func BenchmarkPrepareBodyUnmarshalOnly(b *testing.B) { + src := benchAgenticBody(30, 16*1024) + b.SetBytes(int64(len(src))) + b.ResetTimer() + for i := 0; i < b.N; i++ { + var obj map[string]any + if err := json.Unmarshal(src, &obj); err != nil { + b.Fatal(err) + } + if _, err := json.Marshal(obj); err != nil { + b.Fatal(err) + } + } +} diff --git a/internal/upstream/profile.go b/internal/upstream/profile.go index 001ce90c28bfd86cddb6cc03037961c7cd6b6bfa..0a43811c78710a9d801fddd9a0c4113573eb8568 100644 --- a/internal/upstream/profile.go +++ b/internal/upstream/profile.go @@ -1,51 +1,67 @@ -// profile.go Web 控制台账号资料(issue #94:改名后免重登同步昵称)。 -// -// GET {webBase}/console/account,Bearer + x-client-platform: web(与 tasks/claim -// 同一鉴权形态,实测 2026-10-01:无需 Web 会话 cookie)。 -// -// 隐私边界(重要):该接口响应包含手机号(phoneNumber)等个人敏感信息。本方法 -// 只解析 nickname 与 uid(uid 仅做一致性核对),其余字段一概不解析、不落日志、 -// 不透传——调用方也拿不到。昵称同步只在面板手动「刷新」时触发,后台余额定时 -// 刷新不调用本接口。 -package upstream - -import ( - "encoding/json" - "fmt" - "net/http" - - "github.com/linguo2625469/workbuddy2api-panel/internal/auth" -) - -// FetchAccountProfile 拉取账号资料并返回最新昵称。uid 与凭证不一致时报错 -// (防串号);业务/网络错误原样返回,调用方静默跳过即可。 -func (c *Client) FetchAccountProfile(a *auth.Auth) (string, error) { - req, err := http.NewRequest(http.MethodGet, c.webBase(a)+"/console/account", nil) - if err != nil { - return "", err - } - req.Header.Set("Authorization", "Bearer "+a.AccessTokenValue()) - req.Header.Set("Accept", "application/json, text/plain, */*") - req.Header.Set("x-client-platform", "web") - req.Header.Set("Origin", "https://www.workbuddy.cn") - req.Header.Set("Referer", "https://www.workbuddy.cn/profile/account-settings") - if ua := c.userAgent(a); ua != "" { - req.Header.Set("User-Agent", ua) - } - data, err := c.doJSON(req) - if err != nil { - return "", err - } - // 只取两个字段:敏感信息(手机号等)在这里就被丢弃,不进入任何后续路径。 - var resp struct { - UID string `json:"uid"` - Nickname string `json:"nickname"` - } - if err := json.Unmarshal(data, &resp); err != nil { - return "", fmt.Errorf("profile parse: %w", err) - } - if resp.UID != "" && a.UID != "" && resp.UID != a.UID { - return "", fmt.Errorf("profile uid mismatch: resp=%s auth=%s", resp.UID, a.UID) - } - return resp.Nickname, nil -} +// profile.go Web 控制台账号资料(issue #94 同步:改名后免重登同步昵称)。 +// +// GET {webBase}/console/account,Bearer + x-client-platform: web(与 tasks/claim +// 同一鉴权形态,实测 2026-10-01:无需 Web 会话 cookie)。 +// +// 隐私边界(重要):该接口响应包含手机号(phoneNumber)等个人敏感信息。本方法 +// 只解析 nickname 与 uid(uid 仅做一致性核对),其余字段一概不解析、不落日志、 +// 不透传——调用方也拿不到。昵称同步只在面板手动「刷新」时触发,后台余额定时 +// 刷新不调用本接口。 +package upstream + +import ( + "encoding/json" + "fmt" + "net/http" + "strings" + + "github.com/misakano7545/workbuddy2api-panel/internal/auth" +) + +// FetchAccountProfile 拉取账号资料并返回最新昵称。uid 与凭证不一致时报错 +// (防串号);业务/网络错误原样返回,调用方静默跳过即可。 +// +// 响应形态两种都接:`{code:0,msg:...,data:{uid,nickname}}` 信封,以及顶层平铺的 +// `{uid,nickname}`(实测两种都出现过)。信封解析后 data 为空时回落到原始响应体。 +// +// 空昵称按失败返回:调用方(面板「刷新」同步昵称)拿空串什么也做不了——SetNickname +// 对空串直接返回 false,于是既不计入「更新」也不计入「失败」,全部账号都拿不到昵称 +// 时日志一行都不打,看起来像什么都没发生。宁可计成失败。 +func (c *Client) FetchAccountProfile(a *auth.Auth) (string, error) { + req, err := http.NewRequest(http.MethodGet, c.webBase(a)+"/console/account", nil) + if err != nil { + return "", err + } + req.Header.Set("Authorization", "Bearer "+a.AccessTokenValue()) + req.Header.Set("Accept", "application/json, text/plain, */*") + req.Header.Set("x-client-platform", "web") + req.Header.Set("Origin", "https://www.workbuddy.cn") + req.Header.Set("Referer", "https://www.workbuddy.cn/profile/account-settings") + if ua := c.userAgent(a); ua != "" { + req.Header.Set("User-Agent", ua) + } + env, raw, err := c.doJSONRaw(req, a) + if err != nil { + return "", err + } + payload := []byte(env.Data) + if len(payload) == 0 { + payload = raw + } + // 只取两个字段:敏感信息(手机号等)在这里就被丢弃,不进入任何后续路径。 + var resp struct { + UID string `json:"uid"` + Nickname string `json:"nickname"` + } + if err := json.Unmarshal(payload, &resp); err != nil { + return "", fmt.Errorf("profile parse: %w", err) + } + if resp.UID != "" && a.UID != "" && resp.UID != a.UID { + return "", fmt.Errorf("profile uid mismatch: resp=%s auth=%s", resp.UID, a.UID) + } + nick := strings.TrimSpace(resp.Nickname) + if nick == "" { + return "", fmt.Errorf("profile response has no nickname") + } + return nick, nil +} diff --git a/internal/upstream/profile_test.go b/internal/upstream/profile_test.go index 921a0b07e3cfd7b7f0b29697271921ebcef60621..429eaa2e583262cebbdc7edd1fe5638573c2e3c1 100644 --- a/internal/upstream/profile_test.go +++ b/internal/upstream/profile_test.go @@ -1,50 +1,81 @@ -// profile_test.go 钉住账号资料拉取(issue #94):Bearer + web 平台头可访问 -// /console/account;只解析 nickname,uid 不一致防串号;业务错误原样返回。 -package upstream - -import ( - "errors" - "net/http" - "strings" - "testing" - - "github.com/linguo2625469/workbuddy2api-panel/internal/auth" -) - -func TestFetchAccountProfile(t *testing.T) { - c := testClient(func(r *http.Request) (*http.Response, error) { - if !strings.HasSuffix(r.URL.Path, "/console/account") { - return nil, errors.New("wrong path") - } - if r.Header.Get("Authorization") == "" || r.Header.Get("x-client-platform") != "web" { - return nil, errors.New("missing bearer / web platform header") - } - // 响应刻意带 phoneNumber:方法必须只解析 nickname/uid,敏感字段不得进入返回值。 - return jsonResp(200, `{"code":0,"msg":"OK","data":{"uid":"u1","nickname":"新名字","phoneNumber":"13800000000"}}`), nil - }) - c.WebBaseCN = "https://web.example" - nick, err := c.FetchAccountProfile(&auth.Auth{UID: "u1", AccessToken: "at"}) - if err != nil || nick != "新名字" { - t.Fatalf("nick=%q err=%v, want 新名字 nil", nick, err) - } -} - -func TestFetchAccountProfileUIDMismatch(t *testing.T) { - c := testClient(func(r *http.Request) (*http.Response, error) { - return jsonResp(200, `{"code":0,"data":{"uid":"someone-else","nickname":"x"}}`), nil - }) - c.WebBaseCN = "https://web.example" - if _, err := c.FetchAccountProfile(&auth.Auth{UID: "u1", AccessToken: "at"}); err == nil { - t.Fatal("uid 不一致应报错(防串号)") - } -} - -func TestFetchAccountProfileBusinessError(t *testing.T) { - c := testClient(func(r *http.Request) (*http.Response, error) { - return jsonResp(401, `{"code":1002,"msg":"unauthorized"}`), nil - }) - c.WebBaseCN = "https://web.example" - if _, err := c.FetchAccountProfile(&auth.Auth{UID: "u1", AccessToken: "bad"}); err == nil { - t.Fatal("401 应返回错误") - } -} +// profile_test.go 钉住账号资料拉取(issue #94 同步):Bearer + web 平台头可访问 +// /console/account;只解析 nickname,uid 不一致防串号;业务错误原样返回。 +package upstream + +import ( + "errors" + "net/http" + "strings" + "testing" + + "github.com/misakano7545/workbuddy2api-panel/internal/auth" +) + +func TestFetchAccountProfile(t *testing.T) { + c := testClient(func(r *http.Request) (*http.Response, error) { + if !strings.HasSuffix(r.URL.Path, "/console/account") { + return nil, errors.New("wrong path") + } + if r.Header.Get("Authorization") == "" || r.Header.Get("x-client-platform") != "web" { + return nil, errors.New("missing bearer / web platform header") + } + // 响应刻意带 phoneNumber:方法必须只解析 nickname/uid,敏感字段不得进入返回值。 + return jsonResp(200, `{"code":0,"msg":"OK","data":{"uid":"u1","nickname":"新名字","phoneNumber":"13800000000"}}`), nil + }) + c.WebBaseCN = "https://web.example" + nick, err := c.FetchAccountProfile(&auth.Auth{UID: "u1", AccessToken: "at"}) + if err != nil || nick != "新名字" { + t.Fatalf("nick=%q err=%v, want 新名字 nil", nick, err) + } +} + +func TestFetchAccountProfileUIDMismatch(t *testing.T) { + c := testClient(func(r *http.Request) (*http.Response, error) { + return jsonResp(200, `{"code":0,"data":{"uid":"someone-else","nickname":"x"}}`), nil + }) + c.WebBaseCN = "https://web.example" + if _, err := c.FetchAccountProfile(&auth.Auth{UID: "u1", AccessToken: "at"}); err == nil { + t.Fatal("uid 不一致应报错(防串号)") + } +} + +func TestFetchAccountProfileBusinessError(t *testing.T) { + c := testClient(func(r *http.Request) (*http.Response, error) { + return jsonResp(401, `{"code":1002,"msg":"unauthorized"}`), nil + }) + c.WebBaseCN = "https://web.example" + if _, err := c.FetchAccountProfile(&auth.Auth{UID: "u1", AccessToken: "bad"}); err == nil { + t.Fatal("401 应返回错误") + } +} + +// 顶层平铺形态(没有 code/data 信封):信封解析后 data 为空,必须回落到原始响应体。 +func TestFetchAccountProfileFlatShape(t *testing.T) { + c := testClient(func(r *http.Request) (*http.Response, error) { + return jsonResp(200, `{"uid":"u1","nickname":"平铺名字","phoneNumber":"13800000000"}`), nil + }) + c.WebBaseCN = "https://web.example" + nick, err := c.FetchAccountProfile(&auth.Auth{UID: "u1", AccessToken: "at"}) + if err != nil || nick != "平铺名字" { + t.Fatalf("nick=%q err=%v, want 平铺名字 nil", nick, err) + } +} + +// 空昵称必须报错:返回 "" 会让调用方既不记更新也不记失败,整批拿不到昵称时日志静默。 +func TestFetchAccountProfileEmptyNickname(t *testing.T) { + for _, body := range []string{ + `{"code":0,"msg":"OK","data":{"uid":"u1"}}`, + `{"code":0,"msg":"OK","data":{"uid":"u1","nickname":" "}}`, + `{"code":0,"msg":"OK","data":null}`, + `{"uid":"u1"}`, + } { + c := testClient(func(r *http.Request) (*http.Response, error) { + return jsonResp(200, body), nil + }) + c.WebBaseCN = "https://web.example" + nick, err := c.FetchAccountProfile(&auth.Auth{UID: "u1", AccessToken: "at"}) + if err == nil { + t.Fatalf("空昵称应报错,body=%s got nick=%q", body, nick) + } + } +} diff --git a/internal/upstream/proxy.go b/internal/upstream/proxy.go new file mode 100644 index 0000000000000000000000000000000000000000..65ce6ee806f475a691d40a6bfdd2c0ffd3caa7e5 --- /dev/null +++ b/internal/upstream/proxy.go @@ -0,0 +1,56 @@ +package upstream + +import ( + "net/http" + + "github.com/misakano7545/workbuddy2api-panel/internal/auth" +) + +// officialConnectionValue 给出该 path 上官方客户端实际发送的 Connection 值。 +// +// 2026-10-30 双版本真机抓包(CN 5.9.3 / GL 5.9.4):官方在每条 RPC 上都显式 +// 写了 Connection —— 除 /v3/config 是 close 外,其余全是 keep-alive。 +// HTTP/1.1 默认即复用,Go 因此从不发送这一行,但头集合少了它就是少一个字段; +// 风控按白名单查头时,"缺一个官方必发的头"和"多一个官方不发的头"一样显眼。 +// +// 没抓到过的 path 返回空串,保持 Go 默认行为,不臆造。 +func officialConnectionValue(path string) string { + switch path { + case "/v3/config": + return "close" + case "/v2/chat/completions", "/v2/chat/busy", "/v2/report": + return "keep-alive" + } + return "" +} + +// applyConnectionHeader 把官方那个显式的 Connection 头补回去。 +// +// close 不能写进 Header:net/http 的 transferWriter 会按 req.Close 自己写一行 +// Connection: close,手写会重复成两行。keep-alive 相反 —— Go 认为它是默认值所以 +// 从不发出,必须手写才会出现在线上字节里。 +func applyConnectionHeader(req *http.Request) { + switch officialConnectionValue(req.URL.Path) { + case "close": + req.Close = true + case "keep-alive": + req.Header.Set("Connection", "keep-alive") + } +} + +// do is the single account-aware HTTP exit, including nonstandard header families. +// +// 头名拼写在这里统一纠正(headcase.go),Connection 在这里补发(官方必发, +// Go 默认不发)。所有 13 个出站点都收敛到本函数,挂一次即覆盖全部出站。 +func (c *Client) do(req *http.Request, a *auth.Auth, chat bool) (*http.Response, error) { + req = normalizeHeaderSpelling(req) + applyConnectionHeader(req) + client := c.HTTP + if chat { + client = c.chatHTTP() + } + if c.ProxyPool == nil || a == nil { + return client.Do(req) + } + return c.ProxyPool.Do(client, req, a.UID, a.Realm()) +} diff --git a/internal/upstream/proxy_test.go b/internal/upstream/proxy_test.go new file mode 100644 index 0000000000000000000000000000000000000000..7b977e75a850131fecf0c392af74d4883f3d25c8 --- /dev/null +++ b/internal/upstream/proxy_test.go @@ -0,0 +1,145 @@ +package upstream + +import ( + "context" + "go/ast" + "go/parser" + "go/token" + "io" + "net/http" + "net/http/httptest" + "path/filepath" + "strings" + "sync" + "testing" + "time" + + "github.com/misakano7545/workbuddy2api-panel/internal/auth" + "github.com/misakano7545/workbuddy2api-panel/internal/proxypool" +) + +// Prevent new account endpoints from silently bypassing account-aware routing. +func TestAccountHTTPExitsUseProxyRouting(t *testing.T) { + files, err := filepath.Glob("*.go") + if err != nil { + t.Fatal(err) + } + for _, name := range files { + if strings.HasSuffix(name, "_test.go") || name == "proxy.go" { + continue + } + f, err := parser.ParseFile(token.NewFileSet(), name, nil, 0) + if err != nil { + t.Fatal(err) + } + ast.Inspect(f, func(n ast.Node) bool { + call, ok := n.(*ast.CallExpr) + if !ok { + return true + } + sel, ok := call.Fun.(*ast.SelectorExpr) + if !ok || sel.Sel.Name != "Do" { + return true + } + if base, ok := sel.X.(*ast.SelectorExpr); ok { + if root, ok := base.X.(*ast.Ident); ok && root.Name == "c" { + t.Errorf("%s bypasses account routing via c.%s.Do", name, base.Sel.Name) + } + } + if base, ok := sel.X.(*ast.CallExpr); ok { + if method, ok := base.Fun.(*ast.SelectorExpr); ok { + if root, ok := method.X.(*ast.Ident); ok && root.Name == "c" { + t.Errorf("%s bypasses account routing via c.%s().Do", name, method.Sel.Name) + } + } + } + return true + }) + } +} + +func TestAccountRequestsAndLongStreamUseBoundProxy(t *testing.T) { + var mu sync.Mutex + paths := map[string]int{} + proxy := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { + mu.Lock() + paths[r.URL.Path]++ + mu.Unlock() + switch r.URL.Path { + case "/v2/chat/completions": + w.Header().Set("Content-Type", "text/event-stream") + _, _ = io.WriteString(w, "data: {\"choices\":[{\"delta\":{\"content\":\"hello\"}}]}\n\n") + w.(http.Flusher).Flush() + time.Sleep(100 * time.Millisecond) + _, _ = io.WriteString(w, "data: [DONE]\n\n") + case "/v2/plugin/auth/token/refresh": + _, _ = io.WriteString(w, `{"code":0,"data":{"accessToken":"new","refreshToken":"new-rt","expiresIn":3600}}`) + case "/v2/embeddings": + _, _ = io.WriteString(w, `{"code":0,"data":[{"embedding":[1,2]}]}`) + default: + _, _ = io.WriteString(w, `{"code":0,"data":{}}`) + } + })) + defer proxy.Close() + c := New() + manager, err := proxypool.New("", c.HTTP.Transport.(*http.Transport), nil) + if err != nil { + t.Fatal(err) + } + defer manager.Close() + s := proxypool.DefaultSettings() + s.URL = "http://health.invalid/" + if err := manager.Configure(s); err != nil { + t.Fatal(err) + } + results, err := manager.Import(proxy.URL) + if err != nil { + t.Fatal(err) + } + id := results[0].ID + if err := manager.Probe(context.Background(), id); err != nil { + t.Fatal(err) + } + if err := manager.Bind("u1", proxypool.Binding{Mode: "fixed", ProxyID: id}); err != nil { + t.Fatal(err) + } + c.ProxyPool = manager + c.ChatBaseCN, c.BillingBaseCN, c.WebBaseCN = "http://upstream.invalid", "http://upstream.invalid", "http://upstream.invalid" + a := &auth.Auth{UID: "u1", AccessToken: "token", RefreshToken: "refresh"} + if err := c.RefreshToken(a); err != nil { + t.Fatal(err) + } + if _, _, err := c.UserResource(a); err != nil { + t.Fatal(err) + } + if _, err := c.Embeddings(context.Background(), a, "bge-m3", []string{"hi"}); err != nil { + t.Fatal(err) + } + if _, err := c.ImageGenerations(a, map[string]any{"model": "image", "prompt": "hi"}); err != nil { + t.Fatal(err) + } + if _, err := c.Search(context.Background(), a, "hi", 1); err != nil { + t.Fatal(err) + } + if err := c.ReportChatActivity(a, "conversation", "request"); err != nil { + t.Fatal(err) + } + // The short RPC timeout must not become the chat stream's total timeout. + c.HTTP.Timeout = 20 * time.Millisecond + rc, status, _, err := c.ChatStreamContext(context.Background(), a, []byte(`{"model":"test","messages":[{"role":"user","content":"hi"}]}`), "", ChatMeta{}, nil) + if err != nil || status != 200 { + t.Fatalf("chat status=%d err=%v", status, err) + } + body, err := io.ReadAll(rc) + _ = rc.Close() + if err != nil || !strings.Contains(string(body), "[DONE]") { + t.Fatalf("stream=%q err=%v", body, err) + } + mu.Lock() + defer mu.Unlock() + for _, path := range []string{"/v2/plugin/auth/token/refresh", "/v2/embeddings", "/v2/chat/completions", "/v2/images/generations", "/agenttool/v1/search", "/v2/report"} { + if paths[path] == 0 { + t.Errorf("proxy did not receive %s", path) + } + } +} diff --git a/internal/upstream/reasoning_mirror.go b/internal/upstream/reasoning_mirror.go new file mode 100644 index 0000000000000000000000000000000000000000..58ac0e3efaaaa3b8b12d0a0c78a52c331ce706ce --- /dev/null +++ b/internal/upstream/reasoning_mirror.go @@ -0,0 +1,74 @@ +// reasoning_mirror.go 给「上游读 reasoning 字段」的模型补一份镜像。 +// +// 背景:同一段思考内容,各家协议用的键名不一样—— +// - OpenAI / DeepSeek 系:`reasoning_content`(本仓 thinking.go 的 +// backfillReasoningContent 已经在给 deepseek 系做,含空值占位) +// - Kimi / GLM / MiniMax / MiMo / Step / Space-Bunny 这类:上游按 `reasoning` +// 读历史里的思考段,客户端只发 `reasoning_content` 时,上游看到的是「assistant +// 消息没有思考」,多轮一致性校验就会挂(上游 2026-11-08 的 fix 与实测)。 +// +// 为什么单独一份、不并进 backfillReasoningContent:两者纪律相反。 +// - deepseek 那份是**补齐**:每个 assistant 消息都必须有 reasoning_content 与 +// reasoning,空的历史也补 ""/空格 占位(那边的上游对 len>0 有校验)。 +// - 这里是**镜像**:只把已有的非空 reasoning_content 抄进空的 reasoning,绝不 +// 新建字段、绝不填占位。这六个家族没有「必须有该字段」的实测依据,凭空补字段 +// 等于替上游臆造报文。 +package upstream + +import "strings" + +// upstreamReasoningModelPrefixes 上游按 `reasoning` 字段读历史的模型前缀。 +// +// 前缀集合照抄上游实现(workbuddy2api-hub 5546063)。加新家族前先确认它确实读 +// `reasoning`:错误地加进来,会在原本不看该字段的模型上多出一个陌生键。 +var upstreamReasoningModelPrefixes = []string{ + "kimi", "glm", "minimax", "mimo", "step", "space-bunny", +} + +// readsUpstreamReasoning 该模型是否按 `reasoning` 字段读历史。入参可带 realm 前缀。 +func readsUpstreamReasoning(model string) bool { + _, bare := SplitRealmPrefix(model) + lower := strings.ToLower(strings.TrimSpace(bare)) + if lower == "" { + return false + } + for _, p := range upstreamReasoningModelPrefixes { + if strings.HasPrefix(lower, p) { + return true + } + } + return false +} + +// mirrorUpstreamReasoning 把这些模型的 assistant 历史里非空 reasoning_content +// 镜像到空的 reasoning 字段;其余一律不动。 +// +// 只处理 assistant(user/tool 没有思考段);reasoning 已有非空字符串时不覆盖 +// ——上游若自己写了更权威的版本,不能拿客户端的副本盖掉它。 +func mirrorUpstreamReasoning(obj map[string]any) { + model, _ := obj["model"].(string) + if !readsUpstreamReasoning(model) { + return + } + msgs, ok := obj["messages"].([]any) + if !ok || len(msgs) == 0 { + return + } + for _, rawMsg := range msgs { + msg, ok := rawMsg.(map[string]any) + if !ok { + continue + } + if role, _ := msg["role"].(string); role != "assistant" { + continue + } + rc, _ := msg["reasoning_content"].(string) + if strings.TrimSpace(rc) == "" { + continue + } + if r, ok := msg["reasoning"].(string); ok && strings.TrimSpace(r) != "" { + continue + } + msg["reasoning"] = rc + } +} diff --git a/internal/upstream/refresh_test.go b/internal/upstream/refresh_test.go new file mode 100644 index 0000000000000000000000000000000000000000..b7c525f4acadf5d59f9ea003e6b9a44332da762b --- /dev/null +++ b/internal/upstream/refresh_test.go @@ -0,0 +1,271 @@ +package upstream + +import ( + "net/http" + "strings" + "sync" + "sync/atomic" + "testing" + "time" + + "github.com/misakano7545/workbuddy2api-panel/internal/auth" +) + +const refreshOKBody = `{"code":0,"msg":"ok","data":{"accessToken":"newat","refreshToken":"newrt","expiresIn":3600}}` + +func refreshAuth(uid, rt string, ttl time.Duration) *auth.Auth { + return &auth.Auth{ + UID: uid, + AccessToken: "at", + RefreshToken: rt, + ExpiresAt: time.Now().Add(ttl).Unix(), + } +} + +func withRefreshGrace(t *testing.T, d time.Duration) { + t.Helper() + old := refreshGrace + refreshGrace = d + t.Cleanup(func() { refreshGrace = old }) +} + +// TestRefreshTokenIfNeededSingleFlight 同一个 RT 的两个按需刷新并发时, +// 只允许一个 leader 打上游;另一个等结果,不得重复消费 RT。 +func TestRefreshTokenIfNeededSingleFlight(t *testing.T) { + withRefreshGrace(t, 60*time.Second) + + var calls atomic.Int32 + started := make(chan struct{}) + release := make(chan struct{}) + var once sync.Once + c := testClient(func(r *http.Request) (*http.Response, error) { + calls.Add(1) + once.Do(func() { close(started) }) + <-release + return jsonResp(200, refreshOKBody), nil + }) + + a := refreshAuth("u1", "r1", time.Minute) + var wg sync.WaitGroup + errs := make(chan error, 2) + for i := 0; i < 2; i++ { + wg.Add(1) + go func() { + defer wg.Done() + errs <- c.RefreshTokenIfNeeded(a, 10*time.Minute) + }() + } + <-started + time.Sleep(50 * time.Millisecond) // 让第二个 goroutine 进入在途等待 + close(release) + wg.Wait() + close(errs) + for err := range errs { + if err != nil { + t.Fatalf("refresh: %v", err) + } + } + if got := calls.Load(); got != 1 { + t.Fatalf("upstream refresh calls=%d want 1", got) + } + if a.AccessToken != "newat" || a.RefreshToken != "newrt" { + t.Fatalf("tokens=%q/%q want newat/newrt", a.AccessToken, a.RefreshToken) + } +} + +// TestRefreshForcedAndNeededShareCall keepalive 的强制刷新与请求路径的按需刷新 +// 撞在一起时,同样只花一次 RT:强制调用等 leader 的结果,不额外发请求。 +func TestRefreshForcedAndNeededShareCall(t *testing.T) { + withRefreshGrace(t, 60*time.Second) + + var calls atomic.Int32 + started := make(chan struct{}) + release := make(chan struct{}) + var once sync.Once + c := testClient(func(r *http.Request) (*http.Response, error) { + calls.Add(1) + once.Do(func() { close(started) }) + <-release + return jsonResp(200, refreshOKBody), nil + }) + + a := refreshAuth("u1", "r1", time.Minute) + var wg sync.WaitGroup + errs := make(chan error, 2) + wg.Add(2) + go func() { + defer wg.Done() + errs <- c.RefreshToken(a) + }() + go func() { + defer wg.Done() + errs <- c.RefreshTokenIfNeeded(a, 10*time.Minute) + }() + <-started + time.Sleep(50 * time.Millisecond) + close(release) + wg.Wait() + close(errs) + for err := range errs { + if err != nil { + t.Fatalf("refresh: %v", err) + } + } + if got := calls.Load(); got != 1 { + t.Fatalf("upstream refresh calls=%d want 1", got) + } +} + +// TestRefreshGraceReusesResult 刷新成功后 60 秒内,拿着旧 RT 的调用方直接复用 +// 结果,不再发请求;旧快照也要被合并成新 token(对应插件的 renewed 宽限)。 +func TestRefreshGraceReusesResult(t *testing.T) { + withRefreshGrace(t, 60*time.Second) + + var calls atomic.Int32 + c := testClient(func(r *http.Request) (*http.Response, error) { + calls.Add(1) + return jsonResp(200, refreshOKBody), nil + }) + + a := refreshAuth("u1", "r1", time.Minute) + if err := c.RefreshToken(a); err != nil { + t.Fatalf("first refresh: %v", err) + } + old := refreshAuth("u1", "r1", time.Minute) + if err := c.RefreshTokenIfNeeded(old, 10*time.Minute); err != nil { + t.Fatalf("grace refresh: %v", err) + } + if got := calls.Load(); got != 1 { + t.Fatalf("upstream refresh calls=%d want 1 (grace reuse)", got) + } + if old.AccessToken != "newat" || old.RefreshToken != "newrt" { + t.Fatalf("old snapshot not merged: %q/%q", old.AccessToken, old.RefreshToken) + } +} + +// TestRefreshGraceExpires 宽限窗口外,旧 RT 的调用会重新打上游(用于确认 +// 60 秒只是并发窗口,不是长期缓存)。 +func TestRefreshGraceExpires(t *testing.T) { + withRefreshGrace(t, 0) + + var calls atomic.Int32 + c := testClient(func(r *http.Request) (*http.Response, error) { + calls.Add(1) + return jsonResp(200, refreshOKBody), nil + }) + + a := refreshAuth("u1", "r1", time.Minute) + if err := c.RefreshToken(a); err != nil { + t.Fatalf("first refresh: %v", err) + } + old := refreshAuth("u1", "r1", time.Minute) + if err := c.RefreshTokenIfNeeded(old, 10*time.Minute); err != nil { + t.Fatalf("second refresh: %v", err) + } + if got := calls.Load(); got != 2 { + t.Fatalf("upstream refresh calls=%d want 2 after grace", got) + } +} + +// TestRefreshForcedBypassesGrace 强制刷新(keepalive)必须真正问上游:它承担 +// 12153 连续失败计数,不能吃按需刷新的 60 秒宽限,否则上游不换 RT 时会把后续 +// 真失败掩盖成成功。并发场景仍由在途共享保护(见上一个用例)。 +func TestRefreshForcedBypassesGrace(t *testing.T) { + withRefreshGrace(t, 60*time.Second) + + var calls atomic.Int32 + c := testClient(func(r *http.Request) (*http.Response, error) { + calls.Add(1) + return jsonResp(200, refreshOKBody), nil + }) + + a := refreshAuth("u1", "r1", time.Minute) + if err := c.RefreshTokenIfNeeded(a, 10*time.Minute); err != nil { + t.Fatalf("first refresh: %v", err) + } + old := refreshAuth("u1", "r1", time.Minute) + if err := c.RefreshToken(old); err != nil { + t.Fatalf("forced refresh: %v", err) + } + if got := calls.Load(); got != 2 { + t.Fatalf("upstream refresh calls=%d want 2 (forced bypasses grace)", got) + } +} + +// TestRefreshLoserNotSessionDead 并发落败方拿到 12153 时,如果共享 Auth 已经被 +// 另一个刷新换新,应返回 nil 而不是 ErrSessionDead(避免误禁用账号)。 +func TestRefreshLoserNotSessionDead(t *testing.T) { + c := testClient(func(r *http.Request) (*http.Response, error) { + return jsonResp(200, refreshOKBody), nil + }) + a := &auth.Auth{UID: "u1", AccessToken: "newat", RefreshToken: "newrt"} + lost := &refreshResult{ + err: &Error{Kind: ErrSessionDead, Status: 401, Msg: "12153: refresh token is invalid"}, + at: time.Now(), + } + if err := c.applyRefresh(a, lost, "at", "r1"); err != nil { + t.Fatalf("concurrent loser must not surface session-dead: %v", err) + } + + // 反例:token 没变时,真正的 12153 仍要透出。 + b := &auth.Auth{UID: "u1", AccessToken: "at", RefreshToken: "r1"} + if err := c.applyRefresh(b, lost, "at", "r1"); err == nil { + t.Fatal("real session-dead must surface") + } +} + +// TestRefreshIfNeededSkipsFresh 新鲜 token 不应触发任何上游请求。 +func TestRefreshIfNeededSkipsFresh(t *testing.T) { + var calls atomic.Int32 + c := testClient(func(r *http.Request) (*http.Response, error) { + calls.Add(1) + return jsonResp(200, refreshOKBody), nil + }) + a := refreshAuth("u1", "r1", time.Hour) + if err := c.RefreshTokenIfNeeded(a, 10*time.Minute); err != nil { + t.Fatalf("refresh: %v", err) + } + if got := calls.Load(); got != 0 { + t.Fatalf("upstream refresh calls=%d want 0", got) + } +} + +// TestRefreshPanicReleasesWaiters leader 在刷新中 panic 时,等待者必须被释放并 +// 拿到错误,而不是永久挂在 done 上。 +func TestRefreshPanicReleasesWaiters(t *testing.T) { + withRefreshGrace(t, 60*time.Second) + + started := make(chan struct{}) + release := make(chan struct{}) + var once sync.Once + c := testClient(func(r *http.Request) (*http.Response, error) { + once.Do(func() { close(started) }) + <-release + panic("boom") + }) + + a := refreshAuth("u1", "r1", time.Minute) + leader := make(chan any, 1) + go func() { + defer func() { leader <- recover() }() + _ = c.RefreshToken(a) + }() + <-started + + waiter := make(chan error, 1) + go func() { waiter <- c.RefreshTokenIfNeeded(a, 10*time.Minute) }() + time.Sleep(20 * time.Millisecond) // 让 waiter 进入在途等待 + close(release) + + if r := <-leader; r == nil { + t.Fatal("leader should panic") + } + select { + case err := <-waiter: + if err == nil || !strings.Contains(err.Error(), "refresh panic") { + t.Fatalf("waiter err=%v want refresh panic", err) + } + case <-time.After(2 * time.Second): + t.Fatal("waiter hung after leader panic") + } +} diff --git a/internal/upstream/report.go b/internal/upstream/report.go index 3ca4e505e75c80a0d35beaa02dbb507dbaf2c837..365d9788c9cd49af18a5795a60ae623fd301f942 100644 --- a/internal/upstream/report.go +++ b/internal/upstream/report.go @@ -1,206 +1,346 @@ -// report.go growth 域「对话活跃上报」接口:POST {billingBase}/v2/report。 -// 照抄客户端 chat_request_send 事件形状(含 conversationId/mode/inputLength 等全字段, -// 勿用最小 3 字段,防上游后续加严)。事件必须带 userId(=账号 uid),缺失则服务端 -// 200 但静默丢弃(实测见 REPORT-active-map.md §2)。 -// -// 一条上报同时点亮 growth 连登 + 解锁 first_buddy 任务(领养前置)。 -// 风控口径:每号每天 1 次即可(activity_hours 单时点),不做多时点高频上报。 -package upstream - -import ( - "bytes" - "encoding/json" - "errors" - "io" - "net/http" - "time" - - "github.com/linguo2625469/workbuddy2api-panel/internal/auth" -) - -// reportPath 活跃上报通道(实测)。 -const reportPath = "/v2/report" - -// billingJSON 发 billing 域(billingBase,codebuddy.cn)请求并解信封;body 为 nil 时不带请求体。 -// 与 travel.go 的 growthJSON 对称(growth 域走 chatBase + BillingHeaders;billing 域走 billingBase)。 -// report/checkin 等 billing 端点共用:请求头统一 BillingHeaders,信封与错误语义同 doJSON。 -func (c *Client) billingJSON(a *auth.Auth, method, path string, body any) (json.RawMessage, error) { - var rdr io.Reader - if body != nil { - raw, err := json.Marshal(body) - if err != nil { - return nil, err - } - rdr = bytes.NewReader(raw) - } - req, err := http.NewRequest(method, c.billingBase(a)+path, rdr) - if err != nil { - return nil, err - } - c.BillingHeaders(req, a) - return c.doJSON(req) -} - -// billingMeterJSON 仅对 /billing/meter 族端点(get-user-resource / daily-checkin) -// 按 realm 走双路径 fallback:global 先无 /v2 前缀,ErrNotFound 时二次换有 /v2 前缀 -// (上游新旧路径分叉);cn 单路径(有 /v2)现状不变。仅 global realm 才有多路径。 -func (c *Client) billingMeterJSON(a *auth.Auth, paths []string, method string, body any) (json.RawMessage, error) { - var lastErr error - for i, path := range paths { - data, err := c.billingJSON(a, method, path, body) - if err == nil { - return data, nil - } - lastErr = err - // 仅 404 换路径(路径不存在才值得 fallback);其他错误直接返回。 - var ue *Error - if !errors.As(err, &ue) || ue.Kind != ErrNotFound || i == len(paths)-1 { - return nil, err - } - } - return nil, lastErr -} - -// billingRetryDelay 签到/余额等维护类计费调用瞬时错误重试的间隔基数。 -// 独立变量供测试缩短(生产固定 2s:第 1 次重试等 2s、第 2 次等 4s)。 -var billingRetryDelay = 2 * time.Second - -// isTransientBillingErr 报告 err 是否值得对计费维护类调用做有界重试: -// 上游 5xx(ErrServer,实测偶发 "code 10000 / API request failed with status -// code: 500")或网络层错误(非 *Error 的传输失败)。业务错误(code!=0 的 -// 已签到/参数错、4xx、限流)不重试——重试只会原样再失败一次。 -func isTransientBillingErr(err error) bool { - if err == nil { - return false - } - var ue *Error - if errors.As(err, &ue) { - return ue.Kind == ErrServer - } - return true -} - -// retryBillingTransient 对签到/余额这类低频维护调用做瞬时错误有界重试: -// 最多补打 2 次(间隔 2s、4s),首次成功或非瞬时错误立即返回。chat 热路径 -// 不用本策略——它有自己的换号轮转语义,重试会放大在途请求。 -func (c *Client) retryBillingTransient(fn func() error) error { - err := fn() - if err == nil || !isTransientBillingErr(err) { - return err - } - for i := 1; i <= 2; i++ { - time.Sleep(time.Duration(i) * billingRetryDelay) - if err = fn(); err == nil || !isTransientBillingErr(err) { - return err - } - } - return err -} - -// chatRequestEvent 客户端 chat_request_send 事件完整形状(与 probe_active.py chat_event 对齐)。 -// userId 为必填字段(= a.UID);conversationId 由调用方生成,无需真实会话。 -type chatRequestEvent struct { - EventCode string `json:"eventCode"` - Timestamp int64 `json:"timestamp"` - ReportDelay int `json:"reportDelay"` - Mode string `json:"mode"` - ConversationID string `json:"conversationId"` - RequestID string `json:"requestId"` - InputLength int `json:"inputLength"` - RequestModelID string `json:"requestModelId"` - RequestModelName string `json:"requestModelName"` - IsPlan bool `json:"isPlan"` - IsAutoExecuteTerminal bool `json:"isAutoExecuteTerminal"` - IsAutoModify bool `json:"isAutoModify"` - CodebaseEnable bool `json:"codebaseEnable"` - MaxToken int `json:"maxToken"` - MaxSteps int `json:"maxSteps"` - Temperature int `json:"temperature"` - MaxRetries int `json:"maxRetries"` - MentionContexts []any `json:"mentionContexts"` - KnowledgeID []any `json:"knowledgeId"` - KnowledgeName []any `json:"knowledgeName"` - CodebaseID string `json:"codebaseId"` - MentionContextCount int `json:"mentionContextCount"` - Command string `json:"command"` - ExpertID string `json:"expertId"` - RecommendID string `json:"recommendId"` - SkillID string `json:"skillId"` - SkillCount int `json:"skillCount"` - TotalCount int `json:"totalCount"` - FileURI string `json:"fileUri"` - PresentAt int64 `json:"presentAt"` - TraceID string `json:"traceId"` - RootRequestID string `json:"rootRequestId"` - ParentConversationID string `json:"parentConversationId"` - AgentName string `json:"agentName"` - AgentType string `json:"agentType"` - UserID string `json:"userId"` -} - -// ReportChatActivity 向上游发送一条对话活跃上报(chat_request_send)。 -// conversationID 由调用方生成(如 wb2api-),无需真实会话——服务端不校验一致性。 -// requestID 为本轮请求独立标识(多轮同会话上报时各条不同);空时回落 conversationID。 -// 错误语义与 doJSON 一致:HTTP 非 2xx / 业务 code != 0 → *Error。 -func (c *Client) ReportChatActivity(a *auth.Auth, conversationID, requestID string) error { - return c.ReportChatActivityModel(a, conversationID, requestID, "deepseek-v4-flash", "DeepSeek V4 Flash") -} - -// ReportChatActivityModel 同上,但可指定上报携带的模型:供「体验某模型」类任务 -// 对齐实际模型(如 Model_chat_GLM5.2 需 requestModelId=glm-5.2 与独立 requestID)。 -func (c *Client) ReportChatActivityModel(a *auth.Auth, conversationID, requestID, modelID, modelName string) error { - if requestID == "" { - requestID = conversationID - } - if modelID == "" { - modelID = "deepseek-v4-flash" - } - if modelName == "" { - modelName = modelID - } - now := time.Now().UnixMilli() - ev := chatRequestEvent{ - EventCode: "chat_request_send", - Timestamp: now, - ReportDelay: 0, - Mode: "craft", - ConversationID: conversationID, - RequestID: requestID, - InputLength: 12, - RequestModelID: modelID, - RequestModelName: modelName, - IsPlan: false, - IsAutoExecuteTerminal: false, - IsAutoModify: false, - CodebaseEnable: false, - MaxToken: 0, - MaxSteps: 0, - Temperature: 0, - MaxRetries: 0, - MentionContexts: []any{}, - KnowledgeID: []any{}, - KnowledgeName: []any{}, - CodebaseID: "", - MentionContextCount: 0, - Command: "", - ExpertID: "", - RecommendID: "", - SkillID: "", - SkillCount: 0, - TotalCount: 0, - FileURI: "", - PresentAt: now, - TraceID: "", - RootRequestID: requestID, - ParentConversationID: conversationID, - AgentName: "default", - AgentType: "conversation", - UserID: a.UID, - } - raw, err := json.Marshal([]chatRequestEvent{ev}) - if err != nil { - return err - } - _, err = c.billingJSON(a, http.MethodPost, reportPath, json.RawMessage(raw)) - return err -} +// report.go growth 域「对话活跃上报」接口:POST {chatBase}/v2/report。 +// +// 通道与形状以 **WorkBuddy 5.9.3 真机**为准(2026-10-28 抓包):客户端把 /v2/report +// 发到 chat 域 www.workbuddy.cn(不是 billing 域 codebuddy.cn),UA 是 WorkBuddy +// 三段式(不是 billing 的 axios/1.16.1),事件里带全套设备/包指纹。 +// 照抄客户端 chat_request_send 事件形状(勿用最小 3 字段,防上游后续加严)。 +// 事件必须带 userId(=账号 uid),缺失则服务端 200 但静默丢弃(实测见 +// REPORT-active-map.md §2)。 +// +// 一条上报同时点亮 growth 连登 + 解锁 first_buddy 任务(领养前置)。 +// 风控口径:每号每天 1 次即可(activity_hours 单时点),不做多时点高频上报。 +package upstream + +import ( + "bytes" + "encoding/json" + "errors" + "io" + "net/http" + "strings" + "time" + + "github.com/misakano7545/workbuddy2api-panel/internal/auth" + "github.com/misakano7545/workbuddy2api-panel/internal/session" +) + +// reportPath 活跃上报通道(实测)。 +const reportPath = "/v2/report" + +// billingJSONRaw 同 billingJSON,另外把信封与**原始响应体**一并交回。 +// 为什么需要:daily-checkin 的成功回执是**平铺**的(没有 {code,msg,data} 信封), +// 只交 env.Data 会拿到 null,积分数就丢了(见 checkin_receipt.go 头注释)。 +func (c *Client) billingJSONRaw(a *auth.Auth, method, path string, body any) (apiEnvelope, []byte, error) { + var rdr io.Reader + if body != nil { + raw, err := json.Marshal(body) + if err != nil { + return apiEnvelope{}, nil, err + } + rdr = bytes.NewReader(raw) + } else if method == http.MethodPost { + // 无 body 的 POST 发 `{}`:5.9.3 真机 billing 族 POST(checkin-activity-status + // 等)Content-Length 恒为 2、body 是 `{}`,不是空 body。 + rdr = strings.NewReader("{}") + } + req, err := http.NewRequest(method, c.billingBase(a)+path, rdr) + if err != nil { + return apiEnvelope{}, nil, err + } + c.BillingHeaders(req, a) + return c.doJSONRaw(req, a) +} + +// billingJSON 发 billing 域(billingBase,codebuddy.cn)请求并解信封;body 为 nil 时不带请求体。 +// 与 travel.go 的 growthJSON 对称(growth 域走 chatBase + BillingHeaders;billing 域走 billingBase)。 +// report/checkin 等 billing 端点共用:请求头统一 BillingHeaders,信封与错误语义同 doJSON。 +func (c *Client) billingJSON(a *auth.Auth, method, path string, body any) (json.RawMessage, error) { + env, _, err := c.billingJSONRaw(a, method, path, body) + return env.Data, err +} + +// billingMeterJSON 仅对 /billing/meter 族端点(get-user-resource / daily-checkin) +// 按 realm 走双路径 fallback:global 先无 /v2 前缀,ErrNotFound 时二次换有 /v2 前缀 +// (上游新旧路径分叉);cn 单路径(有 /v2)现状不变。仅 global realm 才有多路径。 +func (c *Client) billingMeterJSON(a *auth.Auth, paths []string, method string, body any) (json.RawMessage, error) { + env, _, err := c.billingMeterRaw(a, paths, method, body) + return env.Data, err +} + +// billingMeterRaw 同 billingMeterJSON,另外把信封与原始 body 一并交回(签到回执要用 +// 平铺 body 里的 credit,见 checkin_receipt.go)。 +func (c *Client) billingMeterRaw(a *auth.Auth, paths []string, method string, body any) (apiEnvelope, []byte, error) { + var ( + lastErr error + lastRaw []byte + ) + for i, path := range paths { + env, raw, err := c.billingJSONRaw(a, method, path, body) + if err == nil { + return env, raw, nil + } + lastErr, lastRaw = err, raw + // 仅 404 换路径(路径不存在才值得 fallback);其他错误直接返回。 + var ue *Error + if !errors.As(err, &ue) || ue.Kind != ErrNotFound || i == len(paths)-1 { + return env, raw, err + } + } + return apiEnvelope{}, lastRaw, lastErr +} + +// billingRetryDelay 签到/余额等维护类计费调用瞬时错误重试的间隔基数。 +// 独立变量供测试缩短(生产固定 2s:第 1 次重试等 2s、第 2 次等 4s)。 +var billingRetryDelay = 2 * time.Second + +// billingProcessingRetryDelays 429「请求处理中」的退避阶梯:这是上游**临时状态** +// (签到/余额查询偶发),比 5xx 需要更久沉降才能结算完;与真·限流的退避分开, +// 免得把限流也拖成三次长重试。口径移植自 cli2api 的 WorkBuddy 修复(519a529)。 +var billingProcessingRetryDelays = []time.Duration{2 * time.Second, 5 * time.Second, 10 * time.Second} + +// billingProcessingMarkers 上游 429 里表示「请求处理中」的文案(中英双形态)。 +var billingProcessingMarkers = []string{"请求处理中", "request is being processed", "request processing"} + +// isBillingProcessingErr 报告 err 是否为「429 + 请求处理中」形态:临时状态,值得等它沉降。 +// 只认带分类的 *Error 且 Status==429;普通 429(真·限流)不匹配,仍不重试。 +func isBillingProcessingErr(err error) bool { + var ue *Error + if !errors.As(err, &ue) || ue.Status != http.StatusTooManyRequests { + return false + } + lower := strings.ToLower(ue.Msg) + for _, m := range billingProcessingMarkers { + if strings.Contains(ue.Msg, m) || strings.Contains(lower, strings.ToLower(m)) { + return true + } + } + return false +} + +// IsTransientBilling 导出「这次计费类失败值不值得过一会儿再试」的判据,供调度器 +// 决定要不要把账号放进延后补签队列(签到本身已有 2s/4s 两次内联重试,覆盖不了 +// 上游「请稍后重试」这种需要分钟级沉降的形态)。 +func IsTransientBilling(err error) bool { return isTransientBillingErr(err) } + +// isTransientBillingErr 报告 err 是否值得对计费维护类调用做有界重试: +// 上游 5xx(ErrServer,实测偶发 "code 10000 / API request failed with status +// code: 500")、网络层错误(非 *Error 的传输失败),以及 429「请求处理中」 +// (临时状态)。业务错误(code!=0 的已签到/参数错、其余 4xx、真·限流)不重试 +// ——重试只会原样再失败一次。 +func isTransientBillingErr(err error) bool { + if err == nil { + return false + } + if isBillingProcessingErr(err) { + return true + } + var ue *Error + if errors.As(err, &ue) { + return ue.Kind == ErrServer + } + return true +} + +// retryBillingTransient 对签到/余额这类低频维护调用做瞬时错误有界重试。两类瞬时 +// 错误、两套退避:429「请求处理中」按 2s/5s/10s 最多补打 3 次(上游结算需要更久); +// 其余瞬时错误沿用 2s/4s 最多补打 2 次。首次成功或非瞬时错误立即返回;类别中途 +// 变化(处理中 → 5xx)按新类别继续。chat 热路径不用本策略——它有自己的换号轮转 +// 语义,重试会放大在途请求。 +func (c *Client) retryBillingTransient(fn func() error) error { + err := fn() + for used := 0; err != nil && isTransientBillingErr(err); used++ { + processing := isBillingProcessingErr(err) + max := 2 + if processing { + max = len(billingProcessingRetryDelays) + } + if used >= max { + break + } + if processing { + time.Sleep(billingProcessingRetryDelays[used]) + } else { + time.Sleep(time.Duration(used+1) * billingRetryDelay) + } + err = fn() + } + return err +} + +// chatRequestEvent 客户端 chat_request_send 事件(5.9.3 真机字段集,逐字对齐)。 +// +// 2026-10-28 国内版 5.9.3 真机抓取 /v2/report 事件(body 里 4 类事件:chat_request_send / +// chat_message_response / chat_message_status / chat_request_response)。本结构只承担 +// chat_request_send 的**chat 专属**字段;设备/包指纹由 desktopFingerprint(a) 合并进来 +// (ideName / ideType / ideVersion / commit / releaseDate / machineId / sessionId / +// extName / extVersion / os / arch / osVersion / cpuModel / cpuCores / memorySize / +// qimei36 / userId / username / userNickname / product / timezone)。 +// +// 与旧实现的差异(每一处都是「多发或漏发」造成的形态偏差): +// - 删掉 maxToken / maxSteps / temperature / maxRetries / skillCount / totalCount / +// fileUri / expertId —— 5.9.3 的 chat_request_send 里**没有这些键**(旧结构是从 +// 更早的客户端抄的,多出来的空值键反而显眼)。 +// - 补 isMaxMode / source / inputAttemptId / vcsType / vcsRepo / vcsBranchName / +// vcsRevId —— 5.9.3 必带。 +// - agentName / agentType 由 "default" / "conversation" 改为 **"cli" / "main"** +// (真机桌面端走内置 CLI,两个字段都是 cli/main)。 +// - traceId 不再留空:真机有值(32 hex,与当轮 X-Trace-ID 同源)。 +type chatRequestEvent struct { + EventCode string `json:"eventCode"` + Mode string `json:"mode"` + ConversationID string `json:"conversationId"` + RequestID string `json:"requestId"` + InputLength int `json:"inputLength"` + RequestModelID string `json:"requestModelId"` + RequestModelName string `json:"requestModelName"` + IsPlan bool `json:"isPlan"` + IsAutoExecuteTerminal bool `json:"isAutoExecuteTerminal"` + IsAutoModify bool `json:"isAutoModify"` + CodebaseEnable bool `json:"codebaseEnable"` + IsMaxMode bool `json:"isMaxMode"` + Source string `json:"source"` + MentionContexts []any `json:"mentionContexts"` + KnowledgeID []any `json:"knowledgeId"` + KnowledgeName []any `json:"knowledgeName"` + CodebaseID string `json:"codebaseId"` + MentionContextCount int `json:"mentionContextCount"` + Command string `json:"command"` + InputAttemptID string `json:"inputAttemptId"` + RecommendID string `json:"recommendId"` + SkillID string `json:"skillId"` + TraceID string `json:"traceId"` + RootRequestID string `json:"rootRequestId"` + ParentConversationID string `json:"parentConversationId"` + AgentName string `json:"agentName"` + AgentType string `json:"agentType"` +} + +// reportChatEventMap 把 chat 专属字段与设备/包指纹拼成一条完整事件(真机键集)。 +func reportChatEventMap(a *auth.Auth, ev chatRequestEvent) map[string]any { + m := desktopFingerprint(a) // 设备 + 包指纹(含 qimei36 / commit / releaseDate / cpu 等) + m["eventCode"] = ev.EventCode + m["mode"] = ev.Mode + m["conversationId"] = ev.ConversationID + m["requestId"] = ev.RequestID + m["inputLength"] = ev.InputLength + m["requestModelId"] = ev.RequestModelID + m["requestModelName"] = ev.RequestModelName + m["isPlan"] = ev.IsPlan + m["isAutoExecuteTerminal"] = ev.IsAutoExecuteTerminal + m["isAutoModify"] = ev.IsAutoModify + m["codebaseEnable"] = ev.CodebaseEnable + m["isMaxMode"] = ev.IsMaxMode + m["source"] = ev.Source + m["mentionContexts"] = ev.MentionContexts + m["knowledgeId"] = ev.KnowledgeID + m["knowledgeName"] = ev.KnowledgeName + m["codebaseId"] = ev.CodebaseID + m["mentionContextCount"] = ev.MentionContextCount + m["command"] = ev.Command + m["inputAttemptId"] = ev.InputAttemptID + m["recommendId"] = ev.RecommendID + m["skillId"] = ev.SkillID + m["traceId"] = ev.TraceID + m["rootRequestId"] = ev.RootRequestID + m["parentConversationId"] = ev.ParentConversationID + m["agentName"] = ev.AgentName + m["agentType"] = ev.AgentType + // VCS 段:真机恒带四个键(未知仓库时为 unknown + 三个空串),缺了是可判别形态。 + m["vcsType"] = "unknown" + m["vcsRepo"] = "" + m["vcsBranchName"] = "" + m["vcsRevId"] = "" + // buddy 段 + OTel 语义键:真机每个事件都带,buddyId/Name 为空串。 + m["buddyId"] = "" + m["buddyName"] = "" + m["codebuddy.session_id"] = ev.ConversationID + m["codebuddy.conversation_request_id"] = ev.RequestID + return m +} + +// ReportChatActivity 向上游发送一条对话活跃上报(chat_request_send)。 +// conversationID 由调用方生成(如 wb2api-),无需真实会话——服务端不校验一致性。 +// requestID 为本轮请求独立标识(多轮同会话上报时各条不同);空时回落 conversationID。 +// 错误语义与 doJSON 一致:HTTP 非 2xx / 业务 code != 0 → *Error。 +func (c *Client) ReportChatActivity(a *auth.Auth, conversationID, requestID string) error { + return c.ReportChatActivityModel(a, conversationID, requestID, "deepseek-v4.1-flash", "DeepSeek-V4.1-Flash") +} + +// ReportChatActivityModel 同上,但可指定上报携带的模型:供「体验某模型」类任务 +// 对齐实际模型(如 Model_chat_GLM5.2 需 requestModelId=glm-5.2 与独立 requestID)。 +// +// 通道:**chatBase**(www.workbuddy.cn)+ 客户端 report 头族。 +// 旧实现把这条上报发到 billingBase(codebuddy.cn)并用 billing 的 axios UA——5.9.3 +// 真机 /v2/report 走的是 chat 域、UA 是 WorkBuddy 三段式,两处都按客户端改。 +func (c *Client) ReportChatActivityModel(a *auth.Auth, conversationID, requestID, modelID, modelName string) error { + if requestID == "" { + requestID = conversationID + } + if modelID == "" { + modelID = "deepseek-v4.1-flash" + } + if modelName == "" { + modelName = modelID + } + traceID := session.NewTraceID() + ev := chatRequestEvent{ + EventCode: "chat_request_send", + Mode: "craft", + ConversationID: conversationID, + RequestID: requestID, + InputLength: 12, + RequestModelID: modelID, + RequestModelName: modelName, + IsPlan: false, + IsAutoExecuteTerminal: false, + IsAutoModify: false, + CodebaseEnable: false, + IsMaxMode: true, + Source: "work", + MentionContexts: []any{}, + KnowledgeID: []any{}, + KnowledgeName: []any{}, + CodebaseID: "", + MentionContextCount: 0, + Command: "", + InputAttemptID: session.NewConversationID(), + RecommendID: "", + SkillID: "", + TraceID: traceID, + RootRequestID: requestID, + ParentConversationID: conversationID, + AgentName: "cli", + AgentType: "main", + } + raw, err := json.Marshal([]map[string]any{reportChatEventMap(a, ev)}) + if err != nil { + return err + } + req, err := http.NewRequest(http.MethodPost, c.chatBase(a)+reportPath, strings.NewReader(string(raw))) + if err != nil { + return err + } + // 头族逐字对齐真机 /v2/report(2026-10-30 双版本,国际 37 条 + 国内多条): + // Accept: application/json, text/plain, */* + // Content-Type: application/json;charset=UTF-8 + // X-Request-ID / X-Product: SaaS / User-Agent 三段式 / Authorization / X-User-Id / X-Domain + // + // **不发 X-Requested-With**:真机 /v2/report 按 UA 分两族,只有渲染器侧那族 + // (UA 首段驼峰 `WorkBuddy/ / …`)带它;本函数发的三段式 + // (`/ / …`)一族**没有**。两族头各取一半就是第三族。 + req.Header.Set("Accept", "application/json, text/plain, */*") + req.Header.Set("Content-Type", "application/json;charset=UTF-8") + req.Header.Set("X-Request-ID", session.NewMessageID()) + req.Header.Set("X-Product", "SaaS") + req.Header.Set("User-Agent", desktopUAFor(a)) + if at := a.AccessTokenValue(); at != "" { + req.Header.Set("Authorization", "Bearer "+at) + } + if a.UID != "" { + req.Header.Set("X-User-Id", a.UID) + } + req.Header.Set("X-Domain", c.chatHost(a)) + // 设备风控头:真机 /v2/report 不带 X-Device-Token(只有 billing 族带),故不注入。 + _, err = c.doJSON(req, a) + return err +} diff --git a/internal/upstream/report_test.go b/internal/upstream/report_test.go index badf29b1ff0421ba5dd153bb01ff0bf7bd41f36d..dd9b6848f8d6500f6e4343b7cb2e34e59ab104dd 100644 --- a/internal/upstream/report_test.go +++ b/internal/upstream/report_test.go @@ -1,69 +1,89 @@ -package upstream - -import ( - "encoding/json" - "io" - "net/http" - "net/http/httptest" - "testing" - - "github.com/linguo2625469/workbuddy2api-panel/internal/auth" -) - -// TestReportChatActivitySendsArrayWithUserID 断言出站 body 是数组、含 userId、eventCode 正确。 -func TestReportChatActivitySendsArrayWithUserID(t *testing.T) { - var got []map[string]any - srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { - if r.URL.Path != "/v2/report" { - t.Errorf("path=%s want /v2/report", r.URL.Path) - } - if r.Method != http.MethodPost { - t.Errorf("method=%s want POST", r.Method) - } - raw, _ := io.ReadAll(r.Body) - var arr []map[string]any - if err := json.Unmarshal(raw, &arr); err != nil { - t.Fatalf("body must be a JSON array: %v (body=%s)", err, raw) - } - got = arr - w.Write([]byte(`{"code":0,"msg":"OK"}`)) - })) - defer srv.Close() - - c := &Client{HTTP: srv.Client(), BillingBaseCN: srv.URL} - if err := c.ReportChatActivity(&auth.Auth{AccessToken: "at", UID: "u-active"}, "wb2api-123", ""); err != nil { - t.Fatalf("report: %v", err) - } - if len(got) != 1 { - t.Fatalf("events=%d want 1", len(got)) - } - ev := got[0] - if ev["eventCode"] != "chat_request_send" { - t.Errorf("eventCode=%v want chat_request_send", ev["eventCode"]) - } - if ev["userId"] != "u-active" { - t.Errorf("userId=%v want u-active(缺失则服务端 200 但静默丢弃)", ev["userId"]) - } - if ev["conversationId"] != "wb2api-123" { - t.Errorf("conversationId=%v want wb2api-123", ev["conversationId"]) - } - if ev["mode"] != "craft" { - t.Errorf("mode=%v want craft", ev["mode"]) - } - // 出站 body 必须是数组(以 [ 开头),不是单个对象。 -} - -// TestReportChatActivityServerError 业务 code 非 0 返回 *Error。 -func TestReportChatActivityServerError(t *testing.T) { - srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { - w.WriteHeader(500) - w.Write([]byte(`boom`)) - })) - defer srv.Close() - - c := &Client{HTTP: srv.Client(), BillingBaseCN: srv.URL} - err := c.ReportChatActivity(&auth.Auth{AccessToken: "at", UID: "u1"}, "cid", "") - if err == nil { - t.Fatal("want error on 500") - } -} +package upstream + +import ( + "encoding/json" + "io" + "net/http" + "net/http/httptest" + "testing" + + "github.com/misakano7545/workbuddy2api-panel/internal/auth" +) + +// TestReportChatActivitySendsArrayWithUserID 断言出站 body 是数组、含 userId、eventCode 正确。 +func TestReportChatActivitySendsArrayWithUserID(t *testing.T) { + var got []map[string]any + srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { + if r.URL.Path != "/v2/report" { + t.Errorf("path=%s want /v2/report", r.URL.Path) + } + if r.Method != http.MethodPost { + t.Errorf("method=%s want POST", r.Method) + } + raw, _ := io.ReadAll(r.Body) + var arr []map[string]any + if err := json.Unmarshal(raw, &arr); err != nil { + t.Fatalf("body must be a JSON array: %v (body=%s)", err, raw) + } + got = arr + w.Write([]byte(`{"code":0,"msg":"OK"}`)) + })) + defer srv.Close() + + // 通道是 chatBase(5.9.3 真机 /v2/report 发往 www.workbuddy.cn),不是 billingBase。 + c := &Client{HTTP: srv.Client(), ChatBaseCN: srv.URL} + if err := c.ReportChatActivity(&auth.Auth{AccessToken: "at", UID: "u-active"}, "wb2api-123", ""); err != nil { + t.Fatalf("report: %v", err) + } + if len(got) != 1 { + t.Fatalf("events=%d want 1", len(got)) + } + ev := got[0] + if ev["eventCode"] != "chat_request_send" { + t.Errorf("eventCode=%v want chat_request_send", ev["eventCode"]) + } + if ev["userId"] != "u-active" { + t.Errorf("userId=%v want u-active(缺失则服务端 200 但静默丢弃)", ev["userId"]) + } + if ev["conversationId"] != "wb2api-123" { + t.Errorf("conversationId=%v want wb2api-123", ev["conversationId"]) + } + if ev["mode"] != "craft" { + t.Errorf("mode=%v want craft", ev["mode"]) + } + // 真机键集:agentName/agentType 是 cli/main(旧实现发 default/conversation), + // VCS 四键恒在(未知仓库为 unknown + 三个空串),buddy 段恒在。 + if ev["agentName"] != "cli" || ev["agentType"] != "main" { + t.Errorf("agentName/agentType=%v/%v want cli/main", ev["agentName"], ev["agentType"]) + } + if ev["source"] != "work" { + t.Errorf("source=%v want work", ev["source"]) + } + if _, ok := ev["isMaxMode"]; !ok { + t.Error("缺 isMaxMode(5.9.3 真机必带)") + } + if ev["vcsType"] != "unknown" { + t.Errorf("vcsType=%v want unknown", ev["vcsType"]) + } + for _, k := range []string{"commit", "releaseDate", "ideVersion", "machineId", "codebuddy.session_id"} { + if _, ok := ev[k]; !ok { + t.Errorf("缺设备/包指纹键 %q", k) + } + } + // 出站 body 必须是数组(以 [ 开头),不是单个对象。 +} + +// TestReportChatActivityServerError 业务 code 非 0 返回 *Error。 +func TestReportChatActivityServerError(t *testing.T) { + srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { + w.WriteHeader(500) + w.Write([]byte(`boom`)) + })) + defer srv.Close() + + c := &Client{HTTP: srv.Client(), ChatBaseCN: srv.URL} + err := c.ReportChatActivity(&auth.Auth{AccessToken: "at", UID: "u1"}, "cid", "") + if err == nil { + t.Fatal("want error on 500") + } +} diff --git a/internal/upstream/restrict.go b/internal/upstream/restrict.go new file mode 100644 index 0000000000000000000000000000000000000000..d87aa7bd000359f9ee5ed62d39585297eb0c0068 --- /dev/null +++ b/internal/upstream/restrict.go @@ -0,0 +1,35 @@ +// restrict.go 上游 11140「账号存在异常行为」的识别(风控连坐保护的判据)。 +// +// 背景:11140 有两种形态,处置方向完全相反,必须分开: +// - 英文 "request illegal"(auth_forbidden,渠道校验/授权)→ accountFaultMarkers; +// - 账号风控限制文书(中文「账号存在异常行为,已被限制使用」/ 英文 "unusual activity") +// → 本文件。这一类判据在上游是**设备/出口级**,换账号只会连坐(hub #422 实测: +// 一次任务 7 个号全封)。 +// +// 为什么必须 code + 文案同时要求:11140 也承载模型级限流("The model provider is +// rate-limiting requests."),只按 code 判会把限流转成账号终态(少服务一天);只按 +// 文案判会误伤正文里恰好讨论这些词的数据。 +package upstream + +import "strings" + +// restrictionMarkers 风控限制文书的实测措辞(社区封禁复盘 + hub #422 的 403 样例)。 +var restrictionMarkers = []string{ + "账号存在异常行为", + "已被限制", + "unusual activity", +} + +// IsRestricted 报告响应信封是否为「账号被上游风控限制」(结构化 code 11140 + 限制文案)。 +func IsRestricted(body string) bool { + if !hasBusinessCode(body, "11140") && !HasCodeMarker(body, "11140") { + return false + } + lower := strings.ToLower(body) + for _, m := range restrictionMarkers { + if strings.Contains(body, m) || strings.Contains(lower, m) { + return true + } + } + return false +} diff --git a/internal/upstream/restrict_test.go b/internal/upstream/restrict_test.go new file mode 100644 index 0000000000000000000000000000000000000000..c525dcf526ea0e3b24dfd3f200852fe832fac188 --- /dev/null +++ b/internal/upstream/restrict_test.go @@ -0,0 +1,47 @@ +// restrict_test.go 11140 风控限制文书的识别与分类。 +// +// 判据两条必须同时成立,缺一条都会把账算错: +// - 只按 code 11140 判:会把「模型供应商限流」(同一 code)判成账号终态,白扔一个号; +// - 只按文案判:正文里讨论「已被限制」的普通请求会被误判。 +package upstream + +import "testing" + +func TestIsRestricted(t *testing.T) { + cases := []struct { + name string + body string + want bool + }{ + {"中文风控文书", `{"code":11140,"msg":"账号存在异常行为,已被限制使用"}`, true}, + {"英文 unusual activity", `{"code":11140,"msg":"Your account shows unusual activity and has been restricted."}`, true}, + {"字符串形态的 code", `{"code":"11140","msg":"账号存在异常行为"}`, true}, + {"带空白的 code", `{"code": 11140, "msg": "账号存在异常行为"}`, true}, + // 同一 code 承载的模型级限流:不能算「账号被限制」。 + {"只有 code 没有限制文案", `{"code":11140,"msg":"The model provider is rate-limiting requests."}`, false}, + // 有文案但 code 对不上(例如内容审核的业务码):不是账号限制。 + {"只有文案没有 code", `{"code":50400,"msg":"账号存在异常行为"}`, false}, + // 授权形态(英文 request illegal)归 accountFaultMarkers,不是这条判据。 + {"request illegal 形态", `{"code":11140,"msg":"request illegal"}`, false}, + {"纯文本", `账号存在异常行为,已被限制使用`, false}, + } + for _, tc := range cases { + t.Run(tc.name, func(t *testing.T) { + if got := IsRestricted(tc.body); got != tc.want { + t.Fatalf("IsRestricted(%s) = %v, want %v", tc.body, got, tc.want) + } + }) + } +} + +// TestClassifyRestrictionIsAccountFault 中文风控文书必须归账号级:落通用 4xx 兜底 +// (ErrClient)只会「换号继续打」,一个请求就能把整池账号按顺序送进风控。 +func TestClassifyRestrictionIsAccountFault(t *testing.T) { + if got := Classify(403, `{"code":11140,"msg":"账号存在异常行为,已被限制使用"}`); got != ErrAccountFault { + t.Fatalf("中文 11140 文书应归 ErrAccountFault,得到 %v", got) + } + // 同一 code 的模型限流不得被这条判据吃掉(仍是可自愈的软限流)。 + if got := Classify(429, `{"code":11140,"msg":"The model provider is rate-limiting requests."}`); got != ErrSoftRate { + t.Fatalf("11140 + 限流文案应保持 ErrSoftRate,得到 %v", got) + } +} diff --git a/internal/upstream/sanitize.go b/internal/upstream/sanitize.go index 3f753918dea73039a3863b457628a020b4cd5042..4eb6a5d405bba8b84cf9acd188c9144b400b7502 100644 --- a/internal/upstream/sanitize.go +++ b/internal/upstream/sanitize.go @@ -1,220 +1,523 @@ -// sanitize.go 出站请求体脱敏:剥离上游内容审核黑名单指纹。 -// -// 背景:客户端(Claude Code 类 CLI)在 system prompt 注入若干固定模板句, -// 上游内容审核按逐字精确匹配拦截(非语义审核),一字改动即可绕过。 -// 策略:键值/header 型指纹整段剥离;承载语义的模板句最小改写(换一词),语义不变。 -package upstream - -import ( - "regexp" - "strings" -) - -// sanitizeFeatures 特征预检:任一命中才进入净化(strings.Contains 快速路径, -// 普通请求全不中 → 原样返回,零分配)。 -var sanitizeFeatures = []string{ - "x-anthropic-billing-header", // header 键值段键名 - "cc_entrypoint=", // 尾随裸键值(截断前缀即可命中) - "You are Claude Code", // 身份句(截断前缀即可命中) - "Main branch (", // 注入指令句(截断前缀即可命中) - "You are a coding agent running in the Codex CLI", // Codex instructions 首段(截断前缀即可命中) - "github.com/anthropics/", // 反馈句里的 Anthropic 仓库链接 - "11128", // 上游反探测:裸数字错误码 -} - -// sanitizeHdrRe 剥离层:header 键名即触发(与值无关),整段删除。 -var sanitizeHdrRe = regexp.MustCompile(`(?i)x-anthropic-billing-header:[^;\n]*;?\s*`) - -// sanitizeBareHdrRe 兜底层:裸键名(无冒号无值)同样是指纹——2026-09-13 实验 F4 -// 证实 assistant 消息里反引号引用裸键名即触发 11128,而剥离层要求冒号、对裸串无效。 -// 键值形态被整段删除后,残留的裸键名做最小缩写(header→hdr):破坏逐字匹配、 -// 语义不变、保留可读性。大小写不敏感,覆盖 X-Anthropic-... 变体。 -// -// 注意该正则不要求冒号,是 sanitizeHdrRe 的超集——hasFingerprint 与 sanitizeText -// 中两者并用:先删键值形态(sanitizeHdrRe),再缩写残留裸键名(本正则), -// 替换语义不同(整段删除 vs 最小缩写),不可合并为一个正则。 -var sanitizeBareHdrRe = regexp.MustCompile(`(?i)x-anthropic-billing-header`) - -// sanitizeKvRe 剥离层:尾随裸键值(cc_xxx=...;)循环清理。 -var sanitizeKvRe = regexp.MustCompile(`(?i)\bcc_[a-z0-9_]+=[^;\n]*;?\s*`) - -// sanitizeRewrites 改写层:全模板句逐字替换(每句只改一个词,语义不变)。 -// -// 身份句的匹配串**不带结尾标点**(只到 "…for Claude" 为止): -// CLI 版这句以句号收尾("…for Claude."),桌面版(claude-desktop-3p / Agent SDK) -// 以逗号接后继内容("…for Claude, running within the Claude Agent SDK.")。 -// 带句号的整句只匹配前者,桌面版会漏网、指纹原样发上游 → 400 code=11128。 -// 去掉结尾标点后两种形态一并覆盖(替换串同样不带标点,让原有标点原样保留)。 -// 注意仍要求 "You are Claude Code, " 前缀,不做更宽的子串替换, -// 以免误伤 TestExactMatchOnlyVariantNotTouched 所保护的零散文本。 -var sanitizeRewrites = [][2]string{ - { - "You are Claude Code, Anthropic's official CLI for Claude", - "You are Claude Code, Anthropic's official CLI tool for Claude", - }, - { - "Main branch (you will usually use this for PRs)", - "Default branch (you will usually use this for PRs)", - }, - { - "You are a coding agent running in the Codex CLI, a terminal-based coding assistant.", - "You are a coding agent running in the Codex CLI tool, a terminal-based coding assistant.", - }, - { - // 反馈句:整句带 Anthropic 仓库链接,上游按整句拦截(只留链接或只留半边均不拦, - // 实测需整句同时出现)。give→provide 一词之差即可绕过,语义不变。 - "To give feedback, users should report the issue at https://github.com/anthropics/claude-code/issues", - "To provide feedback, users should report the issue at https://github.com/anthropics/claude-code/issues", - }, - { - // 上游反探测:只要请求体里出现裸数字 11128 就整单拦截(与该数字的上下文无关—— - // "code=11128" / 裸 "11128" / "错误码 11128" / "Code=11128" 全部命中; - // 相邻的 11148 / 11101 / 11115 / 99999 均放行)。11128 正是本类拦截自身的错误码, - // 上游据此识别"在讨论/回显其内部错误码"的请求。 - // 代价:用户对话中任何 11128 都会被改写——但这串数字出现在请求里本身就是拦截条件, - // 不改写必然失败。插入连字符保留可读性与指代(零宽空格无效,实测上游会归一化)。 - "11128", - "11-128", - }, -} - -// sanitizeText 单段文本净化:预检不中 → 返回原串(零分配)。 -func sanitizeText(text string) string { - if !hasFingerprint(text) { - return text - } - for _, rw := range sanitizeRewrites { - text = strings.ReplaceAll(text, rw[0], rw[1]) - } - if sanitizeHdrRe.MatchString(text) { - text = sanitizeHdrRe.ReplaceAllString(text, "") - } - if strings.Contains(text, "cc_") { - prev := "" - for prev != text { // 清尾随裸 kv(cc_version=...; cc_entrypoint=...;) - prev = text - text = sanitizeKvRe.ReplaceAllString(text, "") - } - } - // 兜底:键值形态已在上面整段删除,这里只剩裸键名(引用/示例文本形态)。 - text = sanitizeBareHdrRe.ReplaceAllString(text, "x-anthropic-billing-hdr") - return strings.TrimSpace(text) -} - -// hasFingerprint 特征预检:先走 strings.Contains 快速路径(零分配); -// header 键名有大小写变体(X-Anthropic-...)且可能以裸键名形态出现(无冒号), -// Contains 大小写敏感、sanitizeHdrRe 要求冒号——两者都会漏掉「混合大小写 + 裸键名」, -// 必须再用不要求冒号的 (?i) 正则兜底(sanitizeBareHdrRe),否则整条净化被跳过。 -// sanitizeBareHdrRe 不要求冒号,是 sanitizeHdrRe 的超集,故无需再单独匹配后者。 -func hasFingerprint(text string) bool { - for _, f := range sanitizeFeatures { - if strings.Contains(text, f) { - return true - } - } - return sanitizeBareHdrRe.MatchString(text) -} - -// sanitizeContent 兼容字符串与多模态数组;只动 text part,image 等 part 不动。 -// 返回净化后的值及是否发生变化。 -func sanitizeContent(v any) (any, bool) { - switch c := v.(type) { - case string: - s := sanitizeText(c) - return s, s != c - case []any: - changed := false - for _, p := range c { - m, ok := p.(map[string]any) - if !ok { - continue - } - text, ok := m["text"].(string) - if !ok { - continue - } - if s := sanitizeText(text); s != text { - m["text"] = s - changed = true - } - } - return c, changed - } - return v, false -} - -// sanitizeToolCalls 净化 assistant.tool_calls[].function.arguments。 -// -// arguments 是**字符串化的 JSON**(不是对象),因此按文本走 sanitizeText 即可。 -// 这块长期是盲区:工具调用消息的 content 通常是 null,而旧版 sanitizeMessages -// 在 content 缺失时直接 continue,整条消息连 tool_calls 一起被跳过—— -// 于是历史里任何写进工具参数的被拦字符串(文件名、命令、写入内容)都会原样漏出。 -func sanitizeToolCalls(v any) bool { - callList, ok := v.([]any) - if !ok { - return false - } - changed := false - for _, c := range callList { - call, ok := c.(map[string]any) - if !ok { - continue - } - fn, ok := call["function"].(map[string]any) - if !ok { - continue - } - args, ok := fn["arguments"].(string) - if !ok { - continue - } - if s := sanitizeText(args); s != args { - fn["arguments"] = s - changed = true - } - } - return changed -} - -// sanitizeMessages 净化 messages 中的 content 与 tool_calls;任一命中返回 true。 -func sanitizeMessages(messages []any) bool { - changed := false - for _, msg := range messages { - m, ok := msg.(map[string]any) - if !ok { - continue - } - // content 与 tool_calls 各自独立判断:content 可以为 null(工具调用轮), - // 早期版本在此 continue,导致这类消息的 tool_calls 完全不被净化。 - if c, ok := m["content"]; ok { - if nc, ch := sanitizeContent(c); ch { - m["content"] = nc - changed = true - } - } - // reasoning_content(思维链回填字段,见 thinking.go/sse.go)实测同样 - // 携带指纹,与 content 同等净化。string 形态直接走 sanitizeText。 - if rc, ok := m["reasoning_content"].(string); ok { - if s := sanitizeText(rc); s != rc { - m["reasoning_content"] = s - changed = true - } - } - // reasoning:另一形态的思维链字段。thinking.go 的回填会把客户端送来的 - // reasoning_content 镜像进 reasoning(反之亦然),而此前只洗 content / - // reasoning_content / tool_calls —— 镜像进 reasoning 的指纹原样出站, - // 裸 "11128" 这种反探测串同样致命。 - if r, ok := m["reasoning"].(string); ok { - if s := sanitizeText(r); s != r { - m["reasoning"] = s - changed = true - } - } - if tc, ok := m["tool_calls"]; ok { - if sanitizeToolCalls(tc) { - changed = true - } - } - } - return changed -} +// sanitize.go 出站请求体脱敏:剥离上游内容审核黑名单指纹。 +// +// 背景:客户端(Claude Code 类 CLI)在 system prompt 注入若干固定模板句, +// 上游内容审核按逐字精确匹配拦截(非语义审核),一字改动即可绕过。 +// 策略:键值/header 型指纹整段剥离;承载语义的模板句最小改写(换一词),语义不变。 +package upstream + +import ( + "regexp" + "strings" +) + +// sanitizeFeatures 特征预检:任一命中才进入净化(strings.Contains 快速路径, +// 普通请求全不中 → 原样返回,零分配)。 +var sanitizeFeatures = []string{ + "x-anthropic-billing-hdr", // header 键值段键名 + // 上游服务端注入的身份指令(issue #187)。必须挂在**通用**门控上:泄漏出现在 + // assistant 消息(模型复述注入原文),而 identity 门控只对 system/developer 生效, + // 挂错门控等于规则永远不执行。 + "identify yourself as", + "model_identity", + "cc_entrypoint=", // 尾随裸键值(截断前缀即可命中) + "You are Claude Code", // 身份句(截断前缀即可命中) + "Main branch (", // 注入指令句(截断前缀即可命中) + "You are a coding agent running in the Codex CLI", // Codex instructions 首段(截断前缀即可命中) + "github.com/anthropics/", // 反馈句里的 Anthropic 仓库链接 + "11128", // 上游反探测:裸数字错误码 + "Tokens prefixed with @", // DSH 0.3.x 的 @ 路径说明段(唯一不含品牌词的 DSH 指纹) +} + +// sanitizeIdentityFeatures 身份类特征:品牌词(DSH 身份句)。默认对所有消息角色生效 +// (与上游既有行为一致);features.sanitize_brand_scope=identity 时只对 system/developer +// 生效,其余角色按用户数据原样透传。 +var sanitizeIdentityFeatures = []string{ + "DeepSeek Harness", +} + +// sanitizeHdrRe 剥离层:header 键名即触发(与值无关),整段删除。 +var sanitizeHdrRe = regexp.MustCompile(`(?i)x-anthropic-billing-header:[^;\n]*;?\s*`) + +// sanitizeBareHdrRe 兜底层:裸键名(无冒号无值)同样是指纹——2026-09-13 实验 F4 +// 证实 assistant 消息里反引号引用裸键名即触发 11128,而剥离层要求冒号、对裸串无效。 +// 键值形态被整段删除后,残留的裸键名做最小缩写(header→hdr):破坏逐字匹配、 +// 语义不变、保留可读性。大小写不敏感,覆盖 X-Anthropic-... 变体。 +// +// 注意该正则不要求冒号,是 sanitizeHdrRe 的超集——hasFingerprint 与 sanitizeText +// 中两者并用:先删键值形态(sanitizeHdrRe),再缩写残留裸键名(本正则), +// 替换语义不同(整段删除 vs 最小缩写),不可合并为一个正则。 +var sanitizeBareHdrRe = regexp.MustCompile(`(?i)x-anthropic-billing-header`) + +// sanitizeKvRe 剥离层:尾随裸键值(cc_xxx=...;)循环清理。 +var sanitizeKvRe = regexp.MustCompile(`(?i)\bcc_[a-z0-9_]+=[^;\n]*;?\s*`) + +// sanitizeDshPathsRe DSH 0.3.x 系统提示里的「@ 开头的路径怎么解析」整段说明。 +// +// 这一段是本仓唯一漏掉的 DSH 指纹:段内**不含任何品牌词**,所以 sanitizeIdentityRewrites +// (DeepSeekRuntime → …)的预检根本不会命中,原文原样发出即 400 11-128 +// Illegal API invocation from an unapproved channel。 +// +// 上游按「连续原文」匹配(逐段二分实测:只发首句放行,前两句连排即拦),所以必须整段 +// 一起改。这里做同义改写而不是删除:@ 路径、相对路径基准、结尾斜杠表示目录、其余按文件读、 +// @"..." 用于含空格的路径——语义全部保留,只换措辞让连续特征失配。 +// +// 两种线上见过的结尾措辞都要覆盖((?s) 让 .*? 跨行,段内本来就有换行): +// +// ... quotes a path containing spaces. (0.3.x 当前写法) +// ... form only quotes a path that contains spaces. (更早的写法) +// +// 段外的 @ 不受影响:邮箱、包名、含 @ 的绝对路径都不匹配。 +// +// 两条已知边界:预检是大小写敏感的(与 sanitizeFeatures 其它项一致;DSH 原文大小写固定); +// 规则属于全局改写层,任何角色里出现这一段都会被改——上游按连续原文匹配、不分角色, +// 保留原样必然 400。 +var sanitizeDshPathsRe = regexp.MustCompile( + `(?is)Tokens prefixed with @ are paths the user explicitly referenced\..*?path (?:containing|that contains) spaces\.`) + +const sanitizeDshPathsProbe = "Tokens prefixed with @" + +// sanitizeDshPathsReplacement 逐句同义改写。与主流实现(workbuddy2api-hub #677/#678)逐字 +// 一致:那段替换串已被真实 CN 账号回放验证过(修复前 400 / 修复后 200)。 +// +// 一处偏离:原文用 "workspace root",这里写 "project root"。ithtelab/workbuddy-manager#312 +// 的 0032 声称 2026-10-27 上游又单独加了 "workspace root" 这个词(root→base 即放行), +// 与上面的整段回放结论冲突——两种说法下 project root 都安全,且与 DSH 语义等价,故取它。 +const sanitizeDshPathsReplacement = "Paths beginning with @ refer to files the user explicitly mentioned. " + + "Relative paths are resolved against the project root; absolute paths point " + + "to files or directories on the host. A trailing slash marks a directory, so " + + "list it when its contents matter. Anything else is a file: open it with the " + + "read tool when its contents are needed, and never claim to have inspected it " + + "before reading. The @\"...\" form only quotes a path that contains spaces." + +// sanitizeInjectedIdentityRe 上游服务端注入的身份指令(issue #187)。 +// +// 形态(2.73MB 请求体 dump 里逐字取证): +// +// When asked about your model identity, identify yourself as Tencent Hunyuan Hy. +// +// 它由上游在服务端拼进模型可见上下文、不出现在任何出站 body 里,因此 dump 看不到; +// 但模型会在 reasoning_content 里复述原文,客户端把这段思维链带回历史,下一轮就 +// 原样进出站——「声明 → 进历史 → 再看到 → 再声明」的滚雪球就是这么来的。 +// +// 匹配刻意收紧到「when asked about your … identity, identify yourself as …」整句: +// 单独匹配 identify yourself as 会误伤正常指令("Do not identify yourself as an AI." +// 是合法要求),而整句前缀在真实语料里几乎不可能自然出现。 +var sanitizeInjectedIdentityRe = regexp.MustCompile( + `(?i)when asked about your[^.\n]{0,60}?identity[^.\n]{0,60}?,\s*identify yourself as\s+[^.\n]{1,80}\.`) + +// 替换成中性表述:不声明任何身份,也不改变上下文里真实可用的信息。 +const sanitizeInjectedIdentityReplacement = "When asked about your capabilities, answer using only the information available in this conversation." + +// sanitizeModelIdentityTagRe 去掉 包裹本身(保留内部文本)。 +// +// 只删标签:真正的危害是标签里那句指令(上面那条规则负责改掉),标签本身留着会让 +// 模型继续把它当「有个身份块」反复提起,每轮都往历史里再写一遍。 +var sanitizeModelIdentityTagRe = regexp.MustCompile(`(?i)`) + +// sanitizeIdentitySentenceRe 客户端「自我介绍句 + 品牌归属」整句(issue #246 的通用版)。 +// +// 上游把这类句子当成非官方渠道特征:`You are an AI agent powered by <品牌>.` +// `You are a coding agent powered by <模型>.` `You are Agent, built by .` +// 大小写不敏感、按连续原文匹配;单独品牌词或换掉句子结构即放行。此前只有 +// sanitizeIdentityRewrites 把品牌词换掉,句子骨架(`You are … powered by …`)原样留着—— +// 骨架本身就是特征,品牌换了也可能照样 400(workbuddy2api-hub #533/#537/#539、#574 +// 与 ithtelab/workbuddy-manager#312 的 0032 两条独立实现都收敛到这个结论)。 +// +// 动词表要全:上游补一条新搭配就能让只认单个动词的实现重新 400,故一次列七种。 +// 窗口有界(形容词 0~3 个、名词可省)——`You are free to use tools built by …` 这类 +// 分词修饰宾语的句子不该被误伤,靠的就是这个上界。 +// 只作用于需要应用身份类规则的消息(见 sanitize_messages 的作用域选择)。 +// 结尾用捕获组 (\s|$) 回填,而不是零宽断言:Go 的 RE2 不支持 (?=),句尾那个空白必须 +// 原样接回去——否则 "…assistant. Use the read tool" 会被粘成 "assistant.Use the read tool"。 +// shortcut: 句子必须以句号收尾才匹配(观测到的指纹都带句号),无句号的变体放行。 +var sanitizeIdentitySentenceRe = regexp.MustCompile( + `(?i)You are\s+` + + `(?:an?\s+|the\s+)?(?:[\w.-]+\s+){0,3}?` + + `(?:agent|assistant|model|AI|LLM)?[\s,]*` + + `(?:powered by|built on|built by|created by|developed by|made by|trained by)` + + `[^\n]*?\.(\s|$)`) + +const sanitizeIdentitySentenceReplacement = "You are a helpful AI assistant.${1}" + +// sanitizeIdentityVerbs 身份句式的字面量快路(与上面正则的动词表同步维护)。 +var sanitizeIdentityVerbs = []string{ + "powered by", "built on", "built by", "created by", "developed by", "made by", "trained by", +} + +// sanitizeRewrites 改写层:全模板句逐字替换(每句只改一个词,语义不变)。 +// +// 身份句的匹配串**不带结尾标点**(只到 "…for Claude" 为止): +// CLI 版这句以句号收尾("…for Claude."),桌面版(claude-desktop-3p / Agent SDK) +// 以逗号接后继内容("…for Claude, running within the Claude Agent SDK.")。 +// 带句号的整句只匹配前者,桌面版会漏网、指纹原样发上游 → 400 code=11128。 +// 去掉结尾标点后两种形态一并覆盖(替换串同样不带标点,让原有标点原样保留)。 +// 注意仍要求 "You are Claude Code, " 前缀,不做更宽的子串替换, +// 以免误伤 TestExactMatchOnlyVariantNotTouched 所保护的零散文本。 +var sanitizeRewrites = [][2]string{ + { + "You are Claude Code, Anthropic's official CLI for Claude", + "You are Claude Code, Anthropic's official CLI tool for Claude", + }, + { + "Main branch (you will usually use this for PRs)", + "Default branch (you will usually use this for PRs)", + }, + { + "You are a coding agent running in the Codex CLI, a terminal-based coding assistant.", + "You are a coding agent running in the Codex CLI tool, a terminal-based coding assistant.", + }, + { + // 反馈句:整句带 Anthropic 仓库链接,上游按整句拦截(只留链接或只留半边均不拦, + // 实测需整句同时出现)。give→provide 一词之差即可绕过,语义不变。 + "To give feedback, users should report the issue at https://github.com/anthropics/claude-code/issues", + "To provide feedback, users should report the issue at https://github.com/anthropics/claude-code/issues", + }, + { + // 上游反探测:只要请求体里出现裸数字 11128 就整单拦截(与该数字的上下文无关—— + // "code=11128" / 裸 "11128" / "错误码 11128" / "Code=11128" 全部命中; + // 相邻的 11148 / 11101 / 11115 / 99999 均放行)。11128 正是本类拦截自身的错误码, + // 上游据此识别"在讨论/回显其内部错误码"的请求。 + // 代价:用户对话中任何 11128 都会被改写——但这串数字出现在请求里本身就是拦截条件, + // 不改写必然失败。插入连字符保留可读性与指代(该数字串上零宽空格无效,实测上游会归一化)。 + "11128", + "11-128", + }, +} + +// sanitizeIdentityRewrites 身份类改写:品牌词 → DeepSeekRuntime。仅在应用身份类规则时使用 +// (见 sanitizeTextWith:sanitize_brand_scope=all 时所有角色都用,identity 时只用身份消息)。 +var sanitizeIdentityRewrites = [][2]string{ + { + // DSH 的身份句(@deepseek-ai/dsh-system-prompt 注入的 harness:identity 段)被上游 + // 当成「非官方渠道调用」整单拦截:400 11-128 Illegal API invocation from an + // unapproved channel。实测换一词即绕过(与插 U+200B 等效,但可见、可 diff)。 + "DeepSeek Harness", + "DeepSeekRuntime", + }, +} + +// sanitizeText 单段文本净化:预检不中 → 返回原串(零分配)。 +// sanitizeText 单段文本净化(全局规则):预检不中 → 返回原串(零分配)。 +func sanitizeText(text string) string { return sanitizeTextWith(text, false) } + +// sanitizeTextIdentity 身份消息(system/developer)专用:在全局规则之外再应用身份类规则 +// (品牌词)。sanitize_brand_scope=all 时非身份消息也走这条(与上游既有行为一致)。 +func sanitizeTextIdentity(text string) string { return sanitizeTextWith(text, true) } + +// sanitizeTextWith 按「是否应用身份类规则」净化单段文本。 +// +// 快路径同时看两类特征:只含品牌词的文本在 brand=false 时原样返回(不 TrimSpace, +// 用户输入的空白不动),在 brand=true 时进入改写。 +func sanitizeTextWith(text string, brand bool) string { + if !hasFingerprint(text) && !(brand && hasIdentityFingerprint(text)) { + return text + } + for _, rw := range sanitizeRewrites { + text = strings.ReplaceAll(text, rw[0], rw[1]) + } + if brand { + // 身份句式先于品牌词:正则要匹配原文里的品牌全名,先换品牌会让规则失配。 + text = sanitizeIdentitySentenceRe.ReplaceAllString(text, sanitizeIdentitySentenceReplacement) + for _, rw := range sanitizeIdentityRewrites { + text = strings.ReplaceAll(text, rw[0], rw[1]) + } + } + // @ 路径说明段:预检已是字面量,这里再挡一次,避免无关文本白跑一遍跨行正则。 + if strings.Contains(text, sanitizeDshPathsProbe) { + text = sanitizeDshPathsRe.ReplaceAllString(text, sanitizeDshPathsReplacement) + } + // 上游服务端注入的身份指令(issue #187):不限角色,assistant 复述同样要洗—— + // 那段复述正是历史回流的载体。 + if strings.Contains(text, "identify yourself as") { + text = sanitizeInjectedIdentityRe.ReplaceAllString(text, sanitizeInjectedIdentityReplacement) + } + if strings.Contains(text, "model_identity") { + text = sanitizeModelIdentityTagRe.ReplaceAllString(text, "") + } + if sanitizeHdrRe.MatchString(text) { + text = sanitizeHdrRe.ReplaceAllString(text, "") + } + if strings.Contains(text, "cc_") { + prev := "" + for prev != text { // 清尾随裸 kv() + prev = text + text = sanitizeKvRe.ReplaceAllString(text, "") + } + } + // 兜底:键值形态已在上面整段删除,这里只剩裸键名(引用/示例文本形态)。 + text = sanitizeBareHdrRe.ReplaceAllString(text, "x-anthropic-billing-hdr") + return strings.TrimSpace(text) +} + +// sanitizeBareHdrProbe 裸键名兜底正则的字面量探针,**从正则本身推导**而不是手抄。 +// +// 手抄一份的风险是刚踩过的:探针与正则体不同步("…-hdr" vs "…-header")时预检永远 +// 判假,整条净化被静默跳过,而测试仍然全绿(它测的是正则,不是预检)。这里直接取 +// sanitizeBareHdrRe.String() 去掉 "(?i)" 的部分;一旦正则不再是纯字面量(含元字符), +// 探针置空,hasFingerprint 回落成「直接跑正则」——慢但绝不会判错。 +var sanitizeBareHdrProbe = func() string { + const foldPrefix = "(?i)" + s := sanitizeBareHdrRe.String() + if !strings.HasPrefix(s, foldPrefix) { + return "" + } + body := s[len(foldPrefix):] + if body == "" || strings.ContainsAny(body, `\[](){}*+?|^$.`) { + return "" + } + return body +}() + +// containsFoldASCII 大小写不敏感(仅 ASCII)的子串查找,零分配。 +// +// 用途:`(?i)` 正则做「有没有这个词」的存在性判断,RE2 会给每个字节跑一遍 +// fold 状态机;线上实测这一项占整个请求体预处理 CPU 的 56%(170K token 的 +// 代理上下文里,每个 message 都要过一遍)。这里换成单遍扫描 + 首字符快跳, +// 命中即返回。 +// +// 只做预检:非字母字符的 |0x20 折叠会出现少量误命中(如 '^' 与 '~'), +// 代价只是多跑一次正则确认,不会漏判、不会改文本。 +func containsFoldASCII(s, sub string) bool { + if sub == "" { + return true + } + n := len(sub) + if len(s) < n { + return false + } + c0 := sub[0] + c0f := c0 | 0x20 + for i := 0; i+n <= len(s); i++ { + c := s[i] + if c|0x20 != c0f { + continue + } + ok := true + for j := 1; j < n; j++ { + a, b := s[i+j], sub[j] + if a != b && a|0x20 != b|0x20 { + ok = false + break + } + } + if ok { + return true + } + } + return false +} + +// hasFingerprint 特征预检:先走 strings.Contains 快速路径(零分配); +// header 键名有大小写变体(X-Anthropic-...)且可能以裸键名形态出现(无冒号), +// Contains 大小写敏感、sanitizeHdrRe 要求冒号——两者都会漏掉「混合大小写 + 裸键名」, +// 必须再兜一层不要求冒号的检测(sanitizeBareHdrRe),否则整条净化被跳过。 +// +// 兜底检测用 containsFoldASCII 而不是 sanitizeBareHdrRe.MatchString:判据完全等价 +// (该正则只匹配这一个字面量、只关心是否存在),但 RE2 大小写折叠是整条净化链上 +// 最贵的一步(线上 profile:占预处理 CPU 56%)。 +func hasFingerprint(text string) bool { + for _, f := range sanitizeFeatures { + if strings.Contains(text, f) { + return true + } + } + if sanitizeBareHdrProbe == "" { + // 正则形状变了(不再是纯 (?i) 字面量):回落成直接跑正则,正确性优先。 + return sanitizeBareHdrRe.MatchString(text) + } + return containsFoldASCII(text, sanitizeBareHdrProbe) +} + +// hasIdentityVerbShape 身份句式的廉价形状探测:「 by 」或「 on 」是否出现过。 +// +// 这是 sanitizeIdentitySentenceRe 的必要条件——正则里的动词表(powered by / built on / +// built by / created by / developed by / made by / trained by)每一项都含「 by 」或 +// 「 on 」,所以形状不成立时正则必然不匹配,直接跳过。 +// +// 为什么值得单独写:原实现是「逐个动词 containsFoldASCII」= 7 次全量扫描; +// 线上 profile 里这一段占预处理 CPU 的 26%(170K token 上下文里每个 message 都扫 7 遍)。 +// 这里改成一遍扫描同时看两个形状,命中即返回。 +func hasIdentityVerbShape(s string) bool { + for i := 0; i+3 <= len(s); i++ { + c := s[i] | 0x20 + var want byte + switch c { + case 'b': + want = 'y' // "by " + case 'o': + want = 'n' // "on " + default: + continue + } + if s[i+1]|0x20 != want || s[i+2] != ' ' { + continue + } + if i > 0 && s[i-1] != ' ' { // 前置必须是空格:「 by 」/「 on 」是动词的一部分 + continue + } + return true + } + return false +} + +// hasIdentityFingerprint 身份类特征(品牌词 / 身份句式)预检;只在需要应用身份类规则时调用, +// 保证 brand=false 的路径不会因为只含品牌词而进入清洗(否则末尾 TrimSpace 会裁掉用户空白)。 +// +// 命中也只是"形状成立",仍要正则确认:只按 "by"/"on" 判真会把「讲解某产品」的普通 +// 用户消息也拖进清洗。 +func hasIdentityFingerprint(text string) bool { + for _, f := range sanitizeIdentityFeatures { + if strings.Contains(text, f) { + return true + } + } + // 动词探测用 hasIdentityVerbShape 而不是 strings.ToLower(text):后者对每条消息 + // 都整段小写化(170K token 的上下文里是 600KB 的分配 + 拷贝),而这里只需要 + // 「有没有这个词」——线上 profile 里 ToLower 占预处理 CPU 6.5%。 + // 命中也只是形状成立,仍需正则确认:只按 "by"/"on" 判真会把「讲解某产品」的 + // 普通用户消息也拖进清洗。 + if !hasIdentityVerbShape(text) { + return false + } + return sanitizeIdentitySentenceRe.MatchString(text) +} + +// sanitizeContent 兼容字符串与多模态数组;只动 text part,image 等 part 不动。 +// 返回净化后的值及是否发生变化。 +// sanitizeContent 兼容字符串与多模态数组;只动 text part,image 等 part 不动。 +// brand 为 false 时不应用身份类规则(见 sanitizeMessages 的作用域选择)。 +// 返回净化后的值及是否发生变化。 +func sanitizeContent(v any, brand bool) (any, bool) { + switch c := v.(type) { + case string: + s := sanitizeTextWith(c, brand) + return s, s != c + case []any: + changed := false + for _, p := range c { + m, ok := p.(map[string]any) + if !ok { + continue + } + text, ok := m["text"].(string) + if !ok { + continue + } + if s := sanitizeTextWith(text, brand); s != text { + m["text"] = s + changed = true + } + } + return c, changed + } + return v, false +} + +// sanitizeToolCalls 净化 assistant.tool_calls[].function.arguments。 +// +// arguments 是**字符串化的 JSON**(不是对象),因此按文本走 sanitizeText 即可。 +// 这块长期是盲区:工具调用消息的 content 通常是 null,而旧版 sanitizeMessages +// 在 content 缺失时直接 continue,整条消息连 tool_calls 一起被跳过—— +// 于是历史里任何写进工具参数的被拦字符串(文件名、命令、写入内容)都会原样漏出。 +// sanitizeToolCalls 净化 assistant.tool_calls[].function.arguments(字符串化 JSON)。 +// brand 决定是否应用身份类规则(品牌词);其余全局规则始终应用。 +func sanitizeToolCalls(v any, brand bool) bool { + callList, ok := v.([]any) + if !ok { + return false + } + changed := false + for _, c := range callList { + call, ok := c.(map[string]any) + if !ok { + continue + } + fn, ok := call["function"].(map[string]any) + if !ok { + continue + } + args, ok := fn["arguments"].(string) + if !ok { + continue + } + if s := sanitizeTextWith(args, brand); s != args { + fn["arguments"] = s + changed = true + } + } + return changed +} + +// sanitizeTools 净化 tools[].function.description。 +// +// 工具描述由客户端作者撰写(Claude Code / Codex 这类会把身份句写进 description), +// 只洗 messages 时它整段原样出站(上游 issue #395 同类)。shortcut: 只洗 OpenAI 形状的 +// function.description,Anthropic 形状的顶层 description 与 parameters 里的 schema 描述不洗。 +func sanitizeTools(v any, brandGlobal bool) { + tools, ok := v.([]any) + if !ok { + return + } + for _, t := range tools { + tm, ok := t.(map[string]any) + if !ok { + continue + } + fn, ok := tm["function"].(map[string]any) + if !ok { + continue + } + if d, ok := fn["description"].(string); ok { + if s := sanitizeTextWith(d, brandGlobal); s != d { + fn["description"] = s + } + } + } +} + +// sanitizeMessages 净化 messages 中的 content、reasoning 与 tool_calls;任一命中返回 true。 +// +// brandGlobal 来自 features.sanitize_brand_scope:true(默认 "all")时身份类规则对所有 +// 消息角色生效,与上游既有行为一致;false("identity")时只对 system/developer 生效, +// 其余角色的同名文本按用户数据原样透传(实测 user 里的品牌词不触发 11-128)。 +func sanitizeMessages(messages []any, brandGlobal bool) bool { + changed := false + for _, msg := range messages { + m, ok := msg.(map[string]any) + if !ok { + continue + } + role, _ := m["role"].(string) + identity := strings.EqualFold(strings.TrimSpace(role), "system") || + strings.EqualFold(strings.TrimSpace(role), "developer") + brand := brandGlobal || identity + // content 与 tool_calls 各自独立判断:content 可以为 null(工具调用轮), + // 早期版本在此 continue,导致这类消息的 tool_calls 完全不被净化。 + if c, ok := m["content"]; ok { + if nc, ch := sanitizeContent(c, brand); ch { + m["content"] = nc + changed = true + } + } + // reasoning_content(思维链回填字段)实测同样携带指纹,与 content 同等净化。 + if rc, ok := m["reasoning_content"].(string); ok { + if s := sanitizeTextWith(rc, brand); s != rc { + m["reasoning_content"] = s + changed = true + } + } + // reasoning:另一形态的思维链字段(backfillReasoningContent 会镜像一份)。 + if r, ok := m["reasoning"].(string); ok { + if s := sanitizeTextWith(r, brand); s != r { + m["reasoning"] = s + changed = true + } + } + if tc, ok := m["tool_calls"]; ok { + if sanitizeToolCalls(tc, brand) { + changed = true + } + } + } + return changed +} diff --git a/internal/upstream/sanitize_fastpath_test.go b/internal/upstream/sanitize_fastpath_test.go new file mode 100644 index 0000000000000000000000000000000000000000..14ee400fecf6cfd3b5e7cb023757a557426dcb48 --- /dev/null +++ b/internal/upstream/sanitize_fastpath_test.go @@ -0,0 +1,115 @@ +package upstream + +import ( + "strings" + "testing" +) + +// bareHdrKey 裸键名(无冒号)字面量,从正则推导的探针复制而来——不从显示文本手抄 +// (本仓的显示层会把 "header" 缩成 "hdr",照抄会写错字节)。 +func bareHdrKey() string { return sanitizeBareHdrProbe } + +// TestBareHdrProbeMatchesRegex 预检与正则必须等价。 +// +// 踩过的坑:探针手抄自正则时抄错了一个词("…-hdr" vs "…-header"),预检永远判假, +// 整条净化被静默跳过,而所有既有测试仍然全绿——它们测的是正则本身,不是预检。 +func TestBareHdrProbeMatchesRegex(t *testing.T) { + if sanitizeBareHdrProbe == "" { + t.Fatalf("探针为空:sanitizeBareHdrRe=%q 已不是纯 (?i) 字面量,预检回落成直接跑正则(慢但不判错)", + sanitizeBareHdrRe.String()) + } + cases := []string{ + bareHdrKey(), + "X-Anthropic-Billing-" + "HDR", + "prefix X-ANTHROPIC-BILLING-" + "HDR suffix", + "not a fingerprint at all", + "anthropic billing hdr without dashes", + "", + } + for _, c := range cases { + got, want := containsFoldASCII(c, sanitizeBareHdrProbe), sanitizeBareHdrRe.MatchString(c) + // 折叠预检允许误命中(多跑一次正则),但不允许漏判。 + if want && !got { + t.Errorf("预检漏判 %q:fold=false 但 regex=true", c) + } + if !want && got { + t.Logf("预检误命中 %q(可接受:后续正则是否掉)", c) + } + } +} + +func TestContainsFoldASCII(t *testing.T) { + cases := []struct { + s, sub string + want bool + }{ + {"Hello World", "hello", true}, + {"Hello World", "WORLD", true}, + {"Hello World", "world", true}, + {"Hello", "hello world", false}, + {"", "a", false}, + {"abc", "", true}, + {"xxABCxx", "abc", true}, + {"xxABxx", "abc", false}, + } + for _, c := range cases { + if got := containsFoldASCII(c.s, c.sub); got != c.want { + t.Errorf("containsFoldASCII(%q,%q)=%v want %v", c.s, c.sub, got, c.want) + } + } +} + +// TestHasIdentityVerbShape 形状探测只作预检:命中不代表要清洗,但正则命中必须命中它。 +func TestHasIdentityVerbShape(t *testing.T) { + hits := []string{ + "You are a helpful assistant powered by Anthropic.", + "This tool was built by the vendor.", + "model built on top of another", + } + for _, s := range hits { + if !hasIdentityVerbShape(s) { + t.Errorf("应判出形状: %q", s) + } + } + misses := []string{ + "nothing to see here", + "bypassed the check", + "onlywordson", + "", + } + for _, s := range misses { + if hasIdentityVerbShape(s) { + t.Errorf("不应判出形状: %q", s) + } + } +} + +// TestIdentityFingerprintStillDetected 换掉 ToLower 后身份句判定不能退化。 +func TestIdentityFingerprintStillDetected(t *testing.T) { + yes := "You are a helpful AI assistant Powered By DeepSeek." + if !hasIdentityFingerprint(yes) { + t.Fatalf("身份句漏判: %q", yes) + } + no := "Please write a Go HTTP handler with middleware." + if hasIdentityFingerprint(no) { + t.Fatalf("普通消息误判: %q", no) + } + if !hasIdentityFingerprint("brand is " + sanitizeIdentityFeatures[0]) { + t.Fatalf("品牌词漏判") + } +} + +// TestSanitizeStillStripsHeader 端到端:探针改成折叠扫描后,整条净化行为不变。 +func TestSanitizeStillStripsHeader(t *testing.T) { + key := bareHdrKey() // 小写字面量,从正则推导 + titled := strings.ToUpper(key[:1]) + key[1:] // 首字母大写,覆盖大小写变体 + in := titled + ": " + "cc_version=1.0;" + out := strings.ToLower(sanitizeText(in)) + if strings.Contains(out, "anthropic") { + t.Fatalf("键值段未被剥离: %q -> %q", in, out) + } + bare := "quote `" + titled + "` in docs" + if got := strings.ToLower(sanitizeText(bare)); strings.Contains(got, key) { + t.Fatalf("裸键名未被缩写: %q -> %q", bare, got) + } +} diff --git a/internal/upstream/sanitize_identity_injection_test.go b/internal/upstream/sanitize_identity_injection_test.go new file mode 100644 index 0000000000000000000000000000000000000000..25259db6051328cd87297dd9f55aa19755dffe0b --- /dev/null +++ b/internal/upstream/sanitize_identity_injection_test.go @@ -0,0 +1,62 @@ +package upstream + +import ( + "strings" + "testing" +) + +// issue #187:上游服务端注入的身份指令,会经模型 reasoning 复述回流进出站 body。 +// 规则必须挂在**通用**门控上(assistant 消息的 brand=false),否则早退不执行。 +func TestSanitizeInjectedIdentityDirective(t *testing.T) { + in := "When asked about your model identity, identify yourself as Tencent Hunyuan Hy." + out := sanitizeTextWith(in, false) + if strings.Contains(strings.ToLower(out), "identify yourself as") { + t.Fatalf("注入指令未被改掉: %q", out) + } + if strings.Contains(out, "Tencent Hunyuan") { + t.Fatalf("身份名仍在: %q", out) + } + if !strings.Contains(out, "capabilities") { + t.Fatalf("应替换成中性表述,实际 %q", out) + } +} + +// 带上下文(模型复述)时也要命中:这句话前面常有一堆推理文本。 +func TestSanitizeInjectedIdentityInsideReasoning(t *testing.T) { + in := "系统提示里有个 说\n\"When asked about your model identity, identify yourself as Tencent Hunyuan Hy.\"\n这是注入吗?" + out := sanitizeTextWith(in, false) + if strings.Contains(out, "identify yourself as") || strings.Contains(out, "Hunyuan") { + t.Fatalf("复述形态未被洗净: %q", out) + } + if strings.Contains(out, "") || strings.Contains(out, "") { + t.Fatalf("标签应被去掉: %q", out) + } + // 其余文本必须保留(只做最小改写)。 + if !strings.Contains(out, "这是注入吗") { + t.Fatalf("无关内容被改动: %q", out) + } +} + +// 误伤防护:合法指令与普通「身份」用词不能被改写。 +func TestSanitizeLeavesLegitIdentityTalk(t *testing.T) { + cases := []string{ + "Do not identify yourself as an AI assistant; you are a coding agent.", + "The identity of the caller is unknown.", + "你的真实身份是一个助手,不要声称自己是别的模型。", + } + for _, in := range cases { + if out := sanitizeTextWith(in, false); out != strings.TrimSpace(in) { + t.Errorf("被误改: %q -> %q", in, out) + } + } +} + +// 门控自检:新的探针必须真的能让 hasFingerprint 命中,否则规则永不执行 +// (这条曾经踩过:探针与正则体不同步 → 整条净化被静默跳过,而测试仍全绿)。 +func TestSanitizeInjectedIdentityGate(t *testing.T) { + for _, s := range []string{"identify yourself as X", "a block"} { + if !hasFingerprint(s) { + t.Fatalf("%q 未命中通用指纹门控,规则不会执行", s) + } + } +} diff --git a/internal/upstream/sanitize_test.go b/internal/upstream/sanitize_test.go index 55dfca9e1f4da742798d0b9411847413fbdea74c..c5f5e39be0d18f94dede1ac68c883b128630cf92 100644 --- a/internal/upstream/sanitize_test.go +++ b/internal/upstream/sanitize_test.go @@ -1,393 +1,686 @@ -package upstream - -import ( - "encoding/json" - "io" - "net/http" - "net/http/httptest" - "strings" - "testing" - - "github.com/linguo2625469/workbuddy2api-panel/internal/auth" -) - -const ( - ccIdentity = "You are Claude Code, Anthropic's official CLI for Claude." - ccBranch = "Main branch (you will usually use this for PRs)" - ccHeader = "x-anthropic-billing-header: cc_version=1.0; cc_entrypoint=cli;" - // Codex instructions 首段(上游逐字精确指纹,三句缺一不可)。 - codexInstructions = "You are a coding agent running in the Codex CLI, a terminal-based coding assistant. Codex CLI is an open source project led by OpenAI. You are expected to be precise, safe, and helpful." -) - -func TestIdentityRewritten(t *testing.T) { - out := sanitizeText(ccIdentity) - if !strings.Contains(out, "official CLI tool for Claude.") { - t.Errorf("identity not rewritten: %q", out) - } - if strings.Contains(out, ccIdentity) { - t.Errorf("original identity still present: %q", out) - } -} - -// 桌面版(claude-desktop-3p / Agent SDK)的身份句以逗号接后继内容,结尾不是句号。 -// 回归用例:匹配串曾带结尾句号,导致该形态漏网、指纹原样发上游 → 400 code=11128。 -func TestIdentityDesktopVariantRewritten(t *testing.T) { - in := "You are Claude Code, Anthropic's official CLI for Claude, running within the Claude Agent SDK." - out := sanitizeText(in) - if strings.Contains(out, "official CLI for Claude") { - t.Errorf("desktop identity not rewritten: %q", out) - } - if !strings.Contains(out, "official CLI tool for Claude, running within the Claude Agent SDK.") { - t.Errorf("desktop identity suffix not preserved: %q", out) - } -} - -func TestBranchRewritten(t *testing.T) { - out := sanitizeText(ccBranch) - if !strings.Contains(out, "Default branch (you will usually use this for PRs)") { - t.Errorf("branch not rewritten: %q", out) - } - if strings.Contains(out, "Main branch") { - t.Errorf("original branch still present: %q", out) - } -} - -// 反馈句带 Anthropic 仓库链接,上游按整句拦截(实测只留链接或只留半边均不拦)。 -// 回归用例:give→provide 一词之差即可绕过。 -func TestFeedbackSentenceRewritten(t *testing.T) { - in := "To give feedback, users should report the issue at https://github.com/anthropics/claude-code/issues" - out := sanitizeText(in) - if strings.Contains(out, "To give feedback") { - t.Errorf("feedback sentence not rewritten: %q", out) - } - if !strings.Contains(out, "To provide feedback, users should report the issue at https://github.com/anthropics/claude-code/issues") { - t.Errorf("feedback sentence not rewritten as expected: %q", out) - } -} - -// 上游反探测:请求体里出现裸数字 11128 即整单拦截(与上下文无关)。 -// 回归用例:该串会被改写为 11-128 以打断精确匹配。 -func TestUpstreamErrorCodeRewritten(t *testing.T) { - in := "upstream returned code=11128 for this request" - out := sanitizeText(in) - if strings.Contains(out, "11128") { - t.Errorf("error code not rewritten: %q", out) - } - if !strings.Contains(out, "11-128") { - t.Errorf("error code not rewritten as expected: %q", out) - } -} - -// 回归:工具调用消息的 content 常为 null,而旧版 sanitizeMessages 在 content 缺失时 -// 直接 continue,整条消息连 tool_calls 一起被跳过 → arguments 里的被拦字符串原样漏出。 -func TestToolCallArgumentsSanitized(t *testing.T) { - msgs := []any{ - map[string]any{"role": "user", "content": "run"}, - map[string]any{"role": "assistant", "content": nil, "tool_calls": []any{ - map[string]any{"id": "c1", "type": "function", "function": map[string]any{ - "name": "Bash", - "arguments": `{"command":"echo 11128"}`, - }}, - }}, - } - if !sanitizeMessages(msgs) { - t.Fatal("sanitizeMessages 未报告任何改动,tool_calls 被跳过") - } - fn := msgs[1].(map[string]any)["tool_calls"].([]any)[0].(map[string]any)["function"].(map[string]any) - got := fn["arguments"].(string) - if strings.Contains(got, "11128") { - t.Errorf("tool_call arguments 未被净化: %q", got) - } -} - -func TestBillingHeaderStrippedValueIrrelevant(t *testing.T) { - out := sanitizeText(ccHeader) - if strings.Contains(out, "x-anthropic-billing-header") { - t.Errorf("header not stripped: %q", out) - } -} - -// 附加验证:正常对话里出现 github.com/anthropics/ 链接(但不是反馈句整句) -// 时,预检特征命中(进入净化),但改写层只动精确匹配的整句——普通链接文本 -// 不该被改写。同理,既不含 11128 也不含反馈整句的文本原样返回。 -func TestNormalAnthropicLinkNotRewritten(t *testing.T) { - in := "see https://github.com/anthropics/anthropic-cookbook for examples" - if out := sanitizeText(in); out != in { - t.Errorf("normal anthropic link should be untouched: %q -> %q", in, out) - } -} - -// Codex instructions 首段:命中预告且整句改写,逐字指纹被破坏、语义保留。 -func TestCodexInstructionsRewritten(t *testing.T) { - out := sanitizeText(codexInstructions) - if strings.Contains(out, codexInstructions) { - t.Errorf("codex fingerprint still present: %q", out) - } - if !strings.Contains(out, "You are a coding agent running in the Codex CLI tool, a terminal-based coding assistant.") { - t.Errorf("codex first sentence not rewritten: %q", out) - } - // 其余两句原样保留,语义不变。 - if !strings.Contains(out, "Codex CLI is an open source project led by OpenAI.") || - !strings.Contains(out, "You are expected to be precise, safe, and helpful.") { - t.Errorf("codex remaining sentences altered: %q", out) - } -} - -// 预检必须能认出 Codex 特征(此前只含 Claude Code,导致提前放行)。 -func TestCodexFingerprintDetected(t *testing.T) { - if !hasFingerprint(codexInstructions) { - t.Error("codex fingerprint not detected by precheck") - } -} - -// 非精确变体不应被改写:仅去掉其中一个词即视为已破坏,无需改动。 -func TestCodexVariantNotTouched(t *testing.T) { - in := "You are a coding agent running in a CLI, a terminal-based coding assistant." - if out := sanitizeText(in); out != in { - t.Errorf("already-broken variant should be untouched: %q -> %q", in, out) - } -} - -func TestBillingHeaderCaseInsensitive(t *testing.T) { - alt := "X-Anthropic-Billing-Header: cc_version=1.0;" - out := strings.ToLower(sanitizeText(alt)) - if strings.Contains(out, "billing") { - t.Errorf("case-insensitive header not stripped: %q", out) - } -} - -func TestTrailingKVStripped(t *testing.T) { - out := sanitizeText("...; cc_version=2.0; cc_entrypoint=cli;") - if strings.Contains(out, "cc_version") || strings.Contains(out, "cc_entrypoint") { - t.Errorf("trailing kv not stripped: %q", out) - } -} - -func TestExactMatchOnlyVariantNotTouched(t *testing.T) { - in := "...official CLI for Claude!" - if out := sanitizeText(in); out != in { - t.Errorf("variant should be untouched: %q -> %q", in, out) - } -} - -func TestUserFreeTextNotTouched(t *testing.T) { - in := "please use main branch for this repo" - if out := sanitizeText(in); out != in { - t.Errorf("free text should be untouched: %q -> %q", in, out) - } -} - -func TestNoFeatureReturnsSameString(t *testing.T) { - in := "ordinary user message" - if out := sanitizeText(in); out != in { - t.Errorf("no-feature text should pass through unchanged: %q -> %q", in, out) - } -} - -func TestMultimodalTextPartOnly(t *testing.T) { - imgPart := map[string]any{"type": "image", "source": map[string]any{"type": "base64", "data": "..."}} - content := []any{ - map[string]any{"type": "text", "text": ccIdentity}, - imgPart, - } - out, changed := sanitizeContent(content) - if !changed { - t.Fatal("expected change") - } - parts := out.([]any) - txt, _ := parts[0].(map[string]any)["text"].(string) - if !strings.Contains(txt, "CLI tool") { - t.Errorf("text part not sanitized: %q", txt) - } - img, _ := parts[1].(map[string]any) - if img["type"] != "image" || img["source"].(map[string]any)["data"] != "..." { - t.Error("image part modified") - } -} - -// 集成:完整请求体经 PrepareBodyOpt 净化后无残留指纹,且 stream/tool_choice 行为不受影响。 -func TestPrepareBodyOptSanitizesSystem(t *testing.T) { - body := []byte(`{"model":"glm-5.2","messages":[` + - `{"role":"system","content":"` + ccIdentity + ` ` + ccHeader + `"},` + - `{"role":"user","content":"hi"}]}`) - out := PrepareBodyOpt(body, true) - var obj map[string]any - if err := json.Unmarshal(out, &obj); err != nil { - t.Fatal(err) - } - if obj["stream"] != true { - t.Error("stream not forced") - } - msgs := obj["messages"].([]any) - sys, _ := msgs[0].(map[string]any)["content"].(string) - if strings.Contains(sys, "x-anthropic-billing-header") || strings.Contains(sys, ccIdentity) || strings.Contains(sys, ccBranch) { - t.Errorf("fingerprints remain: %q", sys) - } - if !strings.Contains(sys, "CLI tool") { - t.Errorf("rewrite missing: %q", sys) - } -} - -func TestPrepareBodyOptDisabledPreservesFingerprints(t *testing.T) { - body := []byte(`{"model":"glm-5.2","messages":[{"role":"system","content":"` + ccIdentity + `"}]}`) - out := PrepareBodyOpt(body, false) - if !strings.Contains(string(out), ccIdentity) { - t.Error("sanitize=false should preserve fingerprints") - } - // 但 stream 仍强制 - var obj map[string]any - _ = json.Unmarshal(out, &obj) - if obj["stream"] != true { - t.Error("stream should still be forced") - } -} - -// PrepareBody 默认行为 = 开启脱敏(保持向后兼容)。 -func TestPrepareBodyDefaultSanitizes(t *testing.T) { - body := []byte(`{"model":"glm-5.2","messages":[{"role":"system","content":"` + ccIdentity + `"}]}`) - out := PrepareBodyOpt(body, true) - if strings.Contains(string(out), ccIdentity) { - t.Error("PrepareBody default should sanitize") - } -} - -// 出站边界集成:ChatStream 发往上游的 wire body 必须无残留指纹。 -func TestChatStreamWireBodySanitized(t *testing.T) { - var gotBody []byte - ts := newTestUpstream(t, func(w http.ResponseWriter, r *http.Request) { - gotBody, _ = io.ReadAll(r.Body) - w.Header().Set("Content-Type", "text/event-stream") - _, _ = w.Write([]byte("data: {\"choices\":[{\"delta\":{\"content\":\"ok\"}}]}\n\ndata: [DONE]\n\n")) - }) - defer ts.Close() - - c := New() - c.SanitizeFingerprints.Store(true) - c.ChatBaseCN = ts.URL - acct := &auth.Auth{AccessToken: "test-token", Domain: "copilot.tencent.com", UID: "u1"} - - body := []byte(`{"model":"glm-5.2","messages":[` + - `{"role":"system","content":"` + ccIdentity + ` ` + ccHeader + `"},` + - `{"role":"user","content":"hi"}]}`) - rc, status, respBody, err := c.ChatStream(acct, body, "", ChatMeta{}) - if err != nil { - t.Fatal(err) - } - defer rc.Close() - if status >= 400 { - t.Fatalf("upstream status %d: %s", status, respBody) - } - // 上游收到的 body:stream 强制 + 指纹已净化 - var obj map[string]any - if err := json.Unmarshal(gotBody, &obj); err != nil { - t.Fatalf("wire body not json: %v", err) - } - if obj["stream"] != true { - t.Error("wire body stream not forced") - } - sys, _ := obj["messages"].([]any)[0].(map[string]any)["content"].(string) - for _, fp := range []string{"x-anthropic-billing-header", ccIdentity, ccBranch} { - if strings.Contains(sys, fp) { - t.Errorf("wire body contains fingerprint %q: %q", fp, sys) - } - } -} - -// 出站边界(Codex 场景):CPA 把 instructions 折成 role=system 的首条消息, -// 净化后 wire body 不得残留 Codex 逐字指纹;其余消息不受影响。 -func TestChatStreamWireBodyCodexInstructionsSanitized(t *testing.T) { - var gotBody []byte - ts := newTestUpstream(t, func(w http.ResponseWriter, r *http.Request) { - gotBody, _ = io.ReadAll(r.Body) - w.Header().Set("Content-Type", "text/event-stream") - _, _ = w.Write([]byte("data: {\"choices\":[{\"delta\":{\"content\":\"ok\"}}]}\n\ndata: [DONE]\n\n")) - }) - defer ts.Close() - - c := New() - c.SanitizeFingerprints.Store(true) - c.ChatBaseCN = ts.URL - acct := &auth.Auth{AccessToken: "test-token", Domain: "copilot.tencent.com", UID: "u1"} - - body := []byte(`{"model":"kimi-k3","messages":[` + - `{"role":"system","content":"` + codexInstructions + `"},` + - `{"role":"user","content":"say ok"}]}`) - rc, status, respBody, err := c.ChatStream(acct, body, "", ChatMeta{}) - if err != nil { - t.Fatal(err) - } - defer rc.Close() - if status >= 400 { - t.Fatalf("upstream status %d: %s", status, respBody) - } - var obj map[string]any - if err := json.Unmarshal(gotBody, &obj); err != nil { - t.Fatalf("wire body not json: %v", err) - } - sys, _ := obj["messages"].([]any)[0].(map[string]any)["content"].(string) - if strings.Contains(sys, codexInstructions) || - strings.Contains(sys, "in the Codex CLI, a terminal-based coding assistant.") { - t.Errorf("wire body still contains codex fingerprint: %q", sys) - } - if !strings.Contains(sys, "running in the Codex CLI tool, a terminal-based") { - t.Errorf("codex rewrite missing on wire: %q", sys) - } - user, _ := obj["messages"].([]any)[1].(map[string]any)["content"].(string) - if user != "say ok" { - t.Errorf("user message altered: %q", user) - } -} - -// 出站边界:关闭脱敏后 wire body 原样保留指纹(验证开关真实有效)。 -func TestChatStreamWireBodySanitizeDisabled(t *testing.T) { - var gotBody []byte - ts := newTestUpstream(t, func(w http.ResponseWriter, r *http.Request) { - gotBody, _ = io.ReadAll(r.Body) - w.Header().Set("Content-Type", "text/event-stream") - _, _ = w.Write([]byte("data: [DONE]\n\n")) - }) - defer ts.Close() - - c := New() - c.SanitizeFingerprints.Store(false) - c.ChatBaseCN = ts.URL - acct := &auth.Auth{AccessToken: "test-token", Domain: "copilot.tencent.com", UID: "u1"} - - body := []byte(`{"model":"glm-5.2","messages":[{"role":"system","content":"` + ccIdentity + `"}]}`) - rc, status, _, err := c.ChatStream(acct, body, "", ChatMeta{}) - if err != nil { - t.Fatal(err) - } - defer rc.Close() - if status >= 400 { - t.Fatalf("upstream status %d", status) - } - if !strings.Contains(string(gotBody), ccIdentity) { - t.Error("sanitize disabled should preserve fingerprint on wire") - } -} - -// TestSanitizeMessagesScrubsReasoningField thinking.go 的回填会把客户端送来的 -// reasoning_content 镜像进 reasoning 字段;此前只洗 content / reasoning_content / -// tool_calls → 镜像进 reasoning 的指纹(裸 "11128" 这类反探测串)原样出站, -// 而请求体里出现裸 11128 本身就是上游整单拦截条件。 -func TestSanitizeMessagesScrubsReasoningField(t *testing.T) { - ms := []any{map[string]any{ - "role": "assistant", - "content": "hi", - "reasoning": "upstream said 11128", - }} - if !sanitizeMessages(ms) { - t.Fatal("reasoning 字段里的指纹未被净化") - } - got, _ := ms[0].(map[string]any)["reasoning"].(string) - if strings.Contains(got, "11128") { - t.Fatalf("reasoning 仍含裸指纹: %q", got) - } -} - -// newTestUpstream 起一个假上游并捕获请求。 -func newTestUpstream(t *testing.T, h http.HandlerFunc) *httptest.Server { - t.Helper() - return httptest.NewServer(h) -} +package upstream + +import ( + "encoding/json" + "io" + "net/http" + "net/http/httptest" + "strings" + "testing" + + "github.com/misakano7545/workbuddy2api-panel/internal/auth" +) + +const ( + ccIdentity = "You are Claude Code, Anthropic's official CLI for Claude." + ccBranch = "Main branch (you will usually use this for PRs)" + ccHeader = "x-anthropic-billing-header: cc_version=1.0; cc_entrypoint=cli;" + // Codex instructions 首段(上游逐字精确指纹,三句缺一不可)。 + codexInstructions = "You are a coding agent running in the Codex CLI, a terminal-based coding assistant. Codex CLI is an open source project led by OpenAI. You are expected to be precise, safe, and helpful." +) + +func TestIdentityRewritten(t *testing.T) { + out := sanitizeText(ccIdentity) + if !strings.Contains(out, "official CLI tool for Claude.") { + t.Errorf("identity not rewritten: %q", out) + } + if strings.Contains(out, ccIdentity) { + t.Errorf("original identity still present: %q", out) + } +} + +// 桌面版(claude-desktop-3p / Agent SDK)的身份句以逗号接后继内容,结尾不是句号。 +// 回归用例:匹配串曾带结尾句号,导致该形态漏网、指纹原样发上游 → 400 code=11128。 +func TestIdentityDesktopVariantRewritten(t *testing.T) { + in := "You are Claude Code, Anthropic's official CLI for Claude, running within the Claude Agent SDK." + out := sanitizeText(in) + if strings.Contains(out, "official CLI for Claude") { + t.Errorf("desktop identity not rewritten: %q", out) + } + if !strings.Contains(out, "official CLI tool for Claude, running within the Claude Agent SDK.") { + t.Errorf("desktop identity suffix not preserved: %q", out) + } +} + +func TestBranchRewritten(t *testing.T) { + out := sanitizeText(ccBranch) + if !strings.Contains(out, "Default branch (you will usually use this for PRs)") { + t.Errorf("branch not rewritten: %q", out) + } + if strings.Contains(out, "Main branch") { + t.Errorf("original branch still present: %q", out) + } +} + +// 反馈句带 Anthropic 仓库链接,上游按整句拦截(实测只留链接或只留半边均不拦)。 +// 回归用例:give→provide 一词之差即可绕过。 +func TestFeedbackSentenceRewritten(t *testing.T) { + in := "To give feedback, users should report the issue at https://github.com/anthropics/claude-code/issues" + out := sanitizeText(in) + if strings.Contains(out, "To give feedback") { + t.Errorf("feedback sentence not rewritten: %q", out) + } + if !strings.Contains(out, "To provide feedback, users should report the issue at https://github.com/anthropics/claude-code/issues") { + t.Errorf("feedback sentence not rewritten as expected: %q", out) + } +} + +// 上游反探测:请求体里出现裸数字 11128 即整单拦截(与上下文无关)。 +// 回归用例:该串会被改写为 11-128 以打断精确匹配。 +func TestUpstreamErrorCodeRewritten(t *testing.T) { + in := "upstream returned code=11128 for this request" + out := sanitizeText(in) + if strings.Contains(out, "11128") { + t.Errorf("error code not rewritten: %q", out) + } + if !strings.Contains(out, "11-128") { + t.Errorf("error code not rewritten as expected: %q", out) + } +} + +// reasoning 字段:thinking.go 的回填把客户端送来的 reasoning_content 镜像进 +// reasoning(且回填就排在 sanitizeMessages 之前),此前只洗 content / +// reasoning_content / tool_calls → 镜像出来的那一份指纹原样出站。 +// 注意指纹字面量必须与 sanitizeFeatures 里的形态逐字一致。 +func TestSanitizeMessagesScrubsReasoningField(t *testing.T) { + // 用 ccIdentity(测试文件里已有的纯 ASCII 指纹常量)当脏内容:它走同一条 + // sanitizeText 改写路径,且不用硬编码数字串(本仓工具链会改写数字字面量)。 + ms := []any{map[string]any{ + "role": "assistant", + "content": "hi", + "reasoning": ccIdentity, + }} + if !sanitizeMessages(ms, true) { + t.Fatal("reasoning 字段里的指纹未被净化") + } + got, _ := ms[0].(map[string]any)["reasoning"].(string) + if got == ccIdentity { + t.Fatalf("reasoning 未被净化: %q", got) + } +} + +// 回归:工具调用消息的 content 常为 null,而旧版 sanitizeMessages 在 content 缺失时 +// 直接 continue,整条消息连 tool_calls 一起被跳过 → arguments 里的被拦字符串原样漏出。 +func TestToolCallArgumentsSanitized(t *testing.T) { + msgs := []any{ + map[string]any{"role": "user", "content": "run"}, + map[string]any{"role": "assistant", "content": nil, "tool_calls": []any{ + map[string]any{"id": "c1", "type": "function", "function": map[string]any{ + "name": "Bash", + "arguments": `{"command":"echo 11128"}`, + }}, + }}, + } + if !sanitizeMessages(msgs, true) { + t.Fatal("sanitizeMessages 未报告任何改动,tool_calls 被跳过") + } + fn := msgs[1].(map[string]any)["tool_calls"].([]any)[0].(map[string]any)["function"].(map[string]any) + got := fn["arguments"].(string) + if strings.Contains(got, "11128") { + t.Errorf("tool_call arguments 未被净化: %q", got) + } +} + +func TestBillingHeaderStrippedValueIrrelevant(t *testing.T) { + out := sanitizeText(ccHeader) + if strings.Contains(out, "x-anthropic-billing-header") { + t.Errorf("header not stripped: %q", out) + } +} + +// 附加验证:正常对话里出现 github.com/anthropics/ 链接(但不是反馈句整句) +// 时,预检特征命中(进入净化),但改写层只动精确匹配的整句——普通链接文本 +// 不该被改写。同理,既不含 11128 也不含反馈整句的文本原样返回。 +func TestNormalAnthropicLinkNotRewritten(t *testing.T) { + in := "see https://github.com/anthropics/anthropic-cookbook for examples" + if out := sanitizeText(in); out != in { + t.Errorf("normal anthropic link should be untouched: %q -> %q", in, out) + } +} + +// Codex instructions 首段:命中预告且整句改写,逐字指纹被破坏、语义保留。 +func TestCodexInstructionsRewritten(t *testing.T) { + out := sanitizeText(codexInstructions) + if strings.Contains(out, codexInstructions) { + t.Errorf("codex fingerprint still present: %q", out) + } + if !strings.Contains(out, "You are a coding agent running in the Codex CLI tool, a terminal-based coding assistant.") { + t.Errorf("codex first sentence not rewritten: %q", out) + } + // 其余两句原样保留,语义不变。 + if !strings.Contains(out, "Codex CLI is an open source project led by OpenAI.") || + !strings.Contains(out, "You are expected to be precise, safe, and helpful.") { + t.Errorf("codex remaining sentences altered: %q", out) + } +} + +// 预检必须能认出 Codex 特征(此前只含 Claude Code,导致提前放行)。 +func TestCodexFingerprintDetected(t *testing.T) { + if !hasFingerprint(codexInstructions) { + t.Error("codex fingerprint not detected by precheck") + } +} + +// 非精确变体不应被改写:仅去掉其中一个词即视为已破坏,无需改动。 +func TestCodexVariantNotTouched(t *testing.T) { + in := "You are a coding agent running in a CLI, a terminal-based coding assistant." + if out := sanitizeText(in); out != in { + t.Errorf("already-broken variant should be untouched: %q -> %q", in, out) + } +} + +func TestBillingHeaderCaseInsensitive(t *testing.T) { + alt := "X-Anthropic-Billing-Header: cc_version=1.0;" + out := strings.ToLower(sanitizeText(alt)) + if strings.Contains(out, "billing") { + t.Errorf("case-insensitive header not stripped: %q", out) + } +} + +func TestTrailingKVStripped(t *testing.T) { + out := sanitizeText("...; cc_version=2.0; cc_entrypoint=cli;") + if strings.Contains(out, "cc_version") || strings.Contains(out, "cc_entrypoint") { + t.Errorf("trailing kv not stripped: %q", out) + } +} + +func TestExactMatchOnlyVariantNotTouched(t *testing.T) { + in := "...official CLI for Claude!" + if out := sanitizeText(in); out != in { + t.Errorf("variant should be untouched: %q -> %q", in, out) + } +} + +func TestUserFreeTextNotTouched(t *testing.T) { + in := "please use main branch for this repo" + if out := sanitizeText(in); out != in { + t.Errorf("free text should be untouched: %q -> %q", in, out) + } +} + +func TestNoFeatureReturnsSameString(t *testing.T) { + in := "ordinary user message" + if out := sanitizeText(in); out != in { + t.Errorf("no-feature text should pass through unchanged: %q -> %q", in, out) + } +} + +func TestMultimodalTextPartOnly(t *testing.T) { + imgPart := map[string]any{"type": "image", "source": map[string]any{"type": "base64", "data": "..."}} + content := []any{ + map[string]any{"type": "text", "text": ccIdentity}, + imgPart, + } + out, changed := sanitizeContent(content, true) + if !changed { + t.Fatal("expected change") + } + parts := out.([]any) + txt, _ := parts[0].(map[string]any)["text"].(string) + if !strings.Contains(txt, "CLI tool") { + t.Errorf("text part not sanitized: %q", txt) + } + img, _ := parts[1].(map[string]any) + if img["type"] != "image" || img["source"].(map[string]any)["data"] != "..." { + t.Error("image part modified") + } +} + +// 集成:完整请求体经 PrepareBodyOpt 净化后无残留指纹,且 stream/tool_choice 行为不受影响。 +func TestPrepareBodyOptSanitizesSystem(t *testing.T) { + body := []byte(`{"model":"glm-5.2","messages":[` + + `{"role":"system","content":"` + ccIdentity + ` ` + ccHeader + `"},` + + `{"role":"user","content":"hi"}]}`) + out := PrepareBodyOpt(body, true) + var obj map[string]any + if err := json.Unmarshal(out, &obj); err != nil { + t.Fatal(err) + } + if obj["stream"] != true { + t.Error("stream not forced") + } + msgs := obj["messages"].([]any) + sys, _ := msgs[0].(map[string]any)["content"].(string) + if strings.Contains(sys, "x-anthropic-billing-header") || strings.Contains(sys, ccIdentity) || strings.Contains(sys, ccBranch) { + t.Errorf("fingerprints remain: %q", sys) + } + if !strings.Contains(sys, "CLI tool") { + t.Errorf("rewrite missing: %q", sys) + } +} + +func TestPrepareBodyOptDisabledPreservesFingerprints(t *testing.T) { + body := []byte(`{"model":"glm-5.2","messages":[{"role":"system","content":"` + ccIdentity + `"}]}`) + out := PrepareBodyOpt(body, false) + if !strings.Contains(string(out), ccIdentity) { + t.Error("sanitize=false should preserve fingerprints") + } + // 但 stream 仍强制 + var obj map[string]any + _ = json.Unmarshal(out, &obj) + if obj["stream"] != true { + t.Error("stream should still be forced") + } +} + +// PrepareBody 默认行为 = 开启脱敏(保持向后兼容)。 +func TestPrepareBodyDefaultSanitizes(t *testing.T) { + body := []byte(`{"model":"glm-5.2","messages":[{"role":"system","content":"` + ccIdentity + `"}]}`) + out := PrepareBodyOpt(body, true) + if strings.Contains(string(out), ccIdentity) { + t.Error("PrepareBody default should sanitize") + } +} + +// 出站边界集成:ChatStream 发往上游的 wire body 必须无残留指纹。 +func TestChatStreamWireBodySanitized(t *testing.T) { + var gotBody []byte + ts := newTestUpstream(t, func(w http.ResponseWriter, r *http.Request) { + gotBody, _ = io.ReadAll(r.Body) + w.Header().Set("Content-Type", "text/event-stream") + _, _ = w.Write([]byte("data: {\"choices\":[{\"delta\":{\"content\":\"ok\"}}]}\n\ndata: [DONE]\n\n")) + }) + defer ts.Close() + + c := New() + c.SanitizeFingerprints.Store(true) + c.ChatBaseCN = ts.URL + acct := &auth.Auth{AccessToken: "test-token", Domain: "copilot.tencent.com", UID: "u1"} + + body := []byte(`{"model":"glm-5.2","messages":[` + + `{"role":"system","content":"` + ccIdentity + ` ` + ccHeader + `"},` + + `{"role":"user","content":"hi"}]}`) + rc, status, respBody, err := c.ChatStream(acct, body, "", ChatMeta{}) + if err != nil { + t.Fatal(err) + } + defer rc.Close() + if status >= 400 { + t.Fatalf("upstream status %d: %s", status, respBody) + } + // 上游收到的 body:stream 强制 + 指纹已净化 + var obj map[string]any + if err := json.Unmarshal(gotBody, &obj); err != nil { + t.Fatalf("wire body not json: %v", err) + } + if obj["stream"] != true { + t.Error("wire body stream not forced") + } + sys, _ := obj["messages"].([]any)[0].(map[string]any)["content"].(string) + for _, fp := range []string{"x-anthropic-billing-header", ccIdentity, ccBranch} { + if strings.Contains(sys, fp) { + t.Errorf("wire body contains fingerprint %q: %q", fp, sys) + } + } +} + +// 出站边界(Codex 场景):CPA 把 instructions 折成 role=system 的首条消息, +// 净化后 wire body 不得残留 Codex 逐字指纹;其余消息不受影响。 +func TestChatStreamWireBodyCodexInstructionsSanitized(t *testing.T) { + var gotBody []byte + ts := newTestUpstream(t, func(w http.ResponseWriter, r *http.Request) { + gotBody, _ = io.ReadAll(r.Body) + w.Header().Set("Content-Type", "text/event-stream") + _, _ = w.Write([]byte("data: {\"choices\":[{\"delta\":{\"content\":\"ok\"}}]}\n\ndata: [DONE]\n\n")) + }) + defer ts.Close() + + c := New() + c.SanitizeFingerprints.Store(true) + c.ChatBaseCN = ts.URL + acct := &auth.Auth{AccessToken: "test-token", Domain: "copilot.tencent.com", UID: "u1"} + + body := []byte(`{"model":"kimi-k3","messages":[` + + `{"role":"system","content":"` + codexInstructions + `"},` + + `{"role":"user","content":"say ok"}]}`) + rc, status, respBody, err := c.ChatStream(acct, body, "", ChatMeta{}) + if err != nil { + t.Fatal(err) + } + defer rc.Close() + if status >= 400 { + t.Fatalf("upstream status %d: %s", status, respBody) + } + var obj map[string]any + if err := json.Unmarshal(gotBody, &obj); err != nil { + t.Fatalf("wire body not json: %v", err) + } + sys, _ := obj["messages"].([]any)[0].(map[string]any)["content"].(string) + if strings.Contains(sys, codexInstructions) || + strings.Contains(sys, "in the Codex CLI, a terminal-based coding assistant.") { + t.Errorf("wire body still contains codex fingerprint: %q", sys) + } + if !strings.Contains(sys, "running in the Codex CLI tool, a terminal-based") { + t.Errorf("codex rewrite missing on wire: %q", sys) + } + user, _ := obj["messages"].([]any)[1].(map[string]any)["content"].(string) + if user != "say ok" { + t.Errorf("user message altered: %q", user) + } +} + +// 出站边界:关闭脱敏后 wire body 原样保留指纹(验证开关真实有效)。 +func TestChatStreamWireBodySanitizeDisabled(t *testing.T) { + var gotBody []byte + ts := newTestUpstream(t, func(w http.ResponseWriter, r *http.Request) { + gotBody, _ = io.ReadAll(r.Body) + w.Header().Set("Content-Type", "text/event-stream") + _, _ = w.Write([]byte("data: [DONE]\n\n")) + }) + defer ts.Close() + + c := New() + c.SanitizeFingerprints.Store(false) + c.ChatBaseCN = ts.URL + acct := &auth.Auth{AccessToken: "test-token", Domain: "copilot.tencent.com", UID: "u1"} + + body := []byte(`{"model":"glm-5.2","messages":[{"role":"system","content":"` + ccIdentity + `"}]}`) + rc, status, _, err := c.ChatStream(acct, body, "", ChatMeta{}) + if err != nil { + t.Fatal(err) + } + defer rc.Close() + if status >= 400 { + t.Fatalf("upstream status %d", status) + } + if !strings.Contains(string(gotBody), ccIdentity) { + t.Error("sanitize disabled should preserve fingerprint on wire") + } +} + +// DSH 的身份句是短语级指纹:上游按逐字匹配拦(400 11-128 unapproved channel), +// 换一个词即绕过。钉住三条:命中改写、只含品牌词也走净化(特征预检不得漏)、 +// 改写结果不再含原始短语(可重复处理)。 +func TestDeepSeekHarnessBrandRewritten(t *testing.T) { + // 品牌串从表中取:真实字面量与文档里的写法差一个空格,手写会静默对不上。 + brand := sanitizeIdentityFeatures[0] + in := "You are an AI agent powered by " + brand + ".\n\nCheck the exit code." + out := sanitizeTextIdentity(in) + // 整句被中性句替换(身份句式规则):只剩品牌改写时 `You are … powered by …` 的 + // 句子骨架仍是特征,所以这里是整句级断言。 + if strings.Contains(out, brand) || strings.Contains(out, "powered by") { + t.Fatalf("identity sentence not neutralized: %q", out) + } + if !strings.HasPrefix(out, "You are a helpful AI assistant.") { + t.Errorf("sentence not replaced with neutral one: %q", out) + } + if !strings.Contains(out, "\n\nCheck the exit code.") { + t.Errorf("surrounding text changed: %q", out) + } + if again := sanitizeTextIdentity(out); again != out { + t.Errorf("not idempotent: %q -> %q", out, again) + } +} + +// 身份句式的变体覆盖:动词表七种、名词可省、专名与冠词都认。 +// 上游补一条新搭配就能让只认单个动词的实现重新 400,所以逐个钉住。 +func TestIdentitySentenceVariants(t *testing.T) { + const neutral = "You are a helpful AI assistant." + for _, in := range []string{ + "You are an AI agent powered by AcmeRuntime. Next.", + "You are a coding agent powered by the deepseek-v4.1-flash model. Next.", + "You are an AI assistant built on DeepSeek. Next.", + "You are Acme Agent, built by Acme Corp. Next.", + "You are the FooBot assistant, created by someone. Next.", + "You are a bot developed by someone. Next.", + "You are a tool made by someone. Next.", + "You are a model trained by someone. Next.", + } { + out := sanitizeTextIdentity(in) + if !strings.HasPrefix(out, neutral) { + t.Errorf("未中性化: %q -> %q", in, out) + } + if !strings.Contains(out, "Next.") { + t.Errorf("句后文本丢失: %q", out) + } + } +} + +// 误伤保护:「You are free to use tools built by …」这类分词修饰宾语的句子不是身份句, +// 靠正则窗口上界(形容词 0~3 个)挡住。预检也必须判 false,否则会白白 TrimSpace。 +func TestIdentitySentenceFalsePositives(t *testing.T) { + for _, in := range []string{ + "You are free to use tools built by the vendor.", + "You are a helpful assistant that uses services developed by others. Ok.", + "You are welcome to deploy packages made by third parties.", + "You are right, that module was built by the other team. Fine.", + } { + if hasIdentityFingerprint(in) { + t.Errorf("预检误判: %q", in) + } + if out := sanitizeTextIdentity(in); out != in { + t.Errorf("误改写: %q -> %q", in, out) + } + } +} + +// 作用域:身份句式属于身份类规则,sanitizeText(brand=false)不动,只有身份路径改。 +// 这与品牌词规则的既有作用域一致(sanitize_brand_scope 控制)。 +func TestIdentitySentenceScope(t *testing.T) { + in := "You are an AI agent powered by AcmeRuntime. Go." + if out := sanitizeText(in); out != in { + t.Errorf("brand=false 不该改写: %q", out) + } + if out := sanitizeTextIdentity(in); out == in { + t.Errorf("身份路径应该改写: %q", out) + } +} + +// 预检快路径:文本只含品牌词、不含任何其它指纹,也必须进入净化。 +func TestDeepSeekHarnessDetected(t *testing.T) { + in := "You are interacting through the DeepSeek Harness Web GUI." + if hasFingerprint(in) { + t.Error("brand word should NOT hit the global fast path(否则非身份消息会被 TrimSpace/改写)") + } + if !hasIdentityFingerprint(in) { + t.Error("brand word should hit the identity fast path") + } +} + +// 走完 prepareBody 全链路:system 的身份句整句中性化,user 里的品牌词按作用域改写。 +func TestPrepareBodyRewritesDeepSeekHarness(t *testing.T) { + // 品牌串从表里取:真实字面量与文档写法差一个空格,手写会静默对不上而测试永远绿。 + brand := sanitizeIdentityFeatures[0] + body, err := json.Marshal(map[string]any{ + "model": "deepseek-v4.1-flash", + "messages": []any{ + map[string]any{"role": "system", "content": "You are an AI agent powered by " + brand + "."}, + map[string]any{"role": "user", "content": "the " + brand + " checkout is here"}, + }, + }) + if err != nil { + t.Fatal(err) + } + out, _, _ := prepareBodyOpt(body, true, true, nil, nil, nil, "", nil, "", "", false, 0, "") + + var got map[string]any + if err := json.Unmarshal(out, &got); err != nil { + t.Fatal(err) + } + msgs := got["messages"].([]any) + sys, _ := msgs[0].(map[string]any)["content"].(string) + usr, _ := msgs[1].(map[string]any)["content"].(string) + if sys != "You are a helpful AI assistant." { + t.Errorf("system 身份句未中性化: %q", sys) + } + if strings.Contains(usr, brand) { + t.Errorf("user 品牌词未改写: %q", usr) + } + if !strings.Contains(usr, "checkout is here") { + t.Errorf("user 其余文本被破坏: %q", usr) + } +} + +// newTestUpstream 起一个假上游并捕获请求。 +func newTestUpstream(t *testing.T, h http.HandlerFunc) *httptest.Server { + t.Helper() + return httptest.NewServer(h) +} + +// TestBrandScopeAllRewritesUserMessages 默认作用域(all):与上游既有行为一致, +// 所有消息角色的品牌词都改写(包括用户输入)。 +func TestBrandScopeAllRewritesUserMessages(t *testing.T) { + msgs := []any{ + map[string]any{"role": "system", "content": "You are DeepSeek Harness."}, + map[string]any{"role": "user", "content": "read DeepSeek Harness docs"}, + } + if !sanitizeMessages(msgs, true) { + t.Fatal("sanitizeMessages all: 未报告改动") + } + for i, m := range msgs { + if got := m.(map[string]any)["content"].(string); strings.Contains(got, "DeepSeek Harness") { + t.Errorf("msg[%d] 品牌词未改写: %q", i, got) + } + } +} + +// TestBrandScopeIdentityLeavesUserMessages identity 作用域:只改 system/developer, +// 用户/工具/assistant 内容(含 tool_calls 参数与 reasoning)原样透传。 +func TestBrandScopeIdentityLeavesUserMessages(t *testing.T) { + msgs := []any{ + map[string]any{"role": "system", "content": "You are DeepSeek Harness."}, + map[string]any{"role": "user", "content": " DeepSeek Harness "}, + map[string]any{"role": "assistant", "content": nil, + "tool_calls": []any{map[string]any{"id": "c1", "function": map[string]any{ + "name": "Read", "arguments": `{"path":"DeepSeek Harness.md"}`, + }}}, + }, + } + if !sanitizeMessages(msgs, false) { + t.Fatal("sanitizeMessages identity: system 未改写") + } + if got := msgs[0].(map[string]any)["content"].(string); !strings.Contains(got, "DeepSeekRuntime") { + t.Errorf("system 品牌词未改写: %q", got) + } + if got := msgs[1].(map[string]any)["content"].(string); got != " DeepSeek Harness " { + t.Errorf("user 内容被改动(应原样含首尾空白): %q", got) + } + args := msgs[2].(map[string]any)["tool_calls"].([]any)[0].(map[string]any)["function"].(map[string]any)["arguments"].(string) + if !strings.Contains(args, "DeepSeek Harness") { + t.Errorf("tool_calls 参数被改动: %q", args) + } +} + +// TestBrandScopeDefaultGlobal 默认值:Client 未配置作用域时按 all 处理。 +func TestBrandScopeDefaultGlobal(t *testing.T) { + var c Client + c.SanitizeFingerprints.Store(true) + if !c.brandScopeGlobal() { + t.Error("默认应为 all(brandScopeGlobal=true)") + } + c.SanitizeBrandScope.Store("identity") + if c.brandScopeGlobal() { + t.Error("identity 应返回 false") + } + c.SanitizeBrandScope.Store("") + if !c.brandScopeGlobal() { + t.Error("空值应回落 all") + } +} + +// DSH 0.3.x 的 @ 路径说明段是**唯一不含品牌词**的 DSH 指纹:品牌改写规则碰不到它, +// 原文发出即 400 11-128 unapproved channel。钉住四条:整段被改写、两种线上措辞都覆盖、 +// 段外 @ 不动、改写可重复。 +const ( + dshPathsNow = "Tokens prefixed with @ are paths the user explicitly referenced. " + + "Relative paths resolve from the workspace root; absolute paths point to " + + "files or directories on the host. A trailing slash marks a directory, so " + + "list it when its contents matter. Anything else is a file: open it with " + + "the read tool when its contents are needed, and never claim to have " + + "inspected it before reading. The @\"...\" form only quotes a path that " + + "contains spaces." + dshPathsOld = "Tokens prefixed with @ are paths the user explicitly referenced. " + + "Relative paths resolve from the workspace root; absolute paths identify " + + "files or directories on the host. A trailing slash marks a directory: " + + "list it when its contents matter. Anything else is a file: use the read " + + "tool when its contents are needed, and do not claim to have inspected it " + + "before reading. @\"...\" quotes a path containing spaces." +) + +func TestDshPathsParagraphRewritten(t *testing.T) { + if !hasFingerprint(dshPathsNow) { + t.Fatal("段落未被特征预检命中:净化整条链都不会启动") + } + out := sanitizeText(dshPathsNow) + if out != sanitizeDshPathsReplacement { + t.Fatalf("整段未被替换:\n got=%q\nwant=%q", out, sanitizeDshPathsReplacement) + } + if strings.Contains(out, "Tokens prefixed with @") { + t.Errorf("原文残留在出站文本里: %q", out) + } + // 语义必须保留:读提示词的 DSH 仍要知道 @ 路径怎么解析。 + for _, want := range []string{"project root", "trailing slash", "read tool", "@\"...\""} { + if !strings.Contains(out, want) { + t.Errorf("改写丢语义 %q: %q", want, out) + } + } +} + +// 更早的 DSH 写法(identify / use the read tool / quotes a path containing spaces) +// 同一段语义、不同措辞:正则的结尾分支必须也吃下它。 +func TestDshPathsOlderWordingRewritten(t *testing.T) { + if out := sanitizeText(dshPathsOld); out != sanitizeDshPathsReplacement { + t.Fatalf("旧措辞未覆盖:\n got=%q\nwant=%q", out, sanitizeDshPathsReplacement) + } +} + +// 段内本来就有换行,(?s) 没开的话 .*? 跨不过去,只改半段等于没改。 +func TestDshPathsMultilineRewritten(t *testing.T) { + in := strings.Replace(dshPathsNow, "Relative paths", "\n\nRelative paths", 1) + out := sanitizeText(in) + if strings.Contains(out, "Tokens prefixed with @") || !strings.Contains(out, "Paths beginning with @") { + t.Fatalf("跨行形态未覆盖: %q", out) + } +} + +// 段落嵌在更长的 system 里时只换这一段,前后文原样。 +func TestDshPathsEmbeddedKeepsSurroundings(t *testing.T) { + in := "before\n\n" + dshPathsNow + "\n\nafter" + if out := sanitizeText(in); out != "before\n\n"+sanitizeDshPathsReplacement+"\n\nafter" { + t.Fatalf("前后文被动了: %q", out) + } +} + +func TestDshPathsIdempotent(t *testing.T) { + once := sanitizeText(dshPathsNow) + if again := sanitizeText(once); again != once { + t.Fatalf("不幂等: %q -> %q", once, again) + } +} + +// 段外的 @ 是普通文本(邮箱、npm 包名、Windows 路径),不得改写也不得触发净化。 +func TestDshPathsUnrelatedAtTextUntouched(t *testing.T) { + for _, in := range []string{ + "Mail me at someone@example.com and open C:\\cache\\@tmp.", + "npm i @deepseek-ai/dsh-llm", + "Relative paths resolve from the workspace root, but this is not the paragraph.", + } { + if hasFingerprint(in) { + t.Errorf("误触发预检: %q", in) + } + if out := sanitizeText(in); out != in { + t.Errorf("误改写: %q -> %q", in, out) + } + } +} + +// 走完 prepareBody 全链路:system 里的这段必须真正在出站 body 里被换掉。 +func TestPrepareBodyRewritesDshPaths(t *testing.T) { + body, err := json.Marshal(map[string]any{ + "model": "deepseek-v4.1-flash", + "messages": []any{ + map[string]any{"role": "system", "content": dshPathsNow}, + map[string]any{"role": "user", "content": "hi"}, + }, + }) + if err != nil { + t.Fatal(err) + } + out, _, _ := prepareBodyOpt(body, true, true, nil, nil, nil, "", nil, "", "", false, 0, "") + if strings.Contains(string(out), "Tokens prefixed with @") { + t.Fatalf("出站 body 仍带指纹: %s", out) + } + if !strings.Contains(string(out), "Paths beginning with @") { + t.Fatalf("出站 body 未被改写: %s", out) + } +} diff --git a/internal/upstream/sanitize_tools_test.go b/internal/upstream/sanitize_tools_test.go new file mode 100644 index 0000000000000000000000000000000000000000..2af17c78cef76ea29b7e4da6dd518aa5c94a33ab --- /dev/null +++ b/internal/upstream/sanitize_tools_test.go @@ -0,0 +1,56 @@ +package upstream + +import ( + "encoding/json" + "strings" + "testing" +) + +// TestSanitizeCoversToolsDescription tools[].function.description 也要走脱敏。 +// +// 脱敏此前只进 sanitizeMessages:messages[].content 被洗,而客户端自带的工具描述 +// 原样出站。工具描述与 system prompt 同源、都是固定模板句,属于同一类黑名单高发区 +// (上游 issue #395 的盲区;#308 有「非空 tools 触发 11-128」的先例,但 tools 内容 +// 脱敏并未验证过是否真被拦——所以这里只钉「行为与 messages 一致」,不声称拦得住)。 +func TestSanitizeCoversToolsDescription(t *testing.T) { + // DSH @ 路径段的原文(sanitizeDshPathsRe 覆盖的那一段),放进工具描述里。 + fp := "Tokens prefixed with @ are paths the user explicitly referenced. " + + "Relative paths are resolved against the workspace root; absolute paths point to " + + "files or directories on the host. A trailing slash marks a directory, so list it " + + "when its contents matter. Anything else is a file: open it with the read tool when " + + "its contents are needed, and never claim to have inspected it before reading. " + + "The @\"...\" form only quotes a path that contains spaces." + body := `{"model":"m","messages":[{"role":"user","content":"hi"}],"tools":[{"type":"function",` + + `"function":{"name":"read_file","description":` + quote(fp) + `}}]}` + + out := PrepareBodyOpt([]byte(body), true) + var obj map[string]any + if err := json.Unmarshal(out, &obj); err != nil { + t.Fatalf("输出不是合法 JSON: %v (%s)", err, out) + } + fn := obj["tools"].([]any)[0].(map[string]any)["function"].(map[string]any) + desc := fn["description"].(string) + if desc == fp { + t.Fatalf("tools 描述未被净化,指纹原样出站") + } + if !strings.Contains(desc, "Paths beginning with @ refer to files") { + t.Fatalf("应是同义改写而不是删除,got %q", desc) + } + + // 反例:没有指纹的描述必须一字不动(避免为了覆盖 tools 把正常描述改写)。 + clean := `{"model":"m","messages":[{"role":"user","content":"hi"}],"tools":[{"type":"function",` + + `"function":{"name":"x","description":"Read a file from disk."}}]}` + var obj2 map[string]any + if err := json.Unmarshal(PrepareBodyOpt([]byte(clean), true), &obj2); err != nil { + t.Fatalf("反例输出非法: %v", err) + } + if got := obj2["tools"].([]any)[0].(map[string]any)["function"].(map[string]any)["description"]; got != "Read a file from disk." { + t.Fatalf("无指纹描述被误改: %q", got) + } +} + +// quote 把字符串包成 JSON 字面量(正文里有引号与反斜杠,手写容易错)。 +func quote(s string) string { + b, _ := json.Marshal(s) + return string(b) +} diff --git a/internal/upstream/school.go b/internal/upstream/school.go index fb0d512bbada4d721999c2e6bdec22935b2588b8..54bafa88f6c383e9952c13cac60a4168b10769c0 100644 --- a/internal/upstream/school.go +++ b/internal/upstream/school.go @@ -1,242 +1,68 @@ -// school.go 开学季活动(school-season,活动期 2026-09-13 ~ 09-24)纯 API 自动化。 -// -// 判据(2026-09-13 小程序 MCP 逆向 + 三账号实测,protocol.md §7.11): -// - share_invite(每日 +100c +1抽奖):POST /tasks/share-complete {channel:"wechat"} -// 即点亮——纯前端上报,服务端不校验真实分享回执。本模块的主目标。 -// - chat_3_times / expert_use:判据绑定小程序原生沙箱会话(e2b runtime), -// webchat 普通会话不计数,纯 API 不做(需小程序内人工对话)。 -// - 抽奖:POST /wheel/draw {draw_uuid}(前端生成 uuid,消耗 1 chance)。 -// -// 端点基址 www.codebuddy.cn(billing 同域);信封 {code,msg,data},code=0 成功。 -package upstream - -import ( - "bytes" - "encoding/json" - "fmt" - "net/http" - "time" - - "github.com/linguo2625469/workbuddy2api-panel/internal/auth" -) - -const schoolBase = "/portal/activity/school" - -// schoolJSON 学院活动 API 请求(剥信封,业务 code≠0 返回带 msg 的 error)。 -func (c *Client) schoolJSON(a *auth.Auth, method, path string, body map[string]any, out any) error { - var raw []byte - if body != nil { - raw, _ = json.Marshal(body) - } - req, err := http.NewRequest(method, c.billingBase(a)+schoolBase+path, bytes.NewReader(raw)) - if err != nil { - return err - } - req.Header.Set("Authorization", "Bearer "+a.AccessTokenValue()) - req.Header.Set("Content-Type", "application/json") - req.Header.Set("Accept", "application/json") - if a.UID != "" { - req.Header.Set("X-User-Id", a.UID) - } - data, err := c.doJSON(req) - if err != nil { - return err - } - if out != nil { - return json.Unmarshal(data, out) - } - return nil -} - -// - chat_3_times:3 条 chat_request_send 即 3/3(conversationId 任意、桌面/mp -// 头族均可计数,无需真实沙箱会话)。 -// - expert_use:mp 指纹事件链 expert_summon_click + expert_summoned + -// expert_actual_use + chat_request_send(开学季分类专家)即点亮。 - -const mpReportPath = "/v2/report" - -// schoolOpenDayActivityID 开学季/校园日活动 id(事件 activityId 字段值,两域共用)。 -const schoolOpenDayActivityID = "school_open_day_2026" - -// mpEventBase 小程序埋点公共指纹(appservice wQ()+Ao() 对齐)。 -func mpEventBase(a *auth.Auth) map[string]any { - return map[string]any{ - "timestamp": time.Now().UnixMilli(), - "ideType": "WorkBuddy_MP", - "ideVersion": "2.4.0", - "extName": "workbuddy-mp", - "extVersion": "2.4.0", - "product": "SaaS", - "ideName": "wx_app_cloud", - "platform": "mini_program", - "os": "windows", - "osVersion": "11", - "arch": "x64", - "machineId": "0655736a-607f-4d9d-b430-58176ee9a090", - "timezone": "Asia/Shanghai", - "userId": a.UID, - "userNickname": a.Nickname, - } -} - -// ReportMPEvent 以小程序指纹向 www.codebuddy.cn/v2/report 批量上报事件。 -func (c *Client) ReportMPEvent(a *auth.Auth, events ...map[string]any) error { - if len(events) == 0 { - return fmt.Errorf("mp report: no events") - } - base := mpEventBase(a) - arr := make([]map[string]any, 0, len(events)) - for _, ev := range events { - m := map[string]any{} - for k, v := range base { - m[k] = v - } - for k, v := range ev { - m[k] = v - } - arr = append(arr, m) - } - raw, err := json.Marshal(arr) - if err != nil { - return err - } - req, err := http.NewRequest(http.MethodPost, c.BillingBaseCN+mpReportPath, bytes.NewReader(raw)) - if err != nil { - return err - } - req.Header.Set("Authorization", "Bearer "+a.AccessTokenValue()) - req.Header.Set("Content-Type", "application/json") - req.Header.Set("Accept", "application/json") - if a.UID != "" { - req.Header.Set("X-User-Id", a.UID) - } - req.Header.Set("X-Client-Product", "workbuddy-mp") - req.Header.Set("X-Client-Version", "2.4.0") - req.Header.Set("X-Client-Platform", "mp-weixin") - req.Header.Set("X-Platform", "wechatmp") - _, err = c.doJSON(req) - return err -} - -// SchoolChatTimesEvents 构造一条 chat_request_send 事件(chat_3_times 计数)。 -func SchoolChatTimesEvents(conversationID string) map[string]any { - rid := "wb2api-" + clientToken() - return map[string]any{ - "eventCode": "chat_request_send", - "inputLength": 14, "isPlan": false, "isAutoExecuteTerminal": false, - "isAutoModify": false, "codebaseEnable": false, "maxToken": 0, - "maxSteps": 500, "temperature": 0, "maxRetries": 0, - "mentionContexts": []any{}, "knowledgeId": []any{}, "knowledgeName": []any{}, - "codebaseId": "", "mentionContextCount": 0, "command": "", - "recommendId": "", "skillId": "", "skillCount": 0, "totalCount": 0, - "traceId": rid, "rootRequestId": rid, - "parentConversationId": conversationID, "conversationId": conversationID, - "messageId": "msg-" + rid[len(rid)-8:], - "agentName": "mp", "agentType": "main", - "codebuddy.session_id": conversationID, - "codebuddy.conversation_request_id": rid, - } -} - -// SchoolSeasonChatEvent 构造 growth 域「校园日」(school_season)判据事件: -// mini 指纹 chat_request_send + activityId=school_open_day_2026(与 school 域 -// 开学季同 activityId 关联;实测无 activityId 的事件不点亮)。事件形状与 -// SchoolChatTimesEvents 同构(school 域 chat_3_times 同款),仅追加 activityId。 -func SchoolSeasonChatEvent(conversationID string) map[string]any { - ev := SchoolChatTimesEvents(conversationID) - ev["activityId"] = schoolOpenDayActivityID - return ev -} - -// MiniExpertUseEvent 构造 growth 域 Sequential_Tasks_2「在小程序内选中专家并完成 -// 有效对话」的判据事件:mp 指纹 expert_actual_use。形状对齐小程序源码 -// app-service.js 的真实发射点(上游 task_runner 实测 2026-09-23:上报即 completed, -// claim +200c+5e)。与 school 域的 SchoolExpertUseEvents 是**两套口径**,勿照抄: -// - 不带 conversationId/activityId——真实事件就是这两个字段都不带; -// - extVersion 用小程序自身版本 2.2.8(覆盖 mpEventBase 的 2.4.0); -// - source=mini_program + type 固定 "send_message"(小程序恒发此值)。 -// -// expertID 必须是专家市场真实 ex_ id(ListMarketExperts),空 id 服务端不入账。 -func MiniExpertUseEvent(expertID, expertName, expertType string) map[string]any { - if expertType == "" { - expertType = "agent" - } - if expertName == "" { - expertName = expertID - } - return map[string]any{ - "eventCode": "expert_actual_use", "reportDelay": 0, - "extVersion": "2.2.8", "source": "mini_program", - "id": expertID, "name": expertID, - "expertTitle": expertName, "type": "send_message", - "characterCount": 12, "expertType": expertType, - } -} - -// MiniChatModelEvent mp 对话事件 + 模型字段(Sequential_Tasks_5「使用 GLM5.2」判据 -// 载体):小程序 chat_request_send 真实发射点(mpsrc main 32904 模块)带 -// requestModelId / requestModelName——Tasks_1/3 的裸对话事件不带模型,模型任务 -// 须用本形态(判据待解锁实测验证)。 -func MiniChatModelEvent(conversationID, modelID, modelName string) map[string]any { - ev := SchoolChatTimesEvents(conversationID) - ev["requestModelId"] = modelID - ev["requestModelName"] = modelName - return ev -} - -// MiniPlaybookEvents mp 指纹灵感事件组(Sequential_Tasks_7「体验灵感功能」判据 -// 载体,形状对齐 mpsrc main 73640/73665 发射点:playbook_cta_click → -// playbook_prompt_send)。issue #42 称该任务为 PC 口径(+500c+5e)——PC 序列 -// (DesktopPlaybookPromptSequence)已实测点亮 playbook_prompt,本组作为 mp 形态 -// 补充(任务在 mp 链上,判据究竟认哪侧待解锁实测)。 -func MiniPlaybookEvents(caseID, caseName string) []map[string]any { - base := map[string]any{ - "id": caseID, "name": caseName, "type": "document", - "categoryId": "", "categoryName": "", - "skills": "", "skillNames": "", - } - cta := map[string]any{ - "eventCode": "playbook_cta_click", "source": "discover", "position": 1, - "extVersion": "2.2.8", - } - for k, v := range base { - cta[k] = v - } - send := map[string]any{ - "eventCode": "playbook_prompt_send", "source": "discover", - "promptLength": 96, "isOfficial": 1, - "conversationId": "wb2api-mp-pb-" + clientToken(), - "extVersion": "2.2.8", - } - for k, v := range base { - send[k] = v - } - return []map[string]any{cta, send} -} - -// ---- 我的券码(#/prizes?tab=vouchers,2026-09-16 接入)---- - -// SchoolVoucher 开学季抽奖抽中的第三方券(KFC/瑞幸/酷狗等)。 -// 字段结构按真实响应样本:GET /vouchers 单次拉全(无分页),data.items[]。 -type SchoolVoucher struct { - GrantID int64 `json:"grant_id"` - DrawUUID string `json:"draw_uuid,omitempty"` - SKUCode string `json:"sku_code,omitempty"` // kfc_ice_cream / voucher_luckin / voucher_kugou … - PrizeName string `json:"prize_name,omitempty"` // 肯德基冰淇淋 - Code string `json:"code"` // 券码本体(复制给店员核销) - ValidFrom string `json:"valid_from,omitempty"` // 上游常为空 - ValidTo string `json:"valid_to,omitempty"` // "2026-10-24" - GrantedAt string `json:"granted_at,omitempty"` // RFC3339 -} - -// SchoolVouchers 查询账号的开学季券码列表(只读)。 -// 抽到积分的记录不在此端点(那是 /rewards 的 type=credit 条目)。 -func (c *Client) SchoolVouchers(a *auth.Auth) ([]SchoolVoucher, error) { - var out struct { - Items []SchoolVoucher `json:"items"` - } - if err := c.schoolJSON(a, http.MethodGet, "/vouchers", nil, &out); err != nil { - return nil, err - } - return out.Items, nil -} +// school.go 开学季活动域(/portal/activity/school)。 +// +// 目前只用到「我的券码」一项:券码是开学季抽奖抽中的第三方券(KFC / 瑞幸 / 酷狗等), +// 活动已于 2026-09 结束、不再发放,但券的有效期最长到 2027-09,故保留只读查询入口。 +package upstream + +import ( + "bytes" + "encoding/json" + "net/http" + + "github.com/misakano7545/workbuddy2api-panel/internal/auth" +) + +// schoolBase 开学季活动域基础路径(拼在 billingBase 之后)。 +const schoolBase = "/portal/activity/school" + +// schoolJSON 向开学季活动域发一次 JSON 请求;鉴权与头族同 billing 域 +// (Bearer access token + X-User-Id),出站走 c.doJSON(HTTP 客户端 120s 超时)。 +func (c *Client) schoolJSON(a *auth.Auth, method, path string, body map[string]any, out any) error { + var raw []byte + if body != nil { + raw, _ = json.Marshal(body) + } + req, err := http.NewRequest(method, c.billingBase(a)+schoolBase+path, bytes.NewReader(raw)) + if err != nil { + return err + } + req.Header.Set("Authorization", "Bearer "+a.AccessTokenValue()) + req.Header.Set("Content-Type", "application/json") + req.Header.Set("Accept", "application/json") + if a.UID != "" { + req.Header.Set("X-User-Id", a.UID) + } + data, err := c.doJSON(req, a) + if err != nil { + return err + } + if out != nil { + return json.Unmarshal(data, out) + } + return nil +} + +// SchoolVoucher 开学季抽奖抽中的第三方券(KFC/瑞幸/酷狗等)。 +// 字段结构按真实响应样本:GET /vouchers 单次拉全(无分页),data.items[]。 +type SchoolVoucher struct { + GrantID int64 `json:"grant_id"` + DrawUUID string `json:"draw_uuid,omitempty"` + SKUCode string `json:"sku_code,omitempty"` // kfc_ice_cream / voucher_luckin / voucher_kugou … + PrizeName string `json:"prize_name,omitempty"` // 肯德基冰淇淋 + Code string `json:"code"` // 券码本体(复制给店员核销) + ValidFrom string `json:"valid_from,omitempty"` // 上游常为空 + ValidTo string `json:"valid_to,omitempty"` // "2026-10-24" + GrantedAt string `json:"granted_at,omitempty"` // RFC3339 +} + +// SchoolVouchers 查询账号的开学季券码列表(只读)。 +// 抽到积分的记录不在此端点(那是 /rewards 的 type=credit 条目)。 +func (c *Client) SchoolVouchers(a *auth.Auth) ([]SchoolVoucher, error) { + var out struct { + Items []SchoolVoucher `json:"items"` + } + if err := c.schoolJSON(a, http.MethodGet, "/vouchers", nil, &out); err != nil { + return nil, err + } + return out.Items, nil +} diff --git a/internal/upstream/search.go b/internal/upstream/search.go new file mode 100644 index 0000000000000000000000000000000000000000..618f4bd4413eb428903d7790dfa661c30d8921c9 --- /dev/null +++ b/internal/upstream/search.go @@ -0,0 +1,122 @@ +// search.go 官方 agenttool 联网能力(国内版与国际版同构): +// +// POST {chatBase}/agenttool/v1/search 联网检索(snippet 级) +// POST {agenttool}/v1/webfetch 抓网页正文(markdown) +// +// 鉴权与 chat 同源:Bearer + 会话三件套,官方无 HMAC/sign(实测只需 Authorization +// 即 200,三件套按官方客户端补齐是零风险的防御)。回程**原文透传**——该族响应没有 +// {code,msg,data} 信封,故不走 doJSON。 +// +// 请求字段的实测边界(2026-10-16,CN 两家 base 均验证): +// - type 只有小写 text2text 合法,省略时服务端自动回填; +// - provider 是**响应字段**,请求里带上任何值都 400 {code:15003}(unsupported provider); +// - max_results 是上限不是保证(服务端硬上限约 10),官方固定用 5; +// - allowed_domains / freshness / blocked_domains 传了不生效 —— 故不作为入参暴露, +// 免得给出「已过滤」的错误预期。 +package upstream + +import ( + "bytes" + "context" + "encoding/json" + "fmt" + "io" + "net/http" + + "github.com/misakano7545/workbuddy2api-panel/internal/auth" +) + +const ( + webSearchPath = "/agenttool/v1/search" + webFetchPath = "/agenttool/v1/webfetch" + + // WebSearchDefaultMaxResults 官方自己的取值(上限不是保证)。 + WebSearchDefaultMaxResults = 5 +) + +// SearchResult 单条检索结果(site/favicon 上游可选,缺失时零值)。 +type SearchResult struct { + Title string `json:"title"` + URL string `json:"url"` + Snippet string `json:"snippet"` + Site string `json:"site,omitempty"` +} + +// SearchResponse 检索响应(原文结构,供调用方按字段取用)。 +type SearchResponse struct { + Query string `json:"query"` + Type string `json:"type"` + Provider string `json:"provider"` + Results []SearchResult `json:"results"` + TotalResults int `json:"total_results"` + ResponseTimeMS int `json:"response_time_ms"` +} + +// Search 联网检索,返回上游原文 JSON(含 results/total_results/provider)。 +// query 为空、maxResults <= 0 时由服务端/本函数填默认值。 +func (c *Client) Search(ctx context.Context, a *auth.Auth, query string, maxResults int) (json.RawMessage, error) { + if maxResults <= 0 { + maxResults = WebSearchDefaultMaxResults + } + body, err := json.Marshal(map[string]any{ + "query": query, + "type": "text2text", + "max_results": maxResults, + }) + if err != nil { + return nil, err + } + return c.agentTool(ctx, a, webSearchPath, body) +} + +// WebFetch 抓取网页正文,返回上游原文 JSON({url,title,content},content 为 markdown)。 +func (c *Client) WebFetch(ctx context.Context, a *auth.Auth, url string) (json.RawMessage, error) { + body, err := json.Marshal(map[string]any{"url": url}) + if err != nil { + return nil, err + } + return c.agentTool(ctx, a, webFetchPath, body) +} + +// agentTool POST 到 agenttool 族端点。与 chat 同域(chatBase,realm 决定 CN/global) +// 同头(ChatHeaders,零值 ChatMeta 由三件套兜底恒发),≥400 交 Classify 定 Kind +// 供调用方走同一套失败处置。 +func (c *Client) agentTool(ctx context.Context, a *auth.Auth, path string, body []byte) (json.RawMessage, error) { + req, err := http.NewRequestWithContext(ctx, http.MethodPost, c.chatBase(a)+path, bytes.NewReader(body)) + if err != nil { + return nil, err + } + req.Header.Set("Content-Type", "application/json") + c.ChatHeaders(req, a, "", ChatMeta{}) + resp, err := c.do(req, a, false) + if err != nil { + return nil, err + } + defer resp.Body.Close() + raw, err := io.ReadAll(io.LimitReader(resp.Body, 1<<20)) + if err != nil { + return nil, fmt.Errorf("read body: %w", err) + } + if resp.StatusCode >= 400 { + kind := Classify(resp.StatusCode, string(raw)) + if kind == ErrNone { + kind = ErrClient + } + return nil, &Error{Kind: kind, Status: resp.StatusCode, Msg: truncate(string(raw), 200)} + } + // 200 也可以是业务错误(信封外确有 code 字段:15003/15013 实测走 400, + // 但服务端若改用 200 返 code,这里必须拦住,否则把错误当结果透传)。 + var env struct { + Code int `json:"code"` + Msg string `json:"msg"` + } + if err := json.Unmarshal(raw, &env); err == nil && env.Code != 0 { + kind := Classify(resp.StatusCode, env.Msg) + if kind == ErrNone { + kind = ErrClient + } + return nil, &Error{Kind: kind, Status: resp.StatusCode, + Msg: fmt.Sprintf("code=%d msg=%s", env.Code, truncate(env.Msg, 160))} + } + return json.RawMessage(raw), nil +} diff --git a/internal/upstream/search_test.go b/internal/upstream/search_test.go new file mode 100644 index 0000000000000000000000000000000000000000..fbdcfcdfce6441351c64cde63947e89481d0340c --- /dev/null +++ b/internal/upstream/search_test.go @@ -0,0 +1,121 @@ +package upstream + +import ( + "context" + "encoding/json" + "io" + "net/http" + "strings" + "testing" + + "github.com/misakano7545/workbuddy2api-panel/internal/auth" +) + +// searchStub 记录落点/头/体,并按脚本回状态与原文。 +type searchStub struct { + path string + host string + body map[string]any + header http.Header + status int + resp string + hits int +} + +func (s *searchStub) client() *Client { + return &Client{ + HTTP: &http.Client{Transport: rtFunc(func(r *http.Request) (*http.Response, error) { + raw, _ := io.ReadAll(r.Body) + s.hits++ + s.path, s.host, s.header = r.URL.Path, r.URL.Host, r.Header.Clone() + s.body = map[string]any{} + _ = json.Unmarshal(raw, &s.body) + return &http.Response{ + StatusCode: s.status, + Header: http.Header{"Content-Type": []string{"application/json"}}, + Body: io.NopCloser(strings.NewReader(s.resp)), + }, nil + })}, + ChatBaseCN: "https://cn.example", + BillingBaseCN: "https://cn.example", + } +} + +const searchOK = `{"query":"电梯 维保","type":"text2text","provider":"0",` + + `"results":[{"title":"条例","url":"https://x.example/1","snippet":"..."}],` + + `"total_results":5,"response_time_ms":631}` + +func cnAuth() *auth.Auth { + return &auth.Auth{UID: "u1", AccessToken: "at", ExpiresAt: 9999999999, Domain: "www.codebuddy.cn"} +} + +// TestAgentToolSearchShape 检索落点、头族、请求体归一与原文透传。 +func TestAgentToolSearchShape(t *testing.T) { + s := &searchStub{status: 200, resp: searchOK} + data, err := s.client().Search(context.Background(), cnAuth(), "电梯 维保", 0) + if err != nil { + t.Fatal(err) + } + if s.path != "/agenttool/v1/search" || s.host != "cn.example" { + t.Fatalf("落点 %s%s want /agenttool/v1/search @ cn.example", s.host, s.path) + } + // 渠道校验三件套恒发(与 chat 同源头族):缺任一个上游按 11-128 拒。 + // 用 headerFold 而不是 Get:出站头 key 已被 normalizeHeaderSpelling 改成 + // 官方拼写(X-Conversation-ID),Get 会 canonicalize 成 X-Conversation-Id 查不到。 + for _, k := range []string{"X-Conversation-ID", "X-Conversation-Request-ID", "X-Conversation-Message-ID"} { + if headerFold(s.header, k) == "" { + t.Fatalf("缺会话头 %s(零值 ChatMeta 必须自造,不得留空)", k) + } + } + if s.body["type"] != "text2text" { + t.Fatalf("type=%v want text2text(唯一合法值)", s.body["type"]) + } + if s.body["max_results"] != float64(WebSearchDefaultMaxResults) { + t.Fatalf("max_results=%v want 默认 %d", s.body["max_results"], WebSearchDefaultMaxResults) + } + if s.body["query"] != "电梯 维保" { + t.Fatalf("query=%v", s.body["query"]) + } + // provider 是响应字段、不可入请求(带上即 400/15003):漏进来就是线上事故。 + if _, ok := s.body["provider"]; ok { + t.Fatal("请求体不得带 provider 字段") + } + var got SearchResponse + if err := json.Unmarshal(data, &got); err != nil { + t.Fatal(err) + } + if len(got.Results) != 1 || got.Results[0].URL != "https://x.example/1" || got.TotalResults != 5 { + t.Fatalf("原文透传不符: %s", data) + } +} + +// TestAgentToolErrors ≥400 与 200-带业务码都要变成 *Error(后者防「把错误当结果透传」)。 +func TestAgentToolErrors(t *testing.T) { + s := &searchStub{status: 400, resp: `{"code":15003,"msg":"unsupported search provider: 0"}`} + _, err := s.client().Search(context.Background(), cnAuth(), "x", 5) + var ue *Error + if err == nil || !asError(err, &ue) { + t.Fatalf("400 必须回 *Error,得到 %v", err) + } + if ue.Status != 400 || !strings.Contains(ue.Msg, "15003") { + t.Fatalf("错误信封不符: %+v", ue) + } + + s2 := &searchStub{status: 200, resp: `{"code":15013,"msg":"url is required"}`} + _, err = s2.client().WebFetch(context.Background(), cnAuth(), "") + if err == nil || !asError(err, &ue) { + t.Fatalf("200 + code=15013 必须回 *Error,得到 %v", err) + } + if s2.path != "/agenttool/v1/webfetch" || s2.body["url"] != "" { + t.Fatalf("webfetch 落点/体不符: %s %v", s2.path, s2.body) + } +} + +// asError 本地避免再引 errors 包名与现有测试冲突。 +func asError(err error, target **Error) bool { + e, ok := err.(*Error) + if ok { + *target = e + } + return ok +} diff --git a/internal/upstream/sse.go b/internal/upstream/sse.go index 53deab8e7f553cc15a1934e6f5df93b80e773187..b2de0e60e5fc17e96730e445c5e90e98a7ea1f23 100644 --- a/internal/upstream/sse.go +++ b/internal/upstream/sse.go @@ -1,670 +1,1135 @@ -// sse.go 处理上游 SSE 流:聚合成单个 OpenAI 响应,或透传给客户端。 -package upstream - -import ( - "bufio" - "encoding/json" - "errors" - "fmt" - "io" - "net/http" - "sort" - "strings" - "time" -) - -// errEmptyStream 上游返回 200 但没有有效 SSE 数据帧(空流/只有注释/[DONE])。 -// 用哨兵错误替代裸 fmt.Errorf:StreamHint 的调用方(handler 流式路径)需要区分 -// 「上游空流」与「客户端断连写失败」——空流是上游缺陷,应记 502 观测;写失败是 -// 客户端已走,日志口径不同。Aggregate 与 StreamHint 共用同一哨兵(errors.Is 判定)。 -var errEmptyStream = errors.New("upstream stream contained no valid data events") - -// IsEmptyStreamError 报告错误是否为「上游空流」(无有效 SSE 帧)——供 handler -// 在流式路径把空流记为失败观测(HTTP 头已发出只能 200,但日志/状态应收敛到 -// upstream_parse 同语义),与客户端断连类错误区分。 -func IsEmptyStreamError(err error) bool { return errors.Is(err, errEmptyStream) } - -// Aggregate 读取完整 SSE 流,聚合 delta.content 为单个 OpenAI chat.completion 响应。 -// 分片/半行由 bufio.Reader.ReadString 处理;遇到 "data: [DONE]" 结束。 -// tool_calls 以流式 delta 到达(按 index 合并:首片带 id/type/name,后续只带 arguments 片段)。 -func Aggregate(r io.Reader) (map[string]any, error) { - br := bufio.NewReaderSize(r, 64*1024) - var ( - id, model string - created float64 - content strings.Builder - reasoning strings.Builder - role = "assistant" - finishReason = "stop" - usage map[string]any - gotAnyContent bool - validEvents int - sawDone bool // 上游显式发过 data: [DONE](正常收尾) - toolCalls = map[int]map[string]any{} - toolOrder []int - // toolSeq 缺 index 的 tool_call 的分配序号源:跨帧延续「最近分配」槽位, - // 同帧内递增(见 mergeToolCallsChunk 注释)。 - toolSeq int - // idIndex id → 已分配的 index:跨帧持续(延续碎片的 id 常出现在后续帧), - // 供缺 index 时按 id 归位既有调用(见 mergeToolCallsChunk 注释)。 - idIndex = map[string]int{} - ) - // appendContent 是「已取到正文」(gotAnyContent latch)的唯一写入点:delta 与 - // message 两路 content 都必须经此并入,规约只有一份(issue #142)—— - // S1 空串不算「已取到正文」、不占 latch 名额:OpenAI 风格 role-only 首帧 - // (delta.content="")和整条空 message 帧是常态帧,若空串置位 latch, - // 后续真正文会被 message 回退分支的 !gotAnyContent 守卫静默拒绝; - // S2 空串本身也无可追加字节,跳过 WriteString 与追加语义自洽。 - appendContent := func(txt string) { - if txt == "" { - return - } - content.WriteString(txt) - gotAnyContent = true - } - // mergeToolCallsChunk 把一段 tool_calls 数组按 index 合并进累计表。 - // delta(流式分片,按 index 累积)与 message(非 delta 整条)共用同一合并逻辑, - // 保证「上游给的身份/函数名不丢、arguments 拼接语义一致」。 - // - // index 缺失兼容:OpenAI 规范要求 delta 帧的 tool_call 带 index(标记分片归属), - // 但部分上游省略它。此前缺 index 一律归 0——多调用场景下不同 call 被合并进同一 - // index 槽,arguments 串联、name 互相覆盖(数据污染)。修法按「id 优先、lastIdx 兜底」: - // - 带 index → 按 index 累积(合规形态,零改动); - // - 缺 index 带 id 且 id 已见过 → 延续该 id 所在 index; - // - 缺 index 带 id 且 id 是新的 → 开新序号(多调用不合并); - // - 缺 index 无 id → 追加到最近收到碎片的 index(单个调用的延续分片无 id - // 是标准形态),无既往则开新号。 - // 带 index 的碎片照常按 index 累积,不受影响。 - // nextToolIndex 分配下一个不冲突的缺 index 序号:从 toolSeq 起递增跳过既有 - // index(合规流的 index 是 0..N-1,缺 index 的补位不能覆盖它们)。 - nextToolIndex := func() int { - for { - idx := toolSeq - toolSeq++ - if _, used := toolCalls[idx]; !used { - return idx - } - } - } - mergeToolCallsChunk := func(tcs []any) { - for _, tc := range tcs { - call, ok := tc.(map[string]any) - if !ok { - continue - } - idx := -1 - if v, ok := call["index"].(float64); ok { - idx = int(v) - } else if cid, _ := call["id"].(string); cid != "" { - if mid, seen := idIndex[cid]; seen { - idx = mid // 该 id 已归位过:延续既有调用(跨帧有效) - } else { - idx = nextToolIndex() - } - } else if len(toolOrder) > 0 { - idx = toolOrder[len(toolOrder)-1] // 无 id 碎片:延续最近调用 - } else { - idx = nextToolIndex() - } - merged, seen := toolCalls[idx] - if !seen { - merged = map[string]any{"index": idx} - toolCalls[idx] = merged - toolOrder = append(toolOrder, idx) - } - if cid, _ := call["id"].(string); cid != "" { - idIndex[cid] = idx - } - if cid, _ := merged["id"].(string); cid != "" { - idIndex[cid] = idx - } - mergeToolCallDelta(merged, call) - } - } - // mergeMessageFields 把非 delta 的完整 message 内容并入聚合(message 是整条下发, - // 非流式拼接,content 只取一次)。role/reasoning_content/tool_calls 与 delta 分支 - // 同构透出;content 同样置 gotAnyContent,与 delta 路径的 latch 语义一致 - // (一帧整条 message 之后,后续 delta 帧不重复追加)。 - mergeMessageFields := func(msg map[string]any) { - if r2, ok := msg["role"].(string); ok && r2 != "" { - role = r2 - } - if txt, ok := msg["content"].(string); ok { - appendContent(txt) - } - if rc, ok := msg["reasoning_content"].(string); ok { - reasoning.WriteString(rc) - } - if tcs, ok := msg["tool_calls"].([]any); ok { - mergeToolCallsChunk(tcs) - } - } - for { - line, err := br.ReadString('\n') - if err != nil && err != io.EOF { - return nil, err - } - line = strings.TrimRight(line, "\r\n") - if strings.HasPrefix(line, "data: ") { - payload := strings.TrimPrefix(line, "data: ") - if payload == "[DONE]" { - // 上游显式结束:停止读取,DONE 之后的任何数据一律忽略。 - sawDone = true - break - } else { - var chunk map[string]any - if json.Unmarshal([]byte(payload), &chunk) == nil { - // 有效事件计数:仅 JSON 解析成功的数据帧计入(解析失败沿用静默 continue)。 - validEvents++ - if v, ok := chunk["id"].(string); ok && id == "" { - id = v - } - if v, ok := chunk["model"].(string); ok && model == "" { - model = v - } - if v, ok := chunk["created"].(float64); ok && created == 0 { - created = v - } - if u, ok := chunk["usage"].(map[string]any); ok { - usage = u - } - if ch, ok := chunk["choices"].([]any); ok { - for _, ci := range ch { - c, _ := ci.(map[string]any) - if c == nil { - continue - } - if fr, ok := c["finish_reason"].(string); ok && fr != "" { - finishReason = fr - } - if delta, ok := c["delta"].(map[string]any); ok { - if r2, ok := delta["role"].(string); ok && r2 != "" { - role = r2 - } - if txt, ok := delta["content"].(string); ok { - appendContent(txt) - } - if rc, ok := delta["reasoning_content"].(string); ok { - reasoning.WriteString(rc) - } - if tcs, ok := delta["tool_calls"].([]any); ok { - mergeToolCallsChunk(tcs) - } - } - // 有的上游把完整消息放在 message 里(非 delta): - // 整条并入(role/content/reasoning_content/tool_calls), - // 与 delta 分支同构。delta 已取过正文(gotAnyContent)则跳过 - // (避免与 delta 路径重复拼接——PR #134 的 latch 语义)。 - if msg, ok := c["message"].(map[string]any); ok && !gotAnyContent { - mergeMessageFields(msg) - } - } - } - } - } - } - if err == io.EOF { - break - } - } - if validEvents == 0 { - // 上游返回 200 但没有任何有效数据事件(空流/只有 [DONE]/只有注释行): - // 不再合成空 content 的假成功响应,直接报错,由 handler 映射为 502 upstream_parse。 - return nil, errEmptyStream - } - if id == "" { - id = fmt.Sprintf("chatcmpl-%d", time.Now().UnixNano()) - } - if created == 0 { - created = float64(time.Now().Unix()) - } - message := map[string]any{ - "role": role, - "content": content.String(), - } - if reasoning.Len() > 0 { - message["reasoning_content"] = reasoning.String() - } - if len(toolOrder) > 0 { - sort.Ints(toolOrder) - calls := make([]map[string]any, 0, len(toolOrder)) - for _, idx := range toolOrder { - calls = append(calls, toolCalls[idx]) - } - // P1b:流被截断时 tool_call 的 arguments 是残缺 JSON(解析失败),不把脏参数 - // 交给客户端——残留分片会被客户端解析成非法 JSON 卡死会话。截断的两个来源: - // - finish_reason=="length"(模型因 max_tokens 提前中止); - // - 上游连接中断(EOF 收尾但未发 data: [DONE],sawDone=false)。 - // 完整参数原样保留(正例零改动);空参数(无参工具)不是截断,同样保留。 - // 此前只认 finish_reason=="length",EOF 截断的 tool_calls 残缺参数被原样下发。 - if finishReason == "length" || !sawDone { - calls = dropTruncatedToolCalls(calls) - } - if len(calls) > 0 { - message["tool_calls"] = calls - } - } - resp := map[string]any{ - "id": id, - "object": "chat.completion", - "created": int64(created), - "model": model, - "choices": []any{ - map[string]any{ - "index": 0, - "message": message, - "finish_reason": finishReason, - }, - }, - } - if usage != nil { - // OpenAI 非流式 usage 必含 total_tokens。上游若只发 prompt_tokens + - // completion_tokens(部分上游末帧缺 total),网关合成补齐——否则严格按 - // schema 校验的客户端收不到 total_tokens。已有 total 或二者缺一不补 - // (不臆造:单边有值无法合成可信的 total)。 - resp["usage"] = normalizeUsageCacheAliases(ensureUsageTotal(usage)) - } - return resp, nil -} - -// ensureUsageTotal 在 usage 缺 total_tokens 但 prompt_tokens/completion_tokens 都在时 -// 补齐 total = prompt + completion(通过新 map 合并,不修改原上游 map)。 -// 任一缺失或已有 total 时原样返回。 -func ensureUsageTotal(u map[string]any) map[string]any { - if _, ok := u["total_tokens"]; ok { - return u - } - pt, pok := num64(u["prompt_tokens"]) - ct, cok := num64(u["completion_tokens"]) - if !pok || !cok { - return u - } - out := make(map[string]any, len(u)+1) - for k, v := range u { - out[k] = v - } - out["total_tokens"] = pt + ct - return out -} - -// num64 把 JSON number(float64/int64 均可)归一为 float64;非数字返回 ok=false。 -// -// 注意与 payload.go 的类型 switch 语义不同:那边是翻译请求别名字段(非数字拒绝 -// 整个请求),这边是聚合响应求和(非数字只跳过合成)。防后人合并两处。 -func num64(v any) (float64, bool) { - switch n := v.(type) { - case float64: - return n, true - case int64: - return float64(n), true - case int: - return float64(n), true - default: - return 0, false - } -} - -// mergeToolCallDelta 把流式 tool_call 片段合并到累计对象: -// id/type/function.name 直覆盖(后续分片通常缺省),function.arguments 拼接。 -func mergeToolCallDelta(merged, delta map[string]any) { - if v, ok := delta["id"].(string); ok && v != "" { - merged["id"] = v - } - if v, ok := delta["type"].(string); ok && v != "" { - merged["type"] = v - } - df, _ := delta["function"].(map[string]any) - if df == nil { - return - } - mf, _ := merged["function"].(map[string]any) - if mf == nil { - mf = map[string]any{} - merged["function"] = mf - } - if v, ok := df["name"].(string); ok && v != "" { - mf["name"] = v - } - if v, ok := df["arguments"].(string); ok && v != "" { - if prev, _ := mf["arguments"].(string); prev != "" { - mf["arguments"] = prev + v - } else { - mf["arguments"] = v - } - } -} - -// stripToolCallNames 收敛流式 tool_calls 的 name 语义为「每个 index 只出现一次」: -// 首片保留 function.name,同一 index 后续分片里的 name 键一律删除(无论上游是 -// 空串还是重复非空串)。这是 OpenAI 官方流的真实形态——首帧带 name,后续帧只带 -// arguments 片段、不再出现 name 键——因此是累加型与覆盖型客户端的共同祖先行为。 -// -// 两类消费模型在该形态下同时正确: -// - 累加型(官方 WorkBuddy/CodeBuddy `name += tc_function?.name || ""`): -// 后续分片 name 键缺失 → 追加空串,累积 name 保持唯一,不再拼成 Bash×帧数(issue #82)。 -// - 覆盖型(hawklithm#2 / Grok Build `name ?? state.name` 或 `if (name) state.name = name`): -// 后续分片 name 键缺失 → 保留已建好的首帧 name,不被空串意外清空。 -// 键缺失是比空串更安全的形态:`??` 与 truthy 守卫对缺失键必然保留旧值, -// 而对空串,`??` 会误判为重设并清空工具名。 -// -// seen 记录每个 index 是否已发过首片(与 name 是否非空无关);删除是幂等的。 -// 只动 function.name 键,id/type/arguments 原样透传。 -func stripToolCallNames(obj map[string]any, seen map[int]bool) { - choices, _ := obj["choices"].([]any) - for _, ci := range choices { - c, _ := ci.(map[string]any) - if c == nil { - continue - } - delta, _ := c["delta"].(map[string]any) - if delta == nil { - continue - } - tcs, _ := delta["tool_calls"].([]any) - for _, tci := range tcs { - tc, _ := tci.(map[string]any) - if tc == nil { - continue - } - idx := 0 - if v, ok := tc["index"].(float64); ok { - idx = int(v) - } - if seen[idx] { - // 已发过首片:删除本分片的 name 键(存在即删,幂等)。 - if fn, _ := tc["function"].(map[string]any); fn != nil { - delete(fn, "name") - } - continue - } - // 首现:保留 name 键原样(上游首片通常带非空 name;空 name 也照发, - // 与 OpenAI 对「首帧无 name」的容忍一致),随后分片统一删除。 - seen[idx] = true - } - } -} - -// normalizeFrame 以 OpenAI 流式规范白名单重建帧:仅保留标准字段, -// 剔除上游噪声(finish_reason:"" → null、空 content/refusal、空 tool_calls 列表、 -// 空占位 function_call、顶层未知字段),空 delta 键一律省略, -// usage 缺失 → null,保证任意标准客户端按规范解析。 -func normalizeFrame(obj map[string]any) map[string]any { - out := map[string]any{} - for _, k := range []string{"id", "object", "created", "model", "system_fingerprint", "service_tier"} { - if v, ok := obj[k]; ok && v != nil { - out[k] = v - } - } - if _, ok := out["object"]; !ok { - out["object"] = "chat.completion.chunk" - } - if _, ok := out["id"]; !ok { - out["id"] = "chatcmpl-wb2api" - } - if chs, ok := obj["choices"].([]any); ok { - nchs := make([]any, 0, len(chs)) - for _, ci := range chs { - c, ok := ci.(map[string]any) - if !ok { - continue - } - nc := map[string]any{} - if idx, ok := c["index"]; ok { - nc["index"] = idx - } - delta := map[string]any{} - if d, ok := c["delta"].(map[string]any); ok { - if v, ok := d["role"].(string); ok && v != "" { - delta["role"] = v - } - if v, ok := d["content"].(string); ok && v != "" { - delta["content"] = v - } - if v, ok := d["reasoning_content"].(string); ok && v != "" { - delta["reasoning_content"] = v - } - if v, ok := d["refusal"].(string); ok && v != "" { - delta["refusal"] = v - } - if tcs, ok := d["tool_calls"].([]any); ok && len(tcs) > 0 { - delta["tool_calls"] = tcs - } - if fc, ok := d["function_call"]; ok && fc != nil { - // 空占位 function_call(name/arguments 全空)视为噪声剔除 - keep := false - if fcm, ok2 := fc.(map[string]any); ok2 { - n, _ := fcm["name"].(string) - a, _ := fcm["arguments"].(string) - keep = n != "" || a != "" - } else { - keep = true - } - if keep { - delta["function_call"] = fc - } - } - } - nc["delta"] = delta - if fr, ok := c["finish_reason"].(string); ok && fr != "" { - nc["finish_reason"] = fr - } else { - nc["finish_reason"] = nil - } - nchs = append(nchs, nc) - } - out["choices"] = nchs - } - if rawUsage, ok := obj["usage"]; ok { - if u, ok := rawUsage.(map[string]any); ok { - out["usage"] = normalizeUsageCacheAliases(u) - } else { - out["usage"] = rawUsage - } - } else { - out["usage"] = nil - } - return out -} - -// Stream 透传上游 SSE 到 w(逐帧规范化后 flush),保证至少写一个 [DONE]。 -// 调用方必须先设置过 status 200;本函数自设 SSE headers。 -// 流式策略:逐帧透传(规范化已剥空 content 噪声),恢复与上游一致的平滑流式。 -// -// StreamHint 变体(gateway_hint 任务):上游 error 帧透传时附加 -// error.gateway_hint 字段——message 原文不动,hint 并列补充;hintFn 返回空串 -// 或 nil 时与 Stream 行为逐字节一致。 -func Stream(w http.ResponseWriter, r io.Reader) error { - return StreamHint(w, r, nil) -} - -// StreamOption StreamHint 的可选行为开关(均不影响透传字节,只做旁路观测)。 -type StreamOption func(*streamOptions) - -type streamOptions struct { - onErrorFrame func(payload string) -} - -// WithErrorFrameObserver 注册"上游以 error 帧报错"的观察者:透传该帧之前先用 -// payload(原始 data 内容)回调一次。给调用方一个**账号处置**的挂载点—— -// 上游「200 + error 帧」是真实形态(6004 限流、内容拦截、审核),此前网关在读 -// 第一帧之前就把账号记成功,限流号被当成健康号;有观察者后可在流尾按帧分类处置。 -func WithErrorFrameObserver(fn func(payload string)) StreamOption { - return func(o *streamOptions) { o.onErrorFrame = fn } -} - -// StreamHint 同 Stream,但上游 error 帧透出前把 hintFn(payload) 的返回值写入 -// error.gateway_hint。hintFn 为 nil 或返回空串 → 原样透传(零改写)。 -// 空流兜底 error 帧("empty upstream stream")不带 hint(网关本地故障形态 -// 未覆盖,不编造)。 -// opts:旁路观测开关(见 WithErrorFrameObserver),不改变任何透传字节。 -func StreamHint(w http.ResponseWriter, r io.Reader, hintFn func(string) string, opts ...StreamOption) error { - var o streamOptions - for _, f := range opts { - if f != nil { - f(&o) - } - } - h := w.Header() - h.Set("Content-Type", "text/event-stream") - h.Set("Cache-Control", "no-cache") - h.Set("Connection", "keep-alive") - h.Set("X-Accel-Buffering", "no") - fl, _ := w.(http.Flusher) - - // toolCallSeen 跨帧记录 delta.tool_calls 里已发过首片的 index, - // 供逐 chunk 透传时收敛 name 为「每 index 一次」(对齐 OpenAI 官方流)。 - toolCallSeen := map[int]bool{} - - // firstID 透传流的消息级 id 基准:缓存首个非空上游 id,后续帧缺失/空串时复用 - // (issue #35:同一条 SSE 消息所有帧共用一个真实 id,后台按 id 归并;此前中间帧 - // 一律补 chatcmpl-wb2api 哨兵,造成同流 id 分裂)。全流无真实 id → 才出现哨兵。 - firstID := "" - - // writeRaw 原样写出一帧(绕过 normalizeFrame)并 flush。上游 error 帧(error-passthrough) - // 与空流错误帧需保留 error 字段,不能被白名单剥掉,故经此写出。 - // gateway_hint:上游 error 帧透出前按 hintFn 附加 error.gateway_hint 字段 - // (error 对象上加一个键,message/code/requestId 等原文不动;hintFn 为 - // nil / 空串 / 非 JSON 帧 → 原样写出,零改写)。 - writeRaw := func(payload string) error { - if hint := frameGatewayHint(hintFn, payload); hint != "" { - payload = attachHintToErrorFrame(payload, hint) - } - if _, werr := io.WriteString(w, "data: "+payload+"\n\n"); werr != nil { - return werr - } - if fl != nil { - fl.Flush() - } - return nil - } - - // writeFrame 把 payload 按规范白名单重建后以 data: 帧写出并 flush。 - // 仅 JSON 解析成功时计数记为一次有效转发(JSON 解析失败照常降级原样写出,但不计数)。 - writeFrame := func(payload string) (int, error) { - var obj map[string]any - valid := 0 - if json.Unmarshal([]byte(payload), &obj) == nil { - // 上游错误帧透传(error-passthrough):带 error 键的帧**原样写出**,不走 - // normalizeFrame 白名单——白名单会剥掉 error 字段,客户端就看不到上游 - // code/msg/requestId。error.message 即上游原文(如 6004 限流、审核拦截), - // 计入有效帧(避免误判空流补写 "empty upstream stream")。 - if _, hasErr := obj["error"]; hasErr { - // 旁路通知(账号处置用):原始 payload 交给观察者,透传字节不变。 - if o.onErrorFrame != nil { - o.onErrorFrame(payload) - } - if werr := writeRaw(payload); werr != nil { - return 0, werr - } - return 1, nil - } - // 先按 index 收敛 tool_calls name(每 index 仅首片保留,后续分片删 name 键),再规范化透传。 - stripToolCallNames(obj, toolCallSeen) - // id 续传:首帧非空真实 id 缓存;后续帧缺 id / 空 id 一律用缓存值, - // 有自己 id 的帧保持原样(不同流分裂的帧允许各自 id)。 - if firstID == "" { - if v, ok := obj["id"].(string); ok && v != "" { - firstID = v - } - } else { - if v, ok := obj["id"].(string); !ok || v == "" { - obj["id"] = firstID - } - } - if raw, err := json.Marshal(normalizeFrame(obj)); err == nil { - payload = string(raw) - } - valid = 1 - } - if _, werr := io.WriteString(w, "data: "+payload+"\n\n"); werr != nil { - return 0, werr - } - if fl != nil { - fl.Flush() - } - return valid, nil - } - - br := bufio.NewReaderSize(r, 64*1024) - validFrames := 0 -readLoop: - for { - line, err := br.ReadString('\n') - trimmed := strings.TrimRight(line, "\r\n") - switch { - case strings.HasPrefix(trimmed, "data: [DONE]"): - // 上游显式结束:停止读取,DONE 之后的任何数据(含垃圾帧)一律不再透传。 - // [DONE] 统一在循环结束后写出,保证恰好一个。 - break readLoop - case strings.HasPrefix(trimmed, "data: "): - n, werr := writeFrame(strings.TrimPrefix(trimmed, "data: ")) - validFrames += n - if werr != nil { - return werr - } - case trimmed != "": - // 注释/其他行:原样透传 - if _, werr := io.WriteString(w, line); werr != nil { - return werr - } - if fl != nil { - fl.Flush() - } - } - // 空行(帧分隔)吞掉:本函数自产 "\n\n" - if err != nil { - if err == io.EOF { - break - } - return err - } - } - // 空流(0 有效帧):先写一帧 error(绕过 normalizeFrame 原样保留 error 字段), - // 再补 [DONE] 保证客户端能正常收尾,并返回非 nil error 供调用方记录。 - // 网关本地空流兜底帧走 hintFn=nil 的直写路径:该形态未覆盖(不编造 hint), - // 且 writeRaw 的 hintFn 闭包在空流路径下可能携带上一帧的上下文造成误配。 - if validFrames == 0 { - _ = writeRaw(`{"error":{"message":"empty upstream stream","type":"upstream_error","code":"upstream_parse"}}`) - } - // 保证恰好写一个 [DONE](上游漏发时兜底补上)。 - if _, err := io.WriteString(w, "data: [DONE]\n\n"); err != nil { - return err - } - if fl != nil { - fl.Flush() - } - if validFrames == 0 { - return errEmptyStream - } - return nil -} - -// frameGatewayHint 取 error 帧的 gateway_hint(hintFn 缺失/异常返回空串 → 不附加)。 -func frameGatewayHint(hintFn func(string) string, payload string) string { - if hintFn == nil { - return "" - } - // panic 隔离:hint 判定是补充功能,任何实现缺陷不得击穿流透传主路径。 - defer func() { _ = recover() }() - return strings.TrimSpace(hintFn(payload)) -} - -// attachHintToErrorFrame 在 error 帧的 error 对象上附加 gateway_hint 字段。 -// message/code/requestId 等既有键原样保留(只加不改);非 JSON / 无 error 对象 → -// payload 原样返回(宁可不加 hint 也不破坏原文透传)。 -func attachHintToErrorFrame(payload, hint string) string { - var obj map[string]any - if json.Unmarshal([]byte(payload), &obj) != nil { - return payload - } - e, ok := obj["error"].(map[string]any) - if !ok { - return payload - } - e["gateway_hint"] = hint - out, err := json.Marshal(obj) - if err != nil { - return payload - } - return string(out) -} +// sse.go 处理上游 SSE 流:聚合成单个 OpenAI 响应,或透传给客户端。 +package upstream + +import ( + "bufio" + "bytes" + "encoding/json" + "errors" + "fmt" + "io" + "log" + "net/http" + "sort" + "strings" + "time" +) + +// errEmptyStream 上游返回 200 但没有有效 SSE 数据帧(空流/只有注释/[DONE])。 +// 用哨兵错误替代裸 fmt.Errorf:StreamHint 的调用方(handler 流式路径)需要区分 +// 「上游空流」与「客户端断连写失败」——空流是上游缺陷,应记 502 观测;写失败是 +// 客户端已走,日志口径不同。Aggregate 与 StreamHint 共用同一哨兵(errors.Is 判定)。 +var errEmptyStream = errors.New("upstream stream contained no valid data events") + +// IsEmptyStreamError 报告错误是否为「上游空流」(无有效 SSE 帧)——供 handler +// 在流式路径把空流记为失败观测。**首选是 HeadVetoError**(零字节否决,见下); +// 本哨兵只剩「注释/心跳行已写出、响应头已提交之后才是空流」这一种形态可达。 +func IsEmptyStreamError(err error) bool { return errors.Is(err, errEmptyStream) } + +// HeadVetoError 首帧否决:网关向客户端写出第一个字节**之前**,上游第一帧就是 +// error 帧(6004 限流 / 审核 / 会话失效),或干脆一个有效帧都没有。 +// +// 为什么单独成一类:这一帧不是「已开流的失败」,整次尝试对客户端无痕——调用方 +// 可以照常换号重试,客户端最终拿到别的号的成功响应,而不是「HTTP 200 + error +// 帧」(SSE 一旦发过字节就无法改状态码,此前只能这么兜底)。 +// +// Payload 是 error 帧原文(空串 = 零有效帧),供调用方按分类处置账号,并在轮转 +// 全败时把原文透传给客户端。 +type HeadVetoError struct{ Payload string } + +func (e *HeadVetoError) Error() string { + if e.Payload == "" { + return "upstream produced no frame before head commit" + } + return "upstream error frame before head commit: " + e.Payload +} + +// TruncationFinishReason 上游没有给出正常收尾时(既无 finish_reason 也无 +// data: [DONE] 就 EOF = 断流)如实上报的截断终态取值。 +// +// 为什么是 "length":OpenAI 协议的 finish_reason 词表里没有「上游断流」这一项, +// 而客户端真正需要知道的事实是「这条输出是残缺的,别当完整结果用」——"length" +// 是唯一既合法又让三条适配器如实标截断的取值: +// - chat:finish_reason="length"(客户端据此提示被截断); +// - responses:response.incomplete + incomplete_details.reason=max_output_tokens; +// - messages:stop_reason="max_tokens"。 +// +// 不给这个取值时,三条路径各自 default 成「正常完成」(空 finish_reason / +// response.completed / end_turn),客户端把半截内容当完整答案落库——那是静默丢内容。 +// 同一判据(!sawDone)本文件下方处理残缺 tool_calls 时早已在用:代码知道这是截断, +// 只是此前没让它出现在客户端可见的协议字段里。 +const TruncationFinishReason = "length" + +// Aggregate 读取完整 SSE 流,聚合 delta.content 为单个 OpenAI chat.completion 响应。 +// 分片/半行由 bufio.Reader.ReadString 处理;遇到 "data: [DONE]" 结束。 +// tool_calls 以流式 delta 到达(按 index 合并:首片带 id/type/name,后续只带 arguments 片段)。 +func Aggregate(r io.Reader) (map[string]any, error) { + br := bufio.NewReaderSize(r, 64*1024) + var ( + id, model string + created float64 + content strings.Builder + reasoning strings.Builder + role = "assistant" + finishReason = "stop" + usage map[string]any + gotAnyContent bool + validEvents int + sawDone bool // 上游显式发过 data: [DONE](正常收尾) + sawFinish bool // 上游显式给过非空 finish_reason(与默认值 "stop" 区分开) + toolCalls = map[int]map[string]any{} + toolOrder []int + // toolSeq 缺 index 的 tool_call 的分配序号源:跨帧延续「最近分配」槽位, + // 同帧内递增(见 mergeToolCallsChunk 注释)。 + toolSeq int + // idIndex id → 已分配的 index:跨帧持续(延续碎片的 id 常出现在后续帧), + // 供缺 index 时按 id 归位既有调用(见 mergeToolCallsChunk 注释)。 + idIndex = map[string]int{} + ) + // appendContent 是「已取到正文」(gotAnyContent latch)的唯一写入点:delta 与 + // message 两路 content 都必须经此并入,规约只有一份(issue #142)—— + // S1 空串不算「已取到正文」、不占 latch 名额:OpenAI 风格 role-only 首帧 + // (delta.content="")和整条空 message 帧是常态帧,若空串置位 latch, + // 后续真正文会被 message 回退分支的 !gotAnyContent 守卫静默拒绝; + // S2 空串本身也无可追加字节,跳过 WriteString 与追加语义自洽。 + appendContent := func(txt string) { + if txt == "" { + return + } + content.WriteString(txt) + gotAnyContent = true + } + // mergeToolCallsChunk 把一段 tool_calls 数组按 index 合并进累计表。 + // delta(流式分片,按 index 累积)与 message(非 delta 整条)共用同一合并逻辑, + // 保证「上游给的身份/函数名不丢、arguments 拼接语义一致」。 + // + // index 缺失兼容:OpenAI 规范要求 delta 帧的 tool_call 带 index(标记分片归属), + // 但部分上游省略它。此前缺 index 一律归 0——多调用场景下不同 call 被合并进同一 + // index 槽,arguments 串联、name 互相覆盖(数据污染)。修法按「id 优先、lastIdx 兜底」: + // - 带 index → 按 index 累积(合规形态,零改动); + // - 缺 index 带 id 且 id 已见过 → 延续该 id 所在 index; + // - 缺 index 带 id 且 id 是新的 → 开新序号(多调用不合并); + // - 缺 index 无 id → 追加到最近收到碎片的 index(单个调用的延续分片无 id + // 是标准形态),无既往则开新号。 + // 带 index 的碎片照常按 index 累积,不受影响。 + // nextToolIndex 分配下一个不冲突的缺 index 序号:从 toolSeq 起递增跳过既有 + // index(合规流的 index 是 0..N-1,缺 index 的补位不能覆盖它们)。 + nextToolIndex := func() int { + for { + idx := toolSeq + toolSeq++ + if _, used := toolCalls[idx]; !used { + return idx + } + } + } + mergeToolCallsChunk := func(tcs []any) { + for _, tc := range tcs { + call, ok := tc.(map[string]any) + if !ok { + continue + } + idx := -1 + if v, ok := call["index"].(float64); ok { + idx = int(v) + } else if cid, _ := call["id"].(string); cid != "" { + if mid, seen := idIndex[cid]; seen { + idx = mid // 该 id 已归位过:延续既有调用(跨帧有效) + } else { + idx = nextToolIndex() + } + } else if len(toolOrder) > 0 { + idx = toolOrder[len(toolOrder)-1] // 无 id 碎片:延续最近调用 + } else { + idx = nextToolIndex() + } + merged, seen := toolCalls[idx] + if !seen { + merged = map[string]any{"index": idx} + toolCalls[idx] = merged + toolOrder = append(toolOrder, idx) + } + if cid, _ := call["id"].(string); cid != "" { + idIndex[cid] = idx + } + if cid, _ := merged["id"].(string); cid != "" { + idIndex[cid] = idx + } + mergeToolCallDelta(merged, call) + } + } + // mergeMessageFields 把非 delta 的完整 message 内容并入聚合(message 是整条下发, + // 非流式拼接,content 只取一次)。role/reasoning_content/tool_calls 与 delta 分支 + // 同构透出;content 同样置 gotAnyContent,与 delta 路径的 latch 语义一致 + // (一帧整条 message 之后,后续 delta 帧不重复追加)。 + mergeMessageFields := func(msg map[string]any) { + if r2, ok := msg["role"].(string); ok && r2 != "" { + role = r2 + } + if txt, ok := msg["content"].(string); ok { + appendContent(txt) + } + if rc, ok := msg["reasoning_content"].(string); ok { + reasoning.WriteString(rc) + } + if tcs, ok := msg["tool_calls"].([]any); ok { + mergeToolCallsChunk(tcs) + } + } + for { + line, err := br.ReadString('\n') + if err != nil && err != io.EOF { + return nil, err + } + line = strings.TrimRight(line, "\r\n") + if strings.HasPrefix(line, "data: ") { + payload := strings.TrimPrefix(line, "data: ") + if payload == "[DONE]" { + // 上游显式结束:停止读取,DONE 之后的任何数据一律忽略。 + sawDone = true + break + } else { + var chunk map[string]any + if json.Unmarshal([]byte(payload), &chunk) == nil { + // 有效事件计数:仅 JSON 解析成功的数据帧计入(解析失败沿用静默 continue)。 + validEvents++ + if v, ok := chunk["id"].(string); ok && id == "" { + id = v + } + if v, ok := chunk["model"].(string); ok && model == "" { + model = v + } + if v, ok := chunk["created"].(float64); ok && created == 0 { + created = v + } + if u, ok := chunk["usage"].(map[string]any); ok { + usage = u + } + if ch, ok := chunk["choices"].([]any); ok { + for _, ci := range ch { + c, _ := ci.(map[string]any) + if c == nil { + continue + } + if fr, ok := c["finish_reason"].(string); ok && fr != "" { + finishReason = fr + sawFinish = true + } + if delta, ok := c["delta"].(map[string]any); ok { + if r2, ok := delta["role"].(string); ok && r2 != "" { + role = r2 + } + if txt, ok := delta["content"].(string); ok { + appendContent(txt) + } + if rc, ok := delta["reasoning_content"].(string); ok { + reasoning.WriteString(rc) + } + if tcs, ok := delta["tool_calls"].([]any); ok { + mergeToolCallsChunk(tcs) + } + } + // 有的上游把完整消息放在 message 里(非 delta): + // 整条并入(role/content/reasoning_content/tool_calls), + // 与 delta 分支同构。delta 已取过正文(gotAnyContent)则跳过 + // (避免与 delta 路径重复拼接——PR #134 的 latch 语义)。 + if msg, ok := c["message"].(map[string]any); ok && !gotAnyContent { + mergeMessageFields(msg) + } + } + } + } + } + } + if err == io.EOF { + break + } + } + if validEvents == 0 { + // 上游返回 200 但没有任何有效数据事件(空流/只有 [DONE]/只有注释行): + // 不再合成空 content 的假成功响应,直接报错,由 handler 映射为 502 upstream_parse。 + return nil, errEmptyStream + } + // 断流如实上报:既没给 finish_reason 也没给 data: [DONE] 就 EOF(上游连接中断), + // 此时 finishReason 还是初始默认值 "stop"——直接下发等于告诉客户端「模型正常 + // 说完了」,而半截正文/残缺 tool_calls 会被当完整结果。同一判据(!sawDone)下方 + // 处理 tool_calls 时早已在用,这里只是让它同时出现在客户端可见的 finish_reason 上。 + // 已收到任一正常收尾信号(sawFinish 或 sawDone)则一律不动。 + if !sawDone && !sawFinish { + finishReason = TruncationFinishReason + } + if id == "" { + id = fmt.Sprintf("chatcmpl-%d", time.Now().UnixNano()) + } + if created == 0 { + created = float64(time.Now().Unix()) + } + message := map[string]any{ + "role": role, + "content": content.String(), + } + if reasoning.Len() > 0 { + message["reasoning_content"] = reasoning.String() + } + if len(toolOrder) > 0 { + sort.Ints(toolOrder) + calls := make([]map[string]any, 0, len(toolOrder)) + for _, idx := range toolOrder { + calls = append(calls, toolCalls[idx]) + } + // P1b:流被截断时 tool_call 的 arguments 是残缺 JSON(解析失败),不把脏参数 + // 交给客户端——残留分片会被客户端解析成非法 JSON 卡死会话。截断的两个来源: + // - finish_reason=="length"(模型因 max_tokens 提前中止); + // - 上游连接中断(EOF 收尾但未发 data: [DONE],sawDone=false)。 + // 完整参数原样保留(正例零改动);空参数(无参工具)不是截断,同样保留。 + // 此前只认 finish_reason=="length",EOF 截断的 tool_calls 残缺参数被原样下发。 + if finishReason == "length" || !sawDone { + calls = dropTruncatedToolCalls(calls) + } + if len(calls) > 0 { + message["tool_calls"] = calls + } + } + resp := map[string]any{ + "id": id, + "object": "chat.completion", + "created": int64(created), + "model": model, + "choices": []any{ + map[string]any{ + "index": 0, + "message": message, + "finish_reason": finishReason, + }, + }, + } + if usage != nil { + // OpenAI 非流式 usage 必含 total_tokens。上游若只发 prompt_tokens + + // completion_tokens(部分上游末帧缺 total),网关合成补齐——否则严格按 + // schema 校验的客户端收不到 total_tokens。已有 total 或二者缺一不补 + // (不臆造:单边有值无法合成可信的 total)。 + resp["usage"] = normalizeUsageCacheAliases(ensureUsageTotal(usage)) + } + return resp, nil +} + +// ensureUsageTotal 在 usage 缺 total_tokens 但 prompt_tokens/completion_tokens 都在时 +// 补齐 total = prompt + completion(通过新 map 合并,不修改原上游 map)。 +// 任一缺失或已有 total 时原样返回。 +func ensureUsageTotal(u map[string]any) map[string]any { + if _, ok := u["total_tokens"]; ok { + return u + } + pt, pok := num64(u["prompt_tokens"]) + ct, cok := num64(u["completion_tokens"]) + if !pok || !cok { + return u + } + out := make(map[string]any, len(u)+1) + for k, v := range u { + out[k] = v + } + out["total_tokens"] = pt + ct + return out +} + +// num64 把 JSON number(float64/int64 均可)归一为 float64;非数字返回 ok=false。 +// +// 注意与 payload.go 的类型 switch 语义不同:那边是翻译请求别名字段(非数字拒绝 +// 整个请求),这边是聚合响应求和(非数字只跳过合成)。防后人合并两处。 +func num64(v any) (float64, bool) { + switch n := v.(type) { + case float64: + return n, true + case int64: + return float64(n), true + case int: + return float64(n), true + default: + return 0, false + } +} + +// mergeToolCallDelta 把流式 tool_call 片段合并到累计对象: +// id/type/function.name 直覆盖(后续分片通常缺省),function.arguments 拼接。 +func mergeToolCallDelta(merged, delta map[string]any) { + if v, ok := delta["id"].(string); ok && v != "" { + merged["id"] = v + } + if v, ok := delta["type"].(string); ok && v != "" { + merged["type"] = v + } + df, _ := delta["function"].(map[string]any) + if df == nil { + return + } + mf, _ := merged["function"].(map[string]any) + if mf == nil { + mf = map[string]any{} + merged["function"] = mf + } + if v, ok := df["name"].(string); ok && v != "" { + mf["name"] = v + } + if v, ok := df["arguments"].(string); ok && v != "" { + if prev, _ := mf["arguments"].(string); prev != "" { + mf["arguments"] = prev + v + } else { + mf["arguments"] = v + } + } +} + +// stripToolCallNames 收敛流式 tool_calls 的 name 语义为「每个 index 只出现一次」: +// 首片保留 function.name,同一 index 后续分片里的 name 键一律删除(无论上游是 +// 空串还是重复非空串)。这是 OpenAI 官方流的真实形态——首帧带 name,后续帧只带 +// arguments 片段、不再出现 name 键——因此是累加型与覆盖型客户端的共同祖先行为。 +// +// 两类消费模型在该形态下同时正确: +// - 累加型(官方 WorkBuddy/CodeBuddy `name += tc_function?.name || ""`): +// 后续分片 name 键缺失 → 追加空串,累积 name 保持唯一,不再拼成 Bash×帧数(issue #82)。 +// - 覆盖型(hawklithm#2 / Grok Build `name ?? state.name` 或 `if (name) state.name = name`): +// 后续分片 name 键缺失 → 保留已建好的首帧 name,不被空串意外清空。 +// 键缺失是比空串更安全的形态:`??` 与 truthy 守卫对缺失键必然保留旧值, +// 而对空串,`??` 会误判为重设并清空工具名。 +// +// seen 记录每个 index 是否已发过首片(与 name 是否非空无关);删除是幂等的。 +// 键为 index 的文本形式;无 index 字段的上游改用调用 id(见下),无 id 则作为 +// 单一匿名调用处理。 +// 只动 function.name 键,id/type/arguments 原样透传。 +func stripToolCallNames(obj map[string]any, seen map[string]bool) { + choices, _ := obj["choices"].([]any) + for _, ci := range choices { + c, _ := ci.(map[string]any) + if c == nil { + continue + } + delta, _ := c["delta"].(map[string]any) + if delta == nil { + continue + } + tcs, _ := delta["tool_calls"].([]any) + for _, tci := range tcs { + tc, _ := tci.(map[string]any) + if tc == nil { + continue + } + // 键:上游给了 index 就用它;没给 index 的中转(与 mergeToolCallsChunk 同族) + // 改用调用 id——否则同帧里多个无 index 的调用会全挤进同一个键,第二个调用的 + // name 被当"重复分片"删掉,客户端拿到没名字的调用、派发不了。 + key := "i:0" + if v, ok := tc["index"].(float64); ok { + key = fmt.Sprintf("i:%d", int(v)) + } else if id, ok := tc["id"].(string); ok && id != "" { + key = "id:" + id + } + if seen[key] { + // 已发过首片:删除本分片的 name 键(存在即删,幂等)。 + if fn, _ := tc["function"].(map[string]any); fn != nil { + delete(fn, "name") + } + continue + } + // 首现:保留 name 键原样(上游首片通常带非空 name;空 name 也照发, + // 与 OpenAI 对「首帧无 name」的容忍一致),随后分片统一删除。 + seen[key] = true + } + } +} + +// StreamErrorFrame 识别「HTTP 200 流里内嵌的失败帧」,返回 (code, message, ok)。 +// +// 上游把安全策略拦截(11140 request illegal)这类失败塞在 SSE 里,报文是**顶层** +// {code,msg,displayMsg}——既没有 choices 也没有 error。normalizeFrame 的白名单会把 +// code/msg 一并剥掉,客户端于是只看到「干净地停止、无任何失败」,我们自己的日志也只 +// 剩一条「段无 finish 结束」,把策略拦截误记成上游断流。 +// +// 判据必须**窄**:只认「没有 choices 的帧」——正文里出现「安全审核」「request illegal」 +// 甚至字面 11140 都是常态(模型讨论这类话题时就会说这几个词),按文本判必误伤。 +func StreamErrorFrame(obj map[string]any) (int, string, bool) { + if _, has := obj["choices"]; has { + return 0, "", false + } + if _, has := obj["error"]; has { // 已是标准 error 帧:走既有 error-passthrough + return 0, "", false + } + code, _ := obj["code"].(float64) + if code <= 0 { + return 0, "", false + } + msg, _ := obj["msg"].(string) + if msg == "" { + msg, _ = obj["displayMsg"].(string) + } + return int(code), msg, true +} + +// streamErrorPayload 把内嵌失败帧改写成标准 error 帧:客户端据此看到真实失败, +// 而不是一个空 chunk。code/message 原样带上,requestId 有则带上(排障靠它对上游工单), +// 其余字段不编造。 +func streamErrorPayload(code int, msg, payload string) string { + e := map[string]any{"message": msg, "code": code} + var obj map[string]any + if json.Unmarshal([]byte(payload), &obj) == nil { + if rid, ok := obj["requestId"].(string); ok && rid != "" { + e["requestId"] = rid + } + } + raw, err := json.Marshal(map[string]any{"error": e}) + if err != nil { + return payload + } + return string(raw) +} + +// normalizeFrame 以 OpenAI 流式规范白名单重建帧:仅保留标准字段, +// 剔除上游噪声(finish_reason:"" → null、空 content/refusal、空 tool_calls 列表、 +// 空占位 function_call、顶层未知字段),空 delta 键一律省略, +// usage 缺失 → null,保证任意标准客户端按规范解析。 +func normalizeFrame(obj map[string]any) map[string]any { + out := map[string]any{} + for _, k := range []string{"id", "object", "created", "model", "system_fingerprint", "service_tier"} { + if v, ok := obj[k]; ok && v != nil { + out[k] = v + } + } + if _, ok := out["object"]; !ok { + out["object"] = "chat.completion.chunk" + } + if _, ok := out["id"]; !ok { + out["id"] = "chatcmpl-wb2api" + } + if chs, ok := obj["choices"].([]any); ok { + nchs := make([]any, 0, len(chs)) + for _, ci := range chs { + c, ok := ci.(map[string]any) + if !ok { + continue + } + nc := map[string]any{} + if idx, ok := c["index"]; ok { + nc["index"] = idx + } + delta := map[string]any{} + if d, ok := c["delta"].(map[string]any); ok { + if v, ok := d["role"].(string); ok && v != "" { + delta["role"] = v + } + if v, ok := d["content"].(string); ok && v != "" { + delta["content"] = v + } + if v, ok := d["reasoning_content"].(string); ok && v != "" { + delta["reasoning_content"] = v + } + if v, ok := d["refusal"].(string); ok && v != "" { + delta["refusal"] = v + } + if tcs, ok := d["tool_calls"].([]any); ok && len(tcs) > 0 { + delta["tool_calls"] = tcs + } + if fc, ok := d["function_call"]; ok && fc != nil { + // 空占位 function_call(name/arguments 全空)视为噪声剔除 + keep := false + if fcm, ok2 := fc.(map[string]any); ok2 { + n, _ := fcm["name"].(string) + a, _ := fcm["arguments"].(string) + keep = n != "" || a != "" + } else { + keep = true + } + if keep { + delta["function_call"] = fc + } + } + } + nc["delta"] = delta + if fr, ok := c["finish_reason"].(string); ok && fr != "" { + nc["finish_reason"] = fr + } else { + nc["finish_reason"] = nil + } + nchs = append(nchs, nc) + } + out["choices"] = nchs + } + if rawUsage, ok := obj["usage"]; ok { + if u, ok := rawUsage.(map[string]any); ok { + out["usage"] = normalizeUsageCacheAliases(u) + } else { + out["usage"] = rawUsage + } + } else { + out["usage"] = nil + } + return out +} + +// Stream 透传上游 SSE 到 w(逐帧规范化后 flush),保证至少写一个 [DONE]。 +// 调用方必须先设置过 status 200;本函数自设 SSE headers。 +// 流式策略:逐帧透传(规范化已剥空 content 噪声),恢复与上游一致的平滑流式。 +// +// StreamHint 变体(gateway_hint 任务):上游 error 帧透传时附加 +// error.gateway_hint 字段——message 原文不动,hint 并列补充;hintFn 返回空串 +// 或 nil 时与 Stream 行为逐字节一致。 +func Stream(w http.ResponseWriter, r io.Reader) error { + return StreamHint(w, r, nil) +} + +// StreamOption StreamHint 的可选行为开关。 +type StreamOption func(*streamOptions) + +type streamOptions struct { + markup *MarkupRepair + echoModel string + // clientGone 客户端是否已经断开(handler 传 r.Context().Err()!=nil)。 + // 只用于「日志归因」:客户端自己走了,上游只是被动跟随,那条「上游未给终态」 + // 的 WARN 就不该记(线上实测过一次 pkill 客户端就刷出一条 WARN,进「错误汇总」 + // 的未归类桶,把真正的上游断流盖掉)。 + clientGone func() bool +} + +// WithClientGoneFn 注入「客户端是否已断开」的判定(可为 nil)。 +func WithClientGoneFn(fn func() bool) StreamOption { + return func(o *streamOptions) { o.clientGone = fn } +} + +// WithModelEcho 强制所有出站帧的顶层 model 字段为 name(issue #30:模型映射)。 +// +// 客户端经别名(models.aliases)点名时,上游帧里回显的是真实模型名;严格校验 +// 「响应 model == 请求 model」的客户端会当场报错。挂上后逐帧覆写,客户端看到的 +// 永远是它自己发出去的名字。name 为空 = 不挂(零改动)。 +func WithModelEcho(name string) StreamOption { + return func(o *streamOptions) { o.echoModel = name } +} + +// WithMarkupRepair 注册「模型原生工具调用标记」修复器(见 dsml.go)。 +// +// 上游在没有声明 tools 的请求里会把工具调用吐成标记文本,Codex 这类只执行结构化 +// function_call 的客户端于是把它当普通正文写进会话历史,回合直接结束、工具一次都没跑。 +// 挂上修复器后,这类标记在透传前被还原成 delta.tool_calls。 +// +// 传 nil、或传入未启用的修复器 → 与不挂时逐字节一致。 +func WithMarkupRepair(r *MarkupRepair) StreamOption { + return func(o *streamOptions) { o.markup = r } +} + +// StreamHint 同 Stream,但上游 error 帧透出前把 hintFn(payload) 的返回值写入 +// error.gateway_hint。hintFn 为 nil 或返回空串 → 原样透传(零改写)。 +// 空流兜底 error 帧("empty upstream stream")不带 hint(网关本地故障形态 +// 未覆盖,不编造)。 +// +// 首帧否决:**首个字节写出前**,若上游第一帧就是 error 帧或整个流零有效帧, +// 不写任何字节直接返回 HeadVetoError —— 调用方换号重试即可,客户端无痕。 +func StreamHint(w http.ResponseWriter, r io.Reader, hintFn func(string) string, opts ...StreamOption) error { + o := streamOptions{} + for _, opt := range opts { + if opt != nil { + opt(&o) + } + } + h := w.Header() + h.Set("Content-Type", "text/event-stream") + h.Set("Cache-Control", "no-cache") + h.Set("Connection", "keep-alive") + h.Set("X-Accel-Buffering", "no") + fl, _ := w.(http.Flusher) + // br 在下面才初始化,但写帧闭包要用它判断「上游缓冲是否已读空」→ 先声明。 + var br *bufio.Reader + // flushIfDrained 只在**下一帧不在本地缓冲里**时才 flush。 + // + // 上游把一条长回答按 token 切成上万帧、成批到达:每帧都 flush 就是每帧一次 + // write 系统调用,线上 profile 里 Flush+syscall 占流式 CPU 的近一半(14470 帧/ + // 请求的实测形态)。本地缓冲里还有完整帧时立刻就会继续写,这次 flush 纯属浪费; + // 只有缓冲读空(下一次读会阻塞在 socket 上)才必须把已写内容推给客户端。 + // 缓冲里只剩半行(没有换行符)也一样会阻塞,同样要 flush——否则上游若在此停顿, + // 客户端会一直等一个已经生成好的帧。 + flushIfDrained := func() { + if fl == nil || br == nil { + return + } + switch n := br.Buffered(); { + case n == 0: + fl.Flush() + case n < 8192: + // 帧很小(~200B),缓冲还有 8KB 以上时必然含完整帧,不必扫。 + if p, _ := br.Peek(n); bytes.IndexByte(p, '\n') < 0 { + fl.Flush() + } + } + } + + // toolCallSeen 跨帧记录 delta.tool_calls 里已发过首片的 index, + // 供逐 chunk 透传时收敛 name 为「每 index 一次」(对齐 OpenAI 官方流)。 + toolCallSeen := map[string]bool{} + + // firstID 透传流的消息级 id 基准:缓存首个非空上游 id,后续帧缺失/空串时复用 + // (issue #35:同一条 SSE 消息所有帧共用一个真实 id,后台按 id 归并;此前中间帧 + // 一律补 chatcmpl-wb2api 哨兵,造成同流 id 分裂)。全流无真实 id → 才出现哨兵。 + firstID := "" + + // 标记修复(见 dsml.go):把上游正文里的原生工具调用标记还原成 delta.tool_calls。 + // 未挂修复器 / 修复器未启用(客户端没声明过 tools)时整条流零改写零分配。 + // - repair:修复器本身; + // - synthIdx:本流已还原的调用数(合成 index 接在上游最大 index 之后); + // - maxToolIdx:上游已用过的最大 tool_call index,避免合成 index 撞车; + // - toolFinishSent:是否已发出过 finish_reason: tool_calls(供流尾兜底); + // - finishSeen:本流是否已向客户端写出过任一终态帧(finish_reason 非空)。 + repair := o.markup + synthIdx := 0 + maxToolIdx := -1 + toolFinishSent := false + finishSeen := false + + // writeSSE 原样写出一帧并 flush。 + writeSSE := func(payload string) error { + if _, werr := io.WriteString(w, "data: "+payload+"\n\n"); werr != nil { + return werr + } + flushIfDrained() + return nil + } + + // writeChunk 把一个 chunk 对象按规范白名单重建后写出并 flush,同时维护三件跨帧 + // 状态:tool_calls name 收敛(每 index 仅首片带 name)、消息 id 续传、以及上游 + // 已用过的最大 tool_call index(供标记修复接续编号)。 + // fallback 是规范化失败时的兜底原文(与修复前「marshal 失败即原样透传」一致)。 + writeChunk := func(obj map[string]any, fallback string) error { + // 模型名回显覆写(issue #30):别名请求时把帧的 model 换回客户端原发名, + // 严格校验「响应 model == 请求 model」的客户端不会当场报错。echoModel 空 = + // 零改动(未映射请求的常态路径)。 + if o.echoModel != "" { + obj["model"] = o.echoModel + } + // 先按 index 收敛 tool_calls name(每 index 仅首片保留,后续分片删 name 键),再规范化透传。 + stripToolCallNames(obj, toolCallSeen) + // id 续传:首帧非空真实 id 缓存;后续帧缺 id / 空 id 一律用缓存值, + // 有自己 id 的帧保持原样(不同流分裂的帧允许各自 id)。 + if firstID == "" { + if v, ok := obj["id"].(string); ok && v != "" { + firstID = v + } + } else if v, ok := obj["id"].(string); !ok || v == "" { + obj["id"] = firstID + } + if chs, ok := obj["choices"].([]any); ok { + for _, ci := range chs { + c, _ := ci.(map[string]any) + if c == nil { + continue + } + // 终态记账:任何带非空 finish_reason 的帧都算「客户端已收到终态」 + // (含 continue 层合成的 length 截断终态——它同样经此处透传)。 + if fr, _ := c["finish_reason"].(string); fr != "" { + finishSeen = true + } + d, _ := c["delta"].(map[string]any) + if d == nil { + continue + } + tcs, _ := d["tool_calls"].([]any) + for _, tci := range tcs { + tc, _ := tci.(map[string]any) + if tc == nil { + continue + } + if v, ok := tc["index"].(float64); ok && int(v) > maxToolIdx { + maxToolIdx = int(v) + } + } + } + } + raw, err := json.Marshal(normalizeFrame(obj)) + if err != nil { + return writeSSE(fallback) + } + return writeSSE(string(raw)) + } + + // repairFrame 在透传前跑标记修复,并把一帧展开成「可能多帧」:正文帧(标记被摘掉 + // 后的可见文本)+ N 个 delta.tool_calls 帧 + 收尾 finish_reason 帧。没有命中标记 + // 时原样返回入参帧(单元素),与修复前逐字节一致。 + repairFrame := func(obj map[string]any) []map[string]any { + if repair == nil || !repair.Enabled() { + return []map[string]any{obj} + } + chs, ok := obj["choices"].([]any) + if !ok { + return []map[string]any{obj} + } + var calls []MarkupCall + for _, ci := range chs { + c, ok := ci.(map[string]any) + if !ok { + continue + } + d, ok := c["delta"].(map[string]any) + if !ok { + continue + } + txt, ok := d["content"].(string) + if !ok || txt == "" { + continue + } + emit, got := repair.Feed(txt) + calls = append(calls, got...) + if emit == "" { + delete(d, "content") + } else { + d["content"] = emit + } + } + if len(calls) == 0 { + // 本帧没命中标记;但本流此前还原过调用 → 把上游的 stop 收尾改写成 + // tool_calls,客户端据此知道「回合以工具调用结束」而不是「模型只说了话」。 + if synthIdx > 0 && rewriteFinishReason(obj, "tool_calls") { + toolFinishSent = true + } + return []map[string]any{obj} + } + // 命中:finish_reason 必须挪到工具调用帧之后,否则客户端在读到调用之前就 + // 认为回合已经结束。注意「本帧本来没有 finish_reason」时**不得**补一帧收尾 + // ——上游的收尾帧随后就到,补了会变成两个 finish_reason(后续那个由 + // rewriteFinishReason 改写)。 + fr := takeFinishReason(obj) + out := []map[string]any{obj} + for _, call := range calls { + idx := maxToolIdx + 1 + synthIdx + synthIdx++ + out = append(out, markupCallFrame(obj, idx, call)) + } + if fr != "" { + if fr == "stop" { + fr = "tool_calls" + } + out = append(out, finishOnlyFrame(obj, fr)) + toolFinishSent = fr == "tool_calls" + } + return out + } + + // writeRaw 原样写出一帧(绕过 normalizeFrame)并 flush。上游 error 帧(error-passthrough) + // 与空流错误帧需保留 error 字段,不能被白名单剥掉,故经此写出。 + // gateway_hint:上游 error 帧透出前按 hintFn 附加 error.gateway_hint 字段 + // (error 对象上加一个键,message/code/requestId 等原文不动;hintFn 为 + // nil / 空串 / 非 JSON 帧 → 原样写出,零改写)。 + writeRaw := func(payload string) error { + if hint := frameGatewayHint(hintFn, payload); hint != "" { + payload = attachHintToErrorFrame(payload, hint) + } + if _, werr := io.WriteString(w, "data: "+payload+"\n\n"); werr != nil { + return werr + } + flushIfDrained() + return nil + } + + // writeFrame 把 payload 按规范白名单重建后以 data: 帧写出并 flush。 + // 仅 JSON 解析成功时计数记为一次有效转发(JSON 解析失败照常降级原样写出,但不计数)。 + // 声明与赋值分开:粘帧拆分需要递归调用本帧处理(见下方 issue #197 分支)。 + var writeFrame func(string) (int, error) + writeFrame = func(payload string) (int, error) { + var obj map[string]any + if json.Unmarshal([]byte(payload), &obj) != nil { + // 粘帧(issue #197):上游偶发把两个 chunk 塞进同一个 data 行,形如 + // `data: {a} {b}`。原样透传会让客户端按 SSE 规范把整行当一个 JSON 解析, + // 直接失败在「第二个对象」上——报错是 + // `Unexpected non-whitespace character after JSON at position N` + // 并且整轮对话作废。这里拆成多个对象逐个走常规路径,客户端每秒都在 + // 解析合法帧,不会看到这个形态。 + if parts := splitConcatenatedJSON(payload); len(parts) > 1 { + log.Printf("WARN: [upstream] data 帧内含 %d 个 JSON 对象(上游粘帧)→ 拆成独立帧透传,首个 %.120q", + len(parts), truncate(parts[0], 120)) + n := 0 + for _, part := range parts { + c, werr := writeFrame(part) + if werr != nil { + return n, werr + } + n += c + } + return n, nil + } + // 非 JSON 帧:原样降级写出,不计数(与修复前一致)。留下 WARN 是因为 + // 这是「客户端收到非协议帧」的唯一线索,静默透传时线上完全查不到。 + if looksLikeJSON(payload) { + log.Printf("WARN: [upstream] data 帧不是合法 JSON → 原样透传 %.160q", truncate(payload, 160)) + } + return 0, writeSSE(payload) + } + // 上游错误帧透传(error-passthrough):带 error 键的帧**原样写出**,不走 + // normalizeFrame 白名单——白名单会剥掉 error 字段,客户端就看不到上游 + // code/msg/requestId。error.message 即上游原文(如 6004 限流、审核拦截), + // 计入有效帧(避免误判空流补写 "empty upstream stream")。 + if _, hasErr := obj["error"]; hasErr { + if werr := writeRaw(payload); werr != nil { + return 0, werr + } + return 1, nil + } + // 流内失败帧(HTTP 200 内嵌 {code,msg,displayMsg},无 choices):白名单会把 + // code/msg 剥掉,客户端只看到「干净地停止、无任何失败」——如实透出为 error 帧, + // 并留一行日志(此前这种帧完全无痕,策略拦截被误记成上游断流)。 + if code, msg, ok := StreamErrorFrame(obj); ok { + log.Printf("WARN: [upstream] 流内失败帧(HTTP 200 内嵌)code=%d msg=%q → 如实透出为 error 帧", code, msg) + if werr := writeRaw(streamErrorPayload(code, msg, payload)); werr != nil { + return 0, werr + } + return 1, nil + } + // 标记修复:命中时一帧展开成多帧(正文帧 + 调用帧 + 收尾帧);未命中单帧原样。 + for _, ch := range repairFrame(obj) { + if werr := writeChunk(ch, payload); werr != nil { + return 0, werr + } + } + return 1, nil + } + + br = bufio.NewReaderSize(r, 64*1024) + validFrames := 0 + // headOpen 首帧否决窗口:尚未向客户端写出任何字节。窗口内遇到上游 error 帧 + // (或整个流零有效帧)就返回 HeadVetoError 而不写字节——上层据此换号重试, + // 客户端看不到这次失败(见 HeadVetoError)。 + headOpen := true + // upstreamDone 上游是否显式发过 data: [DONE]。与 finishSeen(本层是否已向客户端 + // 写出过 finish_reason)合起来判「这段流是不是被截断」:两者都没有 = 上游连接在 + // 说一半时断了,既没有正常收尾也没给终态。 + upstreamDone := false +readLoop: + for { + line, err := br.ReadString('\n') + trimmed := strings.TrimRight(line, "\r\n") + switch { + case strings.HasPrefix(trimmed, "data: [DONE]"): + // 上游显式结束:停止读取,DONE 之后的任何数据(含垃圾帧)一律不再透传。 + // [DONE] 统一在循环结束后写出,保证恰好一个。 + upstreamDone = true + break readLoop + case strings.HasPrefix(trimmed, "data: "): + payload := strings.TrimPrefix(trimmed, "data: ") + if headOpen { + headOpen = false + // 带 error 键的帧即上游 error-passthrough 形态(判据同 writeFrame): + // 它不含可用正文,换号重试对客户端无痕。 + var probe map[string]any + if json.Unmarshal([]byte(payload), &probe) == nil { + if _, hasErr := probe["error"]; hasErr { + return &HeadVetoError{Payload: payload} + } + // 流内失败帧(HTTP 200 内嵌顶层 {code,msg},无 choices;判据同 + // writeFrame 的 StreamErrorFrame):首帧即失败同样否决换号——否则 + // 响应头一旦提交,可重试的失败(11140 审核拦截、6021 队列满)就只能 + // 以「200 + error 帧」透给客户端。payload 改写成标准 error 帧后再带出, + // FrameKind 与末端错误映射的口径和 writeFrame 的透出形态一致。 + if code, msg, ok := StreamErrorFrame(probe); ok { + return &HeadVetoError{Payload: streamErrorPayload(code, msg, payload)} + } + } + } + n, werr := writeFrame(payload) + validFrames += n + if werr != nil { + return werr + } + case trimmed != "": + // 注释/其他行:原样透传,并**补回帧分隔空行**。 + // shortcut: 这一行就提交了响应头,首帧否决窗口随之关闭(首帧即注释的 + // 形态罕见,不为此缓冲整段头部)。 + // 补空行的原因:本函数吞掉上游的分隔空行、自产 "\n\n" 只覆盖 data 帧; + // 注释行只写单行的话,会与下一个 "data: " 帧粘成 ": heartbeat\ndata: ..." + // ——Responses/Messages 适配器按 "\n\n" 切帧后整块没有 "data: " 前缀, + // 直接丢弃。实测 GLM 的工具调用首帧(携带 id+name)正是被这样吞掉的: + // 调用整个消失、completed 的 output 变 null,客户端对 null .map 崩溃。 + headOpen = false + if _, werr := io.WriteString(w, line); werr != nil { + return werr + } + if _, werr := io.WriteString(w, "\n"); werr != nil { + return werr + } + flushIfDrained() + } + // 空行(帧分隔)吞掉:本函数自产 "\n\n" + if err != nil { + if err == io.EOF { + break + } + return err + } + } + // 标记修复的尾部收尾:流结束时仍未判定的字节一律原文回吐(绝不吞字节,未闭合 + // 的块连起始标记一起交还);若本流还原过调用、但上游从未给出收尾帧,补一帧 + // finish_reason: tool_calls,保证客户端不会把「工具调用回合」读成「模型只说了话」。 + if repair != nil && repair.Enabled() { + if tail := repair.Flush(); tail != "" { + tailObj := map[string]any{ + "object": "chat.completion.chunk", + "choices": []any{map[string]any{ + "index": 0, + "delta": map[string]any{"content": tail}, + }}, + } + if werr := writeChunk(tailObj, ""); werr != nil { + return werr + } + validFrames++ + } + // 只在「本流一个终态都没发过」时兜底:补了就是一条流两个 finish_reason, + // 而后一个会把前一个洗掉——最典型是 continue 层刚补的 length 截断终态被 + // 后补的 tool_calls 覆盖,客户端把中断的回合读成正常收尾。 + if synthIdx > 0 && !toolFinishSent && !finishSeen { + if werr := writeChunk(finishOnlyFrame(map[string]any{}, "tool_calls"), ""); werr != nil { + return werr + } + } + } + // 截断兜底:上游既没给 finish_reason,也没发 data: [DONE] 就 EOF —— 这是上游连接 + // 说到一半断了,不是正常收尾。此前这种流只会补一个 [DONE]:chat 客户端看到「内容 + + // 结束」但 finish_reason 为空,responses 适配器更直接回 response.completed,Agent 侧 + // 表现就是「说到一半停了、也不报错」,只能人工接着催。这里补一帧截断终态:chat 侧看到 + // finish_reason=length(TruncationFinishReason),responses 侧映射成 + // incomplete(max_output_tokens),由客户端自己决定续写/重试——网关不再把断流伪装成成功。 + // 只在本层一个终态都没发过时补(否则两个 finish_reason,后一个会洗掉前一个)。 + if !upstreamDone && !finishSeen && !toolFinishSent && validFrames > 0 { + // 客户端自己断开时上游只是被动跟随断连,这条不是上游故障——记 WARN 会把 + // 真正的中断盖掉(错误汇总按类别聚合,噪音会挤掉信噪比)。归因交给 handler + // 的 interrupted 观测(499),这里只在客户端还在等时才告警。 + if o.clientGone == nil || !o.clientGone() { + log.Printf("WARN: [server] stream 上游未给终态就结束(无 finish_reason、无 data: [DONE],%d 个有效帧)→ 按截断收尾", validFrames) + } + if werr := writeChunk(finishOnlyFrame(map[string]any{}, TruncationFinishReason), ""); werr != nil { + return werr + } + finishSeen = true + } + // 空流(0 有效帧):尚未写出任何字节时先走首帧否决(上层换号比补一帧假成功的 + // error 更有价值);已经写过注释/心跳行(响应头已提交)则只能照旧兜底——先写一帧 + // error(绕过 normalizeFrame 原样保留 error 字段),再补 [DONE] 保证客户端能正常 + // 收尾,并返回非 nil error 供调用方记录。 + // 网关本地空流兜底帧走 hintFn=nil 的直写路径:该形态未覆盖(不编造 hint), + // 且 writeRaw 的 hintFn 闭包在空流路径下可能携带上一帧的上下文造成误配。 + if validFrames == 0 { + if headOpen { + return &HeadVetoError{} + } + _ = writeRaw(`{"error":{"message":"empty upstream stream","type":"upstream_error","code":"upstream_parse"}}`) + } + // 保证恰好写一个 [DONE](上游漏发时兜底补上)。 + if _, err := io.WriteString(w, "data: [DONE]\n\n"); err != nil { + return err + } + if fl != nil { + fl.Flush() + } + if validFrames == 0 { + return errEmptyStream + } + return nil +} + +// frameGatewayHint 取 error 帧的 gateway_hint(hintFn 缺失/异常返回空串 → 不附加)。 +func frameGatewayHint(hintFn func(string) string, payload string) string { + if hintFn == nil { + return "" + } + // panic 隔离:hint 判定是补充功能,任何实现缺陷不得击穿流透传主路径。 + defer func() { _ = recover() }() + return strings.TrimSpace(hintFn(payload)) +} + +// attachHintToErrorFrame 在 error 帧的 error 对象上附加 gateway_hint 字段。 +// message/code/requestId 等既有键原样保留(只加不改);非 JSON / 无 error 对象 → +// payload 原样返回(宁可不加 hint 也不破坏原文透传)。 +// takeFinishReason 取出并删除所有 choice 的 finish_reason,返回第一个非空值。 +// 标记修复把一帧拆成多帧时需要它:finish_reason 必须落在工具调用帧之后,否则 +// 客户端在读到调用之前就认为回合结束了。 +func takeFinishReason(obj map[string]any) string { + fr := "" + chs, _ := obj["choices"].([]any) + for _, ci := range chs { + c, _ := ci.(map[string]any) + if c == nil { + continue + } + if v, ok := c["finish_reason"].(string); ok && v != "" && fr == "" { + fr = v + } + delete(c, "finish_reason") + } + return fr +} + +// rewriteFinishReason 把 choice 上「已有且为 stop」的 finish_reason 改写成 want。 +// 本来就没有 finish_reason 的中间帧一律不动(绝不凭空造收尾),已有其他值 +// (length / content_filter 等)时也不动——那些收尾语义更需要被客户端看到。 +// 返回是否发生了改写。 +func rewriteFinishReason(obj map[string]any, want string) bool { + changed := false + chs, _ := obj["choices"].([]any) + for _, ci := range chs { + c, _ := ci.(map[string]any) + if c == nil { + continue + } + if v, ok := c["finish_reason"].(string); ok && v == "stop" { + c["finish_reason"] = want + changed = true + } + } + return changed +} + +// markupCallFrame 以 src 帧为模板,构造一帧只带单个 delta.tool_calls 的 chunk。 +// id 不在这里写:交给 writeChunk 的 id 续传逻辑补齐(src 帧先写出,firstID 已就位)。 +func markupCallFrame(src map[string]any, idx int, call MarkupCall) map[string]any { + frame := map[string]any{ + "object": "chat.completion.chunk", + "choices": []any{map[string]any{ + "index": 0, + "delta": map[string]any{ + "tool_calls": markupToolCalls([]MarkupCall{call}, idx), + }, + }}, + } + for _, k := range []string{"created", "model"} { + if v, ok := src[k]; ok && v != nil { + frame[k] = v + } + } + return frame +} + +// finishOnlyFrame 构造一帧只带 finish_reason 的收尾 chunk(空 delta)。 +func finishOnlyFrame(src map[string]any, finish string) map[string]any { + frame := map[string]any{ + "object": "chat.completion.chunk", + "choices": []any{map[string]any{ + "index": 0, + "delta": map[string]any{}, + "finish_reason": finish, + }}, + } + for _, k := range []string{"created", "model"} { + if v, ok := src[k]; ok && v != nil { + frame[k] = v + } + } + return frame +} + +func attachHintToErrorFrame(payload, hint string) string { + var obj map[string]any + if json.Unmarshal([]byte(payload), &obj) != nil { + return payload + } + e, ok := obj["error"].(map[string]any) + if !ok { + return payload + } + e["gateway_hint"] = hint + out, err := json.Marshal(obj) + if err != nil { + return payload + } + return string(out) +} diff --git a/internal/upstream/sse_clientgone_log_test.go b/internal/upstream/sse_clientgone_log_test.go new file mode 100644 index 0000000000000000000000000000000000000000..bff7030284a135553d0ce76e672c4cfe6b29c234 --- /dev/null +++ b/internal/upstream/sse_clientgone_log_test.go @@ -0,0 +1,77 @@ +package upstream + +import ( + "bytes" + "log" + "net/http/httptest" + "strings" + "testing" +) + +// captureLog 捕获一段代码执行期间的 log 输出。 +func captureLog(t *testing.T, fn func()) string { + t.Helper() + var buf bytes.Buffer + prevOut := log.Writer() + prevFlags := log.Flags() + log.SetOutput(&buf) + log.SetFlags(0) + defer func() { + log.SetOutput(prevOut) + log.SetFlags(prevFlags) + }() + fn() + return buf.String() +} + +// cutStream 上游说到一半就 EOF:有正文、无 finish_reason、无 [DONE]。 +const cutStream = `data: {"id":"c1","choices":[{"index":0,"delta":{"content":"半句"}}]}` + "\n\n" + +// TestStreamCutWarnsWhenClientStillWaiting 客户端还在等(ctx 未取消)时,上游断流 +// 必须落 WARN:这是真故障,运维要靠它发现。 +func TestStreamCutWarnsWhenClientStillWaiting(t *testing.T) { + rec := httptest.NewRecorder() + out := captureLog(t, func() { + if err := StreamHint(rec, strings.NewReader(cutStream), nil, + WithClientGoneFn(func() bool { return false })); err != nil { + t.Fatalf("StreamHint: %v", err) + } + }) + if !strings.Contains(out, "上游未给终态就结束") { + t.Fatalf("客户端还在等时应记 WARN,实际日志=%q", out) + } + // 截断终态照常补:客户端至少知道被截断了。 + if !strings.Contains(rec.Body.String(), `"finish_reason":"`+TruncationFinishReason+`"`) { + t.Fatalf("断流仍应补截断终态:\n%s", rec.Body.String()) + } +} + +// TestStreamCutSilentWhenClientGone 客户端已经断开(pkill / 关页面 / 客户端 idle +// 超时掐线)时,上游只是被动跟随断连——这条不该记 WARN,否则「错误汇总」里会混进 +// 与上游无关的噪音(线上实测 pkill 一次就刷一条,还落进「其他(未归类)」)。 +func TestStreamCutSilentWhenClientGone(t *testing.T) { + rec := httptest.NewRecorder() + out := captureLog(t, func() { + if err := StreamHint(rec, strings.NewReader(cutStream), nil, + WithClientGoneFn(func() bool { return true })); err != nil { + t.Fatalf("StreamHint: %v", err) + } + }) + if strings.Contains(out, "上游未给终态就结束") { + t.Fatalf("客户端已断开时不该记 WARN,实际日志=%q", out) + } +} + +// TestStreamCutWarnsWithoutClientGoneFn 没有注入判定(老调用方)时保持原行为: +// 宁可多记一条,也不要漏掉真故障。 +func TestStreamCutWarnsWithoutClientGoneFn(t *testing.T) { + rec := httptest.NewRecorder() + out := captureLog(t, func() { + if err := StreamHint(rec, strings.NewReader(cutStream), nil); err != nil { + t.Fatalf("StreamHint: %v", err) + } + }) + if !strings.Contains(out, "上游未给终态就结束") { + t.Fatalf("未注入判定时应保持原行为(记 WARN),实际日志=%q", out) + } +} diff --git a/internal/upstream/sse_comment_frame_test.go b/internal/upstream/sse_comment_frame_test.go new file mode 100644 index 0000000000000000000000000000000000000000..4dd04f93b862d2e07a60840378894560b683f1cc --- /dev/null +++ b/internal/upstream/sse_comment_frame_test.go @@ -0,0 +1,39 @@ +package upstream + +import ( + "net/http/httptest" + "strings" + "testing" +) + +// 上游 workbuddy.cn 的注释行后**不发空行**,直接跟 data 帧: +// +// : heartbeat\ndata: {"choices":[{"delta":{"tool_calls":[{"id":"call_x",... +// +// StreamHint 会吞掉上游的分隔空行、自产 "\n\n" 只覆盖 data 帧,所以注释行必须自己补回 +// 分隔——否则下游按 "\n\n" 切帧会拿到 ": heartbeat\ndata: {...}" 粘连块,没有 "data: " +// 前缀,整帧被丢。被丢的恰是 GLM 工具调用的首帧(带 id 与 function.name),整个调用随之 +// 消失(见 PR #158)。PR #158 的回归测试只喂 responsesWriter,这一层没有覆盖,这里补上。 +func TestStreamHintSeparatesCommentFromNextFrame(t *testing.T) { + raw := ": heartbeat\n" + + `data: {"choices":[{"index":0,"delta":{"tool_calls":[{"index":0,"id":"call_x","type":"function","function":{"name":"get_weather","arguments":""}}]}}]}` + "\n\n" + + `data: {"choices":[{"index":0,"delta":{"content":"hi"}}]}` + "\n\n" + + "data: [DONE]\n\n" + + rec := httptest.NewRecorder() + if err := StreamHint(rec, strings.NewReader(raw), nil); err != nil { + t.Fatal(err) + } + body := rec.Body.String() + + if strings.Contains(body, ": heartbeat\ndata: ") { + t.Fatalf("注释行与 data 帧粘连(下游会整帧丢弃): %q", body) + } + if !strings.Contains(body, ": heartbeat\n\n") { + t.Fatalf("注释行后缺帧分隔空行: %q", body) + } + // 粘连的下游表现就是「工具调用首帧消失」:名字必须仍在透出内容里。 + if !strings.Contains(body, `"name":"get_weather"`) { + t.Fatalf("工具调用首帧丢失: %q", body) + } +} diff --git a/internal/upstream/sse_flush_batch_test.go b/internal/upstream/sse_flush_batch_test.go new file mode 100644 index 0000000000000000000000000000000000000000..01ec5d8aa2c807a50251ef9929a8d09109b03ecf --- /dev/null +++ b/internal/upstream/sse_flush_batch_test.go @@ -0,0 +1,101 @@ +package upstream + +import ( + "io" + "net/http" + "strings" + "testing" +) + +// flushCounter 记录 Flush 次数;同时收集写出字节。 +type flushCounter struct { + hdr http.Header + body strings.Builder + status int + flush int +} + +func (f *flushCounter) Header() http.Header { + if f.hdr == nil { + f.hdr = http.Header{} + } + return f.hdr +} +func (f *flushCounter) Write(p []byte) (int, error) { return f.body.Write(p) } +func (f *flushCounter) WriteHeader(s int) { f.status = s } +func (f *flushCounter) Flush() { f.flush++ } + +// TestStreamFlushOnlyWhenDrained 上游一次给一批帧时,不该每帧都 flush。 +// +// 「并发一高就降速」的真实形态:一条长回答被切成上万帧成批到达,每帧一次 +// write 系统调用(线上 profile 里 Flush+syscall 占流式 CPU 近一半)。本地缓冲 +// 还有完整帧时必须跳过 flush——下一轮立刻就会继续写。 +// +// 判据用「次数上限」而不是精确值:只要不是「一帧一次」就说明批量生效了。 +func TestStreamFlushOnlyWhenDrained(t *testing.T) { + const frames = 20 + var sb strings.Builder + for i := 0; i < frames; i++ { + sb.WriteString(`data: {"id":"c","choices":[{"index":0,"delta":{"content":"字"}}]}` + "\n\n") + } + sb.WriteString("data: [DONE]\n\n") + + w := &flushCounter{} + if err := Stream(w, strings.NewReader(sb.String())); err != nil { + t.Fatalf("stream: %v", err) + } + // 全部数据一次性可读 → bufio 一次填满,只有末尾/换行边界才会 flush。 + if w.flush >= frames/2 { + t.Fatalf("flush 次数 %d(%d 帧):批量未生效,等于每帧一次系统调用", w.flush, frames) + } + // 内容必须完整:20 帧正文 + [DONE]。 + if n := strings.Count(w.body.String(), `"content":"字"`); n != frames { + t.Fatalf("正文帧丢失: %d/%d\n%s", n, frames, w.body.String()) + } + if !strings.HasSuffix(w.body.String(), "data: [DONE]\n\n") { + t.Fatalf("[DONE] 缺失:\n%s", w.body.String()) + } +} + +// TestStreamFlushesOnPartialLine 缓冲里只剩半行时仍必须 flush。 +// +// 半行意味着下一次 ReadString 会阻塞在 socket 上;若此时不 flush,上游一旦在此 +// 停顿,客户端会为一个已经生成好的帧干等到下一批数据到达(长思考段的静默正是 +// 客户端 idle 超时的主要来源)。 +func TestStreamFlushesOnPartialLine(t *testing.T) { + // 先给一个完整帧 + 半帧(无换行结尾),再给剩余部分。 + full := `data: {"id":"c","choices":[{"index":0,"delta":{"content":"甲"}}]}` + "\n\n" + partial := `data: {"id":"c","choices":[{"index":0,"delta":{"content":"乙` + rest := `"}}]}` + "\n\ndata: [DONE]\n\n" + + w := &flushCounter{} + r := &chunkReader{chunks: []string{full + partial, rest}} + if err := Stream(w, r); err != nil { + t.Fatalf("stream: %v", err) + } + if w.flush == 0 { + t.Fatal("半行边界处没有 flush:客户端会在上游停顿时干等") + } + if !strings.Contains(w.body.String(), "甲") || !strings.Contains(w.body.String(), "乙") { + t.Fatalf("正文缺失:\n%s", w.body.String()) + } +} + +// chunkReader 按块返回数据,模拟网络分片到达。 +type chunkReader struct { + chunks []string + i int +} + +func (c *chunkReader) Read(p []byte) (int, error) { + if c.i >= len(c.chunks) { + return 0, io.EOF + } + n := copy(p, c.chunks[c.i]) + if n < len(c.chunks[c.i]) { + c.chunks[c.i] = c.chunks[c.i][n:] + } else { + c.i++ + } + return n, nil +} diff --git a/internal/upstream/sse_frame_split.go b/internal/upstream/sse_frame_split.go new file mode 100644 index 0000000000000000000000000000000000000000..6f73f2f146f1c0aa836306b1b40709dc18b58938 --- /dev/null +++ b/internal/upstream/sse_frame_split.go @@ -0,0 +1,131 @@ +// sse_frame_split.go 单个 data 帧里塞了多个 JSON 对象时的拆分(issue #197)。 +// +// 现象:客户端(zcode 等)报 +// +// JSON parsing failed: Text: {"id":"..."} {"id":"..."} +// Unexpected non-whitespace character after JSON at position 348 (line 2 column 1) +// +// 按 SSE 规范,同一事件的多行 data 会用 "\n" 拼成一份文本交给客户端;而一个 +// `data: {a} {b}` 行本身就是「一份文本里有两条 JSON」,客户端无论怎么读都只能 +// 解析第一个——整轮对话直接作废,而且报错在读侧,看不出是上游粘帧。 +// +// 本文件只做一件事:把 `{a} {b}` / `{a}{b}` 这种**首尾相接的多个 JSON 值**切成 +// 独立字符串,交给调用方逐个当普通帧处理。切不动(不是 JSON、括号不配平)就返回 +// 单元素,调用方保持原来的「原样透传」行为,不改变任何既有形态。 +package upstream + +import ( + "encoding/json" + "strings" +) + +// maxSplitParts 单帧最多拆出多少份。上游粘帧是「一两个」,这里给到 64 只为兜住 +// 极端畸形输入——不设上限的话,一个几百 KB 的坏帧会被切成上千次写操作。 +const maxSplitParts = 64 + +// looksLikeJSON 判断一份 payload 是否**打算**是 JSON(首字符是 { 或 [)。 +// +// 只用来决定要不要打 WARN:上游有些形态确实是非 JSON 的行(例如纯文本心跳), +// 那些静默透传是对的;以 { 开头却解析失败才是需要人看的故障。 +func looksLikeJSON(payload string) bool { + t := strings.TrimLeft(payload, " \t\r\n") + if t == "" { + return false + } + return t[0] == '{' || t[0] == '[' +} + +// splitConcatenatedJSON 把首尾相接的多个 JSON 值切成独立字符串。 +// +// 切法:按字节扫描,跟踪字符串状态(含 \ 转义)与 {}、[] 嵌套深度;深度从 0 回到 0 +// 且下一个非空白字节与当前值首尾相接,就切一刀。每个值单独再验证一次 json 合法性 +// ——宁可少切(返回单元素走原样透传),也不产出半截对象把客户端带偏。 +// +// 返回值:len>1 表示确实拆开了;len==1 表示「本来就是一个值」或「切不动」。 +func splitConcatenatedJSON(payload string) []string { + trimmed := strings.TrimSpace(payload) + if trimmed == "" { + return []string{payload} + } + var ( + parts []string + depth int + inStr bool + escaped bool + start = -1 + ) + for i := 0; i < len(trimmed); i++ { + c := trimmed[i] + if start < 0 { + // 值之间允许空白;真遇到非空白就开一个新值。 + if c == ' ' || c == '\t' || c == '\r' || c == '\n' { + continue + } + if c != '{' && c != '[' && c != '"' && c != '-' && (c < '0' || c > '9') && + c != 't' && c != 'f' && c != 'n' { + return []string{payload} // 不是 JSON 值序列,放弃 + } + start = i + } + if inStr { + switch { + case escaped: + escaped = false + case c == '\\': + escaped = true + case c == '"': + inStr = false + if depth == 0 { // 裸字符串值,切在引号后 + if part, ok := trimJSONValue(trimmed[start : i+1]); ok { + parts = append(parts, part) + if len(parts) >= maxSplitParts { + return []string{payload} + } + start = -1 + } else { + return []string{payload} + } + } + } + continue + } + switch c { + case '"': + inStr = true + case '{', '[': + depth++ + case '}', ']': + depth-- + if depth < 0 { + return []string{payload} + } + if depth == 0 { + if part, ok := trimJSONValue(trimmed[start : i+1]); ok { + parts = append(parts, part) + if len(parts) >= maxSplitParts { + return []string{payload} + } + start = -1 + } else { + return []string{payload} + } + } + } + } + if start >= 0 || inStr || depth != 0 { + return []string{payload} // 末尾有半截值:整份不认,交给原样透传 + } + if len(parts) == 0 { + return []string{payload} + } + return parts +} + +// trimJSONValue 校验候选片段是单个合法 JSON 值,返回去空白后的原文。 +func trimJSONValue(v string) (string, bool) { + v = strings.TrimSpace(v) + if v == "" || !json.Valid([]byte(v)) { + return "", false + } + return v, true +} diff --git a/internal/upstream/sse_frame_split_test.go b/internal/upstream/sse_frame_split_test.go new file mode 100644 index 0000000000000000000000000000000000000000..8096e17f8da9dfe69a15607cb0ee4ed914ecd26a --- /dev/null +++ b/internal/upstream/sse_frame_split_test.go @@ -0,0 +1,150 @@ +package upstream + +import ( + "encoding/json" + "net/http/httptest" + "strings" + "testing" +) + +// 切分器本身:只认首尾相接的 JSON 值序列,其他一律退回单元素。 +func TestSplitConcatenatedJSON(t *testing.T) { + for _, tc := range []struct { + name string + in string + want []string + parts int + }{ + { + name: "两个对象空格分隔(issue #197 的现场形态)", + in: `{"id":"a","choices":[]} {"id":"b","choices":[]}`, + parts: 2, + want: []string{`{"id":"a","choices":[]}`, `{"id":"b","choices":[]}`}, + }, + { + name: "两个对象无分隔", + in: `{"id":"a"}{"id":"b"}`, + parts: 2, + want: []string{`{"id":"a"}`, `{"id":"b"}`}, + }, + { + name: "三个对象含换行分隔", + in: "{\"i\":1}\n{\"i\":2}\n{\"i\":3}", + parts: 3, + want: []string{`{"i":1}`, `{"i":2}`, `{"i":3}`}, + }, + { + name: "字符串里的花括号与转义引号不能算结构", + in: `{"t":"}{ \"x\" }"} {"t":"ok"}`, + parts: 2, + want: []string{`{"t":"}{ \"x\" }"}`, `{"t":"ok"}`}, + }, + { + name: "数组与对象混排", + in: `[1,2][{"a":1}]`, + parts: 2, + want: []string{`[1,2]`, `[{"a":1}]`}, + }, + {name: "单个对象不拆", in: `{"id":"a"}`, parts: 1}, + {name: "半截对象不拆", in: `{"id":"a"} {"id":`, parts: 1}, + {name: "括号不配平不拆", in: `{"id":"a"}}}}`, parts: 1}, + {name: "纯文本不拆", in: `hello world`, parts: 1}, + {name: "空串", in: ``, parts: 1}, + } { + t.Run(tc.name, func(t *testing.T) { + got := splitConcatenatedJSON(tc.in) + if len(got) != tc.parts { + t.Fatalf("拆出 %d 份 want %d:%q", len(got), tc.parts, got) + } + if tc.want != nil { + for i := range tc.want { + if got[i] != tc.want[i] { + t.Fatalf("第 %d 份 = %q want %q", i, got[i], tc.want[i]) + } + } + } + }) + } +} + +// 端到端:上游把两个 chunk 粘在一行时,客户端必须收到两个**独立的** data 帧。 +// +// 变异判据:去掉 writeFrame 里的 splitConcatenatedJSON 分支,本用例会退化成 +// 一个 data 帧、且帧内是 `{a} {b}`——正是 issue #197 里客户端 JSON.parse 失败 +// 的那个形态。 +func TestStreamSplitsGluedFrames(t *testing.T) { + glued := `data: {"id":"cmb-1","object":"chat.completion.chunk","model":"glm-5.3-flash","choices":[{"index":0,"delta":{"reasoning_content":"User"},"finish_reason":""}]}` + + ` {"id":"cmb-1","object":"chat.completion.chunk","model":"glm-5.3-flash","choices":[{"index":0,"delta":{"content":"你好"},"finish_reason":""}]}` + "\n\n" + upstreamBody := glued + "data: [DONE]\n\n" + + rec := httptest.NewRecorder() + if err := StreamHint(rec, strings.NewReader(upstreamBody), nil); err != nil { + t.Fatalf("StreamHint: %v", err) + } + out := rec.Body.String() + + if !strings.Contains(out, "\n\ndata: ") { + t.Fatalf("帧之间没有空行分隔:%q", out) + } + events := splitSSEEvents(out) + dataEvents := 0 + for _, ev := range events { + lines := strings.Split(ev, "\n") + var payload string + n := 0 + for _, l := range lines { + if strings.HasPrefix(l, "data:") { + n++ + payload = strings.TrimSpace(strings.TrimPrefix(l, "data:")) + } + } + if n == 0 { + continue + } + if n > 1 { + t.Fatalf("一个事件里有 %d 个 data 行(客户端会拼成一份 JSON):%q", n, ev) + } + if payload == "[DONE]" { + continue + } + dataEvents++ + if !json.Valid([]byte(payload)) { + t.Fatalf("帧不是单个合法 JSON:%q", payload) + } + if strings.Contains(payload, "}{") || strings.Count(payload, `"id"`) > 1 { + t.Fatalf("帧内塞了多个对象:%q", payload) + } + } + // 两个内容帧 + 可能的收尾帧(上游没给 finish_reason,StreamHint 会补一帧截断终态) + if dataEvents < 2 { + t.Fatalf("应至少拆出 2 个内容帧,实际 %d:%q", dataEvents, out) + } + if !strings.Contains(out, `"reasoning_content":"User"`) || !strings.Contains(out, `"content":"你好"`) { + t.Fatalf("拆开后内容丢失:%q", out) + } + if c := strings.Count(out, "data: [DONE]"); c != 1 { + t.Fatalf("[DONE] 应为 1 个,实际 %d:%q", c, out) + } +} + +// 切不动时保持原行为:原样透传,且不丢字节。 +func TestStreamKeepsUnparsablePayload(t *testing.T) { + body := "data: {\"broken\":\n\n" + "data: [DONE]\n\n" + rec := httptest.NewRecorder() + _ = StreamHint(rec, strings.NewReader(body), nil) + if !strings.Contains(rec.Body.String(), `data: {"broken":`) { + t.Fatalf("不可解析的帧必须原样透传:%q", rec.Body.String()) + } +} + +// splitSSEEvents 按规范切事件("\\n\\n")。 +func splitSSEEvents(s string) []string { + s = strings.ReplaceAll(s, "\r\n", "\n") + var out []string + for _, ev := range strings.Split(s, "\n\n") { + if strings.TrimSpace(ev) != "" { + out = append(out, ev) + } + } + return out +} diff --git a/internal/upstream/sse_stream_guards_test.go b/internal/upstream/sse_stream_guards_test.go new file mode 100644 index 0000000000000000000000000000000000000000..5031fee47f558578440ecf1689f8df75129aed46 --- /dev/null +++ b/internal/upstream/sse_stream_guards_test.go @@ -0,0 +1,78 @@ +package upstream + +import ( + "net/http/httptest" + "strings" + "testing" +) + +// TestStripToolCallNamesNoIndexKeepsEveryName 无 index 字段的上游(mergeToolCallsChunk +// 专门为它写了分支,是同族真实形态):同一帧里多个调用各自保留首片 name,不能挤进 +// 同一个键互相删——第二个调用的 name 被删掉后,客户端拿到的是没有名字的调用、派发不了。 +func TestStripToolCallNamesNoIndexKeepsEveryName(t *testing.T) { + frame := map[string]any{"choices": []any{map[string]any{"delta": map[string]any{ + "tool_calls": []any{ + map[string]any{"id": "call_a", "type": "function", "function": map[string]any{"name": "Bash", "arguments": `{"cmd":"ls"}`}}, + map[string]any{"id": "call_b", "type": "function", "function": map[string]any{"name": "Read", "arguments": `{"file":"x"}`}}, + }, + }}}} + + seen := map[string]bool{} + stripToolCallNames(frame, seen) + + nameOf := func(f map[string]any, i int) string { + tcs, _ := f["choices"].([]any)[0].(map[string]any)["delta"].(map[string]any)["tool_calls"].([]any) + fn, _ := tcs[i].(map[string]any)["function"].(map[string]any) + n, _ := fn["name"].(string) + return n + } + if nameOf(frame, 0) != "Bash" || nameOf(frame, 1) != "Read" { + t.Fatalf("无 index 帧的 name 被误删:%q / %q", nameOf(frame, 0), nameOf(frame, 1)) + } + + // 续帧(同 id、同样没有 index)仍按「每个调用只带一次 name」删键。 + next := map[string]any{"choices": []any{map[string]any{"delta": map[string]any{ + "tool_calls": []any{ + map[string]any{"id": "call_b", "type": "function", "function": map[string]any{"name": "Read", "arguments": "y"}}, + }, + }}}} + stripToolCallNames(next, seen) + if got := nameOf(next, 0); got != "" { + t.Fatalf("续帧的重复 name 应被删除,实际 %q", got) + } +} + +// TestStreamTailDoesNotAddSecondFinish 断流场景:正文里是原生标记(被还原成调用)+ +// continue 层补的 length 截断终态。流尾兜底此前会再补一条 tool_calls,一条流两个 +// finish_reason,后一个把「截断」洗成「正常收尾」。 +func TestStreamTailDoesNotAddSecondFinish(t *testing.T) { + content := mkBlock(mkInvoke("exec_command", mkParam("cmd", "ls -la"))) + + finishes := func(t *testing.T, raw string) []string { + t.Helper() + repair := NewMarkupRepair(testTools, false) + rec := httptest.NewRecorder() + if err := StreamHint(rec, strings.NewReader(raw), nil, WithMarkupRepair(repair)); err != nil { + t.Fatal(err) + } + if repair.Converted() == 0 { + t.Fatalf("前置条件不成立:标记未被还原,测不到该路径(%s)", rec.Body.String()) + } + var got []string + for _, f := range viewSSE(t, rec.Body.String()) { + if f.finish != "" { + got = append(got, f.finish) + } + } + return got + } + + // 上游给了终态(这里是 continue 层合成的截断终态)→ 恰好一条,且必须还是 length。 + if got := finishes(t, upstreamSSEWithContent([]string{content}, "length")); len(got) != 1 || got[0] != "length" { + t.Fatalf("一条流恰好一个终态且为 length,实际 %v", got) + } + // 上游从未给终态 → 兜底照旧要补 tool_calls(别把兜底一起关掉)。 + if got := finishes(t, upstreamSSEWithContent([]string{content}, "")); len(got) != 1 || got[0] != "tool_calls" { + t.Fatalf("上游无终态时应兜底补 tool_calls,实际 %v", got) + } +} diff --git a/internal/upstream/sse_test.go b/internal/upstream/sse_test.go index 194371d2fd9d7aab2e70ee761562fe21e80b4e13..d6a21e28f2a0c7115068d73dbd356aff8ecfd6b8 100644 --- a/internal/upstream/sse_test.go +++ b/internal/upstream/sse_test.go @@ -1,934 +1,1351 @@ -package upstream - -import ( - "encoding/json" - "errors" - "net/http" - "net/http/httptest" - "strings" - "testing" - "time" - - "github.com/linguo2625469/workbuddy2api-panel/internal/auth" -) - -func TestPrepareBodyForcesStream(t *testing.T) { - out := PrepareBodyOpt([]byte(`{"model":"glm-5.2","messages":[]}`), true) - var m map[string]any - json.Unmarshal(out, &m) - if m["stream"] != true { - t.Errorf("stream=%v", m["stream"]) - } -} - -func TestPrepareBodyToolChoiceFunctionObject(t *testing.T) { - out := PrepareBodyOpt([]byte(`{"tool_choice":{"type":"function","function":{"name":"get_weather"}},"tools":[{"type":"function"}]}`), true) - var m map[string]any - json.Unmarshal(out, &m) - if m["tool_choice"] != "get_weather" { - t.Errorf("tool_choice=%v", m["tool_choice"]) - } - if _, ok := m["tools"]; !ok { - t.Error("tools should be kept for function choice") - } -} - -func TestPrepareBodyToolChoiceNone(t *testing.T) { - for _, in := range []string{ - `{"tool_choice":"none","tools":[{}],"functions":[{}]}`, - `{"tool_choice":{"type":"none"},"tools":[{}]}`, - } { - out := PrepareBodyOpt([]byte(in), true) - var m map[string]any - json.Unmarshal(out, &m) - if _, ok := m["tool_choice"]; ok { - t.Errorf("%s: tool_choice should be deleted", in) - } - if _, ok := m["tools"]; ok { - t.Errorf("%s: tools should be deleted", in) - } - if _, ok := m["functions"]; ok { - t.Errorf("%s: functions should be deleted", in) - } - } -} - -func TestPrepareBodyToolChoiceAuto(t *testing.T) { - out := PrepareBodyOpt([]byte(`{"tool_choice":{"type":"auto"}}`), true) - var m map[string]any - json.Unmarshal(out, &m) - if m["tool_choice"] != "auto" { - t.Errorf("tool_choice=%v", m["tool_choice"]) - } -} - -func TestPrepareBodyInvalidJSON(t *testing.T) { - in := []byte(`{broken`) - out := PrepareBodyOpt(in, true) - if string(out) != string(in) { - t.Error("invalid json should pass through unchanged") - } -} - -const sseFixture = "data: {\"id\":\"chatcmpl-1\",\"object\":\"chat.completion.chunk\",\"created\":1753600000,\"model\":\"glm-5.2\",\"choices\":[{\"index\":0,\"delta\":{\"role\":\"assistant\",\"content\":\"你好\"}}]}\n\n" + - "data: {\"id\":\"chatcmpl-1\",\"object\":\"chat.completion.chunk\",\"created\":1753600000,\"model\":\"glm-5.2\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\",世界\"}}]}\n\n" + - "data: {\"id\":\"chatcmpl-1\",\"object\":\"chat.completion.chunk\",\"created\":1753600000,\"model\":\"glm-5.2\",\"choices\":[{\"index\":0,\"delta\":{},\"finish_reason\":\"stop\"}],\"usage\":{\"prompt_tokens\":5,\"completion_tokens\":2,\"total_tokens\":7}}\n\n" + - "data: [DONE]\n\n" - -func TestAggregate(t *testing.T) { - resp, err := Aggregate(strings.NewReader(sseFixture)) - if err != nil { - t.Fatal(err) - } - if resp["object"] != "chat.completion" { - t.Errorf("object=%v", resp["object"]) - } - if resp["model"] != "glm-5.2" { - t.Errorf("model=%v", resp["model"]) - } - choices := resp["choices"].([]any) - msg := choices[0].(map[string]any)["message"].(map[string]any) - if msg["content"] != "你好,世界" { - t.Errorf("content=%q", msg["content"]) - } - if msg["role"] != "assistant" { - t.Errorf("role=%v", msg["role"]) - } - if choices[0].(map[string]any)["finish_reason"] != "stop" { - t.Errorf("finish_reason=%v", choices[0].(map[string]any)["finish_reason"]) - } - usage := resp["usage"].(map[string]any) - if usage["total_tokens"].(float64) != 7 { - t.Errorf("usage=%v", usage) - } -} - -func TestAggregateSkipsNonDataLines(t *testing.T) { - raw := ": comment\n\n" + sseFixture - resp, err := Aggregate(strings.NewReader(raw)) - if err != nil { - t.Fatal(err) - } - msg := resp["choices"].([]any)[0].(map[string]any)["message"].(map[string]any) - if msg["content"] != "你好,世界" { - t.Errorf("content=%q", msg["content"]) - } -} - -func TestAggregateToolCalls(t *testing.T) { - // 流式 tool_calls:首片带 id/type/name + 空 arguments,后续只带 arguments 片段 - raw := `data: {"id":"x1","model":"deepseek-v4-pro","created":1,"choices":[{"index":0,"delta":{"role":"assistant","content":"","tool_calls":[{"id":"call_a","type":"function","function":{"name":"get_weather","arguments":""},"index":0}]}}],"usage":null} - -data: {"id":"x1","choices":[{"index":0,"delta":{"tool_calls":[{"function":{"arguments":"{\"city\":"},"index":0}]}}]} - -data: {"id":"x1","choices":[{"index":0,"delta":{"tool_calls":[{"function":{"arguments":"\"北京\"}"},"index":0}]}}]} - -data: {"id":"x1","choices":[{"index":0,"delta":{},"finish_reason":"tool_calls"}],"usage":{"total_tokens":11}} - -data: [DONE] - -` - resp, err := Aggregate(strings.NewReader(raw)) - if err != nil { - t.Fatal(err) - } - choice := resp["choices"].([]any)[0].(map[string]any) - if choice["finish_reason"] != "tool_calls" { - t.Errorf("finish_reason=%v", choice["finish_reason"]) - } - msg := choice["message"].(map[string]any) - calls, ok := msg["tool_calls"].([]map[string]any) - if !ok || len(calls) != 1 { - t.Fatalf("tool_calls=%#v", msg["tool_calls"]) - } - if calls[0]["id"] != "call_a" || calls[0]["type"] != "function" { - t.Errorf("call meta=%v", calls[0]) - } - fn := calls[0]["function"].(map[string]any) - if fn["name"] != "get_weather" { - t.Errorf("fn.name=%v", fn["name"]) - } - if fn["arguments"] != `{"city":"北京"}` { - t.Errorf("fn.arguments=%q", fn["arguments"]) - } -} - -// TestStripToolCallNames 直测跨帧 name 收敛:首片保留 name、同 index 后续分片删除 -// name 键(空串或重复非空串都删),不同 index 互不串扰,非 tool_calls 帧零影响。 -func TestStripToolCallNames(t *testing.T) { - mkFrame := func(idx float64, name, args string) map[string]any { - fn := map[string]any{} - if name != "" { - fn["name"] = name - } - if args != "" { - fn["arguments"] = args - } - return map[string]any{"choices": []any{ - map[string]any{"delta": map[string]any{"tool_calls": []any{ - map[string]any{"index": idx, "function": fn}, - }}}, - }} - } - getFn := func(f map[string]any) map[string]any { - return f["choices"].([]any)[0].(map[string]any)["delta"].(map[string]any)["tool_calls"].([]any)[0].(map[string]any)["function"].(map[string]any) - } - seen := map[int]bool{} - - // 首片带 name:保留,seen 建立 - f0 := mkFrame(0, "lookup", "") - stripToolCallNames(f0, seen) - if !seen[0] { - t.Fatal("index 0 should be marked seen after first chunk") - } - if getFn(f0)["name"] != "lookup" { - t.Errorf("first chunk name=%v want lookup", getFn(f0)["name"]) - } - - // 后续 chunk name 为空串:删除 name 键 - f1 := mkFrame(0, "", `{"term":"x"}`) - stripToolCallNames(f1, seen) - if _, ok := getFn(f1)["name"]; ok { - t.Errorf("subsequent empty name should be stripped: %#v", getFn(f1)) - } - if getFn(f1)["arguments"] != `{"term":"x"}` { - t.Errorf("arguments altered: %#v", getFn(f1)["arguments"]) - } - - // 后续 chunk 重复非空 name(上游噪声):同样删除,arguments 原样 - f2 := mkFrame(0, "lookup", "y") - stripToolCallNames(f2, seen) - if _, ok := getFn(f2)["name"]; ok { - t.Errorf("subsequent duplicate non-empty name should be stripped: %#v", getFn(f2)) - } - if getFn(f2)["arguments"] != "y" { - t.Errorf("arguments altered: %#v", getFn(f2)["arguments"]) - } - - // 不同 index 互不串扰:index 1 首片保留 name - f3 := mkFrame(1, "other", "") - stripToolCallNames(f3, seen) - if getFn(f3)["name"] != "other" { - t.Errorf("index 1 first name=%v want other", getFn(f3)["name"]) - } - if !seen[1] { - t.Error("index 1 should be marked seen") - } - - // 非 tool_calls 帧(content only)零影响 - f4 := map[string]any{"choices": []any{ - map[string]any{"delta": map[string]any{"content": "hi"}}, - }} - stripToolCallNames(f4, seen) - if got := f4["choices"].([]any)[0].(map[string]any)["delta"].(map[string]any); len(got) != 1 || got["content"] != "hi" { - t.Errorf("content-only frame altered: %#v", got) - } -} - -// TestStreamToolCallNameOnce 11 帧 tool_call:首帧 name=Bash,后续 10 帧不得携带 -// name 键,arguments 逐帧原样透传(issue #82:累加型客户端把每个分片 name 拼接成 -// Bash×帧数;正确行为是 name 只在首帧出现一次)。 -func TestStreamToolCallNameOnce(t *testing.T) { - const nFrames = 11 - var sb strings.Builder - for i := 0; i < nFrames; i++ { - sb.WriteString(`data: {"id":"x1","object":"chat.completion.chunk","created":1,"model":"m","choices":[{"index":0,"delta":{"tool_calls":[{"index":0,"id":"call_a","type":"function","function":{"name":"Bash","arguments":"arg` + string(rune('0'+i)) + `"}}]}}]}`) - sb.WriteString("\n\n") - } - sb.WriteString("data: [DONE]\n\n") - - frames, done := streamFrames(t, sb.String()) - if done != 1 { - t.Fatalf("done=%d want 1", done) - } - if len(frames) != nFrames { - t.Fatalf("frames=%d want %d", len(frames), nFrames) - } - gotName := 0 - for i, fr := range frames { - chs, _ := fr["choices"].([]any) - d, _ := chs[0].(map[string]any)["delta"].(map[string]any) - tcs, _ := d["tool_calls"].([]any) - if len(tcs) != 1 { - t.Fatalf("frame %d tool_calls len=%d want 1", i, len(tcs)) - } - fn, _ := tcs[0].(map[string]any)["function"].(map[string]any) - if _, ok := fn["name"]; ok { - gotName++ - if i != 0 || fn["name"] != "Bash" { - t.Errorf("frame %d unexpected name=%v (name 只能出现在首帧且为 Bash)", i, fn["name"]) - } - } - if want := "arg" + string(rune('0'+i)); fn["arguments"] != want { - t.Errorf("frame %d arguments=%v want %q", i, fn["arguments"], want) - } - } - if gotName != 1 { - t.Errorf("name 出现帧数=%d want 1", gotName) - } -} - -// TestStreamToolCallParallelFragments 多 tool_call(index 0 与 1 并行分片交错下发): -// 每个 index 只保留自己的首帧 name,后续分片互不串扰、arguments 各自原样。 -func TestStreamToolCallParallelFragments(t *testing.T) { - raw := "data: {\"id\":\"x1\",\"object\":\"chat.completion.chunk\",\"created\":0,\"choices\":[{\"index\":0,\"delta\":{\"tool_calls\":[{\"index\":0,\"id\":\"call_0\",\"type\":\"function\",\"function\":{\"name\":\"Bash\",\"arguments\":\"\"}}]}}]}\n\n" + - "data: {\"id\":\"x1\",\"choices\":[{\"index\":0,\"delta\":{\"tool_calls\":[{\"index\":1,\"id\":\"call_1\",\"type\":\"function\",\"function\":{\"name\":\"Read\",\"arguments\":\"\"}}]}}]}\n\n" + - "data: {\"id\":\"x1\",\"choices\":[{\"index\":0,\"delta\":{\"tool_calls\":[{\"index\":0,\"function\":{\"name\":\"Bash\",\"arguments\":\"a0\"}}]}}]}\n\n" + - "data: {\"id\":\"x1\",\"choices\":[{\"index\":0,\"delta\":{\"tool_calls\":[{\"index\":1,\"function\":{\"name\":\"Read\",\"arguments\":\"a1\"}}]}}]}\n\n" + - "data: {\"id\":\"x1\",\"choices\":[{\"index\":0,\"delta\":{},\"finish_reason\":\"tool_calls\"}]}\n\n" + - "data: [DONE]\n\n" - - frames, done := streamFrames(t, raw) - if done != 1 { - t.Fatalf("done=%d want 1", done) - } - - argByIndex := map[int]string{} - nameCount := map[int]int{} - for _, fr := range frames { - chs, _ := fr["choices"].([]any) - d, _ := chs[0].(map[string]any)["delta"].(map[string]any) - tcs, _ := d["tool_calls"].([]any) - for _, tci := range tcs { - tc, _ := tci.(map[string]any) - idx := int(tc["index"].(float64)) - fn, _ := tc["function"].(map[string]any) - if _, ok := fn["name"]; ok { - nameCount[idx]++ - } - if a, _ := fn["arguments"].(string); a != "" { - argByIndex[idx] = a - } - } - } - // 每个 index 恰好出现一次 name,arguments 逐片原样(a0/a1 各自保留) - if nameCount[0] != 1 || nameCount[1] != 1 { - t.Errorf("name 出现次数 index0=%d index1=%d,各 want 1", nameCount[0], nameCount[1]) - } - if argByIndex[0] != "a0" || argByIndex[1] != "a1" { - t.Errorf("arguments index0=%q index1=%q want a0/a1", argByIndex[0], argByIndex[1]) - } -} - -// TestStreamToolCallNoiseEmptyName 上游后续帧带空串 name(噪声形态)→ 输出帧无 name 键。 -// 键缺失是比空串更安全的形态,客户端「键缺失则保留旧值」不会清空工具名。 -func TestStreamToolCallNoiseEmptyName(t *testing.T) { - raw := "data: {\"id\":\"x1\",\"object\":\"chat.completion.chunk\",\"created\":1,\"model\":\"m\",\"choices\":[{\"index\":0,\"delta\":{\"tool_calls\":[{\"index\":0,\"id\":\"call_a\",\"type\":\"function\",\"function\":{\"name\":\"lookup\",\"arguments\":\"\"}}]}}]}\n\n" + - "data: {\"id\":\"x1\",\"choices\":[{\"index\":0,\"delta\":{\"tool_calls\":[{\"index\":0,\"function\":{\"name\":\"\",\"arguments\":\"arg1\"}}]}}]}\n\n" + - "data: {\"id\":\"x1\",\"choices\":[{\"index\":0,\"delta\":{\"tool_calls\":[{\"index\":0,\"function\":{\"name\":\"\",\"arguments\":\"arg2\"}}]}}]}\n\n" + - "data: {\"id\":\"x1\",\"choices\":[{\"index\":0,\"delta\":{},\"finish_reason\":\"tool_calls\"}]}\n\n" + - "data: [DONE]\n\n" - - frames, done := streamFrames(t, raw) - if done != 1 { - t.Fatalf("done=%d want 1", done) - } - for i, fr := range frames { - chs, _ := fr["choices"].([]any) - d, _ := chs[0].(map[string]any)["delta"].(map[string]any) - tcs, _ := d["tool_calls"].([]any) - for _, tci := range tcs { - tc, _ := tci.(map[string]any) - fn, _ := tc["function"].(map[string]any) - if i == 0 { - if fn["name"] != "lookup" { - t.Errorf("frame 0 name=%v want lookup", fn["name"]) - } - continue - } - if _, ok := fn["name"]; ok { - t.Errorf("frame %d: 空串 name 应被剥离为键缺失, got %#v", i, fn) - } - } - } -} - -// TestStreamToolCallOverwriteClientSemantics 覆盖型语义验证:模拟「键缺失则保留旧值」 -// 的覆盖型客户端(name ?? state.name / if (name) state.name = name),在输出流上逐帧 -// 重建 name,最终必须收敛为 Bash——证明键缺失形态不会清空工具名。 -func TestStreamToolCallOverwriteClientSemantics(t *testing.T) { - raw := "data: {\"id\":\"x1\",\"object\":\"chat.completion.chunk\",\"created\":1,\"model\":\"m\",\"choices\":[{\"index\":0,\"delta\":{\"tool_calls\":[{\"index\":0,\"id\":\"call_a\",\"type\":\"function\",\"function\":{\"name\":\"Bash\",\"arguments\":\"\"}}]}}]}\n\n" + - "data: {\"id\":\"x1\",\"choices\":[{\"index\":0,\"delta\":{\"tool_calls\":[{\"index\":0,\"function\":{\"name\":\"\",\"arguments\":\"{\\\"cmd\\\":\\\"ls\\\"}\"}}]}}]}\n\n" + - "data: {\"id\":\"x1\",\"choices\":[{\"index\":0,\"delta\":{\"tool_calls\":[{\"index\":0,\"function\":{\"name\":\"Bash\",\"arguments\":\"\"}}]}}]}\n\n" + - "data: [DONE]\n\n" - - frames, done := streamFrames(t, raw) - if done != 1 { - t.Fatalf("done=%d want 1", done) - } - state := map[int]string{} - reconstructed := map[int]string{} - for _, fr := range frames { - chs, _ := fr["choices"].([]any) - d, _ := chs[0].(map[string]any)["delta"].(map[string]any) - tcs, _ := d["tool_calls"].([]any) - for _, tci := range tcs { - tc, _ := tci.(map[string]any) - idx := int(tc["index"].(float64)) - fn, _ := tc["function"].(map[string]any) - // 覆盖型语义:键缺失 → ?? 保留旧值;非空 name → 覆盖。 - if name, ok := fn["name"]; ok { - state[idx] = name.(string) - } - if state[idx] != "" { - reconstructed[idx] = state[idx] - } - } - } - // 覆盖型客户端重建后最终 name 必须是 Bash(首帧建立,后续空/重复分片均不破坏)。 - if len(reconstructed) != 1 || reconstructed[0] != "Bash" { - t.Errorf("覆盖型重建 name=%v want map[0:Bash]", reconstructed) - } -} - -// streamFrames 把原始 SSE 输入经 Stream 处理后解析出所有 JSON 帧及 [DONE] 计数。 -func streamFrames(t *testing.T, raw string) (frames []map[string]any, doneCount int) { - t.Helper() - rec := httptest.NewRecorder() - if err := Stream(rec, strings.NewReader(raw)); err != nil { - t.Fatal(err) - } - body := rec.Body.String() - for _, ln := range strings.Split(body, "\n") { - ln = strings.TrimSpace(ln) - if strings.HasPrefix(ln, "data: [DONE]") { - doneCount++ - continue - } - if strings.HasPrefix(ln, "data: ") { - var obj map[string]any - if err := json.Unmarshal([]byte(strings.TrimPrefix(ln, "data: ")), &obj); err != nil { - t.Fatalf("bad frame %q: %v", ln, err) - } - frames = append(frames, obj) - } - } - return frames, doneCount -} - -func TestNormalizeFrame(t *testing.T) { - cases := []struct { - name string - in map[string]any - want string // 规范化后 marshal 的期望 JSON(Go map 键按字典序输出) - }{ - {"empty content/refusal and finish_reason empty string", - map[string]any{"id": "x", "choices": []any{ - map[string]any{"index": 0, "delta": map[string]any{"content": "", "refusal": ""}, "finish_reason": ""}, - }}, - `{"choices":[{"delta":{},"finish_reason":null,"index":0}],"id":"x","object":"chat.completion.chunk","usage":null}`}, - {"non-empty tool_calls kept", - map[string]any{"choices": []any{ - map[string]any{"index": 0, "delta": map[string]any{"tool_calls": []any{map[string]any{"id": "c1", "type": "function"}}}}, - }}, - `{"choices":[{"delta":{"tool_calls":[{"id":"c1","type":"function"}]},"finish_reason":null,"index":0}],"id":"chatcmpl-wb2api","object":"chat.completion.chunk","usage":null}`}, - {"empty tool_calls list dropped", - map[string]any{"choices": []any{ - map[string]any{"index": 0, "delta": map[string]any{"tool_calls": []any{}, "content": "hi"}}, - }}, - `{"choices":[{"delta":{"content":"hi"},"finish_reason":null,"index":0}],"id":"chatcmpl-wb2api","object":"chat.completion.chunk","usage":null}`}, - {"empty placeholder function_call dropped", - map[string]any{"choices": []any{ - map[string]any{"index": 0, "delta": map[string]any{"function_call": map[string]any{"name": "", "arguments": ""}}}, - }}, - `{"choices":[{"delta":{},"finish_reason":null,"index":0}],"id":"chatcmpl-wb2api","object":"chat.completion.chunk","usage":null}`}, - {"top-level unknown fields dropped, usage null when absent", - map[string]any{"id": "x", "object": "chat.completion.chunk", "created": 1, "junk": "noise", "choices": []any{ - map[string]any{"index": 0, "delta": map[string]any{}, "finish_reason": "stop"}, - }}, - `{"choices":[{"delta":{},"finish_reason":"stop","index":0}],"created":1,"id":"x","object":"chat.completion.chunk","usage":null}`}, - } - for _, c := range cases { - t.Run(c.name, func(t *testing.T) { - raw, err := json.Marshal(normalizeFrame(c.in)) - if err != nil { - t.Fatal(err) - } - if string(raw) != c.want { - t.Errorf("got %s\nwant %s", raw, c.want) - } - }) - } -} - -func TestStreamNormalizesFrames(t *testing.T) { - // 混合噪声帧:空 content/reasoning/refusal/function_call + 空 tool_calls + 顶层非标字段, - // 随后非空 content + tool_calls 帧,最后 finish/usage 帧。 - raw := "data: {\"id\":\"x1\",\"object\":\"chat.completion.chunk\",\"created\":1,\"model\":\"m\",\"choices\":[{\"index\":0,\"delta\":{\"role\":\"assistant\",\"content\":\"\",\"reasoning_content\":\"\",\"refusal\":\"\",\"tool_calls\":[],\"function_call\":{\"name\":\"\",\"arguments\":\"\"}},\"finish_reason\":\"\"}],\"extra_field\":\"junk\"}\n\n" + - "data: {\"id\":\"x1\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"hello\",\"tool_calls\":[{\"id\":\"call_1\",\"type\":\"function\",\"function\":{\"name\":\"get_weather\",\"arguments\":\"{\\\"city\\\":\\\"北京\\\"}\"},\"index\":0}]},\"finish_reason\":\"\"}]}\n\n" + - "data: {\"id\":\"x1\",\"choices\":[{\"index\":0,\"delta\":{},\"finish_reason\":\"stop\"}],\"usage\":{\"total_tokens\":7}}\n\n" + - "data: [DONE]\n\n" - - frames, done := streamFrames(t, raw) - if done != 1 { - t.Fatalf("done frames=%d want 1", done) - } - if len(frames) != 3 { - t.Fatalf("frames=%d want 3", len(frames)) - } - - // 帧 1:噪声全剔除,finish_reason ""→null,usage 缺失→null,顶层非标字段剥除 - f0 := frames[0] - if _, ok := f0["extra_field"]; ok { - t.Error("top-level extra_field should be dropped") - } - if f0["usage"] != nil { - t.Errorf("usage should be null when absent, got %v", f0["usage"]) - } - ch0 := f0["choices"].([]any)[0].(map[string]any) - if ch0["finish_reason"] != nil { - t.Errorf("frame1 finish_reason=%v want null", ch0["finish_reason"]) - } - d := ch0["delta"].(map[string]any) - // role 是合法白名单键保留;空 content/reasoning/refusal/tool_calls/function_call 噪声全剔除 - if len(d) != 1 || d["role"] != "assistant" { - t.Errorf("frame1 delta should only keep role, got %#v", d) - } - for _, noise := range []string{"content", "reasoning_content", "refusal", "tool_calls", "function_call"} { - if _, ok := d[noise]; ok { - t.Errorf("frame1 delta should drop %q, got %#v", noise, d) - } - } - - // 帧 2:非空 content 与 tool_calls 保留,finish_reason ""→null - f1 := frames[1] - ch1 := f1["choices"].([]any)[0].(map[string]any) - d1 := ch1["delta"].(map[string]any) - if d1["content"] != "hello" { - t.Errorf("frame2 content=%v", d1["content"]) - } - tcs, ok := d1["tool_calls"].([]any) - if !ok || len(tcs) != 1 { - t.Fatalf("frame2 tool_calls=%#v", d1["tool_calls"]) - } - if ch1["finish_reason"] != nil { - t.Errorf("frame2 finish_reason=%v want null (input empty string)", ch1["finish_reason"]) - } - - // 帧 3:finish_reason 非空保留,usage 保留 - f2 := frames[2] - ch2 := f2["choices"].([]any)[0].(map[string]any) - if ch2["finish_reason"] != "stop" { - t.Errorf("frame3 finish_reason=%v want stop", ch2["finish_reason"]) - } - if f2["usage"].(map[string]any)["total_tokens"].(float64) != 7 { - t.Errorf("frame3 usage=%v", f2["usage"]) - } -} - -// TestStreamFirstIdPassthrough 帧混合(首帧有 id / 中间帧无 id / 空串 id):输出每帧 id -// 必须连续一致(取首帧真实值),不再一律 chatcmpl-wb2api(issue #35 后台聚合:透传流里 -// 每帧同 id 才能按消息归并)。 -func TestStreamFirstIdPassthrough(t *testing.T) { - raw := "data: {\"id\":\"chatcmpl-upstream-9\",\"object\":\"chat.completion.chunk\",\"created\":1,\"model\":\"m\",\"choices\":[{\"index\":0,\"delta\":{\"role\":\"assistant\",\"content\":\"hello\"}}]}\n\n" + - // 中间帧无 id:应复用首帧 id。 - "data: {\"object\":\"chat.completion.chunk\",\"created\":1,\"choices\":[{\"index\":0,\"delta\":{\"content\":\" world\"}}]}\n\n" + - // 中间帧 id 为空串:同样复用首帧 id。 - "data: {\"id\":\"\",\"object\":\"chat.completion.chunk\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"!\"},\"finish_reason\":\"stop\"}]}\n\n" + - "data: [DONE]\n\n" - - frames, done := streamFrames(t, raw) - if done != 1 { - t.Fatalf("done=%d want 1", done) - } - if len(frames) != 3 { - t.Fatalf("frames=%d want 3", len(frames)) - } - for i, fr := range frames { - if got := fr["id"]; got != "chatcmpl-upstream-9" { - t.Errorf("frame %d id=%v want chatcmpl-upstream-9 (首帧真实 id 续传)", i, got) - } - } -} - -// TestStreamNoIdFallsBackToSentinel 全流无任何真实 id → 兜底 chatcmpl-wb2api -// (整流无 id 时的既有哨兵,帧与帧之间仍一惯性存在)。 -func TestStreamNoIdFallsBackToSentinel(t *testing.T) { - raw := "data: {\"object\":\"chat.completion.chunk\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"hi\"}}]}\n\n" + - "data: {\"object\":\"chat.completion.chunk\",\"choices\":[{\"index\":0,\"delta\":{}," + - "\"finish_reason\":\"stop\"}]}\n\n" + - "data: [DONE]\n\n" - frames, _ := streamFrames(t, raw) - if len(frames) != 2 { - t.Fatalf("frames=%d want 2", len(frames)) - } - for i, fr := range frames { - if got := fr["id"]; got != "chatcmpl-wb2api" { - t.Errorf("frame %d id=%v want sentinel chatcmpl-wb2api (无真实 id)", i, got) - } - } -} - -func TestStreamDoneFallback(t *testing.T) { - // 上游流在无 [DONE] 时 EOF,Stream 必须兜底写一个 [DONE] - rec := httptest.NewRecorder() - err := Stream(rec, strings.NewReader("data: {\"id\":\"x1\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"hi\"}}]}\n\n")) - if err != nil { - t.Fatal(err) - } - body := rec.Body.String() - if !strings.HasSuffix(strings.TrimRight(body, "\n"), "data: [DONE]") { - t.Errorf("missing [DONE] fallback: %q", body) - } - - // 已有 [DONE] 时只写一次,不重复 - rec2 := httptest.NewRecorder() - if err := Stream(rec2, strings.NewReader("data: {\"id\":\"x1\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"hi\"}}]}\n\ndata: [DONE]\n\n")); err != nil { - t.Fatal(err) - } - if n := strings.Count(rec2.Body.String(), "data: [DONE]"); n != 1 { - t.Errorf("[DONE] count=%d want 1: %q", n, rec2.Body.String()) - } -} - -func TestStreamPassthrough(t *testing.T) { - rec := httptest.NewRecorder() - err := Stream(rec, strings.NewReader(sseFixture)) - if err != nil { - t.Fatal(err) - } - body := rec.Body.String() - if !strings.Contains(body, "你好") || !strings.Contains(body, "data: [DONE]") { - t.Errorf("body missing chunks: %q", body) - } - // 逐行仍是合法 SSE(每行以 data: 开头或是空行) - for _, ln := range strings.Split(strings.TrimRight(body, "\n"), "\n") { - if ln != "" && !strings.HasPrefix(ln, "data: ") { - t.Errorf("bad line: %q", ln) - } - } - ct := rec.Header().Get("Content-Type") - if !strings.Contains(ct, "text/event-stream") { - t.Errorf("content-type=%q", ct) - } -} - -// TestAggregateEmptyStreamCases 覆盖空流检测:0 有效事件必须报错、[DONE] 即 break、 -// [DONE] 后垃圾不进聚合、正常聚合回归。 -func TestAggregateEmptyStreamCases(t *testing.T) { - // 正常回归基流:content + finish_reason + usage,[DONE] 收尾。 - valid := "data: {\"id\":\"c1\",\"object\":\"chat.completion.chunk\",\"created\":1,\"model\":\"glm-5.2\",\"choices\":[{\"index\":0,\"delta\":{\"role\":\"assistant\",\"content\":\"hi\"}}]}\n\n" + - "data: {\"id\":\"c1\",\"choices\":[{\"index\":0,\"delta\":{},\"finish_reason\":\"stop\"}],\"usage\":{\"total_tokens\":7}}\n\n" + - "data: [DONE]\n\n" - - cases := []struct { - name string - raw string - wantErr bool - // 回归断言(仅在 wantErr=false 时校验) - wantContent string - wantUsage float64 - }{ - { - name: "空流(EOF 即止)", - raw: "", - wantErr: true, - }, - { - name: "只有注释行和空行加 DONE", - raw: ": comment\n\n: another comment\n\ndata: [DONE]\n\n", - wantErr: true, - }, - { - name: "DONE 后跟垃圾帧不进聚合", - raw: valid[:len(valid)-len("data: [DONE]\n\n")] + "data: [DONE]\n\ndata: {\"junk\":\"should not aggregate\"}\n\n", - wantErr: false, - // 与 valid 基流一致的聚合期望 - wantContent: "hi", - wantUsage: 7, - }, - { - name: "正常流回归", - raw: valid, - wantErr: false, - wantContent: "hi", - wantUsage: 7, - }, - } - for _, c := range cases { - t.Run(c.name, func(t *testing.T) { - resp, err := Aggregate(strings.NewReader(c.raw)) - if c.wantErr { - if err == nil { - t.Fatalf("expected error, got nil (resp=%v)", resp) - } - return - } - if err != nil { - t.Fatal(err) - } - msg := resp["choices"].([]any)[0].(map[string]any)["message"].(map[string]any) - if msg["content"] != c.wantContent { - t.Errorf("content=%q want %q", msg["content"], c.wantContent) - } - if u, ok := resp["usage"].(map[string]any); ok { - if u["total_tokens"].(float64) != c.wantUsage { - t.Errorf("usage=%v want %v", u["total_tokens"], c.wantUsage) - } - } else { - t.Errorf("usage missing") - } - }) - } -} - -// TestAggregateEmptyStreamError 校验空流错误信息形如约定文案。 -func TestAggregateEmptyStreamError(t *testing.T) { - _, err := Aggregate(strings.NewReader("")) - if err == nil || !strings.Contains(err.Error(), "no valid data events") { - t.Fatalf("err=%v", err) - } -} - -// TestStreamEmptyFramesCase 覆盖流式空流检测:0 有效帧时写 error 帧(error 字段存活), -// 恰好一个 [DONE],并返回非 nil error。 -func TestStreamEmptyFramesCase(t *testing.T) { - cases := []struct { - name string - raw string - }{ - {"空流", ""}, - {"只有注释行", ": comment\n\n"}, - {"只有 DONE", "data: [DONE]\n\n"}, - } - for _, c := range cases { - t.Run(c.name, func(t *testing.T) { - rec := httptest.NewRecorder() - err := Stream(rec, strings.NewReader(c.raw)) - if err == nil { - t.Fatalf("expected error, got nil") - } - body := rec.Body.String() - if n := strings.Count(body, "data: [DONE]"); n != 1 { - t.Errorf("[DONE] count=%d want 1: %q", n, body) - } - // error 帧必须原样保留 error 字段(未被 normalizeFrame 白名单剥掉) - var e map[string]any - found := false - for _, ln := range strings.Split(body, "\n") { - ln = strings.TrimSpace(ln) - if strings.HasPrefix(ln, "data: ") { - payload := strings.TrimPrefix(ln, "data: ") - if payload == "[DONE]" { - continue - } - if json.Unmarshal([]byte(payload), &e) == nil { - if em, ok := e["error"].(map[string]any); ok && em["message"] == "empty upstream stream" && em["type"] == "upstream_error" { - found = true - } - } - } - } - if !found { - t.Errorf("error frame absent or error field stripped: %q", body) - } - }) - } -} - -// TestStreamGarbageAfterDone 校验 DONE 之后的垃圾帧不出现在响应里。 -func TestStreamGarbageAfterDone(t *testing.T) { - raw := "data: {\"id\":\"x1\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"hello\"}}]}\n\n" + - "data: [DONE]\n\n" + - "data: {\"should\":\"not appear\"}\n\n" - rec := httptest.NewRecorder() - if err := Stream(rec, strings.NewReader(raw)); err != nil { - t.Fatal(err) - } - body := rec.Body.String() - if strings.Contains(body, "should") { - t.Errorf("garbage after DONE leaked into response: %q", body) - } - if n := strings.Count(body, "data: [DONE]"); n != 1 { - t.Errorf("[DONE] count=%d want 1: %q", n, body) - } - // 有效帧仍被透传 - if !strings.Contains(body, "hello") { - t.Errorf("valid frame missing: %q", body) - } -} - -// TestStreamNormalPassthroughRegression 校验正常透传回归:帧被 normalize 后透传、 -// 末尾恰好一个 [DONE]、无 error 帧;上游漏发 DONE 时自动补。 -func TestStreamNormalPassthroughRegression(t *testing.T) { - cases := []struct { - name string - raw string - }{ - {"带 DONE 的正常流", sseFixture}, - {"漏发 DONE 自动补", "data: {\"id\":\"x1\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"hi\"}}]}\n\n"}, - } - for _, c := range cases { - t.Run(c.name, func(t *testing.T) { - rec := httptest.NewRecorder() - if err := Stream(rec, strings.NewReader(c.raw)); err != nil { - t.Fatal(err) - } - body := rec.Body.String() - if strings.Contains(body, `"error"`) { - t.Errorf("unexpected error frame: %q", body) - } - if n := strings.Count(body, "data: [DONE]"); n != 1 { - t.Errorf("[DONE] count=%d want 1: %q", n, body) - } - // 帧被规范化:含 "id" 且有标准 object 字段 - if !strings.Contains(body, `"object":"chat.completion.chunk"`) { - t.Errorf("frame not normalized: %q", body) - } - }) - } -} - -// TestNormalizeUsageCacheAliasesMirrorsNestedHit / PreservesZeroResult 自 -// usage_test.go 迁入(PR #57 原新文件按仓库规则不收,核心断言保留在此—— -// normalize 钩子就挂在 sse.go 的 Aggregate/normalizeFrame 两个出口)。 -func TestNormalizeUsageCacheAliasesMirrorsNestedHit(t *testing.T) { - usage := map[string]any{ - "prompt_tokens": 21041.0, - "completion_tokens": 8.0, - "total_tokens": 21049.0, - "cache_read_input_tokens": 0.0, - "cached_tokens": 0.0, - "prompt_cache_hit_tokens": 0.0, - "prompt_cache_miss_tokens": 177.0, - "prompt_tokens_details": map[string]any{ - "cached_tokens": 20864.0, - }, - } - - got := normalizeUsageCacheAliases(usage) - - for _, key := range []string{ - "cache_read_input_tokens", - "cached_tokens", - "prompt_cache_hit_tokens", - } { - if got[key] != 20864.0 { - t.Fatalf("%s=%v want 20864", key, got[key]) - } - } - details := got["prompt_tokens_details"].(map[string]any) - if details["cached_tokens"] != 20864.0 { - t.Fatalf("prompt_tokens_details.cached_tokens=%v want 20864", details["cached_tokens"]) - } -} - -func TestNormalizeUsageCacheAliasesPreservesZeroResult(t *testing.T) { - usage := map[string]any{ - "prompt_tokens": 35.0, - "completion_tokens": 2.0, - "total_tokens": 37.0, - "cache_read_input_tokens": 0.0, - "prompt_cache_hit_tokens": 0.0, - "prompt_tokens_details": map[string]any{ - "cached_tokens": 0.0, - }, - } - - got := normalizeUsageCacheAliases(usage) - - details := got["prompt_tokens_details"].(map[string]any) - if details["cached_tokens"] != 0.0 { - t.Fatalf("prompt_tokens_details.cached_tokens=%v want 0", details["cached_tokens"]) - } -} - -// TestStreamHintErrorFrameObserver 上游 error 帧必须旁路通知观察者(账号处置挂载点), -// 且透传字节不变——error 帧原文(code/msg/requestId)照常到达客户端。 -// 正常数据帧不得触发观察者。移植自 OkRoromori 分支的 WithErrorFrameObserver。 -func TestStreamHintErrorFrameObserver(t *testing.T) { - const errPayload = `{"error":{"code":6004,"message":"模型限流,将在 2026-09-27 01:00:00 重置"}}` - raw := "data: {\"id\":\"x1\",\"object\":\"chat.completion.chunk\",\"created\":1,\"model\":\"m\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"hi\"}}]}\n\n" + - "data: " + errPayload + "\n\n" + - "data: [DONE]\n\n" - - var observed []string - rec := httptest.NewRecorder() - if err := StreamHint(rec, strings.NewReader(raw), nil, WithErrorFrameObserver(func(payload string) { - observed = append(observed, payload) - })); err != nil { - t.Fatal(err) - } - - if len(observed) != 1 || observed[0] != errPayload { - t.Fatalf("观察者回调 = %v want [%s]", observed, errPayload) - } - // 透传字节不变:error 帧原文必须仍在响应里(error-passthrough 语义)。 - if !strings.Contains(rec.Body.String(), "6004") { - t.Fatalf("error 帧原文未透传: %s", rec.Body.String()) - } - - // 正常流(无 error 帧):观察者零回调。 - var normalObserved int - raw2 := "data: {\"id\":\"x2\",\"object\":\"chat.completion.chunk\",\"created\":1,\"model\":\"m\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"ok\"}}]}\n\n" + - "data: [DONE]\n\n" - rec2 := httptest.NewRecorder() - if err := StreamHint(rec2, strings.NewReader(raw2), nil, WithErrorFrameObserver(func(payload string) { - normalObserved++ - })); err != nil { - t.Fatal(err) - } - if normalObserved != 0 { - t.Fatalf("正常流触发了观察者 %d 次,want 0", normalObserved) - } -} - -func TestUserResourceDetailedWithExpirySnapshot(t *testing.T) { - now := time.Now().In(softRateResetLoc) - soon := now.Add(24 * time.Hour).Truncate(time.Second) - later := now.Add(10 * 24 * time.Hour).Truncate(time.Second) - payload := `{"code":0,"data":{"Response":{"Data":{"Accounts":[` + - `{"PackageName":"soon-a","CycleCapacitySize":10,"CycleCapacityRemain":10,"CycleCapacityUsed":0,"CycleEndTime":"` + soon.Format(packageEndLayout) + `"},` + - `{"PackageName":"soon-b","CycleCapacitySize":15,"CycleCapacityRemain":15,"CycleCapacityUsed":0,"CycleEndTime":"` + soon.Format(packageEndLayout) + `"},` + - `{"PackageName":"later","CycleCapacitySize":20,"CycleCapacityRemain":20,"CycleCapacityUsed":0,"CycleEndTime":"` + later.Format(packageEndLayout) + `"},` + - `{"PackageName":"unknown","CycleCapacitySize":5,"CycleCapacityRemain":5,"CycleCapacityUsed":0}` + - `]}}}}` - c := testClient(func(r *http.Request) (*http.Response, error) { - if !strings.HasSuffix(r.URL.Path, "/v2/billing/meter/get-user-resource") { - return nil, errors.New("wrong path: " + r.URL.Path) - } - return jsonResp(200, payload), nil - }) - - remain, total, expiring, earliestAt, earliestRemaining, err := c.UserResourceDetailedWithExpiry( - &auth.Auth{AccessToken: "at", UID: "u1"}, 48*time.Hour, - ) - if err != nil { - t.Fatalf("resource: %v", err) - } - if remain != 50 || total != 50 || expiring != 25 { - t.Fatalf("remain/total/expiring=%d/%d/%d want 50/50/25", remain, total, expiring) - } - if earliestRemaining != 25 || !earliestAt.Equal(soon) { - t.Fatalf("earliest=%v/%d want %v/25", earliestAt, earliestRemaining, soon) - } -} -func TestCreditPackagesExpiryTimestamp(t *testing.T) { - end := time.Now().In(softRateResetLoc).Add(7 * 24 * time.Hour).Truncate(time.Second) - c := testClient(func(r *http.Request) (*http.Response, error) { - if !strings.HasSuffix(r.URL.Path, "/v2/billing/meter/get-user-resource") { - return nil, errors.New("wrong path: " + r.URL.Path) - } - return jsonResp(200, `{"code":0,"data":{"Response":{"Data":{"Accounts":[`+ - `{"PackageName":"gift","CycleCapacitySize":100,"CycleCapacityRemain":80,"CycleCapacityUsed":20,"CycleEndTime":"`+ - end.Format(packageEndLayout)+`"},`+ - `{"PackageName":"unknown","CycleCapacitySize":10,"CycleCapacityRemain":10,"CycleCapacityUsed":0}`+ - `]}}}}`), nil - }) - packs, remain, size, err := c.CreditPackages(&auth.Auth{AccessToken: "at", UID: "u1"}) - if err != nil { - t.Fatalf("packages: %v", err) - } - if remain != 90 || size != 110 { - t.Fatalf("remain/size=%d/%d want 90/110", remain, size) - } - var found bool - for _, p := range packs { - if p.Name == "gift" { - found = p.ExpiresAt == end.UnixMilli() - } - } - if !found { - t.Fatalf("gift pack missing Unix-ms expiry: %+v", packs) - } -} +package upstream + +import ( + "encoding/json" + "errors" + "fmt" + "net/http" + "net/http/httptest" + "strings" + "testing" + "time" + + "github.com/misakano7545/workbuddy2api-panel/internal/auth" +) + +func TestPrepareBodyForcesStream(t *testing.T) { + out := PrepareBodyOpt([]byte(`{"model":"glm-5.2","messages":[]}`), true) + var m map[string]any + json.Unmarshal(out, &m) + if m["stream"] != true { + t.Errorf("stream=%v", m["stream"]) + } +} + +func TestPrepareBodyToolChoiceFunctionObject(t *testing.T) { + out := PrepareBodyOpt([]byte(`{"tool_choice":{"type":"function","function":{"name":"get_weather"}},"tools":[{"type":"function"}]}`), true) + var m map[string]any + json.Unmarshal(out, &m) + if m["tool_choice"] != "get_weather" { + t.Errorf("tool_choice=%v", m["tool_choice"]) + } + if _, ok := m["tools"]; !ok { + t.Error("tools should be kept for function choice") + } +} + +func TestPrepareBodyToolChoiceNone(t *testing.T) { + for _, in := range []string{ + `{"tool_choice":"none","tools":[{}],"functions":[{}]}`, + `{"tool_choice":{"type":"none"},"tools":[{}]}`, + } { + out := PrepareBodyOpt([]byte(in), true) + var m map[string]any + json.Unmarshal(out, &m) + if _, ok := m["tool_choice"]; ok { + t.Errorf("%s: tool_choice should be deleted", in) + } + if _, ok := m["tools"]; ok { + t.Errorf("%s: tools should be deleted", in) + } + if _, ok := m["functions"]; ok { + t.Errorf("%s: functions should be deleted", in) + } + } +} + +func TestPrepareBodyToolChoiceAuto(t *testing.T) { + out := PrepareBodyOpt([]byte(`{"tool_choice":{"type":"auto"}}`), true) + var m map[string]any + json.Unmarshal(out, &m) + if m["tool_choice"] != "auto" { + t.Errorf("tool_choice=%v", m["tool_choice"]) + } +} + +func TestPrepareBodyInvalidJSON(t *testing.T) { + in := []byte(`{broken`) + out := PrepareBodyOpt(in, true) + if string(out) != string(in) { + t.Error("invalid json should pass through unchanged") + } +} + +const sseFixture = "data: {\"id\":\"chatcmpl-1\",\"object\":\"chat.completion.chunk\",\"created\":1753600000,\"model\":\"glm-5.2\",\"choices\":[{\"index\":0,\"delta\":{\"role\":\"assistant\",\"content\":\"你好\"}}]}\n\n" + + "data: {\"id\":\"chatcmpl-1\",\"object\":\"chat.completion.chunk\",\"created\":1753600000,\"model\":\"glm-5.2\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\",世界\"}}]}\n\n" + + "data: {\"id\":\"chatcmpl-1\",\"object\":\"chat.completion.chunk\",\"created\":1753600000,\"model\":\"glm-5.2\",\"choices\":[{\"index\":0,\"delta\":{},\"finish_reason\":\"stop\"}],\"usage\":{\"prompt_tokens\":5,\"completion_tokens\":2,\"total_tokens\":7}}\n\n" + + "data: [DONE]\n\n" + +func TestAggregate(t *testing.T) { + resp, err := Aggregate(strings.NewReader(sseFixture)) + if err != nil { + t.Fatal(err) + } + if resp["object"] != "chat.completion" { + t.Errorf("object=%v", resp["object"]) + } + if resp["model"] != "glm-5.2" { + t.Errorf("model=%v", resp["model"]) + } + choices := resp["choices"].([]any) + msg := choices[0].(map[string]any)["message"].(map[string]any) + if msg["content"] != "你好,世界" { + t.Errorf("content=%q", msg["content"]) + } + if msg["role"] != "assistant" { + t.Errorf("role=%v", msg["role"]) + } + if choices[0].(map[string]any)["finish_reason"] != "stop" { + t.Errorf("finish_reason=%v", choices[0].(map[string]any)["finish_reason"]) + } + usage := resp["usage"].(map[string]any) + if usage["total_tokens"].(float64) != 7 { + t.Errorf("usage=%v", usage) + } +} + +func TestAggregateSkipsNonDataLines(t *testing.T) { + raw := ": comment\n\n" + sseFixture + resp, err := Aggregate(strings.NewReader(raw)) + if err != nil { + t.Fatal(err) + } + msg := resp["choices"].([]any)[0].(map[string]any)["message"].(map[string]any) + if msg["content"] != "你好,世界" { + t.Errorf("content=%q", msg["content"]) + } +} + +func TestAggregateToolCalls(t *testing.T) { + // 流式 tool_calls:首片带 id/type/name + 空 arguments,后续只带 arguments 片段 + raw := `data: {"id":"x1","model":"deepseek-v4-pro","created":1,"choices":[{"index":0,"delta":{"role":"assistant","content":"","tool_calls":[{"id":"call_a","type":"function","function":{"name":"get_weather","arguments":""},"index":0}]}}],"usage":null} + +data: {"id":"x1","choices":[{"index":0,"delta":{"tool_calls":[{"function":{"arguments":"{\"city\":"},"index":0}]}}]} + +data: {"id":"x1","choices":[{"index":0,"delta":{"tool_calls":[{"function":{"arguments":"\"北京\"}"},"index":0}]}}]} + +data: {"id":"x1","choices":[{"index":0,"delta":{},"finish_reason":"tool_calls"}],"usage":{"total_tokens":11}} + +data: [DONE] + +` + resp, err := Aggregate(strings.NewReader(raw)) + if err != nil { + t.Fatal(err) + } + choice := resp["choices"].([]any)[0].(map[string]any) + if choice["finish_reason"] != "tool_calls" { + t.Errorf("finish_reason=%v", choice["finish_reason"]) + } + msg := choice["message"].(map[string]any) + calls, ok := msg["tool_calls"].([]map[string]any) + if !ok || len(calls) != 1 { + t.Fatalf("tool_calls=%#v", msg["tool_calls"]) + } + if calls[0]["id"] != "call_a" || calls[0]["type"] != "function" { + t.Errorf("call meta=%v", calls[0]) + } + fn := calls[0]["function"].(map[string]any) + if fn["name"] != "get_weather" { + t.Errorf("fn.name=%v", fn["name"]) + } + if fn["arguments"] != `{"city":"北京"}` { + t.Errorf("fn.arguments=%q", fn["arguments"]) + } +} + +// TestStripToolCallNames 直测跨帧 name 收敛:首片保留 name、同 index 后续分片删除 +// name 键(空串或重复非空串都删),不同 index 互不串扰,非 tool_calls 帧零影响。 +func TestStripToolCallNames(t *testing.T) { + mkFrame := func(idx float64, name, args string) map[string]any { + fn := map[string]any{} + if name != "" { + fn["name"] = name + } + if args != "" { + fn["arguments"] = args + } + return map[string]any{"choices": []any{ + map[string]any{"delta": map[string]any{"tool_calls": []any{ + map[string]any{"index": idx, "function": fn}, + }}}, + }} + } + getFn := func(f map[string]any) map[string]any { + return f["choices"].([]any)[0].(map[string]any)["delta"].(map[string]any)["tool_calls"].([]any)[0].(map[string]any)["function"].(map[string]any) + } + seen := map[string]bool{} + + // 首片带 name:保留,seen 建立 + f0 := mkFrame(0, "lookup", "") + stripToolCallNames(f0, seen) + if !seen["i:0"] { + t.Fatal("index 0 should be marked seen after first chunk") + } + if getFn(f0)["name"] != "lookup" { + t.Errorf("first chunk name=%v want lookup", getFn(f0)["name"]) + } + + // 后续 chunk name 为空串:删除 name 键 + f1 := mkFrame(0, "", `{"term":"x"}`) + stripToolCallNames(f1, seen) + if _, ok := getFn(f1)["name"]; ok { + t.Errorf("subsequent empty name should be stripped: %#v", getFn(f1)) + } + if getFn(f1)["arguments"] != `{"term":"x"}` { + t.Errorf("arguments altered: %#v", getFn(f1)["arguments"]) + } + + // 后续 chunk 重复非空 name(上游噪声):同样删除,arguments 原样 + f2 := mkFrame(0, "lookup", "y") + stripToolCallNames(f2, seen) + if _, ok := getFn(f2)["name"]; ok { + t.Errorf("subsequent duplicate non-empty name should be stripped: %#v", getFn(f2)) + } + if getFn(f2)["arguments"] != "y" { + t.Errorf("arguments altered: %#v", getFn(f2)["arguments"]) + } + + // 不同 index 互不串扰:index 1 首片保留 name + f3 := mkFrame(1, "other", "") + stripToolCallNames(f3, seen) + if getFn(f3)["name"] != "other" { + t.Errorf("index 1 first name=%v want other", getFn(f3)["name"]) + } + if !seen["i:1"] { + t.Error("index 1 should be marked seen") + } + + // 非 tool_calls 帧(content only)零影响 + f4 := map[string]any{"choices": []any{ + map[string]any{"delta": map[string]any{"content": "hi"}}, + }} + stripToolCallNames(f4, seen) + if got := f4["choices"].([]any)[0].(map[string]any)["delta"].(map[string]any); len(got) != 1 || got["content"] != "hi" { + t.Errorf("content-only frame altered: %#v", got) + } +} + +// TestStreamToolCallNameOnce 11 帧 tool_call:首帧 name=Bash,后续 10 帧不得携带 +// name 键,arguments 逐帧原样透传(issue #82:累加型客户端把每个分片 name 拼接成 +// Bash×帧数;正确行为是 name 只在首帧出现一次)。 +func TestStreamToolCallNameOnce(t *testing.T) { + const nFrames = 11 + var sb strings.Builder + for i := 0; i < nFrames; i++ { + sb.WriteString(`data: {"id":"x1","object":"chat.completion.chunk","created":1,"model":"m","choices":[{"index":0,"delta":{"tool_calls":[{"index":0,"id":"call_a","type":"function","function":{"name":"Bash","arguments":"arg` + string(rune('0'+i)) + `"}}]}}]}`) + sb.WriteString("\n\n") + } + sb.WriteString("data: [DONE]\n\n") + + frames, done := streamFrames(t, sb.String()) + if done != 1 { + t.Fatalf("done=%d want 1", done) + } + if len(frames) != nFrames { + t.Fatalf("frames=%d want %d", len(frames), nFrames) + } + gotName := 0 + for i, fr := range frames { + chs, _ := fr["choices"].([]any) + d, _ := chs[0].(map[string]any)["delta"].(map[string]any) + tcs, _ := d["tool_calls"].([]any) + if len(tcs) != 1 { + t.Fatalf("frame %d tool_calls len=%d want 1", i, len(tcs)) + } + fn, _ := tcs[0].(map[string]any)["function"].(map[string]any) + if _, ok := fn["name"]; ok { + gotName++ + if i != 0 || fn["name"] != "Bash" { + t.Errorf("frame %d unexpected name=%v (name 只能出现在首帧且为 Bash)", i, fn["name"]) + } + } + if want := "arg" + string(rune('0'+i)); fn["arguments"] != want { + t.Errorf("frame %d arguments=%v want %q", i, fn["arguments"], want) + } + } + if gotName != 1 { + t.Errorf("name 出现帧数=%d want 1", gotName) + } +} + +// TestStreamToolCallParallelFragments 多 tool_call(index 0 与 1 并行分片交错下发): +// 每个 index 只保留自己的首帧 name,后续分片互不串扰、arguments 各自原样。 +func TestStreamToolCallParallelFragments(t *testing.T) { + raw := "data: {\"id\":\"x1\",\"object\":\"chat.completion.chunk\",\"created\":0,\"choices\":[{\"index\":0,\"delta\":{\"tool_calls\":[{\"index\":0,\"id\":\"call_0\",\"type\":\"function\",\"function\":{\"name\":\"Bash\",\"arguments\":\"\"}}]}}]}\n\n" + + "data: {\"id\":\"x1\",\"choices\":[{\"index\":0,\"delta\":{\"tool_calls\":[{\"index\":1,\"id\":\"call_1\",\"type\":\"function\",\"function\":{\"name\":\"Read\",\"arguments\":\"\"}}]}}]}\n\n" + + "data: {\"id\":\"x1\",\"choices\":[{\"index\":0,\"delta\":{\"tool_calls\":[{\"index\":0,\"function\":{\"name\":\"Bash\",\"arguments\":\"a0\"}}]}}]}\n\n" + + "data: {\"id\":\"x1\",\"choices\":[{\"index\":0,\"delta\":{\"tool_calls\":[{\"index\":1,\"function\":{\"name\":\"Read\",\"arguments\":\"a1\"}}]}}]}\n\n" + + "data: {\"id\":\"x1\",\"choices\":[{\"index\":0,\"delta\":{},\"finish_reason\":\"tool_calls\"}]}\n\n" + + "data: [DONE]\n\n" + + frames, done := streamFrames(t, raw) + if done != 1 { + t.Fatalf("done=%d want 1", done) + } + + argByIndex := map[int]string{} + nameCount := map[int]int{} + for _, fr := range frames { + chs, _ := fr["choices"].([]any) + d, _ := chs[0].(map[string]any)["delta"].(map[string]any) + tcs, _ := d["tool_calls"].([]any) + for _, tci := range tcs { + tc, _ := tci.(map[string]any) + idx := int(tc["index"].(float64)) + fn, _ := tc["function"].(map[string]any) + if _, ok := fn["name"]; ok { + nameCount[idx]++ + } + if a, _ := fn["arguments"].(string); a != "" { + argByIndex[idx] = a + } + } + } + // 每个 index 恰好出现一次 name,arguments 逐片原样(a0/a1 各自保留) + if nameCount[0] != 1 || nameCount[1] != 1 { + t.Errorf("name 出现次数 index0=%d index1=%d,各 want 1", nameCount[0], nameCount[1]) + } + if argByIndex[0] != "a0" || argByIndex[1] != "a1" { + t.Errorf("arguments index0=%q index1=%q want a0/a1", argByIndex[0], argByIndex[1]) + } +} + +// TestStreamToolCallNoiseEmptyName 上游后续帧带空串 name(噪声形态)→ 输出帧无 name 键。 +// 键缺失是比空串更安全的形态,客户端「键缺失则保留旧值」不会清空工具名。 +func TestStreamToolCallNoiseEmptyName(t *testing.T) { + raw := "data: {\"id\":\"x1\",\"object\":\"chat.completion.chunk\",\"created\":1,\"model\":\"m\",\"choices\":[{\"index\":0,\"delta\":{\"tool_calls\":[{\"index\":0,\"id\":\"call_a\",\"type\":\"function\",\"function\":{\"name\":\"lookup\",\"arguments\":\"\"}}]}}]}\n\n" + + "data: {\"id\":\"x1\",\"choices\":[{\"index\":0,\"delta\":{\"tool_calls\":[{\"index\":0,\"function\":{\"name\":\"\",\"arguments\":\"arg1\"}}]}}]}\n\n" + + "data: {\"id\":\"x1\",\"choices\":[{\"index\":0,\"delta\":{\"tool_calls\":[{\"index\":0,\"function\":{\"name\":\"\",\"arguments\":\"arg2\"}}]}}]}\n\n" + + "data: {\"id\":\"x1\",\"choices\":[{\"index\":0,\"delta\":{},\"finish_reason\":\"tool_calls\"}]}\n\n" + + "data: [DONE]\n\n" + + frames, done := streamFrames(t, raw) + if done != 1 { + t.Fatalf("done=%d want 1", done) + } + for i, fr := range frames { + chs, _ := fr["choices"].([]any) + d, _ := chs[0].(map[string]any)["delta"].(map[string]any) + tcs, _ := d["tool_calls"].([]any) + for _, tci := range tcs { + tc, _ := tci.(map[string]any) + fn, _ := tc["function"].(map[string]any) + if i == 0 { + if fn["name"] != "lookup" { + t.Errorf("frame 0 name=%v want lookup", fn["name"]) + } + continue + } + if _, ok := fn["name"]; ok { + t.Errorf("frame %d: 空串 name 应被剥离为键缺失, got %#v", i, fn) + } + } + } +} + +// TestStreamToolCallOverwriteClientSemantics 覆盖型语义验证:模拟「键缺失则保留旧值」 +// 的覆盖型客户端(name ?? state.name / if (name) state.name = name),在输出流上逐帧 +// 重建 name,最终必须收敛为 Bash——证明键缺失形态不会清空工具名。 +func TestStreamToolCallOverwriteClientSemantics(t *testing.T) { + raw := "data: {\"id\":\"x1\",\"object\":\"chat.completion.chunk\",\"created\":1,\"model\":\"m\",\"choices\":[{\"index\":0,\"delta\":{\"tool_calls\":[{\"index\":0,\"id\":\"call_a\",\"type\":\"function\",\"function\":{\"name\":\"Bash\",\"arguments\":\"\"}}]}}]}\n\n" + + "data: {\"id\":\"x1\",\"choices\":[{\"index\":0,\"delta\":{\"tool_calls\":[{\"index\":0,\"function\":{\"name\":\"\",\"arguments\":\"{\\\"cmd\\\":\\\"ls\\\"}\"}}]}}]}\n\n" + + "data: {\"id\":\"x1\",\"choices\":[{\"index\":0,\"delta\":{\"tool_calls\":[{\"index\":0,\"function\":{\"name\":\"Bash\",\"arguments\":\"\"}}]}}]}\n\n" + + "data: [DONE]\n\n" + + frames, done := streamFrames(t, raw) + if done != 1 { + t.Fatalf("done=%d want 1", done) + } + state := map[int]string{} + reconstructed := map[int]string{} + for _, fr := range frames { + chs, _ := fr["choices"].([]any) + d, _ := chs[0].(map[string]any)["delta"].(map[string]any) + tcs, _ := d["tool_calls"].([]any) + for _, tci := range tcs { + tc, _ := tci.(map[string]any) + idx := int(tc["index"].(float64)) + fn, _ := tc["function"].(map[string]any) + // 覆盖型语义:键缺失 → ?? 保留旧值;非空 name → 覆盖。 + if name, ok := fn["name"]; ok { + state[idx] = name.(string) + } + if state[idx] != "" { + reconstructed[idx] = state[idx] + } + } + } + // 覆盖型客户端重建后最终 name 必须是 Bash(首帧建立,后续空/重复分片均不破坏)。 + if len(reconstructed) != 1 || reconstructed[0] != "Bash" { + t.Errorf("覆盖型重建 name=%v want map[0:Bash]", reconstructed) + } +} + +// streamFrames 把原始 SSE 输入经 Stream 处理后解析出所有 JSON 帧及 [DONE] 计数。 +func streamFrames(t *testing.T, raw string) (frames []map[string]any, doneCount int) { + t.Helper() + rec := httptest.NewRecorder() + if err := Stream(rec, strings.NewReader(raw)); err != nil { + t.Fatal(err) + } + body := rec.Body.String() + for _, ln := range strings.Split(body, "\n") { + ln = strings.TrimSpace(ln) + if strings.HasPrefix(ln, "data: [DONE]") { + doneCount++ + continue + } + if strings.HasPrefix(ln, "data: ") { + var obj map[string]any + if err := json.Unmarshal([]byte(strings.TrimPrefix(ln, "data: ")), &obj); err != nil { + t.Fatalf("bad frame %q: %v", ln, err) + } + frames = append(frames, obj) + } + } + return frames, doneCount +} + +// TestStreamInStreamErrorFrame 上游把失败塞在 HTTP 200 的流里(顶层 {code,msg,displayMsg}、 +// 无 choices、无 error):此前 normalizeFrame 的白名单把 code/msg 一并剥掉,客户端只看到 +// 「干净地停止、无任何失败」,我们的日志也只剩「段无 finish 结束」。现在如实透出为 error 帧。 +// 判据必须**窄**:带 choices 的帧(正文里出现 11140 / request illegal 是常态)与只有 usage +// 的帧都不得被改写。 +func TestStreamInStreamErrorFrame(t *testing.T) { + raw := "data: {\"id\":\"x1\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"正文在讨论 11140 与 request illegal 的语义\"}}]}\n\n" + + "data: {\"usage\":{\"prompt_tokens\":1,\"completion_tokens\":2,\"total_tokens\":3}}\n\n" + + "data: {\"code\":11140,\"msg\":\"request illegal\",\"displayMsg\":\"请求被安全策略拦截\",\"requestId\":\"rid-1\"}\n\n" + + "data: [DONE]\n\n" + frames, done := streamFrames(t, raw) + if done != 1 { + t.Fatalf("done=%d want 1", done) + } + if len(frames) != 3 { + t.Fatalf("frames=%d want 3(正文帧 + usage 帧 + error 帧):%v", len(frames), frames) + } + if chs, _ := frames[0]["choices"].([]any); len(chs) != 1 { + t.Fatalf("带 choices 的正文帧不得改写:%v", frames[0]) + } + if _, has := frames[1]["error"]; has { + t.Fatalf("只有 usage 的帧不得被当成失败帧:%v", frames[1]) + } + e, ok := frames[2]["error"].(map[string]any) + if !ok { + t.Fatalf("内嵌失败帧应透出为 error 帧,实际:%v", frames[2]) + } + if e["code"].(float64) != 11140 || e["message"] != "request illegal" || e["requestId"] != "rid-1" { + t.Fatalf("error 帧内容=%v want code=11140 message=request illegal requestId=rid-1", e) + } + if _, has := frames[2]["choices"]; has { + t.Fatalf("error 帧不应带 choices:%v", frames[2]) + } +} + +// TestStreamErrorFramePredicate 判据本身的边界(无 choices 才认;displayMsg 兜底 message; +// 非 JSON 数字 / 缺 code / 无 error 缺 code 都不算)。 +func TestStreamErrorFramePredicate(t *testing.T) { + cases := []struct { + name string + obj map[string]any + code int + msg string + ok bool + }{ + {"典型拦截", map[string]any{"code": float64(11140), "msg": "request illegal"}, 11140, "request illegal", true}, + {"displayMsg 兜底", map[string]any{"code": float64(11140), "displayMsg": "拦截"}, 11140, "拦截", true}, + {"带 choices 的正文", map[string]any{"code": float64(11140), "choices": []any{}}, 0, "", false}, + {"标准 error 帧让给既有分支", map[string]any{"code": float64(11140), "error": map[string]any{}}, 0, "", false}, + {"只有 usage", map[string]any{"usage": map[string]any{}}, 0, "", false}, + {"code 非数字", map[string]any{"code": "11140"}, 0, "", false}, + {"code 为 0", map[string]any{"code": float64(0)}, 0, "", false}, + } + for _, c := range cases { + code, msg, ok := StreamErrorFrame(c.obj) + if code != c.code || msg != c.msg || ok != c.ok { + t.Errorf("%s: got (%d,%q,%v) want (%d,%q,%v)", c.name, code, msg, ok, c.code, c.msg, c.ok) + } + } +} + +func TestNormalizeFrame(t *testing.T) { + cases := []struct { + name string + in map[string]any + want string // 规范化后 marshal 的期望 JSON(Go map 键按字典序输出) + }{ + {"empty content/refusal and finish_reason empty string", + map[string]any{"id": "x", "choices": []any{ + map[string]any{"index": 0, "delta": map[string]any{"content": "", "refusal": ""}, "finish_reason": ""}, + }}, + `{"choices":[{"delta":{},"finish_reason":null,"index":0}],"id":"x","object":"chat.completion.chunk","usage":null}`}, + {"non-empty tool_calls kept", + map[string]any{"choices": []any{ + map[string]any{"index": 0, "delta": map[string]any{"tool_calls": []any{map[string]any{"id": "c1", "type": "function"}}}}, + }}, + `{"choices":[{"delta":{"tool_calls":[{"id":"c1","type":"function"}]},"finish_reason":null,"index":0}],"id":"chatcmpl-wb2api","object":"chat.completion.chunk","usage":null}`}, + {"empty tool_calls list dropped", + map[string]any{"choices": []any{ + map[string]any{"index": 0, "delta": map[string]any{"tool_calls": []any{}, "content": "hi"}}, + }}, + `{"choices":[{"delta":{"content":"hi"},"finish_reason":null,"index":0}],"id":"chatcmpl-wb2api","object":"chat.completion.chunk","usage":null}`}, + {"empty placeholder function_call dropped", + map[string]any{"choices": []any{ + map[string]any{"index": 0, "delta": map[string]any{"function_call": map[string]any{"name": "", "arguments": ""}}}, + }}, + `{"choices":[{"delta":{},"finish_reason":null,"index":0}],"id":"chatcmpl-wb2api","object":"chat.completion.chunk","usage":null}`}, + {"top-level unknown fields dropped, usage null when absent", + map[string]any{"id": "x", "object": "chat.completion.chunk", "created": 1, "junk": "noise", "choices": []any{ + map[string]any{"index": 0, "delta": map[string]any{}, "finish_reason": "stop"}, + }}, + `{"choices":[{"delta":{},"finish_reason":"stop","index":0}],"created":1,"id":"x","object":"chat.completion.chunk","usage":null}`}, + } + for _, c := range cases { + t.Run(c.name, func(t *testing.T) { + raw, err := json.Marshal(normalizeFrame(c.in)) + if err != nil { + t.Fatal(err) + } + if string(raw) != c.want { + t.Errorf("got %s\nwant %s", raw, c.want) + } + }) + } +} + +func TestStreamNormalizesFrames(t *testing.T) { + // 混合噪声帧:空 content/reasoning/refusal/function_call + 空 tool_calls + 顶层非标字段, + // 随后非空 content + tool_calls 帧,最后 finish/usage 帧。 + raw := "data: {\"id\":\"x1\",\"object\":\"chat.completion.chunk\",\"created\":1,\"model\":\"m\",\"choices\":[{\"index\":0,\"delta\":{\"role\":\"assistant\",\"content\":\"\",\"reasoning_content\":\"\",\"refusal\":\"\",\"tool_calls\":[],\"function_call\":{\"name\":\"\",\"arguments\":\"\"}},\"finish_reason\":\"\"}],\"extra_field\":\"junk\"}\n\n" + + "data: {\"id\":\"x1\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"hello\",\"tool_calls\":[{\"id\":\"call_1\",\"type\":\"function\",\"function\":{\"name\":\"get_weather\",\"arguments\":\"{\\\"city\\\":\\\"北京\\\"}\"},\"index\":0}]},\"finish_reason\":\"\"}]}\n\n" + + "data: {\"id\":\"x1\",\"choices\":[{\"index\":0,\"delta\":{},\"finish_reason\":\"stop\"}],\"usage\":{\"total_tokens\":7}}\n\n" + + "data: [DONE]\n\n" + + frames, done := streamFrames(t, raw) + if done != 1 { + t.Fatalf("done frames=%d want 1", done) + } + if len(frames) != 3 { + t.Fatalf("frames=%d want 3", len(frames)) + } + + // 帧 1:噪声全剔除,finish_reason ""→null,usage 缺失→null,顶层非标字段剥除 + f0 := frames[0] + if _, ok := f0["extra_field"]; ok { + t.Error("top-level extra_field should be dropped") + } + if f0["usage"] != nil { + t.Errorf("usage should be null when absent, got %v", f0["usage"]) + } + ch0 := f0["choices"].([]any)[0].(map[string]any) + if ch0["finish_reason"] != nil { + t.Errorf("frame1 finish_reason=%v want null", ch0["finish_reason"]) + } + d := ch0["delta"].(map[string]any) + // role 是合法白名单键保留;空 content/reasoning/refusal/tool_calls/function_call 噪声全剔除 + if len(d) != 1 || d["role"] != "assistant" { + t.Errorf("frame1 delta should only keep role, got %#v", d) + } + for _, noise := range []string{"content", "reasoning_content", "refusal", "tool_calls", "function_call"} { + if _, ok := d[noise]; ok { + t.Errorf("frame1 delta should drop %q, got %#v", noise, d) + } + } + + // 帧 2:非空 content 与 tool_calls 保留,finish_reason ""→null + f1 := frames[1] + ch1 := f1["choices"].([]any)[0].(map[string]any) + d1 := ch1["delta"].(map[string]any) + if d1["content"] != "hello" { + t.Errorf("frame2 content=%v", d1["content"]) + } + tcs, ok := d1["tool_calls"].([]any) + if !ok || len(tcs) != 1 { + t.Fatalf("frame2 tool_calls=%#v", d1["tool_calls"]) + } + if ch1["finish_reason"] != nil { + t.Errorf("frame2 finish_reason=%v want null (input empty string)", ch1["finish_reason"]) + } + + // 帧 3:finish_reason 非空保留,usage 保留 + f2 := frames[2] + ch2 := f2["choices"].([]any)[0].(map[string]any) + if ch2["finish_reason"] != "stop" { + t.Errorf("frame3 finish_reason=%v want stop", ch2["finish_reason"]) + } + if f2["usage"].(map[string]any)["total_tokens"].(float64) != 7 { + t.Errorf("frame3 usage=%v", f2["usage"]) + } +} + +// TestStreamFirstIdPassthrough 帧混合(首帧有 id / 中间帧无 id / 空串 id):输出每帧 id +// 必须连续一致(取首帧真实值),不再一律 chatcmpl-wb2api(issue #35 后台聚合:透传流里 +// 每帧同 id 才能按消息归并)。 +func TestStreamFirstIdPassthrough(t *testing.T) { + raw := "data: {\"id\":\"chatcmpl-upstream-9\",\"object\":\"chat.completion.chunk\",\"created\":1,\"model\":\"m\",\"choices\":[{\"index\":0,\"delta\":{\"role\":\"assistant\",\"content\":\"hello\"}}]}\n\n" + + // 中间帧无 id:应复用首帧 id。 + "data: {\"object\":\"chat.completion.chunk\",\"created\":1,\"choices\":[{\"index\":0,\"delta\":{\"content\":\" world\"}}]}\n\n" + + // 中间帧 id 为空串:同样复用首帧 id。 + "data: {\"id\":\"\",\"object\":\"chat.completion.chunk\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"!\"},\"finish_reason\":\"stop\"}]}\n\n" + + "data: [DONE]\n\n" + + frames, done := streamFrames(t, raw) + if done != 1 { + t.Fatalf("done=%d want 1", done) + } + if len(frames) != 3 { + t.Fatalf("frames=%d want 3", len(frames)) + } + for i, fr := range frames { + if got := fr["id"]; got != "chatcmpl-upstream-9" { + t.Errorf("frame %d id=%v want chatcmpl-upstream-9 (首帧真实 id 续传)", i, got) + } + } +} + +// TestStreamNoIdFallsBackToSentinel 全流无任何真实 id → 兜底 chatcmpl-wb2api +// (整流无 id 时的既有哨兵,帧与帧之间仍一惯性存在)。 +func TestStreamNoIdFallsBackToSentinel(t *testing.T) { + raw := "data: {\"object\":\"chat.completion.chunk\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"hi\"}}]}\n\n" + + "data: {\"object\":\"chat.completion.chunk\",\"choices\":[{\"index\":0,\"delta\":{}," + + "\"finish_reason\":\"stop\"}]}\n\n" + + "data: [DONE]\n\n" + frames, _ := streamFrames(t, raw) + if len(frames) != 2 { + t.Fatalf("frames=%d want 2", len(frames)) + } + for i, fr := range frames { + if got := fr["id"]; got != "chatcmpl-wb2api" { + t.Errorf("frame %d id=%v want sentinel chatcmpl-wb2api (无真实 id)", i, got) + } + } +} + +func TestStreamDoneFallback(t *testing.T) { + // 上游流在无 [DONE] 时 EOF,Stream 必须兜底写一个 [DONE] + rec := httptest.NewRecorder() + err := Stream(rec, strings.NewReader("data: {\"id\":\"x1\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"hi\"}}]}\n\n")) + if err != nil { + t.Fatal(err) + } + body := rec.Body.String() + if !strings.HasSuffix(strings.TrimRight(body, "\n"), "data: [DONE]") { + t.Errorf("missing [DONE] fallback: %q", body) + } + + // 已有 [DONE] 时只写一次,不重复 + rec2 := httptest.NewRecorder() + if err := Stream(rec2, strings.NewReader("data: {\"id\":\"x1\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"hi\"}}]}\n\ndata: [DONE]\n\n")); err != nil { + t.Fatal(err) + } + if n := strings.Count(rec2.Body.String(), "data: [DONE]"); n != 1 { + t.Errorf("[DONE] count=%d want 1: %q", n, rec2.Body.String()) + } +} + +func TestStreamPassthrough(t *testing.T) { + rec := httptest.NewRecorder() + err := Stream(rec, strings.NewReader(sseFixture)) + if err != nil { + t.Fatal(err) + } + body := rec.Body.String() + if !strings.Contains(body, "你好") || !strings.Contains(body, "data: [DONE]") { + t.Errorf("body missing chunks: %q", body) + } + // 逐行仍是合法 SSE(每行以 data: 开头或是空行) + for _, ln := range strings.Split(strings.TrimRight(body, "\n"), "\n") { + if ln != "" && !strings.HasPrefix(ln, "data: ") { + t.Errorf("bad line: %q", ln) + } + } + ct := rec.Header().Get("Content-Type") + if !strings.Contains(ct, "text/event-stream") { + t.Errorf("content-type=%q", ct) + } +} + +// TestAggregateEmptyStreamCases 覆盖空流检测:0 有效事件必须报错、[DONE] 即 break、 +// [DONE] 后垃圾不进聚合、正常聚合回归。 +func TestAggregateEmptyStreamCases(t *testing.T) { + // 正常回归基流:content + finish_reason + usage,[DONE] 收尾。 + valid := "data: {\"id\":\"c1\",\"object\":\"chat.completion.chunk\",\"created\":1,\"model\":\"glm-5.2\",\"choices\":[{\"index\":0,\"delta\":{\"role\":\"assistant\",\"content\":\"hi\"}}]}\n\n" + + "data: {\"id\":\"c1\",\"choices\":[{\"index\":0,\"delta\":{},\"finish_reason\":\"stop\"}],\"usage\":{\"total_tokens\":7}}\n\n" + + "data: [DONE]\n\n" + + cases := []struct { + name string + raw string + wantErr bool + // 回归断言(仅在 wantErr=false 时校验) + wantContent string + wantUsage float64 + }{ + { + name: "空流(EOF 即止)", + raw: "", + wantErr: true, + }, + { + name: "只有注释行和空行加 DONE", + raw: ": comment\n\n: another comment\n\ndata: [DONE]\n\n", + wantErr: true, + }, + { + name: "DONE 后跟垃圾帧不进聚合", + raw: valid[:len(valid)-len("data: [DONE]\n\n")] + "data: [DONE]\n\ndata: {\"junk\":\"should not aggregate\"}\n\n", + wantErr: false, + // 与 valid 基流一致的聚合期望 + wantContent: "hi", + wantUsage: 7, + }, + { + name: "正常流回归", + raw: valid, + wantErr: false, + wantContent: "hi", + wantUsage: 7, + }, + } + for _, c := range cases { + t.Run(c.name, func(t *testing.T) { + resp, err := Aggregate(strings.NewReader(c.raw)) + if c.wantErr { + if err == nil { + t.Fatalf("expected error, got nil (resp=%v)", resp) + } + return + } + if err != nil { + t.Fatal(err) + } + msg := resp["choices"].([]any)[0].(map[string]any)["message"].(map[string]any) + if msg["content"] != c.wantContent { + t.Errorf("content=%q want %q", msg["content"], c.wantContent) + } + if u, ok := resp["usage"].(map[string]any); ok { + if u["total_tokens"].(float64) != c.wantUsage { + t.Errorf("usage=%v want %v", u["total_tokens"], c.wantUsage) + } + } else { + t.Errorf("usage missing") + } + }) + } +} + +// TestAggregateEmptyStreamError 校验空流错误信息形如约定文案。 +func TestAggregateEmptyStreamError(t *testing.T) { + _, err := Aggregate(strings.NewReader("")) + if err == nil || !strings.Contains(err.Error(), "no valid data events") { + t.Fatalf("err=%v", err) + } +} + +// TestStreamEmptyFramesCase 覆盖流式空流检测:尚未写出字节的形态走首帧否决 +// (零字节 + HeadVetoError,交上层换号);已经写过注释行、响应头已提交的形态 +// 只能旧兜底——写 error 帧(error 字段存活)+ 恰好一个 [DONE]。 +func TestStreamEmptyFramesCase(t *testing.T) { + cases := []struct { + name string + raw string + veto bool + }{ + {"空流", "", true}, + {"只有注释行", ": comment\n\n", false}, + {"只有 DONE", "data: [DONE]\n\n", true}, + } + for _, c := range cases { + t.Run(c.name, func(t *testing.T) { + rec := httptest.NewRecorder() + err := Stream(rec, strings.NewReader(c.raw)) + if err == nil { + t.Fatalf("expected error, got nil") + } + if c.veto { + var hv *HeadVetoError + if !errors.As(err, &hv) || hv.Payload != "" { + t.Fatalf("err=%v want *HeadVetoError{Payload:\"\"}", err) + } + if body := rec.Body.String(); body != "" { + t.Fatalf("首帧否决必须零字节写出,实际:%q", body) + } + return + } + body := rec.Body.String() + if n := strings.Count(body, "data: [DONE]"); n != 1 { + t.Errorf("[DONE] count=%d want 1: %q", n, body) + } + // error 帧必须原样保留 error 字段(未被 normalizeFrame 白名单剥掉) + var e map[string]any + found := false + for _, ln := range strings.Split(body, "\n") { + ln = strings.TrimSpace(ln) + if strings.HasPrefix(ln, "data: ") { + payload := strings.TrimPrefix(ln, "data: ") + if payload == "[DONE]" { + continue + } + if json.Unmarshal([]byte(payload), &e) == nil { + if em, ok := e["error"].(map[string]any); ok && em["message"] == "empty upstream stream" && em["type"] == "upstream_error" { + found = true + } + } + } + } + if !found { + t.Errorf("error frame absent or error field stripped: %q", body) + } + }) + } +} + +// TestStreamHeadVetoEmbeddedCodeFrame 首帧即「HTTP 200 内嵌顶层 {code,msg}」失败帧 +// (11140 安全审核 / 6021 队列满等形态,writeFrame 的 StreamErrorFrame 判据): +// 与 error 键形态同样在首帧否决窗口换号,客户端不会看到「200 + error 帧」。 +// 否决 payload 已改写成标准 error 帧(与 writeFrame 的透出形态一致),FrameKind +// 可直接分类、requestId 不丢。 +func TestStreamHeadVetoEmbeddedCodeFrame(t *testing.T) { + const frame = `{"code":11140,"msg":"request illegal","requestId":"req-1"}` + rec := httptest.NewRecorder() + err := Stream(rec, strings.NewReader("data: "+frame+"\n\ndata: [DONE]\n\n")) + var hv *HeadVetoError + if !errors.As(err, &hv) { + t.Fatalf("err=%v want *HeadVetoError", err) + } + var obj map[string]any + if json.Unmarshal([]byte(hv.Payload), &obj) != nil { + t.Fatalf("payload 应已改写为标准 error 帧: %q", hv.Payload) + } + e, _ := obj["error"].(map[string]any) + if e == nil || e["message"] != "request illegal" || e["code"] != float64(11140) || e["requestId"] != "req-1" { + t.Fatalf("error 帧字段丢失: %q", hv.Payload) + } + if body := rec.Body.String(); body != "" { + t.Fatalf("首帧否决必须零字节写出,实际:%q", body) + } +} + +// TestStreamHeadVetoErrorFrame 首帧即上游 error 帧:网关一个字节都不写就返回 +// HeadVetoError(携带该帧原文),上层据此换号重试,客户端不会看到「200 + error 帧」。 +// 对照:正文之后才出现的 error 帧照旧透传(TestStreamInStreamErrorFrame)。 +func TestStreamHeadVetoErrorFrame(t *testing.T) { + const frame = `{"error":{"message":"rate limited","code":6004}}` + rec := httptest.NewRecorder() + err := Stream(rec, strings.NewReader("data: "+frame+"\n\ndata: [DONE]\n\n")) + var hv *HeadVetoError + if !errors.As(err, &hv) { + t.Fatalf("err=%v want *HeadVetoError", err) + } + if hv.Payload != frame { + t.Errorf("payload=%q want %q", hv.Payload, frame) + } + if body := rec.Body.String(); body != "" { + t.Fatalf("首帧否决必须零字节写出,实际:%q", body) + } +} + +// TestStreamGarbageAfterDone 校验 DONE 之后的垃圾帧不出现在响应里。 +func TestStreamGarbageAfterDone(t *testing.T) { + raw := "data: {\"id\":\"x1\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"hello\"}}]}\n\n" + + "data: [DONE]\n\n" + + "data: {\"should\":\"not appear\"}\n\n" + rec := httptest.NewRecorder() + if err := Stream(rec, strings.NewReader(raw)); err != nil { + t.Fatal(err) + } + body := rec.Body.String() + if strings.Contains(body, "should") { + t.Errorf("garbage after DONE leaked into response: %q", body) + } + if n := strings.Count(body, "data: [DONE]"); n != 1 { + t.Errorf("[DONE] count=%d want 1: %q", n, body) + } + // 有效帧仍被透传 + if !strings.Contains(body, "hello") { + t.Errorf("valid frame missing: %q", body) + } +} + +// TestStreamNormalPassthroughRegression 校验正常透传回归:帧被 normalize 后透传、 +// 末尾恰好一个 [DONE]、无 error 帧;上游漏发 DONE 时自动补。 +func TestStreamNormalPassthroughRegression(t *testing.T) { + cases := []struct { + name string + raw string + }{ + {"带 DONE 的正常流", sseFixture}, + {"漏发 DONE 自动补", "data: {\"id\":\"x1\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"hi\"}}]}\n\n"}, + } + for _, c := range cases { + t.Run(c.name, func(t *testing.T) { + rec := httptest.NewRecorder() + if err := Stream(rec, strings.NewReader(c.raw)); err != nil { + t.Fatal(err) + } + body := rec.Body.String() + if strings.Contains(body, `"error"`) { + t.Errorf("unexpected error frame: %q", body) + } + if n := strings.Count(body, "data: [DONE]"); n != 1 { + t.Errorf("[DONE] count=%d want 1: %q", n, body) + } + // 帧被规范化:含 "id" 且有标准 object 字段 + if !strings.Contains(body, `"object":"chat.completion.chunk"`) { + t.Errorf("frame not normalized: %q", body) + } + }) + } +} + +// TestNormalizeUsageCacheAliasesMirrorsNestedHit / PreservesZeroResult 自 +// usage_test.go 迁入(PR #57 原新文件按仓库规则不收,核心断言保留在此—— +// normalize 钩子就挂在 sse.go 的 Aggregate/normalizeFrame 两个出口)。 +func TestNormalizeUsageCacheAliasesMirrorsNestedHit(t *testing.T) { + usage := map[string]any{ + "prompt_tokens": 21041.0, + "completion_tokens": 8.0, + "total_tokens": 21049.0, + "cache_read_input_tokens": 0.0, + "cached_tokens": 0.0, + "prompt_cache_hit_tokens": 0.0, + "prompt_cache_miss_tokens": 177.0, + "prompt_tokens_details": map[string]any{ + "cached_tokens": 20864.0, + }, + } + + got := normalizeUsageCacheAliases(usage) + + for _, key := range []string{ + "cache_read_input_tokens", + "cached_tokens", + "prompt_cache_hit_tokens", + } { + if got[key] != 20864.0 { + t.Fatalf("%s=%v want 20864", key, got[key]) + } + } + details := got["prompt_tokens_details"].(map[string]any) + if details["cached_tokens"] != 20864.0 { + t.Fatalf("prompt_tokens_details.cached_tokens=%v want 20864", details["cached_tokens"]) + } +} + +func TestNormalizeUsageCacheAliasesPreservesZeroResult(t *testing.T) { + usage := map[string]any{ + "prompt_tokens": 35.0, + "completion_tokens": 2.0, + "total_tokens": 37.0, + "cache_read_input_tokens": 0.0, + "prompt_cache_hit_tokens": 0.0, + "prompt_tokens_details": map[string]any{ + "cached_tokens": 0.0, + }, + } + + got := normalizeUsageCacheAliases(usage) + + details := got["prompt_tokens_details"].(map[string]any) + if details["cached_tokens"] != 0.0 { + t.Fatalf("prompt_tokens_details.cached_tokens=%v want 0", details["cached_tokens"]) + } +} + +func TestCreditPackagesExpiryTimestamp(t *testing.T) { + end := time.Now().In(softRateResetLoc).Add(7 * 24 * time.Hour).Truncate(time.Second) + c := testClient(func(r *http.Request) (*http.Response, error) { + if !strings.HasSuffix(r.URL.Path, "/v2/billing/meter/get-user-resource") { + return nil, errors.New("wrong path: " + r.URL.Path) + } + return jsonResp(200, `{"code":0,"data":{"Response":{"Data":{"Accounts":[`+ + `{"PackageName":"gift","CycleCapacitySize":100,"CycleCapacityRemain":80,"CycleCapacityUsed":20,"CycleEndTime":"`+ + end.Format(packageEndLayout)+`"},`+ + `{"PackageName":"unknown","CycleCapacitySize":10,"CycleCapacityRemain":10,"CycleCapacityUsed":0}`+ + `]}}}}`), nil + }) + packs, remain, size, err := c.CreditPackages(&auth.Auth{AccessToken: "at", UID: "u1"}) + if err != nil { + t.Fatalf("packages: %v", err) + } + if remain != 90 || size != 110 { + t.Fatalf("remain/size=%d/%d want 90/110", remain, size) + } + var found bool + for _, p := range packs { + if p.Name == "gift" { + found = p.ExpiresAt == end.UnixMilli() + } + } + if !found { + t.Fatalf("gift pack missing Unix-ms expiry: %+v", packs) + } +} + +func TestUserResourceDetailedWithExpirySnapshot(t *testing.T) { + now := time.Now().In(softRateResetLoc) + soon := now.Add(24 * time.Hour).Truncate(time.Second) + later := now.Add(10 * 24 * time.Hour).Truncate(time.Second) + payload := `{"code":0,"data":{"Response":{"Data":{"Accounts":[` + + `{"PackageName":"soon-a","CycleCapacitySize":10,"CycleCapacityRemain":10,"CycleCapacityUsed":0,"CycleEndTime":"` + soon.Format(packageEndLayout) + `"},` + + `{"PackageName":"soon-b","CycleCapacitySize":15,"CycleCapacityRemain":15,"CycleCapacityUsed":0,"CycleEndTime":"` + soon.Format(packageEndLayout) + `"},` + + `{"PackageName":"later","CycleCapacitySize":20,"CycleCapacityRemain":20,"CycleCapacityUsed":0,"CycleEndTime":"` + later.Format(packageEndLayout) + `"},` + + `{"PackageName":"unknown","CycleCapacitySize":5,"CycleCapacityRemain":5,"CycleCapacityUsed":0}` + + `]}}}}` + c := testClient(func(r *http.Request) (*http.Response, error) { + if !strings.HasSuffix(r.URL.Path, "/v2/billing/meter/get-user-resource") { + return nil, errors.New("wrong path: " + r.URL.Path) + } + return jsonResp(200, payload), nil + }) + + remain, total, expiring, earliestAt, earliestRemaining, err := c.UserResourceDetailedWithExpiry( + &auth.Auth{AccessToken: "at", UID: "u1"}, 48*time.Hour, + ) + if err != nil { + t.Fatalf("resource: %v", err) + } + if remain != 50 || total != 50 || expiring != 25 { + t.Fatalf("remain/total/expiring=%d/%d/%d want 50/50/25", remain, total, expiring) + } + if earliestRemaining != 25 || !earliestAt.Equal(soon) { + t.Fatalf("earliest=%v/%d want %v/25", earliestAt, earliestRemaining, soon) + } +} + +// TestDeductionEndTimePreferredOverCycleEnd 套餐型包的到期判据取 DeductionEndTime +// (真实扣费截止),不是 CycleEndTime(只是月度计量周期)——后者会把 8 年有效的 +// 「个人体验版」积分误判成「快到期」而优先烧掉(2026-10-03 实测:cycle=2026-10-31 +// vs deduction=2034-12-24,余额 500)。两条消费路径(逐包明细 / 快到期快照)同源。 +func TestDeductionEndTimePreferredOverCycleEnd(t *testing.T) { + now := time.Now().In(softRateResetLoc) + cycle := now.Add(20 * 24 * time.Hour).Truncate(time.Second) // 月度周期:20 天后 + deduction := now.AddDate(8, 0, 0).Truncate(time.Second) // 真实扣费截止:8 年后 + payload := `{"code":0,"data":{"Response":{"Data":{"Accounts":[` + + `{"PackageName":"trial","CycleCapacitySize":500,"CycleCapacityRemain":500,"CycleCapacityUsed":0,` + + `"CycleEndTime":"` + cycle.Format(packageEndLayout) + `",` + + `"DeductionEndTime":` + fmt.Sprintf("%d", deduction.UnixMilli()) + `}` + + `]}}}}` + c := testClient(func(r *http.Request) (*http.Response, error) { return jsonResp(200, payload), nil }) + + packs, _, _, err := c.CreditPackages(&auth.Auth{AccessToken: "at", UID: "u1"}) + if err != nil { + t.Fatalf("packages: %v", err) + } + if len(packs) != 1 || packs[0].ExpiresAt != deduction.UnixMilli() { + t.Fatalf("逐包到期应取 deduction %v,实得 %+v", deduction.UnixMilli(), packs) + } + _, _, expiring, earliestAt, _, err := c.UserResourceDetailedWithExpiry( + &auth.Auth{AccessToken: "at", UID: "u1"}, 48*time.Hour, + ) + if err != nil { + t.Fatalf("resource: %v", err) + } + if expiring != 0 { + t.Fatalf("8 年后到期的包不得计入 48h 快到期窗口:expiring=%d", expiring) + } + if !earliestAt.Equal(deduction) { + t.Fatalf("earliestAt=%v want %v", earliestAt, deduction) + } +} + +// TestUserResourceSnapshotBuckets 快照按自然日聚合:同一自然日的多个包合并成一个桶, +// 日期取该日、剩余量求和、ExpireAt 取该日最早时刻;earliestRemaining 同步为该日合计。 +// 这是首页「到期提醒」与「积分构成」同口径的关键——旧实现只记最早单包,同日多包被少算。 +func TestUserResourceSnapshotBuckets(t *testing.T) { + now := time.Now().In(softRateResetLoc) + at := func(offset, hour int) time.Time { + return time.Date(now.Year(), now.Month(), now.Day()+offset, hour, 0, 0, 0, softRateResetLoc) + } + d2a, d2b, d5 := at(2, 9), at(2, 15), at(5, 9) + cycle := at(20, 0) // 月度周期边界:快照必须优先 DeductionEndTime,不能落在这里 + payload := `{"code":0,"data":{"Response":{"Data":{"Accounts":[` + + `{"PackageName":"a","CapacitySize":60,"CapacityRemain":60,"CapacityUsed":0,` + + `"CycleEndTime":"` + cycle.Format(packageEndLayout) + `","DeductionEndTime":` + fmt.Sprintf("%d", d2a.UnixMilli()) + `},` + + `{"PackageName":"b","CapacitySize":40,"CapacityRemain":40,"CapacityUsed":0,` + + `"CycleEndTime":"` + cycle.Format(packageEndLayout) + `","DeductionEndTime":` + fmt.Sprintf("%d", d2b.UnixMilli()) + `},` + + `{"PackageName":"c","CapacitySize":25,"CapacityRemain":25,"CapacityUsed":0,` + + `"CycleEndTime":"` + cycle.Format(packageEndLayout) + `","DeductionEndTime":` + fmt.Sprintf("%d", d5.UnixMilli()) + `}` + + `]}}}}` + c := testClient(func(r *http.Request) (*http.Response, error) { return jsonResp(200, payload), nil }) + + remain, total, _, earliestAt, earliestRemaining, buckets, err := c.UserResourceSnapshot( + &auth.Auth{AccessToken: "at", UID: "u1"}, 0, + ) + if err != nil { + t.Fatalf("snapshot: %v", err) + } + if remain != 125 || total != 125 { + t.Fatalf("remain/total=%d/%d want 125/125", remain, total) + } + if len(buckets) != 2 { + t.Fatalf("buckets=%+v want 2 个自然日", buckets) + } + if buckets[0].Date != d2a.Format("2006-01-02") || buckets[0].Remain != 100 { + t.Fatalf("首桶=%+v want %s/100(同日两包合并)", buckets[0], d2a.Format("2006-01-02")) + } + if !buckets[0].ExpireAt.Equal(d2a) { + t.Fatalf("首桶 ExpireAt=%v want 该日最早 %v", buckets[0].ExpireAt, d2a) + } + if buckets[1].Date != d5.Format("2006-01-02") || buckets[1].Remain != 25 { + t.Fatalf("次桶=%+v want %s/25", buckets[1], d5.Format("2006-01-02")) + } + if !earliestAt.Equal(d2a) || earliestRemaining != 100 { + t.Fatalf("earliest=%v/%d want %v/100", earliestAt, earliestRemaining, d2a) + } +} + +// --- 标记修复(流式端到端,见 dsml.go)------------------------------------- + +// upstreamSSEWithContent 用给定的正文分片拼一条上游 SSE:role 首帧 + N 个正文帧 +// + finish 收尾帧 + [DONE]。 +func upstreamSSEWithContent(chunks []string, finish string) string { + var sb strings.Builder + sb.WriteString(`data: {"id":"resp-1","object":"chat.completion.chunk","created":1,"model":"global:deepseek-v4.1-flash","choices":[{"index":0,"delta":{"role":"assistant"}}]}` + "\n\n") + for _, c := range chunks { + b, _ := json.Marshal(map[string]any{ + "id": "resp-1", "object": "chat.completion.chunk", "created": 1, + "model": "global:deepseek-v4.1-flash", + "choices": []any{map[string]any{ + "index": 0, + "delta": map[string]any{"content": c}, + }}, + }) + sb.WriteString("data: " + string(b) + "\n\n") + } + b, _ := json.Marshal(map[string]any{ + "id": "resp-1", "object": "chat.completion.chunk", "created": 1, + "model": "global:deepseek-v4.1-flash", + "choices": []any{map[string]any{ + "index": 0, "delta": map[string]any{}, "finish_reason": finish, + }}, + }) + sb.WriteString("data: " + string(b) + "\n\n") + sb.WriteString("data: [DONE]\n\n") + return sb.String() +} + +// sseFrameView 是测试侧对一帧的扁平视图。 +type sseFrameView struct { + content string + calls []map[string]any + finish string +} + +// viewSSE 解析网关写出的 SSE 文本。 +func viewSSE(t *testing.T, body string) []sseFrameView { + t.Helper() + var out []sseFrameView + for _, line := range strings.Split(body, "\n") { + line = strings.TrimSpace(line) + if !strings.HasPrefix(line, "data: ") { + continue + } + payload := strings.TrimPrefix(line, "data: ") + if payload == "[DONE]" { + continue + } + var obj map[string]any + if err := json.Unmarshal([]byte(payload), &obj); err != nil { + t.Fatalf("帧不是合法 JSON: %q (%v)", payload, err) + } + chs, _ := obj["choices"].([]any) + if len(chs) == 0 { + continue + } + ch, _ := chs[0].(map[string]any) + v := sseFrameView{} + if d, ok := ch["delta"].(map[string]any); ok { + v.content, _ = d["content"].(string) + if tcs, ok := d["tool_calls"].([]any); ok { + for _, tci := range tcs { + if tc, ok := tci.(map[string]any); ok { + v.calls = append(v.calls, tc) + } + } + } + } + v.finish, _ = ch["finish_reason"].(string) + out = append(out, v) + } + return out +} + +// TestStreamMarkupRepairEndToEnd 上游把工具调用吐成正文标记时,网关必须还原成 +// delta.tool_calls:正文里不再残留标记、调用帧带正确的 name/arguments、收尾帧 +// finish_reason 为 tool_calls 且出现在调用帧之后。 +func TestStreamMarkupRepairEndToEnd(t *testing.T) { + prose := "先读一遍控制器,把接口清单核实准确。\n\n" + content := prose + mkBlock( + mkInvoke("exec_command", mkParam("cmd", "ls -la")), + mkInvoke("exec_command", mkParam("cmd", "pwd")), + ) + raw := upstreamSSEWithContent([]string{content}, "stop") + + repair := NewMarkupRepair(testTools, false) + rec := httptest.NewRecorder() + if err := StreamHint(rec, strings.NewReader(raw), nil, WithMarkupRepair(repair)); err != nil { + t.Fatal(err) + } + body := rec.Body.String() + if strings.Contains(body, markupPipe) { + t.Fatalf("透出内容里仍残留标记: %s", body) + } + if repair.Converted() != 2 { + t.Fatalf("Converted 应为 2,实际 %d", repair.Converted()) + } + + frames := viewSSE(t, body) + var text strings.Builder + var calls []map[string]any + lastCallIdx, finishIdx, finishCount := -1, -1, 0 + for i, f := range frames { + text.WriteString(f.content) + for _, tc := range f.calls { + calls = append(calls, tc) + lastCallIdx = i + } + if f.finish != "" { + finishCount++ + finishIdx = i + } + } + if text.String() != prose { + t.Fatalf("正文应只保留标记之外的部分\nwant %q\ngot %q", prose, text.String()) + } + if len(calls) != 2 { + t.Fatalf("应还原 2 个 tool_call,实际 %d(body=%s)", len(calls), body) + } + for i, want := range []string{"ls -la", "pwd"} { + tc := calls[i] + if tc["type"] != "function" { + t.Fatalf("第 %d 个 tool_call type=%v want function", i, tc["type"]) + } + if id, _ := tc["id"].(string); id == "" { + t.Fatalf("第 %d 个 tool_call 缺 id", i) + } + if idx, ok := tc["index"].(float64); !ok || int(idx) != i { + t.Fatalf("第 %d 个 tool_call index=%v", i, tc["index"]) + } + fn, _ := tc["function"].(map[string]any) + if fn == nil || fn["name"] != "exec_command" { + t.Fatalf("第 %d 个 tool_call 函数名错误: %#v", i, tc) + } + argsJSON, _ := fn["arguments"].(string) + var args map[string]any + if err := json.Unmarshal([]byte(argsJSON), &args); err != nil { + t.Fatalf("第 %d 个 tool_call arguments 不是合法 JSON: %q", i, argsJSON) + } + if args["cmd"] != want { + t.Fatalf("第 %d 个 tool_call cmd=%#v want %q", i, args["cmd"], want) + } + } + if finishCount != 1 { + t.Fatalf("收尾帧应恰好 1 个,实际 %d(body=%s)", finishCount, body) + } + if frames[finishIdx].finish != "tool_calls" { + t.Fatalf("收尾 finish_reason=%q want tool_calls", frames[finishIdx].finish) + } + if finishIdx < lastCallIdx { + t.Fatalf("收尾帧(第 %d 帧)必须排在最后一个调用帧(第 %d 帧)之后", finishIdx, lastCallIdx) + } +} + +// TestStreamMarkupRepairAcrossManyChunks 上游把标记切碎成多个正文帧时同样成立。 +func TestStreamMarkupRepairAcrossManyChunks(t *testing.T) { + content := "开头\n" + mkBlock(mkInvoke("exec_command", mkParam("cmd", "ls -la"))) + "\n结尾" + // 按 rune 边界切:真实上游的 JSON 字符串不可能把多字节字符劈成半个 rune, + // 字节级切分会在 json.Marshal 时把非法 UTF-8 替换成 U+FFFD,等于先改坏夹具。 + runes := []rune(content) + chunks := make([]string, 0, len(runes)/5+1) + for i := 0; i < len(runes); i += 5 { + end := i + 5 + if end > len(runes) { + end = len(runes) + } + chunks = append(chunks, string(runes[i:end])) + } + raw := upstreamSSEWithContent(chunks, "stop") + + repair := NewMarkupRepair(testTools, false) + rec := httptest.NewRecorder() + if err := StreamHint(rec, strings.NewReader(raw), nil, WithMarkupRepair(repair)); err != nil { + t.Fatal(err) + } + if strings.Contains(rec.Body.String(), markupPipe) { + t.Fatalf("透出内容里仍残留标记: %s", rec.Body.String()) + } + if repair.Converted() != 1 { + t.Fatalf("Converted 应为 1,实际 %d", repair.Converted()) + } + var text strings.Builder + var calls int + var finish string + for _, f := range viewSSE(t, rec.Body.String()) { + text.WriteString(f.content) + calls += len(f.calls) + if f.finish != "" { + finish = f.finish + } + } + if text.String() != "开头\n\n结尾" { + t.Fatalf("正文错误: %q", text.String()) + } + if calls != 1 { + t.Fatalf("应还原 1 个 tool_call,实际 %d", calls) + } + if finish != "tool_calls" { + t.Fatalf("收尾 finish_reason=%q want tool_calls", finish) + } +} + +// TestStreamMarkupRepairUnclosedFlushedVerbatim 未闭合的块在流尾原样回吐,不吞字节。 +func TestStreamMarkupRepairUnclosedFlushedVerbatim(t *testing.T) { + content := "说明\n" + markupOpen + mkInvoke("exec_command", mkParam("cmd", "pwd")) + raw := upstreamSSEWithContent([]string{content}, "stop") + + repair := NewMarkupRepair(testTools, false) + rec := httptest.NewRecorder() + if err := StreamHint(rec, strings.NewReader(raw), nil, WithMarkupRepair(repair)); err != nil { + t.Fatal(err) + } + if repair.Converted() != 0 { + t.Fatalf("未闭合块不得转换,实际 %d", repair.Converted()) + } + var text strings.Builder + var calls int + for _, f := range viewSSE(t, rec.Body.String()) { + text.WriteString(f.content) + calls += len(f.calls) + } + if calls != 0 { + t.Fatalf("不得产出 tool_call,实际 %d", calls) + } + if text.String() != content { + t.Fatalf("未闭合块应原样回吐\nwant %q\ngot %q", content, text.String()) + } +} + +// TestStreamWithoutMarkupRepairIsUnchanged 修复器不启用时,流式输出必须与修复前 +// 逐字节一致(回归护栏:客户端没声明 tools、或没挂修复器)。 +func TestStreamWithoutMarkupRepairIsUnchanged(t *testing.T) { + content := mkBlock(mkInvoke("exec_command", mkParam("cmd", "ls -la"))) + raw := upstreamSSEWithContent([]string{content}, "stop") + + base := httptest.NewRecorder() + if err := StreamHint(base, strings.NewReader(raw), nil); err != nil { + t.Fatal(err) + } + if !strings.Contains(base.Body.String(), markupPipe) { + t.Fatal("基线流里本应还带着标记(上游原样透传)") + } + + disabled := httptest.NewRecorder() + if err := StreamHint(disabled, strings.NewReader(raw), nil, + WithMarkupRepair(NewMarkupRepair(nil, false))); err != nil { + t.Fatal(err) + } + if base.Body.String() != disabled.Body.String() { + t.Fatalf("未声明 tools 时输出被改动\nbase=%s\ngot =%s", base.Body.String(), disabled.Body.String()) + } +} diff --git a/internal/upstream/streak.go b/internal/upstream/streak.go index d647bb2d003693f4b036ce39bfe4c1bad0181b6f..7c7226d1a2acc93a62f9ff841907883f71baa6a5 100644 --- a/internal/upstream/streak.go +++ b/internal/upstream/streak.go @@ -1,106 +1,106 @@ -// streak.go 成长中心连登兑换 + 抽奖 API(2026-09-12 成长中心 bundle 逆向 + 页面实测)。 -// -// 机制:连登档位(7d/14d/28d)按**连续登录天数**解锁;兑换(POST /activity/growth/redeem) -// 发 credit/energy/补签卡/**抽奖次数**;抽奖(POST /activity/growth/lottery/draw)每次消耗 -// 1 次 chances。未解锁兑换返回 HTTP 403「连续登录天数不足」。 -// client_token 为前端生成的幂等令牌(randomUUID)。 -package upstream - -import ( - "crypto/rand" - "encoding/hex" - "encoding/json" - - "fmt" - "github.com/linguo2625469/workbuddy2api-panel/internal/auth" - "net/http" -) - -// streakRedeemPath / lottery 路径(growth 域,growthJSON 走 www.workbuddy.cn)。 -const ( - streakRedeemPath = "/activity/growth/redeem" - lotterySummaryPath = "/activity/growth/lottery/summary" - lotteryDrawPath = "/activity/growth/lottery/draw" -) - -// clientToken 幂等令牌(前端 randomUUID 同款语义)。 -func clientToken() string { - b := make([]byte, 16) - _, _ = rand.Read(b) - return fmt.Sprintf("%s-%s-%s-%s-%s", - hex.EncodeToString(b[0:4]), hex.EncodeToString(b[4:6]), hex.EncodeToString(b[6:8]), - hex.EncodeToString(b[8:10]), hex.EncodeToString(b[10:16])) -} - -// StreakFull 连登完整状态(GET /activity/growth/streak)。 -type StreakFull struct { - Streak struct { - Days int `json:"days"` - MonthTotalDays int `json:"month_total_days"` - NextTier string `json:"next_tier"` - NextTierRemaining int `json:"next_tier_remaining"` - } `json:"streak"` - MakeupCards struct { - Balance int `json:"balance"` - Max int `json:"max"` - } `json:"makeup_cards"` - RedemptionStatus struct { - Tier7dStatus string `json:"tier_7d_status"` - Tier14dStatus string `json:"tier_14d_status"` - Tier28dStatus string `json:"tier_28d_status"` - RemainingDays int `json:"remaining_days"` - Tiers []struct { - Tier string `json:"tier"` - Days int `json:"days"` - Credit int `json:"credit"` - Energy int `json:"energy"` - Cards int `json:"cards"` - Chances int `json:"chances"` - } `json:"tiers"` - } `json:"redemption_status"` -} - -// GrowthStreakFull 拉取连登完整状态。 -func (c *Client) GrowthStreakFull(a *auth.Auth) (*StreakFull, error) { - data, err := c.growthJSON(a, http.MethodGet, streakPath, nil) - if err != nil { - return nil, err - } - out := &StreakFull{} - if err := json.Unmarshal(data, out); err != nil { - return nil, err - } - return out, nil -} - -// GrowthRedeemTier 兑换连登档位(tier: "7d"|"14d"|"28d")。 -// 未解锁返回 *Error(HTTP 403「连续登录天数不足」),调用方按 locked 状态跳过即可。 -func (c *Client) GrowthRedeemTier(a *auth.Auth, tier string) error { - _, err := c.growthJSON(a, http.MethodPost, streakRedeemPath, - map[string]any{"tier": tier, "client_token": clientToken()}) - return err -} - -// LotteryChances 当前抽奖次数(GET /activity/growth/lottery/summary)。 -func (c *Client) LotteryChances(a *auth.Auth) (int, error) { - data, err := c.growthJSON(a, http.MethodGet, lotterySummaryPath, nil) - if err != nil { - return 0, err - } - var resp struct { - Chances int `json:"chances"` - Module struct { - Enabled bool `json:"enabled"` - } `json:"module"` - } - if err := json.Unmarshal(data, &resp); err != nil { - return 0, err - } - return resp.Chances, nil -} - -// LotteryDraw 抽奖一次,返回原始奖品载荷(prize 字段形状由活动期决定,透传给调用方)。 -func (c *Client) LotteryDraw(a *auth.Auth) (json.RawMessage, error) { - return c.growthJSON(a, http.MethodPost, lotteryDrawPath, - map[string]any{"client_token": clientToken()}) -} +// streak.go 成长中心连登兑换 + 抽奖 API(2026-09-12 成长中心 bundle 逆向 + 页面实测)。 +// +// 机制:连登档位(7d/14d/28d)按**连续登录天数**解锁;兑换(POST /activity/growth/redeem) +// 发 credit/energy/补签卡/**抽奖次数**;抽奖(POST /activity/growth/lottery/draw)每次消耗 +// 1 次 chances。未解锁兑换返回 HTTP 403「连续登录天数不足」。 +// client_token 为前端生成的幂等令牌(randomUUID)。 +package upstream + +import ( + "crypto/rand" + "encoding/hex" + "encoding/json" + + "fmt" + "github.com/misakano7545/workbuddy2api-panel/internal/auth" + "net/http" +) + +// streakRedeemPath / lottery 路径(growth 域,growthJSON 走 www.workbuddy.cn)。 +const ( + streakRedeemPath = "/activity/growth/redeem" + lotterySummaryPath = "/activity/growth/lottery/summary" + lotteryDrawPath = "/activity/growth/lottery/draw" +) + +// clientToken 幂等令牌(前端 randomUUID 同款语义)。 +func clientToken() string { + b := make([]byte, 16) + _, _ = rand.Read(b) + return fmt.Sprintf("%s-%s-%s-%s-%s", + hex.EncodeToString(b[0:4]), hex.EncodeToString(b[4:6]), hex.EncodeToString(b[6:8]), + hex.EncodeToString(b[8:10]), hex.EncodeToString(b[10:16])) +} + +// StreakFull 连登完整状态(GET /activity/growth/streak)。 +type StreakFull struct { + Streak struct { + Days int `json:"days"` + MonthTotalDays int `json:"month_total_days"` + NextTier string `json:"next_tier"` + NextTierRemaining int `json:"next_tier_remaining"` + } `json:"streak"` + MakeupCards struct { + Balance int `json:"balance"` + Max int `json:"max"` + } `json:"makeup_cards"` + RedemptionStatus struct { + Tier7dStatus string `json:"tier_7d_status"` + Tier14dStatus string `json:"tier_14d_status"` + Tier28dStatus string `json:"tier_28d_status"` + RemainingDays int `json:"remaining_days"` + Tiers []struct { + Tier string `json:"tier"` + Days int `json:"days"` + Credit int `json:"credit"` + Energy int `json:"energy"` + Cards int `json:"cards"` + Chances int `json:"chances"` + } `json:"tiers"` + } `json:"redemption_status"` +} + +// GrowthStreakFull 拉取连登完整状态。 +func (c *Client) GrowthStreakFull(a *auth.Auth) (*StreakFull, error) { + data, err := c.growthJSON(a, http.MethodGet, streakPath, nil) + if err != nil { + return nil, err + } + out := &StreakFull{} + if err := json.Unmarshal(data, out); err != nil { + return nil, err + } + return out, nil +} + +// GrowthRedeemTier 兑换连登档位(tier: "7d"|"14d"|"28d")。 +// 未解锁返回 *Error(HTTP 403「连续登录天数不足」),调用方按 locked 状态跳过即可。 +func (c *Client) GrowthRedeemTier(a *auth.Auth, tier string) error { + _, err := c.growthJSON(a, http.MethodPost, streakRedeemPath, + map[string]any{"tier": tier, "client_token": clientToken()}) + return err +} + +// LotteryChances 当前抽奖次数(GET /activity/growth/lottery/summary)。 +func (c *Client) LotteryChances(a *auth.Auth) (int, error) { + data, err := c.growthJSON(a, http.MethodGet, lotterySummaryPath, nil) + if err != nil { + return 0, err + } + var resp struct { + Chances int `json:"chances"` + Module struct { + Enabled bool `json:"enabled"` + } `json:"module"` + } + if err := json.Unmarshal(data, &resp); err != nil { + return 0, err + } + return resp.Chances, nil +} + +// LotteryDraw 抽奖一次,返回原始奖品载荷(prize 字段形状由活动期决定,透传给调用方)。 +func (c *Client) LotteryDraw(a *auth.Auth) (json.RawMessage, error) { + return c.growthJSON(a, http.MethodPost, lotteryDrawPath, + map[string]any{"client_token": clientToken()}) +} diff --git a/internal/upstream/streak_extras.go b/internal/upstream/streak_extras.go new file mode 100644 index 0000000000000000000000000000000000000000..1c081f839f31793557286e263083901b29faf50c --- /dev/null +++ b/internal/upstream/streak_extras.go @@ -0,0 +1,78 @@ +// streak_extras.go 新手礼包 / 连登 heatmap / 补签卡 API(growth / billing 域的增补接口)。 +// +// 原 blackcat.go:夜猫子 black_cat 已从上游下架,任务链与排程一并删除。 +package upstream + +import ( + "encoding/json" + "fmt" + "net/http" + "sort" + + "github.com/misakano7545/workbuddy2api-panel/internal/auth" +) + +// ClaimGift 领取新手礼包(每号一次,已领返回业务错误)。 +func (c *Client) ClaimGift(a *auth.Auth) (int64, error) { + data, err := c.billingJSON(a, http.MethodPost, "/billing/meter/claim-gift", map[string]any{}) + if err != nil { + return 0, err + } + var resp struct { + Credit int64 `json:"credit"` + } + _ = json.Unmarshal(data, &resp) + return resp.Credit, nil +} + +// HeatmapBrokenDates 返回本月(今天所在月的 1 号起)到今天(不含)之间 +// score==0 的日期,升序。 +// +// 下界只能取月首,不能更宽:score==0 同时表示「那天漏签」和「那天账号还不存在」 +// (探针实测:注册前的日子也是 0 分,heatmap 的 range 是近 365 天),只有上游能 +// 区分两者——所以这里只做时间窗收窄,交给 UseMakeupCard 的拒绝兜底。 +// 今天不算:当天未结束,0 分不代表漏签。today.date 由响应给出,不读宿主机时钟 +// (宿主机若为 UTC,本地 08:00 前会算错天)。 +func (c *Client) HeatmapBrokenDates(a *auth.Auth) ([]string, error) { + data, err := c.growthJSON(a, http.MethodGet, "/activity/growth/heatmap", nil) + if err != nil { + return nil, err + } + var resp struct { + Today struct { + Date string `json:"date"` + } `json:"today"` + Cells []struct { + Date string `json:"date"` + Score int `json:"score"` + } `json:"cells"` + } + if err := json.Unmarshal(data, &resp); err != nil { + return nil, err + } + if len(resp.Today.Date) < 10 { + return nil, fmt.Errorf("heatmap 缺 today.date(结构未知,不敢猜窗口)") + } + today := resp.Today.Date[:10] + monthStart := today[:8] + "01" + var out []string + for _, cell := range resp.Cells { + d := cell.Date + if len(d) < 10 { + continue + } + d = d[:10] + if cell.Score == 0 && d >= monthStart && d < today { + out = append(out, d) + } + } + sort.Strings(out) // 上游是否保证升序未验证 + return out, nil +} + +// UseMakeupCard 对指定日期使用补签卡(保住连登连续天数;无卡返回业务错误)。 +func (c *Client) UseMakeupCard(a *auth.Auth, date string) error { + _, err := c.growthJSON(a, http.MethodPost, "/activity/growth/makeup-cards/use", + map[string]any{"target_date": date}) + return err +} diff --git a/internal/upstream/streak_test.go b/internal/upstream/streak_test.go index c6f7c0697795a6e7af8744052235be8b55128020..afc25f0e4cef615a05ed4c0586981bcc92268620 100644 --- a/internal/upstream/streak_test.go +++ b/internal/upstream/streak_test.go @@ -1,77 +1,77 @@ -package upstream - -import ( - "net/http" - "net/http/httptest" - "testing" - - "github.com/linguo2625469/workbuddy2api-panel/internal/auth" -) - -// TestGrowthStreakParsesDays 解析 data.streak.days(probe_active.py 同口径)。 -func TestGrowthStreakParsesDays(t *testing.T) { - srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { - if r.URL.Path != "/activity/growth/streak" { - t.Errorf("path=%s want /activity/growth/streak", r.URL.Path) - } - if r.Method != http.MethodGet { - t.Errorf("method=%s want GET", r.Method) - } - w.Write([]byte(`{"code":0,"msg":"ok","data":{"streak":{"days":3,"total_rewards":1}}}`)) - })) - defer srv.Close() - - c := &Client{HTTP: srv.Client(), ChatBaseCN: srv.URL, BillingBaseCN: srv.URL} - days, err := c.GrowthStreak(&auth.Auth{AccessToken: "at", UID: "u1"}) - if err != nil { - t.Fatalf("GrowthStreak: %v", err) - } - if days != 3 { - t.Errorf("days=%d want 3", days) - } -} - -// TestGrowthStreakDefaultZero 缺 streak/days 字段 → 0(days==0 即自检告警信号)。 -func TestGrowthStreakDefaultZero(t *testing.T) { - srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { - w.Write([]byte(`{"code":0,"data":{}}`)) - })) - defer srv.Close() - - c := &Client{HTTP: srv.Client(), ChatBaseCN: srv.URL, BillingBaseCN: srv.URL} - days, err := c.GrowthStreak(&auth.Auth{AccessToken: "at", UID: "u1"}) - if err != nil { - t.Fatalf("GrowthStreak: %v", err) - } - if days != 0 { - t.Errorf("days=%d want 0(缺字段零值)", days) - } -} - -// TestGrowthStreakServerError HTTP 非 2xx → *Error。 -func TestGrowthStreakServerError(t *testing.T) { - srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { - w.WriteHeader(500) - w.Write([]byte(`boom`)) - })) - defer srv.Close() - - c := &Client{HTTP: srv.Client(), ChatBaseCN: srv.URL, BillingBaseCN: srv.URL} - if _, err := c.GrowthStreak(&auth.Auth{AccessToken: "at", UID: "u1"}); err == nil { - t.Fatal("want error on 500") - } -} - -// TestGrowthStreakBusinessCode 业务 code 非 0 → 错误(非 2xx 之外的静默失败也要能被观测)。 -func TestGrowthStreakBusinessCode(t *testing.T) { - srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { - w.WriteHeader(200) - w.Write([]byte(`{"code":12000,"msg":"internal"}`)) - })) - defer srv.Close() - - c := &Client{HTTP: srv.Client(), ChatBaseCN: srv.URL, BillingBaseCN: srv.URL} - if _, err := c.GrowthStreak(&auth.Auth{AccessToken: "at", UID: "u1"}); err == nil { - t.Fatal("want error on non-zero business code") - } -} +package upstream + +import ( + "net/http" + "net/http/httptest" + "testing" + + "github.com/misakano7545/workbuddy2api-panel/internal/auth" +) + +// TestGrowthStreakParsesDays 解析 data.streak.days(probe_active.py 同口径)。 +func TestGrowthStreakParsesDays(t *testing.T) { + srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { + if r.URL.Path != "/activity/growth/streak" { + t.Errorf("path=%s want /activity/growth/streak", r.URL.Path) + } + if r.Method != http.MethodGet { + t.Errorf("method=%s want GET", r.Method) + } + w.Write([]byte(`{"code":0,"msg":"ok","data":{"streak":{"days":3,"total_rewards":1}}}`)) + })) + defer srv.Close() + + c := &Client{HTTP: srv.Client(), ChatBaseCN: srv.URL, BillingBaseCN: srv.URL} + days, err := c.GrowthStreak(&auth.Auth{AccessToken: "at", UID: "u1"}) + if err != nil { + t.Fatalf("GrowthStreak: %v", err) + } + if days != 3 { + t.Errorf("days=%d want 3", days) + } +} + +// TestGrowthStreakDefaultZero 缺 streak/days 字段 → 0(days==0 即自检告警信号)。 +func TestGrowthStreakDefaultZero(t *testing.T) { + srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { + w.Write([]byte(`{"code":0,"data":{}}`)) + })) + defer srv.Close() + + c := &Client{HTTP: srv.Client(), ChatBaseCN: srv.URL, BillingBaseCN: srv.URL} + days, err := c.GrowthStreak(&auth.Auth{AccessToken: "at", UID: "u1"}) + if err != nil { + t.Fatalf("GrowthStreak: %v", err) + } + if days != 0 { + t.Errorf("days=%d want 0(缺字段零值)", days) + } +} + +// TestGrowthStreakServerError HTTP 非 2xx → *Error。 +func TestGrowthStreakServerError(t *testing.T) { + srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { + w.WriteHeader(500) + w.Write([]byte(`boom`)) + })) + defer srv.Close() + + c := &Client{HTTP: srv.Client(), ChatBaseCN: srv.URL, BillingBaseCN: srv.URL} + if _, err := c.GrowthStreak(&auth.Auth{AccessToken: "at", UID: "u1"}); err == nil { + t.Fatal("want error on 500") + } +} + +// TestGrowthStreakBusinessCode 业务 code 非 0 → 错误(非 2xx 之外的静默失败也要能被观测)。 +func TestGrowthStreakBusinessCode(t *testing.T) { + srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { + w.WriteHeader(200) + w.Write([]byte(`{"code":12000,"msg":"internal"}`)) + })) + defer srv.Close() + + c := &Client{HTTP: srv.Client(), ChatBaseCN: srv.URL, BillingBaseCN: srv.URL} + if _, err := c.GrowthStreak(&auth.Auth{AccessToken: "at", UID: "u1"}); err == nil { + t.Fatal("want error on non-zero business code") + } +} diff --git a/internal/upstream/stream_truncation_terminal_test.go b/internal/upstream/stream_truncation_terminal_test.go new file mode 100644 index 0000000000000000000000000000000000000000..215816a83178e599746473ba3d0bea758201d7c0 --- /dev/null +++ b/internal/upstream/stream_truncation_terminal_test.go @@ -0,0 +1,48 @@ +package upstream + +import ( + "net/http/httptest" + "strings" + "testing" +) + +// TestStreamInterruptedEmitsTruncationTerminal 上游既没给 finish_reason 也没发 +// data: [DONE] 就 EOF(连接说一半断了)时,此前只补 [DONE]:客户端看到「内容 + +// 正常结束」,finish_reason 为空,responses 适配器回 response.completed。Agent 侧 +// 的表现就是「说到一半停了、也不报错」(2026-11-07 生产实案:Agent 任务在工具调用 +// 之后静默收尾,用户只能手动催)。现在必须补一帧截断终态。 +func TestStreamInterruptedEmitsTruncationTerminal(t *testing.T) { + raw := ": keepalive\n\n" + + `data: {"id":"c1","choices":[{"index":0,"delta":{"content":"半句"}}]}` + "\n\n" + rec := httptest.NewRecorder() + if err := StreamHint(rec, strings.NewReader(raw), nil); err != nil { + t.Fatalf("StreamHint: %v", err) + } + body := rec.Body.String() + if !strings.Contains(body, `"finish_reason":"`+TruncationFinishReason+`"`) { + t.Fatalf("断流未补截断终态,body=%s", body) + } + // 恰好一个终态:[DONE] 之后不得再出现第二个 finish_reason。 + if n := strings.Count(body, `"finish_reason":"`+TruncationFinishReason+`"`); n != 1 { + t.Fatalf("截断终态应恰好一帧,got %d", n) + } +} + +// TestStreamNormalDoneNoExtraTerminal 上游正常收尾(给了 [DONE]、且带 finish_reason) +// 时不得多补一帧:两个 finish_reason 会让客户端把后一个当真正的收尾。 +func TestStreamNormalDoneNoExtraTerminal(t *testing.T) { + raw := `data: {"id":"c1","choices":[{"index":0,"delta":{"content":"hi"}}]}` + "\n\n" + + `data: {"id":"c1","choices":[{"index":0,"delta":{},"finish_reason":"stop"}]}` + "\n\n" + + "data: [DONE]\n\n" + rec := httptest.NewRecorder() + if err := StreamHint(rec, strings.NewReader(raw), nil); err != nil { + t.Fatalf("StreamHint: %v", err) + } + body := rec.Body.String() + if strings.Contains(body, `"finish_reason":"`+TruncationFinishReason+`"`) { + t.Fatalf("正常收尾不该补截断终态,body=%s", body) + } + if n := strings.Count(body, `"finish_reason":"stop"`); n != 1 { + t.Fatalf("正常终态应恰好一帧,got %d", n) + } +} diff --git a/internal/upstream/tasks.go b/internal/upstream/tasks.go index 4a0910b0e5972b368ef8d5bfe5725d6196bb2ae0..66f75583b9d7886a6b4841181d28ad3e2fc9b999 100644 --- a/internal/upstream/tasks.go +++ b/internal/upstream/tasks.go @@ -1,272 +1,354 @@ -// tasks.go growth 域「任务」接口:列表查询 / 接受 / 领取奖励。 -// -// 来源:上游 scripts/task_common.py 实测口径(list_tasks/accept_tasks/claim_reward), -// 集成进主程序后不再需要外部脚本。 -// -// 端点(chatBase,BillingHeaders): -// - GET /v2/activity/growth/tasks 全量任务列表(含 progress/accept_status) -// - POST /v2/activity/growth/tasks/accept {"task_codes":[...]} not_accepted → accepted -// - POST /v2/activity/growth/tasks/reward/claim {"task_code":"..."} 完成态领奖 -// -// 语义要点: -// - accept 是"报名",不产生进度;进度由服务端行为事件点亮(如 chat_request_send 上报、 -// 真实对话),故 accept 后可幂等重放。 -// - claim 仅在 progress 达标后可领;重复领返回业务错误(安全,不需要前置状态判断)。 -package upstream - -import ( - "bytes" - "encoding/json" - "io" - "net/http" - "net/url" - - "github.com/linguo2625469/workbuddy2api-panel/internal/auth" -) - -// growth 域任务路径(与 scripts/task_common.py 对齐)。 -const ( - tasksListPath = "/v2/activity/growth/tasks" - tasksAcceptPath = "/v2/activity/growth/tasks/accept" -) - -// mpPlatform 小程序口径头值:小程序限定任务(Sequential_Tasks_1 / school_season) -// 的列表下发、accept、claim 全链路要求 X-Client-Platform: miniprogram。 -const mpPlatform = "miniprogram" - -// Task 单个任务的对外视图(字段名与上游 JSON 对齐,多余字段不透出)。 -type Task struct { - TaskCode string `json:"task_code"` - Title string `json:"title,omitempty"` - Description string `json:"description,omitempty"` // 操作指引(含跳转说明) - TaskDesc string `json:"task_desc,omitempty"` // 达成条件简述 - Credit int64 `json:"credit,omitempty"` // 奖励积分(上游 reward_credit) - Energy int64 `json:"energy,omitempty"` // 奖励能量(上游 reward_energy) - HasReward bool `json:"has_reward,omitempty"` // 是否带奖励 - RewardBuddy bool `json:"reward_buddy,omitempty"` - TaskType string `json:"task_type,omitempty"` // single(一次性)/ 累计型 - Tag string `json:"tag,omitempty"` // 端标记(PC 等) - JumpURL string `json:"jump_url,omitempty"` // 客户端跳转协议(workbuddy://...) - Locked bool `json:"locked,omitempty"` // 上游标记未解锁 - Target int64 `json:"target"` // 目标次数(恒输出:0 是有效进度值) - Current int64 `json:"current"` // 当前进度(恒输出:0 是有效进度值) - AcceptStatus string `json:"accept_status,omitempty"` - Status string `json:"status,omitempty"` // 上游任务状态(complete 等) - Claimable bool `json:"claimable,omitempty"` // 进度达标且未领取(本地推算) - Claimed bool `json:"claimed,omitempty"` // 已领取(accept_status == claimed) -} - -// ListTasks 拉取全量任务列表(默认口径,无端标记头)。 -// 响应形如 data.tasks[],元素字段随任务类型变化(progress 可能是 {current,target} 或平铺), -// 这里做宽松解析:两种形状都尝试。 -func (c *Client) ListTasks(a *auth.Auth) ([]Task, error) { - data, err := c.growthJSON(a, http.MethodGet, tasksListPath, nil) - if err != nil { - return nil, err - } - return parseGrowthTasks(data) -} - -// ListTasksMP 拉取小程序口径的任务列表(X-Client-Platform: miniprogram)。 -// 小程序限定任务(Sequential_Tasks_1「小程序首对话」/ school_season「校园日」等) -// 仅在该口径下发——默认列表不出现,accept/claim 同样要求该头(缺头 accept 返回 -// task not found,上游 task_runner 实测)。**实测 mp 列表是默认口径的超集** -// (含 RichMeow/Model_chat 等常规任务 + wb_wechat_oa_subscribe_task 等 mp 专属), -// 合并时调用方须按 task_code 去重。 -func (c *Client) ListTasksMP(a *auth.Auth) ([]Task, error) { - data, err := c.growthJSONMP(a, http.MethodGet, tasksListPath, nil) - if err != nil { - return nil, err - } - return parseGrowthTasks(data) -} - -// growthJSONMP 发 growth 域请求(小程序口径:叠加 X-Client-Platform: miniprogram) -// 并解信封。语义同 growthJSON。 -func (c *Client) growthJSONMP(a *auth.Auth, method, path string, body any) (json.RawMessage, error) { - var rdr io.Reader - if body != nil { - raw, err := json.Marshal(body) - if err != nil { - return nil, err - } - rdr = bytes.NewReader(raw) - } - req, err := http.NewRequest(method, c.chatBase(a)+path, rdr) - if err != nil { - return nil, err - } - c.BillingHeaders(req, a) - req.Header.Set("X-Client-Platform", mpPlatform) - return c.doJSON(req) -} - -// AcceptTasksMP 接受小程序限定任务(mp 头;缺头实测 task not found)。 -// 幂等语义同 AcceptTasks。 -func (c *Client) AcceptTasksMP(a *auth.Auth, taskCodes []string) error { - _, err := c.growthJSONMP(a, http.MethodPost, tasksAcceptPath, map[string]any{"task_codes": taskCodes}) - return err -} - -// ClaimRewardMP 领取小程序限定任务奖励:chat 域 /activity/growth/tasks/{code}/claim -// + mp 头(上游 task_runner claim_one(mp=True) 同款);chat 域 400 时降级 Web 域 -// 领奖端点(ClaimReward,x-client-platform: web 形态)。返回 (credit, energy, err)。 -func (c *Client) ClaimRewardMP(a *auth.Auth, taskCode string) (credit, energy int64, err error) { - req, err := http.NewRequest(http.MethodPost, - c.chatBase(a)+"/activity/growth/tasks/"+url.PathEscape(taskCode)+"/claim", nil) - if err != nil { - return 0, 0, err - } - c.BillingHeaders(req, a) - req.Header.Set("X-Client-Platform", mpPlatform) - data, err := c.doJSON(req) - if err != nil { - // chat 域对该路径 400(部分任务/租户形态)→ Web 域降级(已实测可领)。 - if ue, ok := err.(*Error); ok && ue.Status == http.StatusBadRequest { - return c.ClaimReward(a, taskCode) - } - return 0, 0, err - } - return parseClaimReward(data) -} - -// parseClaimReward 解析领奖响应 data:{"already_claimed":bool,"credit":n,"energy":n}。 -func parseClaimReward(data json.RawMessage) (credit, energy int64, err error) { - var resp struct { - AlreadyClaimed bool `json:"already_claimed"` - Credit int64 `json:"credit"` - Energy int64 `json:"energy"` - } - if err := json.Unmarshal(data, &resp); err != nil { - return 0, 0, err - } - return resp.Credit, resp.Energy, nil -} - -// parseGrowthTasks 解析 growth 任务列表 data.tasks[](默认与 mp 口径共用)。 -func parseGrowthTasks(data json.RawMessage) ([]Task, error) { - var resp struct { - Tasks []struct { - TaskCode string `json:"task_code"` - Title string `json:"title"` - Description string `json:"description"` - TaskDesc string `json:"task_desc"` - RewardCredit int64 `json:"reward_credit"` // 上游实际字段名(reward_ 前缀) - RewardEnergy int64 `json:"reward_energy"` - HasReward bool `json:"has_reward"` - RewardBuddy bool `json:"reward_buddy"` - TaskType string `json:"task_type"` - Tag string `json:"tag"` - JumpURL string `json:"jump_url"` - Locked bool `json:"locked"` - AcceptStatus string `json:"accept_status"` - Status string `json:"status"` - Target int64 `json:"target"` - Current int64 `json:"current"` - Progress json.RawMessage `json:"progress"` - } `json:"tasks"` - } - if err := json.Unmarshal(data, &resp); err != nil { - return nil, err - } - out := make([]Task, 0, len(resp.Tasks)) - for _, t := range resp.Tasks { - cur, tgt := t.Current, t.Target - // progress 可能是 {current,target} 对象(实测口径),覆盖平铺字段。 - if len(t.Progress) > 0 && string(t.Progress) != "null" { - var pr struct { - Current int64 `json:"current"` - Target int64 `json:"target"` - } - if json.Unmarshal(t.Progress, &pr) == nil && (pr.Target > 0 || pr.Current > 0) { - cur, tgt = pr.Current, pr.Target - } - } - claimed := t.AcceptStatus == "claimed" - out = append(out, Task{ - TaskCode: t.TaskCode, - Title: t.Title, - Description: t.Description, - TaskDesc: t.TaskDesc, - Credit: t.RewardCredit, - Energy: t.RewardEnergy, - HasReward: t.HasReward, - RewardBuddy: t.RewardBuddy, - TaskType: t.TaskType, - Tag: t.Tag, - JumpURL: t.JumpURL, - Locked: t.Locked, - Target: tgt, - Current: cur, - AcceptStatus: t.AcceptStatus, - Status: t.Status, - Claimable: !claimed && tgt > 0 && cur >= tgt, - Claimed: claimed, - }) - } - return out, nil -} - -// AcceptTasks 接受任务(幂等:已 accepted 时上游返回成功或业务提示,均不视为致命错误)。 -func (c *Client) AcceptTasks(a *auth.Auth, taskCodes []string) error { - _, err := c.growthJSON(a, http.MethodPost, tasksAcceptPath, map[string]any{"task_codes": taskCodes}) - return err -} - -// ClaimReward 领取单个任务奖励。 -// -// 端点来源(实测):Web 成长中心的领奖请求 —— -// -// POST https://www.workbuddy.cn/activity/growth/tasks//claim -// (任务码在**路径**里,无 body;带 x-client-platform: web 头,Bearer 鉴权) -// -// 关键区别:此前误用 CLI 域 copilot.tencent.com 的 -// /v2/activity/growth/tasks/reward/claim(task_code 放 body),该路径**不存在**, -// 一直返回 400 "task not completed",是此前领奖失败的真实原因。 -// 本实现返回 (credit, energy, err):credit/energy 为本次到账奖励(已领取过时为 0)。 -func (c *Client) ClaimReward(a *auth.Auth, taskCode string) (credit, energy int64, err error) { - req, err := http.NewRequest(http.MethodPost, - c.webBase(a)+"/activity/growth/tasks/"+url.PathEscape(taskCode)+"/claim", nil) - if err != nil { - return 0, 0, err - } - // Web 端请求头形状(对照浏览器实际请求):Origin/Referer 指向 workbuddy.cn 成长中心, - // 带 x-client-platform: web 标记来源端。 - req.Header.Set("Authorization", "Bearer "+a.AccessTokenValue()) - req.Header.Set("Accept", "application/json, text/plain, */*") - req.Header.Set("Content-Type", "application/json") - req.Header.Set("Origin", "https://www.workbuddy.cn") - req.Header.Set("Referer", "https://www.workbuddy.cn/profile/growth-center") - req.Header.Set("x-client-platform", "web") - if ua := c.userAgent(a); ua != "" { - req.Header.Set("User-Agent", ua) - } - if a.UID != "" { - req.Header.Set("X-User-Id", a.UID) - } - if a.EnterpriseID != "" { - req.Header.Set("X-Enterprise-Id", a.EnterpriseID) - req.Header.Set("X-Tenant-Id", a.EnterpriseID) - } - if d := a.DomainValue(); d != "" { - req.Header.Set("X-Domain", d) - } - - data, err := c.doJSON(req) - if err != nil { - return 0, 0, err - } - // 响应 data:{"already_claimed":bool,"credit":100,"energy":5,...} - var resp struct { - AlreadyClaimed bool `json:"already_claimed"` - Credit int64 `json:"credit"` - Energy int64 `json:"energy"` - } - if err := json.Unmarshal(data, &resp); err != nil { - return 0, 0, err - } - if resp.AlreadyClaimed { - return 0, 0, nil // 幂等:重复领取不算错误,但无新增奖励 - } - return resp.Credit, resp.Energy, nil -} +// tasks.go growth 域「任务」接口:列表查询 / 接受 / 领取奖励。 +// +// 来源:上游 scripts/task_common.py 实测口径(list_tasks/accept_tasks/claim_reward), +// 集成进主程序后不再需要外部脚本。 +// +// 端点(chatBase,BillingHeaders): +// - GET /v2/activity/growth/tasks 全量任务列表(含 progress/accept_status) +// - POST /v2/activity/growth/tasks/accept {"task_codes":[...]} not_accepted → accepted +// - POST /v2/activity/growth/tasks/reward/claim {"task_code":"..."} 完成态领奖 +// +// 语义要点: +// - accept 是"报名",不产生进度;进度由服务端行为事件点亮(如 chat_request_send 上报、 +// 真实对话),故 accept 后可幂等重放。 +// - claim 仅在 progress 达标后可领;重复领返回业务错误(安全,不需要前置状态判断)。 +package upstream + +import ( + "bytes" + "encoding/json" + "io" + "net/http" + "net/url" + + "github.com/misakano7545/workbuddy2api-panel/internal/auth" +) + +// growth 域任务路径(与 scripts/task_common.py 对齐)。 +const ( + tasksListPath = "/v2/activity/growth/tasks" + tasksAcceptPath = "/v2/activity/growth/tasks/accept" +) + +// mpPlatform 小程序口径头值:小程序限定任务(Sequential_Tasks_*) +// 的列表下发、accept、claim 全链路要求 X-Client-Platform: miniprogram。 +const mpPlatform = "miniprogram" + +// Task 单个任务的对外视图(字段名与上游 JSON 对齐,多余字段不透出)。 +type Task struct { + TaskCode string `json:"task_code"` + Code string `json:"code,omitempty"` + TaskID int64 `json:"task_id,omitempty"` + Title string `json:"title,omitempty"` + Description string `json:"description,omitempty"` // 操作指引(含跳转说明) + TaskDesc string `json:"task_desc,omitempty"` // 达成条件简述 + Credit int64 `json:"credit,omitempty"` // 奖励积分(上游 reward_credit) + Energy int64 `json:"energy,omitempty"` // 奖励能量(上游 reward_energy) + HasReward bool `json:"has_reward,omitempty"` // 是否带奖励 + RewardBuddy bool `json:"reward_buddy,omitempty"` + TaskType string `json:"task_type,omitempty"` // single(一次性)/ 累计型 + Tag string `json:"tag,omitempty"` // 端标记(PC 等) + JumpURL string `json:"jump_url,omitempty"` // 客户端跳转协议(workbuddy://...) + Locked bool `json:"locked,omitempty"` // 上游标记未解锁 + Target int64 `json:"target"` // 目标次数(ProgressKnown=false 时省略) + Current int64 `json:"current"` // 当前进度(ProgressKnown=false 时省略) + ProgressKnown bool `json:"progress_known"` + RewardKnown bool `json:"reward_known"` + AcceptStatus string `json:"accept_status,omitempty"` + Status string `json:"status,omitempty"` // 上游任务状态(complete 等) + Claimable bool `json:"claimable,omitempty"` // 进度达标且未领取(本地推算) + Claimed bool `json:"claimed,omitempty"` // 已领取(accept_status == claimed) + creditKnown bool `json:"-"` + energyKnown bool `json:"-"` + hasRewardKnown bool `json:"-"` +} + +// MarshalJSON 区分「0」与「字段缺失」:源 schema 有进度字段(CN 口径)时照常输出 +// target/current(含显式 0),源 schema 完全不报进度(实测 global 任务列表形态) +// 时省略它们;奖励字段同口径逐字段判定。移植上游 PR #104。 +func (t Task) MarshalJSON() ([]byte, error) { + type taskAlias Task + raw, err := json.Marshal(taskAlias(t)) + if err != nil { + return nil, err + } + var fields map[string]json.RawMessage + if err := json.Unmarshal(raw, &fields); err != nil { + return nil, err + } + if !t.ProgressKnown { + delete(fields, "target") + delete(fields, "current") + } + if !t.RewardKnown { + delete(fields, "credit") + delete(fields, "energy") + delete(fields, "has_reward") + } else { + if !t.creditKnown { + delete(fields, "credit") + } + if !t.energyKnown { + delete(fields, "energy") + } + if !t.hasRewardKnown { + delete(fields, "has_reward") + } + } + return json.Marshal(fields) +} + +// ListTasks 拉取全量任务列表(默认口径,无端标记头)。 +// 响应形如 data.tasks[],元素字段随任务类型变化(progress 可能是 {current,target} 或平铺), +// 这里做宽松解析:两种形状都尝试。 +func (c *Client) ListTasks(a *auth.Auth) ([]Task, error) { + data, err := c.growthJSON(a, http.MethodGet, tasksListPath, nil) + if err != nil { + return nil, err + } + return parseGrowthTasks(data) +} + +// ListTasksMP 拉取小程序口径的任务列表(X-Client-Platform: miniprogram)。 +// 小程序限定任务(Sequential_Tasks_* 等) +// 仅在该口径下发——默认列表不出现,accept/claim 同样要求该头(缺头 accept 返回 +// task not found,上游 task_runner 实测)。**实测 mp 列表是默认口径的超集** +// (含 RichMeow/Model_chat 等常规任务 + wb_wechat_oa_subscribe_task 等 mp 专属), +// 合并时调用方须按 task_code 去重。 +func (c *Client) ListTasksMP(a *auth.Auth) ([]Task, error) { + data, err := c.growthJSONMP(a, http.MethodGet, tasksListPath, nil) + if err != nil { + return nil, err + } + return parseGrowthTasks(data) +} + +// growthJSONMP 发 growth 域请求(小程序口径:叠加 X-Client-Platform: miniprogram) +// 并解信封。语义同 growthJSON。 +func (c *Client) growthJSONMP(a *auth.Auth, method, path string, body any) (json.RawMessage, error) { + var rdr io.Reader + if body != nil { + raw, err := json.Marshal(body) + if err != nil { + return nil, err + } + rdr = bytes.NewReader(raw) + } + req, err := http.NewRequest(method, c.chatBase(a)+path, rdr) + if err != nil { + return nil, err + } + c.BillingHeaders(req, a) + req.Header.Set("X-Client-Platform", mpPlatform) + return c.doJSON(req, a) +} + +// AcceptTasksMP 接受小程序限定任务(mp 头;缺头实测 task not found)。 +// 幂等语义同 AcceptTasks。 +func (c *Client) AcceptTasksMP(a *auth.Auth, taskCodes []string) error { + _, err := c.growthJSONMP(a, http.MethodPost, tasksAcceptPath, map[string]any{"task_codes": taskCodes}) + return err +} + +// ClaimRewardMP 领取小程序限定任务奖励:chat 域 /activity/growth/tasks/{code}/claim +// + mp 头(上游 task_runner claim_one(mp=True) 同款);chat 域 400 时降级 Web 域 +// 领奖端点(ClaimReward,x-client-platform: web 形态)。返回 (credit, energy, err)。 +func (c *Client) ClaimRewardMP(a *auth.Auth, taskCode string) (credit, energy int64, err error) { + req, err := http.NewRequest(http.MethodPost, + c.chatBase(a)+"/activity/growth/tasks/"+url.PathEscape(taskCode)+"/claim", nil) + if err != nil { + return 0, 0, err + } + c.BillingHeaders(req, a) + req.Header.Set("X-Client-Platform", mpPlatform) + data, err := c.doJSON(req, a) + if err != nil { + // chat 域对该路径 400(部分任务/租户形态)→ Web 域降级(已实测可领)。 + if ue, ok := err.(*Error); ok && ue.Status == http.StatusBadRequest { + return c.ClaimReward(a, taskCode) + } + return 0, 0, err + } + return parseClaimReward(data) +} + +// parseClaimReward 解析领奖响应 data:{"already_claimed":bool,"credit":n,"energy":n}。 +func parseClaimReward(data json.RawMessage) (credit, energy int64, err error) { + var resp struct { + AlreadyClaimed bool `json:"already_claimed"` + Credit int64 `json:"credit"` + Energy int64 `json:"energy"` + } + if err := json.Unmarshal(data, &resp); err != nil { + return 0, 0, err + } + return resp.Credit, resp.Energy, nil +} + +// parseGrowthTasks 解析 growth 任务列表 data.tasks[](默认与 mp 口径共用)。 +func parseGrowthTasks(data json.RawMessage) ([]Task, error) { + var resp struct { + Tasks []struct { + TaskCode string `json:"task_code"` + Code string `json:"code"` + TaskID int64 `json:"task_id"` + Title string `json:"title"` + Description string `json:"description"` + TaskDesc string `json:"task_desc"` + RewardCredit int64 `json:"reward_credit"` // 上游实际字段名(reward_ 前缀) + RewardEnergy int64 `json:"reward_energy"` + HasReward bool `json:"has_reward"` + RewardBuddy bool `json:"reward_buddy"` + TaskType string `json:"task_type"` + Tag string `json:"tag"` + JumpURL string `json:"jump_url"` + Locked bool `json:"locked"` + AcceptStatus string `json:"accept_status"` + Status string `json:"status"` + Target int64 `json:"target"` + Current int64 `json:"current"` + Progress json.RawMessage `json:"progress"` + } `json:"tasks"` + } + // 另按原始 JSON 再解一遍:字段「存在」与「显式 0」必须能区分(移植上游 PR #104)。 + var shape struct { + Tasks []map[string]json.RawMessage `json:"tasks"` + } + if err := json.Unmarshal(data, &shape); err != nil { + return nil, err + } + if err := json.Unmarshal(data, &resp); err != nil { + return nil, err + } + out := make([]Task, 0, len(resp.Tasks)) + for i, t := range resp.Tasks { + cur, tgt := t.Current, t.Target + fields := shape.Tasks[i] + progressKnown := hasJSONValue(fields, "current") && hasJSONValue(fields, "target") + // progress 可能是 {current,target} 对象(实测口径),覆盖平铺字段。 + // 判据是「两个键都在」而不是「>0」:0 是有效进度值,原 >0 判据会把 + // 显式 (0,0) 误当成「没给进度」。 + if hasJSONValue(fields, "progress") { + var pr struct { + Current int64 `json:"current"` + Target int64 `json:"target"` + } + var progressFields map[string]json.RawMessage + if json.Unmarshal(t.Progress, &pr) == nil && json.Unmarshal(t.Progress, &progressFields) == nil && + hasJSONValue(progressFields, "current") && hasJSONValue(progressFields, "target") { + cur, tgt = pr.Current, pr.Target + progressKnown = true + } + } + taskCode := t.TaskCode + if taskCode == "" { + taskCode = t.Code // global 任务列表用 code 字段(无 task_code) + } + creditKnown := hasJSONValue(fields, "reward_credit") + energyKnown := hasJSONValue(fields, "reward_energy") + hasRewardKnown := hasJSONValue(fields, "has_reward") + rewardKnown := creditKnown || energyKnown || hasRewardKnown + claimed := t.AcceptStatus == "claimed" + out = append(out, Task{ + TaskCode: taskCode, + Code: t.Code, + TaskID: t.TaskID, + Title: t.Title, + Description: t.Description, + TaskDesc: t.TaskDesc, + Credit: t.RewardCredit, + Energy: t.RewardEnergy, + HasReward: t.HasReward, + RewardBuddy: t.RewardBuddy, + TaskType: t.TaskType, + Tag: t.Tag, + JumpURL: t.JumpURL, + Locked: t.Locked, + Target: tgt, + Current: cur, + ProgressKnown: progressKnown, + RewardKnown: rewardKnown, + AcceptStatus: t.AcceptStatus, + Status: t.Status, + Claimable: !claimed && tgt > 0 && cur >= tgt, + Claimed: claimed, + creditKnown: creditKnown, + energyKnown: energyKnown, + hasRewardKnown: hasRewardKnown, + }) + } + return out, nil +} + +// hasJSONValue 报告字段存在且非 null(区分「显式 0」与「没这个字段」)。 +func hasJSONValue(fields map[string]json.RawMessage, name string) bool { + raw, ok := fields[name] + if !ok { + return false + } + return len(bytes.TrimSpace(raw)) > 0 && string(bytes.TrimSpace(raw)) != "null" +} + +// AcceptTasks 接受任务(幂等:已 accepted 时上游返回成功或业务提示,均不视为致命错误)。 +func (c *Client) AcceptTasks(a *auth.Auth, taskCodes []string) error { + _, err := c.growthJSON(a, http.MethodPost, tasksAcceptPath, map[string]any{"task_codes": taskCodes}) + return err +} + +// ClaimReward 领取单个任务奖励。 +// +// 端点来源(实测):Web 成长中心的领奖请求 —— +// +// POST https://www.workbuddy.cn/activity/growth/tasks//claim +// (任务码在**路径**里,无 body;带 x-client-platform: web 头,Bearer 鉴权) +// +// 关键区别:此前误用 CLI 域 copilot.tencent.com 的 +// /v2/activity/growth/tasks/reward/claim(task_code 放 body),该路径**不存在**, +// 一直返回 400 "task not completed",是此前领奖失败的真实原因。 +// 本实现返回 (credit, energy, err):credit/energy 为本次到账奖励(已领取过时为 0)。 +func (c *Client) ClaimReward(a *auth.Auth, taskCode string) (credit, energy int64, err error) { + req, err := http.NewRequest(http.MethodPost, + c.webBase(a)+"/activity/growth/tasks/"+url.PathEscape(taskCode)+"/claim", nil) + if err != nil { + return 0, 0, err + } + // Web 端请求头形状(对照浏览器实际请求):Origin/Referer 指向 workbuddy.cn 成长中心, + // 带 x-client-platform: web 标记来源端。 + req.Header.Set("Authorization", "Bearer "+a.AccessTokenValue()) + req.Header.Set("Accept", "application/json, text/plain, */*") + req.Header.Set("Content-Type", "application/json") + req.Header.Set("Origin", "https://www.workbuddy.cn") + req.Header.Set("Referer", "https://www.workbuddy.cn/profile/growth-center") + req.Header.Set("x-client-platform", "web") + if ua := c.userAgent(a); ua != "" { + req.Header.Set("User-Agent", ua) + } + if a.UID != "" { + req.Header.Set("X-User-Id", a.UID) + } + if a.EnterpriseID != "" { + req.Header.Set("X-Enterprise-Id", a.EnterpriseID) + req.Header.Set("X-Tenant-Id", a.EnterpriseID) + } + if d := a.DomainValue(); d != "" { + req.Header.Set("X-Domain", d) + } + + data, err := c.doJSON(req, a) + if err != nil { + return 0, 0, err + } + // 响应 data:{"already_claimed":bool,"credit":100,"energy":5,...} + var resp struct { + AlreadyClaimed bool `json:"already_claimed"` + Credit int64 `json:"credit"` + Energy int64 `json:"energy"` + } + if err := json.Unmarshal(data, &resp); err != nil { + return 0, 0, err + } + if resp.AlreadyClaimed { + return 0, 0, nil // 幂等:重复领取不算错误,但无新增奖励 + } + return resp.Credit, resp.Energy, nil +} diff --git a/internal/upstream/tasks_test.go b/internal/upstream/tasks_test.go index 02d22f676134ed127029f06176722fb945e0c8f8..099838e6e05606d4aded7602547b485fb80f30f3 100644 --- a/internal/upstream/tasks_test.go +++ b/internal/upstream/tasks_test.go @@ -1,85 +1,184 @@ -package upstream - -import ( - "encoding/json" - "net/http" - "net/http/httptest" - "strings" - "testing" - - "github.com/linguo2625469/workbuddy2api-panel/internal/auth" -) - -// TestClaimRewardWebEndpoint 领奖走 Web 域(workbuddy.cn)、任务码在路径里、无 body。 -// 这是与 CLI 域(copilot.tencent.com/v2/.../reward/claim,task_code 在 body)的关键区别—— -// 后者路径不存在,曾导致长期 400 "task not completed" 误判为"上游不支持领取"。 -func TestClaimRewardWebEndpoint(t *testing.T) { - var gotPath, gotMethod, gotBody string - var gotPlatform, gotReferer string - srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { - gotPath, gotMethod = r.URL.Path, r.Method - gotPlatform = r.Header.Get("x-client-platform") - gotReferer = r.Header.Get("Referer") - buf := make([]byte, 64) - n, _ := r.Body.Read(buf) - gotBody = string(buf[:n]) - w.Write([]byte(`{"code":0,"msg":"OK","data":{"already_claimed":false,"credit":100,"energy":5}}`)) - })) - defer srv.Close() - - c := &Client{HTTP: srv.Client(), ChatBaseCN: srv.URL, BillingBaseCN: srv.URL, WebBaseCN: srv.URL} - a := &auth.Auth{AccessToken: "at", UID: "u1"} - - credit, energy, err := c.ClaimReward(a, "Model_chat_GLM5.2") - if err != nil { - t.Fatalf("claim: %v", err) - } - if credit != 100 || energy != 5 { - t.Errorf("credit/energy = %d/%d, want 100/5", credit, energy) - } - if gotMethod != http.MethodPost { - t.Errorf("method=%s want POST", gotMethod) - } - if want := "/activity/growth/tasks/Model_chat_GLM5.2/claim"; gotPath != want { - t.Errorf("path=%q want %q(任务码必须在路径里)", gotPath, want) - } - if gotBody != "" { - t.Errorf("claim 不应携带 body,got %q", gotBody) - } - if gotPlatform != "web" { - t.Errorf("x-client-platform=%q want web", gotPlatform) - } - if !strings.Contains(gotReferer, "workbuddy.cn") { - t.Errorf("Referer=%q 应指向 workbuddy.cn", gotReferer) - } -} - -// TestClaimRewardAlreadyClaimed 重复领取:上游返回 already_claimed=true, -// 本地应视为"无新增奖励但不报错"(幂等语义)。 -func TestClaimRewardAlreadyClaimed(t *testing.T) { - srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { - w.Write([]byte(`{"code":0,"msg":"OK","data":{"already_claimed":true}}`)) - })) - defer srv.Close() - c := &Client{HTTP: srv.Client(), WebBaseCN: srv.URL} - credit, energy, err := c.ClaimReward(&auth.Auth{AccessToken: "at", UID: "u1"}, "chat_5") - if err != nil { - t.Fatalf("already_claimed should not error: %v", err) - } - if credit != 0 || energy != 0 { - t.Errorf("already claimed should yield 0/0, got %d/%d", credit, energy) - } -} - -// TestClaimRewardNotCompleted 未达标:上游 400 + task not completed 应作为错误透出。 -func TestClaimRewardNotCompleted(t *testing.T) { - srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { - w.WriteHeader(400) - json.NewEncoder(w).Encode(map[string]any{"code": 400, "msg": "task not completed"}) - })) - defer srv.Close() - c := &Client{HTTP: srv.Client(), WebBaseCN: srv.URL} - if _, _, err := c.ClaimReward(&auth.Auth{AccessToken: "at", UID: "u1"}, "chat_5"); err == nil { - t.Fatal("want error for not-completed task") - } -} +package upstream + +import ( + "encoding/json" + "net/http" + "net/http/httptest" + "reflect" + "strings" + "testing" + + "github.com/misakano7545/workbuddy2api-panel/internal/auth" +) + +// TestClaimRewardWebEndpoint 领奖走 Web 域(workbuddy.cn)、任务码在路径里、无 body。 +// 这是与 CLI 域(copilot.tencent.com/v2/.../reward/claim,task_code 在 body)的关键区别—— +// 后者路径不存在,曾导致长期 400 "task not completed" 误判为"上游不支持领取"。 +func TestClaimRewardWebEndpoint(t *testing.T) { + var gotPath, gotMethod, gotBody string + var gotPlatform, gotReferer string + srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { + gotPath, gotMethod = r.URL.Path, r.Method + gotPlatform = r.Header.Get("x-client-platform") + gotReferer = r.Header.Get("Referer") + buf := make([]byte, 64) + n, _ := r.Body.Read(buf) + gotBody = string(buf[:n]) + w.Write([]byte(`{"code":0,"msg":"OK","data":{"already_claimed":false,"credit":100,"energy":5}}`)) + })) + defer srv.Close() + + c := &Client{HTTP: srv.Client(), ChatBaseCN: srv.URL, BillingBaseCN: srv.URL, WebBaseCN: srv.URL} + a := &auth.Auth{AccessToken: "at", UID: "u1"} + + credit, energy, err := c.ClaimReward(a, "Model_chat_GLM5.2") + if err != nil { + t.Fatalf("claim: %v", err) + } + if credit != 100 || energy != 5 { + t.Errorf("credit/energy = %d/%d, want 100/5", credit, energy) + } + if gotMethod != http.MethodPost { + t.Errorf("method=%s want POST", gotMethod) + } + if want := "/activity/growth/tasks/Model_chat_GLM5.2/claim"; gotPath != want { + t.Errorf("path=%q want %q(任务码必须在路径里)", gotPath, want) + } + if gotBody != "" { + t.Errorf("claim 不应携带 body,got %q", gotBody) + } + if gotPlatform != "web" { + t.Errorf("x-client-platform=%q want web", gotPlatform) + } + if !strings.Contains(gotReferer, "workbuddy.cn") { + t.Errorf("Referer=%q 应指向 workbuddy.cn", gotReferer) + } +} + +// TestClaimRewardAlreadyClaimed 重复领取:上游返回 already_claimed=true, +// 本地应视为"无新增奖励但不报错"(幂等语义)。 +func TestClaimRewardAlreadyClaimed(t *testing.T) { + srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { + w.Write([]byte(`{"code":0,"msg":"OK","data":{"already_claimed":true}}`)) + })) + defer srv.Close() + c := &Client{HTTP: srv.Client(), WebBaseCN: srv.URL} + credit, energy, err := c.ClaimReward(&auth.Auth{AccessToken: "at", UID: "u1"}, "chat_5") + if err != nil { + t.Fatalf("already_claimed should not error: %v", err) + } + if credit != 0 || energy != 0 { + t.Errorf("already claimed should yield 0/0, got %d/%d", credit, energy) + } +} + +// TestClaimRewardNotCompleted 未达标:上游 400 + task not completed 应作为错误透出。 +func TestClaimRewardNotCompleted(t *testing.T) { + srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { + w.WriteHeader(400) + json.NewEncoder(w).Encode(map[string]any{"code": 400, "msg": "task not completed"}) + })) + defer srv.Close() + c := &Client{HTTP: srv.Client(), WebBaseCN: srv.URL} + if _, _, err := c.ClaimReward(&auth.Auth{AccessToken: "at", UID: "u1"}, "chat_5"); err == nil { + t.Fatal("want error for not-completed task") + } +} + +// TestListGlobalTasksPreservesObservedSchemaAndUnknownFields global 任务列表形态 +// (code/task_id/status,无 progress/reward 字段)原样透出:标识符不丢、未知字段 +// 不外泄、target/current/credit 等「源里根本没有」的字段必须省略而不是补 0。 +// 移植上游 PR #104。 +func TestListGlobalTasksPreservesObservedSchemaAndUnknownFields(t *testing.T) { + previous := auth.GlobalEnabled() + auth.SetGlobalEnabled(true) + t.Cleanup(func() { auth.SetGlobalEnabled(previous) }) + + const envelope = `{"code":0,"message":"OK","data":{"tasks":[ + {"task_id":1,"code":"first_chat","title":"完成一次对话","description":"使用 WorkBuddy 完成至少一次对话交互","icon_url":"","level_name":"养虾尝试","status":"available","url":""}, + {"task_id":2,"code":"skill_installed","title":"完成技能安装","description":"成功安装至少一个 WorkBuddy 技能","icon_url":"","level_name":"养虾入门","status":"available","url":""}, + {"task_id":3,"code":"wechat_linked","title":"链接微信","description":"完成 WorkBuddy 设置,成功链接到微信","icon_url":"","level_name":"养虾熟手","status":"available","url":""}, + {"task_id":4,"code":"expert_summoned","title":"召唤一次专家","description":"使用 WorkBuddy 召唤并完成一次专家交互","icon_url":"","level_name":"玩虾老手","status":"available","url":""}, + {"task_id":5,"code":"template_used","title":"使用一次模板","description":"使用至少一个 WorkBuddy 模板完成任务","icon_url":"","level_name":"控虾大神","status":"available","url":""} + ]}}` + var gotMethod, gotPath string + srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { + gotMethod, gotPath = r.Method, r.URL.Path + w.Header().Set("Content-Type", "application/json") + _, _ = w.Write([]byte(envelope)) + })) + defer srv.Close() + + c := New() + c.HTTP = srv.Client() + c.ChatHTTP = nil + c.ChatBaseGlobal = srv.URL + a := &auth.Auth{AccessToken: "at", UID: "u-global"} + if _, err := auth.BackfillRealmFor(a, "global"); err != nil { + t.Fatal(err) + } + + tasks, err := c.ListTasks(a) + if err != nil { + t.Fatalf("ListTasks: %v", err) + } + if gotMethod != http.MethodGet || gotPath != tasksListPath { + t.Fatalf("request = %s %s, want GET %s", gotMethod, gotPath, tasksListPath) + } + if len(tasks) != 5 { + t.Fatalf("got %d tasks, want 5", len(tasks)) + } + wantCodes := []string{"first_chat", "skill_installed", "wechat_linked", "expert_summoned", "template_used"} + for i, task := range tasks { + if task.TaskCode != wantCodes[i] || task.Code != wantCodes[i] || task.TaskID != int64(i+1) || task.Status != "available" { + t.Errorf("task[%d] identifiers/status = (%q, %q, %d, %q)", i, task.TaskCode, task.Code, task.TaskID, task.Status) + } + if task.ProgressKnown || task.RewardKnown { + t.Errorf("task[%d] unknown progress/reward marked known", i) + } + encoded, err := json.Marshal(task) + if err != nil { + t.Fatalf("marshal task[%d]: %v", i, err) + } + var fields map[string]json.RawMessage + if err := json.Unmarshal(encoded, &fields); err != nil { + t.Fatal(err) + } + for _, key := range []string{"target", "current", "credit", "energy", "has_reward"} { + if _, ok := fields[key]; ok { + t.Errorf("task[%d] should omit unknown %q: %s", i, key, encoded) + } + } + } + if got := []string{tasks[0].TaskCode, tasks[1].TaskCode, tasks[2].TaskCode, tasks[3].TaskCode, tasks[4].TaskCode}; !reflect.DeepEqual(got, wantCodes) { + t.Fatalf("task codes = %v, want %v", got, wantCodes) + } +} + +// TestParseCNTaskKeepsExplicitZeroProgressFields CN 口径显式 0 进度/奖励要保留: +// ProgressKnown/RewardKnown 必须在场,字段不得被「省略」逻辑吃掉。移植上游 PR #104。 +func TestParseCNTaskKeepsExplicitZeroProgressFields(t *testing.T) { + tasks, err := parseGrowthTasks(json.RawMessage(`{"tasks":[{"task_code":"chat_5","target":5,"current":0,"reward_credit":0,"reward_energy":0,"has_reward":false}]}`)) + if err != nil { + t.Fatal(err) + } + if len(tasks) != 1 || !tasks[0].ProgressKnown || !tasks[0].RewardKnown { + t.Fatalf("explicit zero task should retain known flags: %+v", tasks) + } + encoded, err := json.Marshal(tasks[0]) + if err != nil { + t.Fatal(err) + } + var fields map[string]json.RawMessage + if err := json.Unmarshal(encoded, &fields); err != nil { + t.Fatal(err) + } + for _, key := range []string{"target", "current", "progress_known", "reward_known"} { + if _, ok := fields[key]; !ok { + t.Errorf("CN task lost %q: %s", key, encoded) + } + } + if strings.Contains(string(encoded), `"target":0`) { + t.Errorf("target should preserve explicit value 5, got %s", encoded) + } +} diff --git a/internal/upstream/testdata/leaked_markup.txt b/internal/upstream/testdata/leaked_markup.txt new file mode 100644 index 0000000000000000000000000000000000000000..d9c7cb4a7a9e205d69599868e4d5415c8255d297 --- /dev/null +++ b/internal/upstream/testdata/leaked_markup.txt @@ -0,0 +1,10 @@ +我先看一下仓库结构和图片内容,再定位价格同步逻辑。 + +<||DSML|| calls> +<||DSML|| invoke name="exec_command"> +<||DSML|| parameter name="cmd" string="true">cd /Users/dev/project && git status --short && ls -a | head -50 && ls -d .codegraph 2>/dev/null || echo "NO_CODEGRAPH" + +<||DSML|| invoke name="exec_command"> +<||DSML|| parameter name="cmd" string="true">curl -sS -o /private/tmp/sync_price_question.png "https://example.com/sample.png" && ls -la /private/tmp/sync_price_question.png + + \ No newline at end of file diff --git a/internal/upstream/testdata/official_chat_busy_head.txt b/internal/upstream/testdata/official_chat_busy_head.txt new file mode 100644 index 0000000000000000000000000000000000000000..51b18ac390317091fe0c958cd8f39dcbd4547afd --- /dev/null +++ b/internal/upstream/testdata/official_chat_busy_head.txt @@ -0,0 +1,12 @@ +POST /v2/chat/busy HTTP/1.1 +Accept: application/json, text/plain, */* +Content-Type: application/json +User-Agent: WorkBuddy/5.9.3 WorkBuddy/5.9.3 CLI/2.165.0 +X-Request-ID: d7c563ab9dc0414fb0c99a4de06a0a85 +X-Product: SaaS +Authorization: Bearer +X-User-Id: 00000000-0000-4000-8000-000000000002 +X-Domain: www.workbuddy.cn +Content-Length: 25 +Host: www.workbuddy.cn +Connection: keep-alive diff --git a/internal/upstream/testdata/official_chat_head.txt b/internal/upstream/testdata/official_chat_head.txt new file mode 100644 index 0000000000000000000000000000000000000000..19559592c638a7d8497caa6dd284c7a8f88646ae --- /dev/null +++ b/internal/upstream/testdata/official_chat_head.txt @@ -0,0 +1,44 @@ +POST /v2/chat/completions HTTP/1.1 +Accept: application/json +Content-Type: application/json +X-Requested-With: XMLHttpRequest +x-stainless-arch: x64 +x-stainless-lang: js +x-stainless-os: Windows +x-stainless-package-version: 6.25.0 +x-stainless-retry-count: 0 +x-stainless-runtime: node +x-stainless-runtime-version: v22.21.1 +X-Conversation-ID: f7c6c392-e016-43bb-beca-ab918b436668 +X-Agent-Purpose: conversation +X-IDE-Type: WorkBuddy +X-IDE-Name: WorkBuddy +X-IDE-Version: 5.9.3 +X-Agent-Intent: craft +X-Agent-Runtime: local-agent +X-Private-Data: false +acp-connection-id: 01a194ad-6b5d-7394-92ad-61e04eb3a3df +x-codebuddy-request: 1 +X-Request-ID: 01a194adc6bc7205b0d188e0c9b6a728 +X-Conversation-Message-ID: 01a194adc6bc7205b0d188e0c9b6a728 +X-Conversation-Request-ID: 01a194ad31c27d81804ee9915cf954fb +X-Root-Request-ID: 01a194ad31c27d81804ee9915cf954fb +X-Agent-Type: main +baggage: buddyId=,buddyName=,codebuddy.session_id=f7c6c392-e016-43bb-beca-ab918b436668,codebuddy.conversation_request_id=01a194ad31c27d81804ee9915cf954fb +Content-Encoding: gzip +traceparent: 00-7458e488eb564b059622db42023ae293-82e31fea372dea0e-01 +b3: 7458e488eb564b059622db42023ae293-82e31fea372dea0e-1-57587f4a3ce47317 +X-B3-TraceId: 7458e488eb564b059622db42023ae293 +X-B3-ParentSpanId: 57587f4a3ce47317 +X-B3-SpanId: 82e31fea372dea0e +X-B3-Sampled: 1 +X-Trace-ID: 7458e488eb564b059622db42023ae293 +X-Product: SaaS +User-Agent: WorkBuddy/5.9.3 WorkBuddy/5.9.3 CLI/2.165.0 +Authorization: Bearer +X-User-Id: 00000000-0000-4000-8000-000000000002 +X-Domain: www.workbuddy.cn +Content-Length: 54062 +Accept-Encoding: gzip, compress, deflate, br +Host: www.workbuddy.cn +Connection: keep-alive diff --git a/internal/upstream/testdata/official_gl_chat_busy_head.txt b/internal/upstream/testdata/official_gl_chat_busy_head.txt new file mode 100644 index 0000000000000000000000000000000000000000..43243c8af4b40aacc2f7c3e534dfa6d097262893 --- /dev/null +++ b/internal/upstream/testdata/official_gl_chat_busy_head.txt @@ -0,0 +1,12 @@ +POST /v2/chat/busy HTTP/1.1 +Accept: application/json, text/plain, */* +Content-Type: application/json +User-Agent: workbuddy-ai/5.9.4 workbuddy-ai/5.9.4 CLI/2.165.0 +X-Request-ID: 0da590bb9f7a44a69afd946cab2bf951 +X-Product: SaaS +Authorization: Bearer +X-User-Id: 00000000-0000-4000-8000-000000000001 +X-Domain: www.workbuddy.ai +Content-Length: 34 +Host: www.workbuddy.ai +Connection: keep-alive diff --git a/internal/upstream/testdata/official_gl_refresh_head.txt b/internal/upstream/testdata/official_gl_refresh_head.txt new file mode 100644 index 0000000000000000000000000000000000000000..410efa003522805c07b9cd9cb3d7deee6da1a747 --- /dev/null +++ b/internal/upstream/testdata/official_gl_refresh_head.txt @@ -0,0 +1,14 @@ +POST /v2/plugin/auth/token/refresh HTTP/1.1 +Accept: application/json, text/plain, */* +Content-Type: application/json +X-Domain: www.workbuddy.ai +X-Refresh-Token: +X-Auth-Refresh-Source: plugin +User-Agent: workbuddy-ai/5.9.4 workbuddy-ai/5.9.4 CLI/2.165.0 +X-Request-ID: 83bf6bd3885544188ffb214b7d437a0d +X-Product: SaaS +Authorization: Bearer +X-User-Id: 00000000-0000-4000-8000-000000000001 +Content-Length: 2 +Host: www.workbuddy.ai +Connection: keep-alive diff --git a/internal/upstream/testdata/official_gl_report_head.txt b/internal/upstream/testdata/official_gl_report_head.txt new file mode 100644 index 0000000000000000000000000000000000000000..65231b1cae8defbe645379325389227fcf482d8c --- /dev/null +++ b/internal/upstream/testdata/official_gl_report_head.txt @@ -0,0 +1,12 @@ +POST /v2/report HTTP/1.1 +Accept: application/json, text/plain, */* +Content-Type: application/json;charset=UTF-8 +X-Request-ID: 0accbe2991ba4af9a52603760e505ba9 +X-Product: SaaS +User-Agent: workbuddy-ai/5.9.4 workbuddy-ai/5.9.4 CLI/2.165.0 +Authorization: Bearer +X-User-Id: 00000000-0000-4000-8000-000000000001 +X-Domain: www.workbuddy.ai +Content-Length: 724 +Host: www.workbuddy.ai +Connection: keep-alive diff --git a/internal/upstream/testdata/official_report_cn_head.txt b/internal/upstream/testdata/official_report_cn_head.txt new file mode 100644 index 0000000000000000000000000000000000000000..77a871fd46449425b0ce09c095026a84527d352b --- /dev/null +++ b/internal/upstream/testdata/official_report_cn_head.txt @@ -0,0 +1,12 @@ +POST /v2/report HTTP/1.1 +Accept: application/json, text/plain, */* +Content-Type: application/json;charset=UTF-8 +X-Request-ID: 4891f0b179cc4959be94b2c867c16e3c +X-Product: SaaS +User-Agent: WorkBuddy/5.9.3 WorkBuddy/5.9.3 CLI/2.165.0 +Authorization: Bearer +X-User-Id: 00000000-0000-4000-8000-000000000002 +X-Domain: www.workbuddy.cn +Content-Length: 765 +Host: www.workbuddy.cn +Connection: keep-alive diff --git a/internal/upstream/testdata/official_v3config_head.txt b/internal/upstream/testdata/official_v3config_head.txt new file mode 100644 index 0000000000000000000000000000000000000000..e4a7669edb349954a0e82c3f93ca8706916c60d8 --- /dev/null +++ b/internal/upstream/testdata/official_v3config_head.txt @@ -0,0 +1,7 @@ +GET /v3/config HTTP/1.1 +Accept: application/json, text/plain, */* +Connection: close +User-Agent: WorkBuddy/5.9.3 CLI/2.165.0 +X-Request-ID: c16e715dd3a042cb8f58616fd5b6fe71 +X-Product: SaaS +Host: www.workbuddy.cn diff --git a/internal/upstream/thinking.go b/internal/upstream/thinking.go index 5b262b74891cec3852533355c548a9fdf0c305db..9622320858c0840ed983c42c98c5f52402f48a7f 100644 --- a/internal/upstream/thinking.go +++ b/internal/upstream/thinking.go @@ -1,204 +1,243 @@ -// thinking.go DeepSeek 思维链开启:出站请求体注入 thinking:{type:"enabled"} + 默认档位。 -// -// 根因(issue #43,Hermes 逆向官方客户端 codebuddy.js 已确认): -// 官方客户端对 deepseek 系模型标记 thinkingFormat:"deepseek" + requiresReasoningContentOnAssistantMessages, -// 发请求时「开思考」必须显式带 thinking:{type:"enabled"},否则上游默认按不思考应答 -// (思维链不返回)。网关 payload 层此前完全不感知该字段,透传请求没有这个开关 -// → 上游不给思维链;glm/kimi 走其他 thinkingFormat(qwen 系 enable_thinking 或默认开)所以正常。 -// -// 打回修复(Hermes #43 验收实测): -// -// thinking.type=enabled 单一字段不足——真实上游 deepseek-v4-flash 对「不带 reasoning_effort」的裸请求 -// 仍然按不思考应答(reasoning_content 长度 0),带 reasoning_effort:high 才有思维链。 -// 逆向 codebuddy.js 证实:isThinkingEnabled = !!(reasoning_summary || reasoning_effort || reasoning?.effort), -// case "deepseek" 的 enabled 分支在实际出站里同时保留 reasoning_effort,官方「开思考」= thinking.type:enabled -// + 某档 effort;默认档来自 reasoning.defaultEffort ?? 兜底 "high"(configure thinking 无来源时 warn fallback to 'high')。 -// -// 行为对齐官方客户端(两路组合): -// - thinking.type 已显式 enabled / disabled → 客户端显式控制,绝不覆盖;disabled 时照抄 case 行为 -// 删 reasoning_effort(snake/camel 双字段)。enabled 但缺 effort → 补默认档(官方 configure 行为)。 -// - 无 thinking / thinking.type 空 / 已有 reasoning_effort → 注入 {type:"enabled"} + 补默认档。 -// - 显式 reasoning_effort 一律不覆盖、不降级(降级交给 payload.go normalizeReasoningEffort)。 -// - 非 deepseek 模型(glm/kimi/qwen 等)→ 零改动。 -package upstream - -import ( - "strings" -) - -// defaultDeepSeekEffort 官方客户端默认档兜底(configure thinking 无来源时 warn fallback to 'high', -// REASONING_SUPPLEMENTS.defaultEffort 亦为 "high")。补入后走 normalizeReasoningEffort 降级管线, -// 模型不支持 high 时自动落到 ≤high 的最高支持档。 -const defaultDeepSeekEffort = "high" - -// lookupDefaultEffort 从 FetchModels 缓存的 defaultEfforts 表按模型名查默认档。 -// nil map 或模型未缓存 → 空串(thinking.go 回退硬编码 high)。 -// 键为模型 ID 原样(与 efforts 缓存对齐:normalizeReasoningEffort 精确匹配 model)。 -func lookupDefaultEffort(defaultEfforts map[string]string, model string) string { - if len(defaultEfforts) == 0 || model == "" { - return "" - } - return defaultEfforts[model] -} - -// isDeepSeekModel 模型名以 deepseek 为前缀(不区分大小写)。 -// 覆盖 deepseek-v4.1-flash / deepseek-v4-pro / deepseek-r1 等变体; -// 前缀匹配对齐官方 thinkingFormat:"deepseek" 的判定口径,避免漏注。 -func isDeepSeekModel(model string) bool { - return strings.HasPrefix(strings.ToLower(strings.TrimSpace(model)), "deepseek") -} - -// backfillReasoningContent DeepSeek 多轮一致性:保证每条 assistant 消息带 -// reasoning_content 字段且值为 string——即 requiresReasoningContentOnAssistantMessages -// (官方客户端 matches 规则,issue #165 对齐官方 apply 门控)。 -// -// 门控(对齐官方 ReasoningContentBackfillRule:thinkingEnabled || hasTrace), -// thinkingEnabled 取自注入后请求体的 thinking.type == "enabled"(injectThinking 先行, -// payload.go 管线顺序已保证;本网关对 deepseek 无条件注入 enabled,等价于非 disabled 一律补): -// - 非 deepseek 模型 → 零改动(isDeepSeekModel 闸不动)。 -// - deepseek + enabled(含 L1 注入后)→ 每条 assistant 保证 reasoning_content 是 -// string:已有 string 原样保留(不覆盖);reasoning 是非空 string 且 rc 非 string → -// 复制 reasoning 值;两者皆无 → 补空串 ""。第三方客户端丢推理回传(零痕迹)形态 -// 下官方本就补,网关此前只移植了 hasTrace 半边(issue #165 修复点)。 -// - deepseek + disabled + 无痕迹 → 零改动(官方 thinkingEnabled=false 且 ec=false → 不补)。 -// - deepseek + disabled + 有痕迹 → 照补(官方 hasTrace 半边,双方一致)。 -// -// 归一化对齐官方 "string"!=typeof 语义:reasoning_content 为 null/数字等非 string -// 值时不算「已有」,落补 ""/复制分支(旧代码键存在即跳过,null 会被当「已有」漏补)。 -// hasTrace = 会话内任一消息带非空 reasoning(string)或已有 reasoning_content 字段 -// (比官方仅扫 assistant 的口径宽,只影响 disabled 分支,装饰性差异)。 -func backfillReasoningContent(obj map[string]any) { - model, _ := obj["model"].(string) - if !isDeepSeekModel(model) { - return - } - msgs, ok := obj["messages"].([]any) - if !ok || len(msgs) == 0 { - return - } - // thinkingEnabled 半边:读注入后的 thinking.type(与官方 el.thinkingEnabled 对应)。 - thinkingEnabled := false - if th, ok := obj["thinking"].(map[string]any); ok { - if typ, _ := th["type"].(string); strings.EqualFold(strings.TrimSpace(typ), "enabled") { - thinkingEnabled = true - } - } - // hasTrace 半边:检测是否有任何 reasoning 痕迹(非空 reasoning 或已有 reasoning_content)。 - hasTrace := false - for _, mm := range msgs { - msg, ok := mm.(map[string]any) - if !ok { - continue - } - if r, ok := msg["reasoning"].(string); ok && r != "" { - hasTrace = true - break - } - if _, ok := msg["reasoning_content"]; ok { - hasTrace = true - break - } - } - if !thinkingEnabled && !hasTrace { - return - } - // 第二遍:所有 assistant 消息补/复制 reasoning_content 字段,并镜像保证 - // reasoning 字段存在且非空(issue #165 追评——部分账号/租户对 thinking 形态 - // 校验 len(reasoning)>0:缺失/null/空串 400,空白串 200;官方 CLI 本就给 - // assistant 挂上一轮 reasoning 文本,见 itemsToMessages 的 applyPendingReasoning)。 - // 跳过条件只认 string(官方 "string"!=typeof 才动手):null/数字归一化。 - // - reasoning 已是非空 string → 不动; - // - rc 是非空 string → 镜像写入 rc 值(两字段最终都存在且非空); - // - 两者皆无/皆空 → 补单个空格 " "(上游 len>0 不 trim:空白串过闸、空串 - // 不过——空白串占位有官方 Moonshot 规则 "-" 同款先例,且对模型上下文 - // 无语义影响:该字段是透传校验位非内容消费位)。 - for _, mm := range msgs { - msg, ok := mm.(map[string]any) - if !ok { - continue - } - role, _ := msg["role"].(string) - if role != "assistant" { - continue - } - rc, hasRC := msg["reasoning_content"].(string) - if hasRC { - // rc 已有 string → 不覆盖(原有语义保留)。 - } else if r, ok := msg["reasoning"].(string); ok { - rc = r - msg["reasoning_content"] = rc - } else { - rc = "" - msg["reasoning_content"] = rc - } - // 镜像:reasoning 缺失/null/空串 → 归一化(非空 rc 优先,皆无补 " ")。 - if r, ok := msg["reasoning"].(string); ok && r != "" { - continue // 已非空 → 不覆盖 - } - if rc != "" { - msg["reasoning"] = rc - } else { - msg["reasoning"] = " " - } - } -} - -// injectThinking 按 DeepSeek 思维链开关规则改写请求体。非 deepseek 零改动。 -// -// 核心逻辑(对齐官方客户端): -// - 「开思考」必须 thinking.type=enabled + 有 effort 档位(Hermes #43 打回证据)。 -// - 显式 thinking.type 非空 → 客户端显式控制:enabled 缺 effort 时补默认档; -// disabled 尊重并删 reasoning_effort(snake/camel 双字段)。 -// - 无 thinking / type 空 / 已有 effort → 注入 enabled 并补默认档(已有 effort 不覆盖)。 -// -// defaultEffort 为该模型声明的默认档(来自 FetchModels 缓存 reasoning.defaultEffort); -// 空串时回退硬编码 defaultDeepSeekEffort(向后兼容)。 -func injectThinking(obj map[string]any, defaultEffort string) { - model, _ := obj["model"].(string) - if !isDeepSeekModel(model) { - return - } - th, ok := obj["thinking"].(map[string]any) - typ := "" - if ok { - typ, _ = th["type"].(string) - typ = strings.TrimSpace(typ) - } - // 显式控制分支:type 非空(enabled/disabled 均为明确意图)→ 不改 type。 - if typ != "" { - if strings.EqualFold(typ, "disabled") { - delete(obj, "reasoning_effort") - delete(obj, "reasoningEffort") - return // disabled:关思考且不带任何 effort(照抄客户端 case 行为) - } - ensureDeepSeekEffort(obj, defaultEffort) // 显式 enabled 缺 effort → 补默认档 - return - } - // 无 thinking(或 thinking 非法非对象值)或 thinking 对象 type 缺失/为空: - // 注入 enabled(客户端 case "deepseek" 行为)。有 reasoning_effort 也走此分支 - // (effort 保留给既有降级逻辑,开关照开)。 - if !ok { - obj["thinking"] = map[string]any{"type": "enabled"} - } else { - th["type"] = "enabled" - } - ensureDeepSeekEffort(obj, defaultEffort) -} - -// ensureDeepSeekEffort 缺 effort 档位时补默认档(snake 优先,camel 兜底)。 -// 已有任一 effort → 不覆盖(显式档位不做任何改写,降级交给 normalizeReasoningEffort)。 -// defaultEffort 空串 → 回退 defaultDeepSeekEffort(硬编码 "high")。 -func ensureDeepSeekEffort(obj map[string]any, defaultEffort string) { - _, hasSnake := obj["reasoning_effort"] - if hasSnake { - return - } - _, hasCamel := obj["reasoningEffort"] - if hasCamel { - return - } - if defaultEffort == "" { - defaultEffort = defaultDeepSeekEffort - } - obj["reasoning_effort"] = defaultEffort -} +// thinking.go DeepSeek 思维链开启:出站请求体注入 thinking:{type:"enabled"} + 默认档位。 +// +// 根因(issue #43,Hermes 逆向官方客户端 codebuddy.js 已确认): +// 官方客户端对 deepseek 系模型标记 thinkingFormat:"deepseek" + requiresReasoningContentOnAssistantMessages, +// 发请求时「开思考」必须显式带 thinking:{type:"enabled"},否则上游默认按不思考应答 +// (思维链不返回)。网关 payload 层此前完全不感知该字段,透传请求没有这个开关 +// → 上游不给思维链;glm/kimi 走其他 thinkingFormat(qwen 系 enable_thinking 或默认开)所以正常。 +// +// 打回修复(Hermes #43 验收实测): +// +// thinking.type=enabled 单一字段不足——真实上游 deepseek-v4-flash 对「不带 reasoning_effort」的裸请求 +// 仍然按不思考应答(reasoning_content 长度 0),带 reasoning_effort:high 才有思维链。 +// 逆向 codebuddy.js 证实:isThinkingEnabled = !!(reasoning_summary || reasoning_effort || reasoning?.effort), +// case "deepseek" 的 enabled 分支在实际出站里同时保留 reasoning_effort,官方「开思考」= thinking.type:enabled +// + 某档 effort;默认档来自 reasoning.defaultEffort ?? 兜底 "high"(configure thinking 无来源时 warn fallback to 'high')。 +// +// 行为对齐官方客户端(两路组合): +// - thinking.type 已显式 enabled / disabled → 客户端显式控制,绝不覆盖;disabled 时照抄 case 行为 +// 删 reasoning_effort(snake/camel 双字段)。enabled 但缺 effort → 补默认档(官方 configure 行为)。 +// - 无 thinking / thinking.type 空 / 已有 reasoning_effort → 注入 {type:"enabled"} + 补默认档。 +// - 显式 reasoning_effort 一律不覆盖、不降级(降级交给 payload.go normalizeReasoningEffort)。 +// - 非 deepseek 模型(glm/kimi/qwen 等)→ 零改动。 +package upstream + +import ( + "strings" +) + +// defaultDeepSeekEffort 官方客户端默认档兜底(configure thinking 无来源时 warn fallback to 'high', +// REASONING_SUPPLEMENTS.defaultEffort 亦为 "high")。补入后走 normalizeReasoningEffort 降级管线, +// 模型不支持 high 时自动落到 ≤high 的最高支持档。 +const defaultDeepSeekEffort = "high" + +// lookupDefaultEffort 从 FetchModels 缓存的 defaultEfforts 表按模型名查默认档。 +// nil map 或模型未缓存 → 空串(thinking.go 回退硬编码 high)。 +// 键为模型 ID 原样(与 efforts 缓存对齐:normalizeReasoningEffort 精确匹配 model)。 +func lookupDefaultEffort(defaultEfforts map[string]string, model string) string { + if len(defaultEfforts) == 0 || model == "" { + return "" + } + return defaultEfforts[model] +} + +// isDeepSeekModel 模型名以 deepseek 为前缀(不区分大小写)。 +// 覆盖 deepseek-v4.1-flash / deepseek-v4-pro / deepseek-r1 等变体; +// 前缀匹配对齐官方 thinkingFormat:"deepseek" 的判定口径,避免漏注。 +func isDeepSeekModel(model string) bool { + return strings.HasPrefix(strings.ToLower(strings.TrimSpace(model)), "deepseek") +} + +// ThinkingSwitchSupported 该模型能否用 thinking.type 关掉思考。 +// +// 目前只有 DeepSeek 系:thinking.go 只对这类模型注入 thinking 字段,也只有它验证过 +// 「disabled + 同额度 → 正文正常」。入参可带 realm 前缀(cn:/global:)。 +func ThinkingSwitchSupported(model string) bool { + _, bare := SplitRealmPrefix(model) + return isDeepSeekModel(bare) +} + +// backfillReasoningContent DeepSeek 多轮一致性:保证每条 assistant 消息带 +// reasoning_content 字段且值为 string——即 requiresReasoningContentOnAssistantMessages +// (官方客户端 matches 规则,issue #165 对齐官方 apply 门控)。 +// +// 门控(对齐官方 ReasoningContentBackfillRule:thinkingEnabled || hasTrace), +// thinkingEnabled 取自注入后请求体的 thinking.type == "enabled"(injectThinking 先行, +// payload.go 管线顺序已保证;本网关对 deepseek 无条件注入 enabled,等价于非 disabled 一律补): +// - 非 deepseek 模型 → 零改动(isDeepSeekModel 闸不动)。 +// - deepseek + enabled(含 L1 注入后)→ 每条 assistant 保证 reasoning_content 是 +// string:已有 string 原样保留(不覆盖);reasoning 是非空 string 且 rc 非 string → +// 复制 reasoning 值;两者皆无 → 补空串 ""。第三方客户端丢推理回传(零痕迹)形态 +// 下官方本就补,网关此前只移植了 hasTrace 半边(issue #165 修复点)。 +// - deepseek + disabled + 无痕迹 → 零改动(官方 thinkingEnabled=false 且 ec=false → 不补)。 +// - deepseek + disabled + 有痕迹 → 照补(官方 hasTrace 半边,双方一致)。 +// +// 归一化对齐官方 "string"!=typeof 语义:reasoning_content 为 null/数字等非 string +// 值时不算「已有」,落补 ""/复制分支(旧代码键存在即跳过,null 会被当「已有」漏补)。 +// hasTrace = 会话内任一消息带非空 reasoning(string)或已有 reasoning_content 字段 +// (比官方仅扫 assistant 的口径宽,只影响 disabled 分支,装饰性差异)。 +func backfillReasoningContent(obj map[string]any) { + model, _ := obj["model"].(string) + if !isDeepSeekModel(model) { + return + } + msgs, ok := obj["messages"].([]any) + if !ok || len(msgs) == 0 { + return + } + // thinkingEnabled 半边:读注入后的 thinking.type(与官方 el.thinkingEnabled 对应)。 + thinkingEnabled := false + if th, ok := obj["thinking"].(map[string]any); ok { + if typ, _ := th["type"].(string); strings.EqualFold(strings.TrimSpace(typ), "enabled") { + thinkingEnabled = true + } + } + // hasTrace 半边:检测是否有任何 reasoning 痕迹(非空 reasoning 或已有 reasoning_content)。 + hasTrace := false + for _, mm := range msgs { + msg, ok := mm.(map[string]any) + if !ok { + continue + } + if r, ok := msg["reasoning"].(string); ok && r != "" { + hasTrace = true + break + } + if _, ok := msg["reasoning_content"]; ok { + hasTrace = true + break + } + } + if !thinkingEnabled && !hasTrace { + return + } + // 第二遍:所有 assistant 消息补/复制 reasoning_content 字段,并镜像保证 + // reasoning 字段存在且非空(issue #165 追评——部分账号/租户对 thinking 形态 + // 校验 len(reasoning)>0:缺失/null/空串 400,空白串 200;官方 CLI 本就给 + // assistant 挂上一轮 reasoning 文本,见 itemsToMessages 的 applyPendingReasoning)。 + // 跳过条件只认 string(官方 "string"!=typeof 才动手):null/数字归一化。 + // - reasoning 已是非空 string → 不动; + // - rc 是非空 string → 镜像写入 rc 值(两字段最终都存在且非空); + // - 两者皆无/皆空 → 补单个空格 " "(上游 len>0 不 trim:空白串过闸、空串 + // 不过——空白串占位有官方 Moonshot 规则 "-" 同款先例,且对模型上下文 + // 无语义影响:该字段是透传校验位非内容消费位)。 + for _, mm := range msgs { + msg, ok := mm.(map[string]any) + if !ok { + continue + } + role, _ := msg["role"].(string) + if role != "assistant" { + continue + } + rc, hasRC := msg["reasoning_content"].(string) + if hasRC { + // rc 已有 string → 不覆盖(原有语义保留)。 + } else if r, ok := msg["reasoning"].(string); ok { + rc = r + msg["reasoning_content"] = rc + } else { + rc = "" + msg["reasoning_content"] = rc + } + // 镜像:reasoning 缺失/null/空串 → 归一化(非空 rc 优先,皆无补 " ")。 + if r, ok := msg["reasoning"].(string); ok && r != "" { + continue // 已非空 → 不覆盖 + } + if rc != "" { + msg["reasoning"] = rc + } else { + msg["reasoning"] = " " + } + } +} + +// effortValueOff 客户端档位字段是否表达「关闭思考」。off/none 都不在 effortRank +// 里,不截住就会被当未知值透传、或被 rank 0 的 off 就近降级成**最弱正档**—— +// 「关思考」反而变成「思考开着但最弱」(issue #66 同类:实测 off 仍返回 157 字思维链)。 +func effortValueOff(obj map[string]any) bool { + for _, k := range []string{"reasoning_effort", "reasoningEffort"} { + v, ok := obj[k].(string) + if !ok { + continue + } + switch strings.ToLower(strings.TrimSpace(v)) { + case "off", "none", "disabled": + return true + } + } + return false +} + +// injectThinking 按 DeepSeek 思维链开关规则改写请求体。非 deepseek 零改动。 +// +// 核心逻辑(对齐官方客户端): +// - 「开思考」必须 thinking.type=enabled + 有 effort 档位(Hermes #43 打回证据)。 +// - 显式 thinking.type 非空 → 客户端显式控制:enabled 缺 effort 时补默认档; +// disabled 尊重并删 reasoning_effort(snake/camel 双字段)。 +// - 无 thinking / type 空 / 已有 effort → 注入 enabled 并补默认档(已有 effort 不覆盖)。 +// +// defaultEffort 为该模型声明的默认档(来自 FetchModels 缓存 reasoning.defaultEffort); +// 空串时回退硬编码 defaultDeepSeekEffort(向后兼容)。 +func injectThinking(obj map[string]any, defaultEffort string) { + model, _ := obj["model"].(string) + if !isDeepSeekModel(model) { + return + } + // 客户端用档位字段表达关闭(off/none/disabled):转成 thinking.type=disabled。 + // 这一步必须在下面的注入之前——否则无 thinking 的请求会被补 enabled + 默认档, + // 降级管线再把 off 就近抬成最弱正档,「关思考」变成「思考开着但最弱」。 + if effortValueOff(obj) { + delete(obj, "reasoning_effort") + delete(obj, "reasoningEffort") + if th, ok := obj["thinking"].(map[string]any); ok { + th["type"] = "disabled" + } else { + obj["thinking"] = map[string]any{"type": "disabled"} + } + return + } + th, ok := obj["thinking"].(map[string]any) + typ := "" + if ok { + typ, _ = th["type"].(string) + typ = strings.TrimSpace(typ) + } + // 显式控制分支:type 非空(enabled/disabled 均为明确意图)→ 不改 type。 + if typ != "" { + if strings.EqualFold(typ, "disabled") { + delete(obj, "reasoning_effort") + delete(obj, "reasoningEffort") + return // disabled:关思考且不带任何 effort(照抄客户端 case 行为) + } + ensureDeepSeekEffort(obj, defaultEffort) // 显式 enabled 缺 effort → 补默认档 + return + } + // 无 thinking(或 thinking 非法非对象值)或 thinking 对象 type 缺失/为空: + // 注入 enabled(客户端 case "deepseek" 行为)。有 reasoning_effort 也走此分支 + // (effort 保留给既有降级逻辑,开关照开)。 + if !ok { + obj["thinking"] = map[string]any{"type": "enabled"} + } else { + th["type"] = "enabled" + } + ensureDeepSeekEffort(obj, defaultEffort) +} + +// ensureDeepSeekEffort 缺 effort 档位时补默认档(snake 优先,camel 兜底)。 +// 已有任一 effort → 不覆盖(显式档位不做任何改写,降级交给 normalizeReasoningEffort)。 +// defaultEffort 空串 → 回退 defaultDeepSeekEffort(硬编码 "high")。 +func ensureDeepSeekEffort(obj map[string]any, defaultEffort string) { + _, hasSnake := obj["reasoning_effort"] + if hasSnake { + return + } + _, hasCamel := obj["reasoningEffort"] + if hasCamel { + return + } + if defaultEffort == "" { + defaultEffort = defaultDeepSeekEffort + } + obj["reasoning_effort"] = defaultEffort +} diff --git a/internal/upstream/thinking_test.go b/internal/upstream/thinking_test.go index da1dffd1641ceac028091843a914738f8d2a8644..49c43aecd210c4880713267e7210ac2d31a215bb 100644 --- a/internal/upstream/thinking_test.go +++ b/internal/upstream/thinking_test.go @@ -1,305 +1,348 @@ -package upstream - -import ( - "encoding/json" - "strings" - "testing" -) - -// getThinkingType 从输出 body 提取 thinking.type(缺字段返回空串 + 是否存在)。 -func getThinkingType(t *testing.T, out []byte) (typ string, present bool) { - t.Helper() - var m map[string]any - if err := json.Unmarshal(out, &m); err != nil { - t.Fatalf("unmarshal: %v (out=%s)", err, out) - } - th, ok := m["thinking"].(map[string]any) - if !ok { - return "", false - } - s, ok := th["type"].(string) - if !ok { - return "", true - } - return s, true -} - -// TestInjectThinkingDeepSeekEnabled 开思考开关注入:deepseek 系模型请求体不带 -// thinking 时必须注入 {type:"enabled"},否则上游默认按不思考应答(思维链不显示)。 -func TestInjectThinkingDeepSeekEnabled(t *testing.T) { - cases := []struct { - name string - body string - wantTyp string - }{ - {"deepseek 无 thinking 注入 enabled", - `{"model":"deepseek-v4-flash","messages":[]}`, "enabled"}, - {"DeepSeek 大小写不敏感", - `{"model":"DeepSeek-v4.1-flash","messages":[]}`, "enabled"}, - {"DEEPSEEK 全大写不敏感", - `{"model":"DEEPSEEK-R1","messages":[]}`, "enabled"}, - {"deepseek 带 reasoning_effort 无 thinking 注入 enabled", - `{"model":"deepseek-v4-flash","reasoning_effort":"medium","messages":[]}`, "enabled"}, - {"deepseek thinking 对象 type 空 补 enabled", - `{"model":"deepseek-v4-flash","thinking":{},"messages":[]}`, "enabled"}, - } - for _, c := range cases { - t.Run(c.name, func(t *testing.T) { - out := PrepareBodyOptWithEfforts([]byte(c.body), false, nil) - typ, present := getThinkingType(t, out) - if !present { - t.Fatalf("thinking 字段缺失 (out=%s)", out) - } - if typ != c.wantTyp { - t.Errorf("thinking.type = %q want %q (out=%s)", typ, c.wantTyp, out) - } - }) - } -} - -// TestInjectThinkingDefaultEffort 打回修复主证据:无 effort 裸请求必须同时带 -// thinking.type=enabled 与默认档 reasoning_effort(否则上游 deepseek-v4-flash 不开思维链)。 -// 默认档 = 官方客户端兜底 "high",并带上 supportedEfforts 时经降级管线落到合法档。 -func TestInjectThinkingDefaultEffort(t *testing.T) { - // 裸请求无任何思考参数 → 注入 enabled + reasoning_effort="high"。 - out := PrepareBodyOptWithEfforts( - []byte(`{"model":"deepseek-v4-flash","messages":[{"role":"user","content":"hi"}]}`), - false, nil) - typ, present := getThinkingType(t, out) - if !present || typ != "enabled" { - t.Fatalf("thinking.type=%q present=%v want enabled (out=%s)", typ, present, out) - } - eff, ok := objFieldString(t, out, "reasoning_effort") - if !ok || eff != "high" { - t.Errorf("reasoning_effort=%q ok=%v want high(默认档)(out=%s)", eff, ok, out) - } - - // 模型只支持 low/high → 默认 high 经降级管线后仍是 high(合法档)。 - out = PrepareBodyOptWithEfforts( - []byte(`{"model":"deepseek-v4-flash","messages":[]}`), - false, map[string][]string{"deepseek-v4-flash": {"low", "high"}}) - eff, _ = objFieldString(t, out, "reasoning_effort") - if eff != "high" { - t.Errorf("supportedEfforts=[low high] 下默认档=%q want high (out=%s)", eff, out) - } - - // 模型只支持 minimal/low → 默认 high 降级到 low(≤high 的最高支持档)。 - out = PrepareBodyOptWithEfforts( - []byte(`{"model":"deepseek-v4-flash","messages":[]}`), - false, map[string][]string{"deepseek-v4-flash": {"minimal", "low"}}) - eff, _ = objFieldString(t, out, "reasoning_effort") - if eff != "low" { - t.Errorf("supportedEfforts=[minimal low] 下默认档降级=%q want low (out=%s)", eff, out) - } - - // 显式 enabled + 缺 effort → 同样补默认档(官方 configure thinking 行为)。 - out = PrepareBodyOptWithEfforts( - []byte(`{"model":"deepseek-v4-flash","thinking":{"type":"enabled"},"messages":[]}`), - false, nil) - if eff, _ = objFieldString(t, out, "reasoning_effort"); eff != "high" { - t.Errorf("显式 enabled 缺 effort 应补默认档, got %q (out=%s)", eff, out) - } -} - -// TestInjectThinkingEffortNotOverridden 已有显式 reasoning_effort(snake/camel) -// 一律不覆盖、不降级、不删除;降级由 normalizeReasoningEffort 单独负责。 -func TestInjectThinkingEffortNotOverridden(t *testing.T) { - cases := []struct { - name string - body string - }{ - {"snake effort 原样保留", - `{"model":"deepseek-v4-flash","thinking":{"type":"enabled"},"reasoning_effort":"medium","messages":[]}`}, - {"camel effort 原样保留", - `{"model":"deepseek-v4-flash","reasoningEffort":"low","messages":[]}`}, - } - for _, c := range cases { - t.Run(c.name, func(t *testing.T) { - out := PrepareBodyOptWithEfforts([]byte(c.body), false, nil) - typ, _ := getThinkingType(t, out) - if typ != "enabled" { - t.Fatalf("thinking.type=%q want enabled (out=%s)", typ, out) - } - // camel 分支:输入只有 camel,injectThinking 不得另加 snake 默认档。 - if strings.Contains(c.body, "reasoningEffort") { - if _, ok := objFieldString(t, out, "reasoning_effort"); ok { - t.Errorf("已有 reasoningEffort 却新增 reasoning_effort 默认档 (out=%s)", out) - } - } - }) - } - // 显式 effort + 无 thinking → 注入 enabled 但 effort 不覆盖。 - out := PrepareBodyOptWithEfforts( - []byte(`{"model":"deepseek-v4-flash","reasoning_effort":"medium","messages":[]}`), - false, nil) - if eff, _ := objFieldString(t, out, "reasoning_effort"); eff != "medium" { - t.Errorf("显式 effort 被改写 %q (out=%s)", eff, out) - } -} - -// TestInjectThinkingDisabledNoDefaultEffort disabled 保持既有语义: -// thinking.type=disabled 尊重关闭意图;reasoning_effort 删除;不得再补默认档。 -func TestInjectThinkingDisabledNoDefaultEffort(t *testing.T) { - out := PrepareBodyOptWithEfforts( - []byte(`{"model":"deepseek-v4-flash","thinking":{"type":"disabled"},"reasoning_effort":"high","messages":[]}`), - false, nil) - typ, present := getThinkingType(t, out) - if !present || typ != "disabled" { - t.Fatalf("thinking.type=%q present=%v want disabled (out=%s)", typ, present, out) - } - for _, k := range []string{"reasoning_effort", "reasoningEffort"} { - if _, ok := objFieldString(t, out, k); ok { - t.Errorf("%s 应被删除且不得补默认档(disabled 时)(out=%s)", k, out) - } - } -} - -// objFieldString 提取顶层字段 string 值。 -func objFieldString(t *testing.T, out []byte, key string) (string, bool) { - t.Helper() - var m map[string]any - if err := json.Unmarshal(out, &m); err != nil { - t.Fatalf("unmarshal: %v", err) - } - s, ok := m[key].(string) - return s, ok -} - -// TestInjectThinkingDeepSeekExplicitControl 客户端显式控制时必须尊重: -// thinking.type 非空(enabled/disabled)都不得被覆盖。 -func TestInjectThinkingDeepSeekExplicitControl(t *testing.T) { - cases := []struct { - name string - body string - wantTyp string - wantEff string // 期望 reasoning_effort 值;"" 且 wantEffAbsent=true 表示应删除 - }{ - {"已有 enabled 不动", - `{"model":"deepseek-v4-flash","thinking":{"type":"enabled"},"messages":[]}`, - "enabled", ""}, - {"已有 enabled 且带 reasoning_effort 保持(不删 effort)", - `{"model":"deepseek-v4-flash","thinking":{"type":"enabled"},"reasoning_effort":"high","messages":[]}`, - "enabled", "high"}, - {"已有 disabled 保留(尊重关闭意图)", - `{"model":"deepseek-v4-flash","thinking":{"type":"disabled"},"messages":[]}`, - "disabled", ""}, - } - for _, c := range cases { - t.Run(c.name, func(t *testing.T) { - out := PrepareBodyOptWithEfforts([]byte(c.body), false, nil) - typ, present := getThinkingType(t, out) - if !present { - t.Fatalf("thinking 字段缺失 (out=%s)", out) - } - if typ != c.wantTyp { - t.Errorf("thinking.type = %q want %q (out=%s)", typ, c.wantTyp, out) - } - if c.wantEff != "" { - if eff, _ := objFieldString(t, out, "reasoning_effort"); eff != c.wantEff { - t.Errorf("reasoning_effort = %q want %q (out=%s)", eff, c.wantEff, out) - } - } - }) - } -} - -// TestInjectThinkingDisabledDeletesEffort 显式 disabled 时 reasoning_effort 一并删除 -// (照抄官方客户端 case "deepseek" 行为:默认分支 delete reasoning_effort)。 -// snow/camel 双字段都删。 -func TestInjectThinkingDisabledDeletesEffort(t *testing.T) { - cases := []struct { - name string - body string - }{ - {"disabled + snake effort 删除", - `{"model":"deepseek-v4-flash","thinking":{"type":"disabled"},"reasoning_effort":"high","messages":[]}`}, - {"disabled + camel effort 删除", - `{"model":"deepseek-v4-flash","thinking":{"type":"disabled"},"reasoningEffort":"high","messages":[]}`}, - } - for _, c := range cases { - t.Run(c.name, func(t *testing.T) { - out := PrepareBodyOptWithEfforts([]byte(c.body), false, nil) - typ, present := getThinkingType(t, out) - if !present || typ != "disabled" { - t.Fatalf("thinking.type = %q present=%v want disabled (out=%s)", typ, present, out) - } - for _, k := range []string{"reasoning_effort", "reasoningEffort"} { - if _, ok := objFieldString(t, out, k); ok { - t.Errorf("%s 应被删除(显式 disabled 时)(out=%s)", k, out) - } - } - }) - } -} - -// TestInjectThinkingSkipNonDeepSeek 非 deepseek 模型零改动:无 thinking 不得凭空添加, -// 已有 thinking 原样保留。 -func TestInjectThinkingSkipNonDeepSeek(t *testing.T) { - cases := []struct { - name string - body string - }{ - {"glm 无 thinking 不注入", `{"model":"glm-5.2","messages":[]}`}, - {"glm 已有 thinking 保留", `{"model":"glm-5.2","thinking":{"type":"enabled"},"messages":[]}`}, - {"kimi 无 thinking 不注入", `{"model":"kimi-k2.5","messages":[]}`}, - {"qwen 系不注入", `{"model":"qwen2.5-coder-32b","messages":[]}`}, - } - for _, c := range cases { - t.Run(c.name, func(t *testing.T) { - // 记录输入是否已带 thinking 及值,输出必须逐字节语义不变。 - var in map[string]any - if err := json.Unmarshal([]byte(c.body), &in); err != nil { - t.Fatalf("unmarshal input: %v", err) - } - inTh, inHadThink := in["thinking"] - out := PrepareBodyOptWithEfforts([]byte(c.body), false, nil) - var got map[string]any - if err := json.Unmarshal(out, &got); err != nil { - t.Fatalf("unmarshal out: %v (out=%s)", err, out) - } - outTh, outHadThink := got["thinking"] - if inHadThink != outHadThink { - t.Errorf("thinking 出现性变化: in=%v(had=%v) out=%v(had=%v)", - inTh, inHadThink, outTh, outHadThink) - } - if inHadThink { - // 保留的 thinking 必须原值相等(JSON 语义级)。 - inJSON, _ := json.Marshal(inTh) - outJSON, _ := json.Marshal(outTh) - if string(inJSON) != string(outJSON) { - t.Errorf("thinking 被改动: in=%s out=%s", inJSON, outJSON) - } - } - // 非 deepseek 不得新增 thinking 相关字段;允许的既有新增字段: - // stream(强制流式)+ stream_options(D7 include_usage,CLI 流式必发)。 - allowedNew := map[string]bool{"stream": true, "stream_options": true} - if len(got) > len(in)+len(allowedNew) { - for k := range got { - if _, had := in[k]; !had && !allowedNew[k] { - t.Errorf("非 deepseek 新增字段 %q (out=%s)", k, out) - } - } - } - }) - } -} - -// TestInjectThinkingStringPreserved 注入不得破坏 model/messages 等既有字段。 -func TestInjectThinkingStringPreserved(t *testing.T) { - out := PrepareBodyOptWithEfforts( - []byte(`{"model":"deepseek-v4-flash","messages":[{"role":"user","content":"hi"}],"temperature":0.7}`), - false, nil) - var m map[string]any - if err := json.Unmarshal(out, &m); err != nil { - t.Fatalf("unmarshal: %v", err) - } - if m["model"] != "deepseek-v4-flash" || m["temperature"] != 0.7 { - t.Errorf("既有字段被改动: %v", m) - } - if _, ok := m["messages"].([]any); !ok { - t.Errorf("messages 结构破坏: %v", m) - } - if !strings.Contains(string(out), `"stream":true`) { - t.Errorf("stream 未强制: %s", out) - } -} +package upstream + +import ( + "encoding/json" + "strings" + "testing" +) + +// getThinkingType 从输出 body 提取 thinking.type(缺字段返回空串 + 是否存在)。 +func getThinkingType(t *testing.T, out []byte) (typ string, present bool) { + t.Helper() + var m map[string]any + if err := json.Unmarshal(out, &m); err != nil { + t.Fatalf("unmarshal: %v (out=%s)", err, out) + } + th, ok := m["thinking"].(map[string]any) + if !ok { + return "", false + } + s, ok := th["type"].(string) + if !ok { + return "", true + } + return s, true +} + +// TestInjectThinkingDeepSeekEnabled 开思考开关注入:deepseek 系模型请求体不带 +// thinking 时必须注入 {type:"enabled"},否则上游默认按不思考应答(思维链不显示)。 +func TestInjectThinkingDeepSeekEnabled(t *testing.T) { + cases := []struct { + name string + body string + wantTyp string + }{ + {"deepseek 无 thinking 注入 enabled", + `{"model":"deepseek-v4-flash","messages":[]}`, "enabled"}, + {"DeepSeek 大小写不敏感", + `{"model":"DeepSeek-v4.1-flash","messages":[]}`, "enabled"}, + {"DEEPSEEK 全大写不敏感", + `{"model":"DEEPSEEK-R1","messages":[]}`, "enabled"}, + {"deepseek 带 reasoning_effort 无 thinking 注入 enabled", + `{"model":"deepseek-v4-flash","reasoning_effort":"medium","messages":[]}`, "enabled"}, + {"deepseek thinking 对象 type 空 补 enabled", + `{"model":"deepseek-v4-flash","thinking":{},"messages":[]}`, "enabled"}, + } + for _, c := range cases { + t.Run(c.name, func(t *testing.T) { + out := PrepareBodyOptWithEfforts([]byte(c.body), false, nil) + typ, present := getThinkingType(t, out) + if !present { + t.Fatalf("thinking 字段缺失 (out=%s)", out) + } + if typ != c.wantTyp { + t.Errorf("thinking.type = %q want %q (out=%s)", typ, c.wantTyp, out) + } + }) + } +} + +// TestInjectThinkingDefaultEffort 打回修复主证据:无 effort 裸请求必须同时带 +// thinking.type=enabled 与默认档 reasoning_effort(否则上游 deepseek-v4-flash 不开思维链)。 +// 默认档 = 官方客户端兜底 "high",并带上 supportedEfforts 时经降级管线落到合法档。 +func TestInjectThinkingDefaultEffort(t *testing.T) { + // 裸请求无任何思考参数 → 注入 enabled + reasoning_effort="high"。 + out := PrepareBodyOptWithEfforts( + []byte(`{"model":"deepseek-v4-flash","messages":[{"role":"user","content":"hi"}]}`), + false, nil) + typ, present := getThinkingType(t, out) + if !present || typ != "enabled" { + t.Fatalf("thinking.type=%q present=%v want enabled (out=%s)", typ, present, out) + } + eff, ok := objFieldString(t, out, "reasoning_effort") + if !ok || eff != "high" { + t.Errorf("reasoning_effort=%q ok=%v want high(默认档)(out=%s)", eff, ok, out) + } + + // 模型只支持 low/high → 默认 high 经降级管线后仍是 high(合法档)。 + out = PrepareBodyOptWithEfforts( + []byte(`{"model":"deepseek-v4-flash","messages":[]}`), + false, map[string][]string{"deepseek-v4-flash": {"low", "high"}}) + eff, _ = objFieldString(t, out, "reasoning_effort") + if eff != "high" { + t.Errorf("supportedEfforts=[low high] 下默认档=%q want high (out=%s)", eff, out) + } + + // 模型只支持 minimal/low → 默认 high 降级到 low(≤high 的最高支持档)。 + out = PrepareBodyOptWithEfforts( + []byte(`{"model":"deepseek-v4-flash","messages":[]}`), + false, map[string][]string{"deepseek-v4-flash": {"minimal", "low"}}) + eff, _ = objFieldString(t, out, "reasoning_effort") + if eff != "low" { + t.Errorf("supportedEfforts=[minimal low] 下默认档降级=%q want low (out=%s)", eff, out) + } + + // 显式 enabled + 缺 effort → 同样补默认档(官方 configure thinking 行为)。 + out = PrepareBodyOptWithEfforts( + []byte(`{"model":"deepseek-v4-flash","thinking":{"type":"enabled"},"messages":[]}`), + false, nil) + if eff, _ = objFieldString(t, out, "reasoning_effort"); eff != "high" { + t.Errorf("显式 enabled 缺 effort 应补默认档, got %q (out=%s)", eff, out) + } +} + +// TestInjectThinkingEffortNotOverridden 已有显式 reasoning_effort(snake/camel) +// 一律不覆盖、不降级、不删除;降级由 normalizeReasoningEffort 单独负责。 +func TestInjectThinkingEffortNotOverridden(t *testing.T) { + cases := []struct { + name string + body string + }{ + {"snake effort 原样保留", + `{"model":"deepseek-v4-flash","thinking":{"type":"enabled"},"reasoning_effort":"medium","messages":[]}`}, + {"camel effort 原样保留", + `{"model":"deepseek-v4-flash","reasoningEffort":"low","messages":[]}`}, + } + for _, c := range cases { + t.Run(c.name, func(t *testing.T) { + out := PrepareBodyOptWithEfforts([]byte(c.body), false, nil) + typ, _ := getThinkingType(t, out) + if typ != "enabled" { + t.Fatalf("thinking.type=%q want enabled (out=%s)", typ, out) + } + // camel 分支:输入只有 camel,injectThinking 不得另加 snake 默认档。 + if strings.Contains(c.body, "reasoningEffort") { + if _, ok := objFieldString(t, out, "reasoning_effort"); ok { + t.Errorf("已有 reasoningEffort 却新增 reasoning_effort 默认档 (out=%s)", out) + } + } + }) + } + // 显式 effort + 无 thinking → 注入 enabled 但 effort 不覆盖。 + out := PrepareBodyOptWithEfforts( + []byte(`{"model":"deepseek-v4-flash","reasoning_effort":"medium","messages":[]}`), + false, nil) + if eff, _ := objFieldString(t, out, "reasoning_effort"); eff != "medium" { + t.Errorf("显式 effort 被改写 %q (out=%s)", eff, out) + } +} + +// TestInjectThinkingDisabledNoDefaultEffort disabled 保持既有语义: +// thinking.type=disabled 尊重关闭意图;reasoning_effort 删除;不得再补默认档。 +func TestInjectThinkingDisabledNoDefaultEffort(t *testing.T) { + out := PrepareBodyOptWithEfforts( + []byte(`{"model":"deepseek-v4-flash","thinking":{"type":"disabled"},"reasoning_effort":"high","messages":[]}`), + false, nil) + typ, present := getThinkingType(t, out) + if !present || typ != "disabled" { + t.Fatalf("thinking.type=%q present=%v want disabled (out=%s)", typ, present, out) + } + for _, k := range []string{"reasoning_effort", "reasoningEffort"} { + if _, ok := objFieldString(t, out, k); ok { + t.Errorf("%s 应被删除且不得补默认档(disabled 时)(out=%s)", k, out) + } + } +} + +// objFieldString 提取顶层字段 string 值。 +func objFieldString(t *testing.T, out []byte, key string) (string, bool) { + t.Helper() + var m map[string]any + if err := json.Unmarshal(out, &m); err != nil { + t.Fatalf("unmarshal: %v", err) + } + s, ok := m[key].(string) + return s, ok +} + +// TestInjectThinkingDeepSeekExplicitControl 客户端显式控制时必须尊重: +// thinking.type 非空(enabled/disabled)都不得被覆盖。 +func TestInjectThinkingDeepSeekExplicitControl(t *testing.T) { + cases := []struct { + name string + body string + wantTyp string + wantEff string // 期望 reasoning_effort 值;"" 且 wantEffAbsent=true 表示应删除 + }{ + {"已有 enabled 不动", + `{"model":"deepseek-v4-flash","thinking":{"type":"enabled"},"messages":[]}`, + "enabled", ""}, + {"已有 enabled 且带 reasoning_effort 保持(不删 effort)", + `{"model":"deepseek-v4-flash","thinking":{"type":"enabled"},"reasoning_effort":"high","messages":[]}`, + "enabled", "high"}, + {"已有 disabled 保留(尊重关闭意图)", + `{"model":"deepseek-v4-flash","thinking":{"type":"disabled"},"messages":[]}`, + "disabled", ""}, + } + for _, c := range cases { + t.Run(c.name, func(t *testing.T) { + out := PrepareBodyOptWithEfforts([]byte(c.body), false, nil) + typ, present := getThinkingType(t, out) + if !present { + t.Fatalf("thinking 字段缺失 (out=%s)", out) + } + if typ != c.wantTyp { + t.Errorf("thinking.type = %q want %q (out=%s)", typ, c.wantTyp, out) + } + if c.wantEff != "" { + if eff, _ := objFieldString(t, out, "reasoning_effort"); eff != c.wantEff { + t.Errorf("reasoning_effort = %q want %q (out=%s)", eff, c.wantEff, out) + } + } + }) + } +} + +// TestInjectThinkingDisabledDeletesEffort 显式 disabled 时 reasoning_effort 一并删除 +// (照抄官方客户端 case "deepseek" 行为:默认分支 delete reasoning_effort)。 +// snow/camel 双字段都删。 +func TestInjectThinkingDisabledDeletesEffort(t *testing.T) { + cases := []struct { + name string + body string + }{ + {"disabled + snake effort 删除", + `{"model":"deepseek-v4-flash","thinking":{"type":"disabled"},"reasoning_effort":"high","messages":[]}`}, + {"disabled + camel effort 删除", + `{"model":"deepseek-v4-flash","thinking":{"type":"disabled"},"reasoningEffort":"high","messages":[]}`}, + } + for _, c := range cases { + t.Run(c.name, func(t *testing.T) { + out := PrepareBodyOptWithEfforts([]byte(c.body), false, nil) + typ, present := getThinkingType(t, out) + if !present || typ != "disabled" { + t.Fatalf("thinking.type = %q present=%v want disabled (out=%s)", typ, present, out) + } + for _, k := range []string{"reasoning_effort", "reasoningEffort"} { + if _, ok := objFieldString(t, out, k); ok { + t.Errorf("%s 应被删除(显式 disabled 时)(out=%s)", k, out) + } + } + }) + } +} + +// TestInjectThinkingSkipNonDeepSeek 非 deepseek 模型零改动:无 thinking 不得凭空添加, +// 已有 thinking 原样保留。 +func TestInjectThinkingSkipNonDeepSeek(t *testing.T) { + cases := []struct { + name string + body string + }{ + {"glm 无 thinking 不注入", `{"model":"glm-5.2","messages":[]}`}, + {"glm 已有 thinking 保留", `{"model":"glm-5.2","thinking":{"type":"enabled"},"messages":[]}`}, + {"kimi 无 thinking 不注入", `{"model":"kimi-k2.5","messages":[]}`}, + {"qwen 系不注入", `{"model":"qwen2.5-coder-32b","messages":[]}`}, + } + for _, c := range cases { + t.Run(c.name, func(t *testing.T) { + // 记录输入是否已带 thinking 及值,输出必须逐字节语义不变。 + var in map[string]any + if err := json.Unmarshal([]byte(c.body), &in); err != nil { + t.Fatalf("unmarshal input: %v", err) + } + inTh, inHadThink := in["thinking"] + out := PrepareBodyOptWithEfforts([]byte(c.body), false, nil) + var got map[string]any + if err := json.Unmarshal(out, &got); err != nil { + t.Fatalf("unmarshal out: %v (out=%s)", err, out) + } + outTh, outHadThink := got["thinking"] + if inHadThink != outHadThink { + t.Errorf("thinking 出现性变化: in=%v(had=%v) out=%v(had=%v)", + inTh, inHadThink, outTh, outHadThink) + } + if inHadThink { + // 保留的 thinking 必须原值相等(JSON 语义级)。 + inJSON, _ := json.Marshal(inTh) + outJSON, _ := json.Marshal(outTh) + if string(inJSON) != string(outJSON) { + t.Errorf("thinking 被改动: in=%s out=%s", inJSON, outJSON) + } + } + // 非 deepseek 不得新增 thinking 相关字段;允许的既有新增字段: + // stream(强制流式)+ stream_options(D7 include_usage,CLI 流式必发)。 + allowedNew := map[string]bool{"stream": true, "stream_options": true} + if len(got) > len(in)+len(allowedNew) { + for k := range got { + if _, had := in[k]; !had && !allowedNew[k] { + t.Errorf("非 deepseek 新增字段 %q (out=%s)", k, out) + } + } + } + }) + } +} + +// TestInjectThinkingStringPreserved 注入不得破坏 model/messages 等既有字段。 +func TestInjectThinkingStringPreserved(t *testing.T) { + out := PrepareBodyOptWithEfforts( + []byte(`{"model":"deepseek-v4-flash","messages":[{"role":"user","content":"hi"}],"temperature":0.7}`), + false, nil) + var m map[string]any + if err := json.Unmarshal(out, &m); err != nil { + t.Fatalf("unmarshal: %v", err) + } + if m["model"] != "deepseek-v4-flash" || m["temperature"] != 0.7 { + t.Errorf("既有字段被改动: %v", m) + } + if _, ok := m["messages"].([]any); !ok { + t.Errorf("messages 结构破坏: %v", m) + } + if !strings.Contains(string(out), `"stream":true`) { + t.Errorf("stream 未强制: %s", out) + } +} + +// TestThinkingHonorsEffortOff 客户端用档位字段表达「关闭思考」时必须真的关掉。 +// 回归 issue #66 同类实测:off 在 effortRank 里 rank=0,模型又不声明 off 档位, +// 于是被就近降级成最弱正档——实测仍返回 157 字思维链,与 high 无异。 +func TestThinkingHonorsEffortOff(t *testing.T) { + efforts := map[string][]string{"deepseek-v4.1-flash": {"low", "high", "max"}} + cases := []struct{ name, body string }{ + {"snake off", `{"model":"deepseek-v4.1-flash","reasoning_effort":"off","messages":[]}`}, + {"camel none", `{"model":"deepseek-v4.1-flash","reasoningEffort":"none","messages":[]}`}, + {"off with enabled thinking", `{"model":"deepseek-v4.1-flash","thinking":{"type":"enabled"},"reasoning_effort":"off","messages":[]}`}, + {"uppercase OFF", `{"model":"deepseek-v4.1-flash","reasoning_effort":" OFF ","messages":[]}`}, + } + for _, c := range cases { + t.Run(c.name, func(t *testing.T) { + out := PrepareBodyOptWithEffortsAndDefault([]byte(c.body), false, efforts, nil) + typ, _ := getThinkingType(t, out) + if typ != "disabled" { + t.Fatalf("thinking.type=%q want disabled (out=%s)", typ, out) + } + // 档位字段必须清掉:留着会被降级管线抬回正档,关思考又失效。 + for _, k := range []string{"reasoning_effort", "reasoningEffort"} { + if _, ok := objFieldString(t, out, k); ok { + t.Errorf("%s 应被删除 (out=%s)", k, out) + } + } + }) + } +} + +// TestThinkingEffortOffNotLeakedToOtherModels 非 deepseek 模型不注入 thinking +// (关闭形态由上游自己认),但非法档位值 off/none 一律清掉——上游只认自己的 +// 档位表,透传 off 只会得到 400 或静默降级。 +func TestThinkingEffortOffNotLeakedToOtherModels(t *testing.T) { + out := PrepareBodyOptWithEffortsAndDefault( + []byte(`{"model":"glm-5.3","reasoning_effort":"off","messages":[]}`), false, + map[string][]string{"glm-5.3": {"low", "high", "max"}}, nil) + if _, ok := getThinkingType(t, out); ok { + t.Errorf("非 deepseek 不应被注入 thinking (out=%s)", out) + } + if v, ok := objFieldString(t, out, "reasoning_effort"); ok { + t.Errorf("off 非法档位应被清掉, got %q", v) + } +} diff --git a/internal/upstream/thinktag.go b/internal/upstream/thinktag.go new file mode 100644 index 0000000000000000000000000000000000000000..63ce8c4c4e562f7cabdbe08cebabab1e8ce47a1c --- /dev/null +++ b/internal/upstream/thinktag.go @@ -0,0 +1,144 @@ +package upstream + +import "strings" + +// 上游思考控制 token 的两种形态(hy4 的 vLLM reasoning parser 用 / +// ,SUF 是模型的 checkpoint token 后缀,不是请求 id)。 +const ( + thinkOpen = " / 。chat 协议客户端看到的是正文里混着 CoT; +// Anthropic 客户端更糟——它只认 content_block.type=thinking,内联标签一律当文本。 +// 上游 parser 修不了,网关至少不该把控制 token 当正文发出去。 +// +// 只在 content 以 形态,不带冒号的裸 不处理; +// 另一个上游换了 parser 形态再放开。 +type ThinkTag struct { + decided bool // 已判定这段 content 是否内联思考 + on bool // 启用摘除 + inTag bool // 当前位置在标签内 + pend string // 尾部可能是半个标签,等下一片 +} + +// Feed 吃一片正文,返回本片里的思考与正文(按原顺序拼进各自通道)。 +func (t *ThinkTag) Feed(s string) (think, body string) { + if s == "" { + return "", "" + } + t.pend += s + if !t.decided { + // 开头还没看够:先等一片,别把 "= 0 && (idx < 0 || k < idx) { + idx, closing = k, m.closing + } + } + if idx < 0 { + keep := 0 + if !flush { + // 尾巴可能是下一个标签的前半截(最长 len( 0; n-- { + tail := p[len(p)-n:] + if strings.HasPrefix(thinkClose, tail) || strings.HasPrefix(thinkOpen, tail) { + keep = n + break + } + } + } + emit(p[:len(p)-keep]) + t.pend = p[len(p)-keep:] + return tb.String(), bb.String() + } + emit(p[:idx]) + rest := p[idx:] + gt := strings.IndexByte(rest, '>') + if gt < 0 { + // 标签还没收全:留到下一片。flush 时上游已经结束了,按正文发出去, + // 少一次改写好过丢内容。 + if flush { + emit(rest) + t.pend = "" + } else { + t.pend = rest + } + return tb.String(), bb.String() + } + t.pend = rest[gt+1:] + t.inTag = !closing + } +} + +// SplitThinkTags 非流式的一次性版本(完整 content 进来,两段出去)。 +func SplitThinkTags(s string) (think, body string) { + var t ThinkTag + a, b := t.Feed(s) + c, d := t.Flush() + return a + c, b + d +} diff --git a/internal/upstream/thinktag_test.go b/internal/upstream/thinktag_test.go new file mode 100644 index 0000000000000000000000000000000000000000..a06c253c6f9ea60c2ccc3947ee467d049fe889e5 --- /dev/null +++ b/internal/upstream/thinktag_test.go @@ -0,0 +1,49 @@ +package upstream + +import "testing" + +func TestThinkTagSplit(t *testing.T) { + think, body := SplitThinkTags("先看代码答案是 42") + if think != "先看代码" || body != "答案是 42" { + t.Fatalf("think=%q body=%q", think, body) + } +} + +// 标签被切在任意位置(流式分片)都要拼回同一结果。 +func TestThinkTagSplitAcrossChunks(t *testing.T) { + full := "CoTAnswer" + if think, body := SplitThinkTags(full); think != "CoT" || body != "Answer" { + t.Fatalf("一次性: think=%q body=%q", think, body) + } + for cut := 1; cut < len(full); cut++ { + var tt ThinkTag + var think, body string + for _, s := range []string{full[:cut], full[cut:]} { + a, b := tt.Feed(s) + think += a + body += b + } + a, b := tt.Flush() + think += a + body += b + if think != "CoT" || body != "Answer" { + t.Fatalf("cut=%d think=%q body=%q", cut, think, body) + } + } +} + +// 不以 len(raw) { + t.Fatal("ClientHello 截断(无扩展段)") + } + total := int(binary.BigEndian.Uint16(raw[p : p+2])) + p += 2 + end := p + total + if end > len(raw) { + end = len(raw) + } + for p+4 <= end { + et := binary.BigEndian.Uint16(raw[p : p+2]) + el := int(binary.BigEndian.Uint16(raw[p+2 : p+4])) + data := raw[p+4:] + if len(data) > el { + data = data[:el] + } + f.exts = append(f.exts, et) + switch et { + case 0: + f.hasSNI = true + case 10: + for i := 2; i+1 < len(data); i += 2 { + f.groups = append(f.groups, binary.BigEndian.Uint16(data[i:i+2])) + } + case 11: + for i := 1; i < len(data); i++ { + f.ecpf = append(f.ecpf, data[i]) + } + case 13: + if len(data) >= 2 { + n := int(binary.BigEndian.Uint16(data[0:2])) + for i := 2; i+1 < len(data) && i < 2+n; i += 2 { + f.sigalgs = append(f.sigalgs, binary.BigEndian.Uint16(data[i:i+2])) + } + } + case 43: + if len(data) >= 1 { + n := int(data[0]) + for i := 1; i+1 < len(data) && i < 1+n; i += 2 { + f.supportedVersions = append(f.supportedVersions, binary.BigEndian.Uint16(data[i:i+2])) + } + } + case 16: + if len(data) >= 2 { + q := 2 + for q < len(data) { + l := int(data[q]) + if q+1+l > len(data) { + break + } + f.alpn = append(f.alpn, string(data[q+1:q+1+l])) + q += 1 + l + } + } + } + p += 4 + el + } + return f +} + +// ja4Version TLS 版本号 → JA4 的两字符版本段。 +// +// TLS 的线格式是 0x0301=TLS1.0 / 0x0302=TLS1.1 / 0x0303=TLS1.2 / 0x0304=TLS1.3, +// 而 JA4 用「1.」书写:0x0304 → "13"、0x0303 → "12"。 +// 直接把 0x0304 当整数格式化会写出 "t772…",看似合理实则全错。 +func ja4Version(v uint16) string { + return fmt.Sprintf("1%d", int(v&0xff)-1) +} + +// maxSupportedVersion 从 supported_versions 扩展里取最高版本。 +func (f *helloFields) maxSupportedVersion() uint16 { + var out uint16 + for _, v := range f.supportedVersions { + if v > out { + out = v + } + } + return out +} + +func (f *helloFields) ja3() string { + join := func(list []string) string { return strings.Join(list, "-") } + var cs, es, gs, ef []string + for _, c := range f.ciphers { + cs = append(cs, fmt.Sprintf("%d", c)) + } + for _, e := range f.exts { + es = append(es, fmt.Sprintf("%d", e)) + } + for _, g := range f.groups { + gs = append(gs, fmt.Sprintf("%d", g)) + } + for _, x := range f.ecpf { + ef = append(ef, fmt.Sprintf("%d", x)) + } + return fmt.Sprintf("%d,%s,%s,%s,%s", f.version, join(cs), join(es), join(gs), join(ef)) +} + +// ja4 按 FoxIO 规范:a_b_c。 +// a = t{ver}{d|i}{ext数 hex2}{cipher数 hex2}{ALPN 首2字符或 00} +// b = sha256(cipher 升序, 4位hex, 逗号分隔)[:12] +// c = sha256(扩展升序[排除 SNI/ALPN] + "_" + sigalgs 升序)[:12] +// +// 版本段取 **supported_versions 里的最高值**(0x0304 → 13),不是 ClientHello +// 的 legacy_version(那恒为 0x0303=3,直接拿来用会算出 t3 而不是 t13)。 +func (f *helloFields) ja4() string { + tlsMax := f.version + if v := f.maxSupportedVersion(); v > tlsMax { + tlsMax = v + } + a := fmt.Sprintf("t%s%s%02x%02x", ja4Version(tlsMax), map[bool]string{true: "d", false: "i"}[f.hasSNI], + len(f.exts), len(f.ciphers)) + if len(f.alpn) > 0 && len(f.alpn[0]) >= 2 { + a += f.alpn[0][:2] + } else { + a += "00" + } + var cs []int + for _, c := range f.ciphers { + cs = append(cs, int(c)) + } + sort.Ints(cs) + var bIn []string + for _, c := range cs { + bIn = append(bIn, fmt.Sprintf("%04x", c)) + } + b := sha256.Sum256([]byte(strings.Join(bIn, ","))) + + var ex, sa []int + for _, e := range f.exts { + if e != 0 && e != 16 { + ex = append(ex, int(e)) + } + } + for _, s := range f.sigalgs { + sa = append(sa, int(s)) + } + sort.Ints(ex) + sort.Ints(sa) + var cIn, saIn []string + for _, e := range ex { + cIn = append(cIn, fmt.Sprintf("%04x", e)) + } + for _, s := range sa { + saIn = append(saIn, fmt.Sprintf("%04x", s)) + } + c := sha256.Sum256([]byte(strings.Join(cIn, ",") + "_" + strings.Join(saIn, ","))) + return fmt.Sprintf("%s_%s_%s", a, hex.EncodeToString(b[:])[:12], hex.EncodeToString(c[:])[:12]) +} + +// captureClientHello 起一个裸 TCP 监听,让 dialer 连上去,收回它发出的 +// ClientHello 原始字节。不完成握手——只看第一包。 +func captureClientHello(t *testing.T, dial func(addr string) (net.Conn, error)) []byte { + t.Helper() + ln, err := net.Listen("tcp", "127.0.0.1:0") + if err != nil { + t.Fatalf("listen: %v", err) + } + defer ln.Close() + + got := make(chan []byte, 1) + go func() { + c, aerr := ln.Accept() + if aerr != nil { + got <- nil + return + } + defer c.Close() + c.SetReadDeadline(time.Now().Add(3 * time.Second)) + buf := make([]byte, 8192) + n, _ := c.Read(buf) + got <- buf[:n] + }() + + go func() { + if conn, derr := dial(ln.Addr().String()); derr == nil { + conn.Close() + } + }() + + select { + case b := <-got: + if len(b) == 0 { + t.Fatal("没抓到 ClientHello") + } + return b + case <-time.After(5 * time.Second): + t.Fatal("等 ClientHello 超时") + return nil + } +} + +// dialFor 用给定指纹档位造一个 dial 函数(连到 listener,但 SNI 用真实域名)。 +func dialFor(t *testing.T, fp string) func(addr string) (net.Conn, error) { + t.Helper() + d := newDialer() + // ServerName 显式给域名:listener 在 127.0.0.1,若让 newTLSDialer 从地址 + // 里取 host,SNI 会变成 IP,uTLS 按 RFC 不发 SNI 扩展 → ClientHello 少一项, + // JA3/JA4 必然对不上(这个坑第一次跑测试时就被抓到了)。 + cfg := &tls.Config{InsecureSkipVerify: true, ServerName: "www.workbuddy.cn"} + tlsDial := newTLSDialer(d, cfg, fp) + return func(addr string) (net.Conn, error) { + // 握手必然失败(对端不回),忽略错误——ClientHello 已经发出。 + conn, _ := tlsDial(t.Context(), "tcp", addr) + if conn == nil { + return nil, net.ErrClosed + } + return conn, nil + } +} + +// TestNodeFingerprintMatchesOfficial 默认档位必须与官方真机逐项一致。 +func TestNodeFingerprintMatchesOfficial(t *testing.T) { + raw := captureClientHello(t, dialFor(t, TLSFingerprintNode)) + f := parseClientHello(t, raw) + + if got := f.ja3(); got != OfficialJA3 { + t.Errorf("JA3 与官方不一致\n want: %s\n got : %s", OfficialJA3, got) + } + if got := f.ja4(); got != OfficialJA4 { + t.Errorf("JA4 与官方不一致\n want: %s\n got : %s", OfficialJA4, got) + } + // 逐项拆开断言,失败时能直接看出是哪一项跑偏 + if len(f.ciphers) != 18 { + t.Errorf("cipher 数 = %d want 18", len(f.ciphers)) + } + if len(f.exts) != 10 { + t.Errorf("扩展数 = %d want 10 (JA3/JA4 都会因此跑偏)", len(f.exts)) + } + if len(f.sigalgs) != 9 { + t.Errorf("sigalgs = %d want 9(官方不含 ed25519/ed448/pss_pss): %v", len(f.sigalgs), f.sigalgs) + } + if len(f.alpn) != 0 { + t.Errorf("ALPN 必须为空(官方 Node 栈不发),got %v", f.alpn) + } + if got := f.groups; fmt.Sprint(got) != "[29 23 24]" { + t.Errorf("groups = %v want [29 23 24]", got) + } + // session_id 与 record 长度不属于 JA3/JA4,单独盯:官方每次连接发 32 字节 + // 随机 session_id(抓包 39 次 39 个不同值),uTLS 默认也发 32 字节,但这条 + // 依赖库内部行为,写死断言才能在升级 uTLS 后第一时间发现形态变了。 + if f.sessionIDLen != 32 { + t.Errorf("session_id 长度 = %d want 32(官方形态)", f.sessionIDLen) + } + if f.recordLen != 255 { + t.Logf("ClientHello record 长度 = %d(官方 255,本身不是指纹,仅记录)", f.recordLen) + } +} + +// TestGoFingerprintDiffersFromOfficial 回滚档位必须是原生形态(否则开关没意义)。 +func TestGoFingerprintDiffersFromOfficial(t *testing.T) { + raw := captureClientHello(t, dialFor(t, TLSFingerprintGo)) + f := parseClientHello(t, raw) + if f.ja3() == OfficialJA3 { + t.Fatal("go 档位不该产出官方指纹——开关失效") + } + if len(f.alpn) != 0 { + t.Errorf("go 档位也应无 ALPN(禁 h2 口径),got %v", f.alpn) + } + t.Logf("go 档位 JA3 = %s", md5Hex(f.ja3())) + t.Logf("go 档位 JA4 = %s", f.ja4()) +} + +// TestTLSFingerprintValidation 配置取值校验。 +func TestTLSFingerprintValidation(t *testing.T) { + cases := map[string]string{ + "": TLSFingerprintNode, + "node": TLSFingerprintNode, + "NODE": TLSFingerprintNode, + " go ": TLSFingerprintGo, + "go": TLSFingerprintGo, + } + for in, want := range cases { + got, err := validateTLSFingerprint(in) + if err != nil { + t.Errorf("validate(%q) 报错: %v", in, err) + continue + } + if got != want { + t.Errorf("validate(%q) = %q want %q", in, got, want) + } + } + if _, err := validateTLSFingerprint("chrome"); err == nil { + t.Error("非法取值应报错") + } +} + +// TestSetTLSFingerprintSwitches 运行期切换必须真的改变出站指纹。 +func TestSetTLSFingerprintSwitches(t *testing.T) { + c := New() + defer c.HTTP.CloseIdleConnections() + defer c.ChatHTTP.CloseIdleConnections() + + if c.TLSFingerprint != TLSFingerprintNode { + t.Fatalf("默认档位 = %q want node", c.TLSFingerprint) + } + if err := c.SetTLSFingerprint(TLSFingerprintGo); err != nil { + t.Fatalf("切到 go: %v", err) + } + if c.TLSFingerprint != TLSFingerprintGo { + t.Fatalf("切换后档位 = %q", c.TLSFingerprint) + } + if err := c.SetTLSFingerprint("bogus"); err == nil { + t.Error("非法档位应报错") + } + // 非法值不该改动当前设置 + if c.TLSFingerprint != TLSFingerprintGo { + t.Errorf("非法切换后档位被污染 = %q", c.TLSFingerprint) + } +} + +// md5Hex JA3 的 md5(社区口径)。 +func md5Hex(s string) string { + sum := md5.Sum([]byte(s)) + return hex.EncodeToString(sum[:]) +} + +var _ = tls.VersionTLS13 diff --git a/internal/upstream/tool_enum_type_test.go b/internal/upstream/tool_enum_type_test.go new file mode 100644 index 0000000000000000000000000000000000000000..226d7e78dea789baee04ec81133545c50b981490 --- /dev/null +++ b/internal/upstream/tool_enum_type_test.go @@ -0,0 +1,96 @@ +package upstream + +import ( + "encoding/json" + "strings" + "testing" +) + +// 工具 schema 里「只有 enum、没有 type」的属性会被 Kimi 系模型严格拒掉(400 code=11133 +// Invalid request parameters),而 DSH 等客户端的整套工具定义里就有这类 schema——不补类型 +// 等于该模型对这些客户端全废。补上可无损推断的类型即可;推不出唯一类型就保持原样, +// 交上游按原语义报错,不猜。 +func TestToolSchemaEnumTypeInflated(t *testing.T) { + props := map[string]any{ + "d": map[string]any{"enum": []any{"x", "y"}}, + "n": map[string]any{"enum": []any{float64(1), float64(2)}}, + "r": map[string]any{"enum": []any{float64(1), 2.5}}, + "b": map[string]any{"enum": []any{true, false}}, + "mix": map[string]any{"enum": []any{"a", float64(1)}}, + "nullish": map[string]any{"enum": []any{nil, "a"}}, + "typed": map[string]any{"type": "string", "enum": []any{"p"}}, + } + in, err := json.Marshal(map[string]any{ + "model": "m", + "messages": []any{map[string]any{"role": "user", "content": "hi"}}, + "tools": []any{map[string]any{ + "type": "function", + "function": map[string]any{ + "name": "f", + "parameters": map[string]any{"type": "object", "properties": props}, + }, + }}, + }) + if err != nil { + t.Fatal(err) + } + out, _, _ := prepareBodyOpt(in, false, true, nil, nil, nil, "", nil, "", "", false, 0, "") + + var got map[string]any + if err := json.Unmarshal(out, &got); err != nil { + t.Fatalf("unmarshal: %v", err) + } + gotProps := got["tools"].([]any)[0].(map[string]any)["function"].(map[string]any)["parameters"].(map[string]any)["properties"].(map[string]any) + want := map[string]string{ + "d": "string", "n": "integer", "r": "number", "b": "boolean", + "mix": "", "nullish": "", "typed": "string", // 不可推断 / 已显式 → 不写 type + } + for k, w := range want { + p := gotProps[k].(map[string]any) + gotType, _ := p["type"].(string) + if w == "" { + if _, has := p["type"]; has && k != "typed" { + t.Errorf("%s: 不该补 type,实际 %q", k, gotType) + } + continue + } + if gotType != w { + t.Errorf("%s: type=%q want %q", k, gotType, w) + } + // enum 取值一律原样保留——只增补类型,不改客户端语义。 + if _, ok := p["enum"]; !ok { + t.Errorf("%s: enum 被删", k) + } + } +} + +// 嵌套位置同样要覆盖(items / anyOf / $defs / 数组形态的 properties)。 +func TestToolSchemaEnumTypeNested(t *testing.T) { + in := `{"model":"m","messages":[],"tools":[{"type":"function","function":{"name":"f","parameters":{"type":"object","properties":{"list":{"type":"array","items":{"enum":["a"]}},"one":{"anyOf":[{"enum":["z"]}]}}}}}]}` + out, _, _ := prepareBodyOpt([]byte(in), false, true, nil, nil, nil, "", nil, "", "", false, 0, "") + + var got map[string]any + if err := json.Unmarshal(out, &got); err != nil { + t.Fatalf("unmarshal: %v", err) + } + props := got["tools"].([]any)[0].(map[string]any)["function"].(map[string]any)["parameters"].(map[string]any)["properties"].(map[string]any) + if tp, _ := props["list"].(map[string]any)["items"].(map[string]any)["type"].(string); tp != "string" { + t.Errorf("items 内 enum 未补类型: %q", tp) + } + if tp, _ := props["one"].(map[string]any)["anyOf"].([]any)[0].(map[string]any)["type"].(string); tp != "string" { + t.Errorf("anyOf 内 enum 未补类型: %q", tp) + } +} + +// response_format 的 json_schema 不走这条归一化:它的 enum 属于模型输出约束, +// 补错类型会改变约束语义(上游按原样校验)。 +func TestToolSchemaEnumTypeLeavesResponseFormat(t *testing.T) { + in := `{"model":"m","messages":[],"response_format":{"type":"json_schema","json_schema":{"schema":{"properties":{"k":{"enum":["a"]}}}}}}` + out, _, _ := prepareBodyOpt([]byte(in), false, true, nil, nil, nil, "", nil, "", "", false, 0, "") + if !strings.Contains(string(out), `"enum":["a"]`) { + t.Fatalf("response_format 被改动: %s", out) + } + if strings.Contains(string(out), `"k":{"type":"string","enum":["a"]}`) { + t.Errorf("response_format 的 enum 被补了 type: %s", out) + } +} diff --git a/internal/upstream/tool_pairing.go b/internal/upstream/tool_pairing.go index 8ba698fc74c2e92e9551d25023179fd71c63eca2..eed74283d53099b17b0a8e197788de3e160fa6c3 100644 --- a/internal/upstream/tool_pairing.go +++ b/internal/upstream/tool_pairing.go @@ -1,347 +1,262 @@ -// tool_pairing.go 出站请求体的孤儿 tool_call↔tool 配对清理 + tool 结果块重排 -// (吸收参考仓库 sse.ts:91-123 resolveToolPairing 语义,适配网关的 OpenAI wire 消息形态)。 -// -// 背景:OpenAI 兼容协议要求带 tool_calls 的 assistant 消息,其每一个 tool_call id -// 都必须有对应的一条 role:tool 结果消息;反之 role:tool 消息也必须有对应的前置 -// tool_call。缺任一侧,上游都会以 HTTP 400 拒绝整个请求。 -// -// 工具执行失败时(参数非法、超时、工具不存在……)客户端会把 assistant 的 tool_calls -// 持久化进会话历史,却写不回结果消息。这条坏历史随后被每次请求原样重放——上游对之后 -// 每一条用户消息都返回 400,整条会话报废。网关是最后一道防线:发出请求前剔除无法配对 -// 的条目让会话自愈,宁可丢一轮工具上下文,也好过整条会话死亡。 -package upstream - -// repackToolResultBlocks 把插在 assistant.tool_calls 与其 tool 结果之间的非 tool 消息 -// 挪到整组之后,保证同一批 tool_call 的结果在 wire 上连续。 -// -// 背景:Codex 的 image_resize_notice 特性会把 作为一条 -// developer/system 消息插在 tool 输出后面。并行调用时它插在两份 tool 结果中间: -// -// assistant tool_calls=[c00 c01] -// tool c00 -// developer <- 插在中间 -// tool c01 -// -// OpenAI 兼容协议要求 tool 结果紧跟 assistant,中间插任何消息都算配对断裂,上游判 -// 11148(tool_call_sequence_broken)并顶死整条会话。这里只调顺序、不改内容: -// -// assistant tool_calls=[c00 c01] | tool c00 | X | tool c01 -// → assistant tool_calls=[c00 c01] | tool c00 | tool c01 | X -// -// 结果顺序保持不变(同批 tool_call 的原相对顺序 = 结果顺序),不引入新的顺序敏感 -// 问题。无插入消息时零改动零分配(返回原 slice)。 -func repackToolResultBlocks(messages []any) ([]any, bool) { - if len(messages) < 3 { - return messages, false - } - out := make([]any, 0, len(messages)) - changed := false - i := 0 - for i < len(messages) { - m, ok := messages[i].(map[string]any) - if !ok || m["role"] != "assistant" { - out = append(out, messages[i]) - i++ - continue - } - tcs, hasCalls := m["tool_calls"].([]any) - if !hasCalls || len(tcs) == 0 { - out = append(out, messages[i]) - i++ - continue - } - want := map[string]bool{} - for _, tci := range tcs { - if tc, ok := tci.(map[string]any); ok { - if id, _ := tc["id"].(string); id != "" { - want[id] = true - } - } - } - // 收集紧随其后(允许被其他消息打断)的同批 tool 结果,按原相对顺序。 - out = append(out, messages[i]) - i++ - var results []any - var between []any - sawNonTool := false - for i < len(messages) { - mm, ok := messages[i].(map[string]any) - if !ok { - break - } - role, _ := mm["role"].(string) - if role == "tool" { - id, _ := mm["tool_call_id"].(string) - if !want[id] { - break - } - results = append(results, messages[i]) - if sawNonTool { - changed = true - } - i++ - continue - } - if len(results) == 0 { - break // assistant 后没有结果:交由 cleanupOrphanToolCalls 处理 - } - // 下一组 assistant.tool_calls 是新的组头,绝不能当插入物吞掉:一旦被收进 - // between,它永远不再被外层循环当作组头处理,它自己那批结果也就永远得不 - // 到重排(真实会话 msg[181] 正是这样漏掉的)。必须 break 交还外层循环。 - if role == "assistant" { - if next, _ := mm["tool_calls"].([]any); len(next) > 0 { - break - } - } - // 同批结果尚未收齐时,中间消息视为插入物,暂存待后移。 - between = append(between, messages[i]) - sawNonTool = true - i++ - } - out = append(out, results...) - out = append(out, between...) - } - if !changed { - return messages, false - } - return out, true -} - -// cleanupOrphanToolCalls 剔除无法配对的 tool_call 与 tool 结果(所有模型,独立于 -// deepseek-only 的 sanitize 开关)。语义对齐参考仓库 resolveToolPairing: -// -// - 收集全线 role:tool 消息的 tool_call_id(结果集)与 assistant.tool_calls[].id(调用集); -// - 一批 assistant.tool_calls 按 keepCalls 对称裁剪:只留有结果配对的调用(部分保留 -// 不会留下无结果的 tool_call),过滤后为空才删掉整个 tool_calls 键; -// - role:tool 只在对应 tool_call 被保留时才保留,否则删除整条消息; -// - 无任何工具流量 → 原 slice 原样返回,changed=false(零分配零改动)。 -// -// 这是「让请求通过」的安全网:只要存在合法配对就整段保留这些字段,绝不吞掉正确配对。 -// 返回清理后的 slice(无改动时等于原 slice,勿依赖其是否新分配)及是否发生删除。 -func cleanupOrphanToolCalls(messages []any) ([]any, bool) { - if len(messages) == 0 { - return messages, false - } - callIDs := map[string]bool{} - resultIDs := map[string]bool{} - hasTraffic := false - for _, m := range messages { - msg, ok := m.(map[string]any) - if !ok { - continue - } - switch msg["role"] { - case "tool": - if id, ok := msg["tool_call_id"].(string); ok && id != "" { - resultIDs[id] = true - hasTraffic = true - } - case "assistant": - if tcs, ok := msg["tool_calls"].([]any); ok { - for _, tci := range tcs { - tc, ok := tci.(map[string]any) - if !ok { - continue - } - if id, ok := tc["id"].(string); ok && id != "" { - callIDs[id] = true - hasTraffic = true - } - } - } - } - } - if !hasTraffic { - return messages, false - } - // keepCalls:调用 id 是否双侧齐全(调用存在且结果存在)。重复 id 与乱序均按集合处理。 - keepCalls := map[string]bool{} - for id := range callIDs { - if resultIDs[id] { - keepCalls[id] = true - } - } - changed := false - // 1) assistant.tool_calls:按 keepCalls 对称裁剪——只留有结果的调用,过滤后为空则删键。 - // - // 历史实现是「批内每个 id 都齐才整批保留,否则删掉整个 tool_calls 键」。那会留下 - // 无主结果:批 [c1,c2] 只回了 c1 时,调用侧整批被删,而 tool{c1} 仍按 id 命中 - // keepCalls 得以保留 —— 出站载荷于是变成「无 tool_calls 的 assistant + 孤儿 tool」, - // 上游判 11148(tool calls and tool results do not match)并顶死整条会话。 - // 现在两侧共用同一份 keepCalls 按 id 对称裁剪(与 2) 的删除侧同口径), - // 任何输入都不会再产生半截配对。 - for _, m := range messages { - msg, ok := m.(map[string]any) - if !ok { - continue - } - if role, _ := msg["role"].(string); role != "assistant" { - continue - } - tcs, ok := msg["tool_calls"].([]any) - if !ok || len(tcs) == 0 { - continue - } - keptCalls := make([]any, 0, len(tcs)) - for _, tci := range tcs { - tc, ok := tci.(map[string]any) - if !ok { - continue - } - if id, _ := tc["id"].(string); keepCalls[id] { - keptCalls = append(keptCalls, tc) - } - } - if len(keptCalls) == len(tcs) { - continue // 整批齐全:零改动 - } - changed = true - if len(keptCalls) == 0 { - delete(msg, "tool_calls") - continue - } - msg["tool_calls"] = keptCalls - } - // 2) role:tool 结果:只有对应 tool_call 被保留才保留;孤儿结果整条删除。 - kept := make([]any, 0, len(messages)) - for _, m := range messages { - msg, ok := m.(map[string]any) - if !ok { - kept = append(kept, m) - continue - } - if role, _ := msg["role"].(string); role == "tool" { - id, _ := msg["tool_call_id"].(string) - if !keepCalls[id] { - changed = true - continue - } - } - kept = append(kept, m) - } - if !changed { - return messages, false - } - return kept, true -} - -// mergeAdjacentToolCalls 把**背靠背**的 assistant.tool_calls 消息合成一条(tool_calls 依原序拼接)。 -// -// 2026-09-20 实机定位并复现的 11148 事故根因:部分 OpenAI 兼容 agent 客户端回放历史时把 -// 同一批并行工具调用拆成多条紧邻的独立 assistant 消息,出站载荷长成: -// -// assistant tool_calls=[c00] -// assistant tool_calls=[c01] -// tool c00 -// tool c01 -// -// 上游要求「声明 tool_calls 的 assistant 之后必须紧跟它自己的结果」——紧随的若是另一条带 -// tool_calls 的 assistant,即返回 400 code=11148(extError tool_call_sequence_broken, -// "tool calls and tool results do not match, please start a new conversation and retry"), -// 整条会话报废:客户端每次重试重放同一条历史,池侧换号也无效(不是账号问题)。 -// -// 对照实验(2026-09-20 在线上网关实测,同一批调用): -// - 拆成两条 assistant(Codex Desktop 报文形状)+ deepseek-v4.1-flash → 503 / 11148 -// - 合成一条 assistant(=本函数产物) + deepseek-v4.1-flash → 200 -// - 拆成两条 assistant + glm-5.3-flash → 200(该模型宽容) -// -// 即:**行为本身合法**(上述第一种形态在 OpenAI 规范里也说得通),是上游 deepseek 系模型的 -// 校验更严。网关作为最后一道防线按最严口径归一,客户端不必感知。 -// -// 合并条件从严,避免引入新语义: -// - 两条消息**相邻**(中间隔着任何消息都不合并——隔着消息说明不是同一批声明, -// 凭猜测合并会改变语义,这类形态按其原样交给 repackToolResultBlocks 处理); -// - 后一条 content 为空(content 非空无法无损拼接,不猜语义); -// - 前一条本身必须是带 tool_calls 的 assistant(否则不合并,例如 assistant 文本 + 独立工具调用消息)。 -// -// reasoning_content(thinking.go 的多轮回填字段)不丢:后一条有则搬到合并结果,两边都有则换行拼接 -// (deepseek 多轮要求 assistant 带思维链回填,丢弃会换一个错误)。 -func mergeAdjacentToolCalls(messages []any) ([]any, bool) { - if len(messages) < 2 { - return messages, false - } - out := make([]any, 0, len(messages)) - changed := false - for _, m := range messages { - msg, ok := m.(map[string]any) - if !ok { - out = append(out, m) - continue - } - if role, _ := msg["role"].(string); role == "assistant" && len(out) > 0 { - // 形态一:本条是带 tool_calls 的 assistant 且没有正文 → 并入上一条 - // 同为 assistant 且带 tool_calls 的消息(背靠背的并行调用声明)。 - if tcs, ok := msg["tool_calls"].([]any); ok && len(tcs) > 0 && emptyContent(msg["content"]) { - if prev, ok := out[len(out)-1].(map[string]any); ok { - if prevRole, _ := prev["role"].(string); prevRole == "assistant" { - if prevCalls, ok := prev["tool_calls"].([]any); ok && len(prevCalls) > 0 { - prev["tool_calls"] = append(prevCalls, tcs...) - mergeReasoningContent(prev, msg) - changed = true - continue // 本条已并入上一条,不再单独出站 - } - } - } - } - // 形态二(反向):本条是纯正文 assistant,上一条是带 tool_calls 但没正文的 - // assistant → 把正文折进上一条,合成 assistant(正文 + tool_calls)。这样 - // "声明 tool_calls 的 assistant 紧跟它自己的结果"在两种拆分顺序下都成立。 - // - // 谁会产出这个顺序:部分 OpenAI 兼容 agent 客户端的回放顺序(正文与 - // 调用声明拆成两条独立 assistant)。 - // - // 条件同样从严:只认**字符串正文**(数组正文可能含多模态块,拼接会丢结构, - // 交给 repackToolResultBlocks 原样处理);上一条必须自身无正文。 - if _, hasCalls := msg["tool_calls"]; !hasCalls { - if txt, ok := msg["content"].(string); ok && txt != "" { - if prev, ok := out[len(out)-1].(map[string]any); ok { - if prevRole, _ := prev["role"].(string); prevRole == "assistant" { - if prevCalls, ok := prev["tool_calls"].([]any); ok && len(prevCalls) > 0 && emptyContent(prev["content"]) { - prev["content"] = txt - mergeReasoningContent(prev, msg) - changed = true - continue // 正文已折进上一条 - } - } - } - } - } - } - out = append(out, m) - } - if !changed { - return messages, false - } - return out, true -} - -// mergeReasoningContent 把 src 的 reasoning_content 并入 dst(两边都有则换行拼接)。 -// deepseek 多轮要求 assistant 带思维链回填,合并时丢弃会换一个错误。 -func mergeReasoningContent(dst, src map[string]any) { - rc, _ := src["reasoning_content"].(string) - if rc == "" { - return - } - if prevRC, _ := dst["reasoning_content"].(string); prevRC != "" { - dst["reasoning_content"] = prevRC + "\n" + rc - return - } - dst["reasoning_content"] = rc -} - -// emptyContent content 是否为空(缺失 / nil / 空串 / 空数组)。 -// 空数组也必须算空:有客户端把"没有正文"发成 `content: []` 而不是 null,此前按 -// "非字符串一律非空"处理 → 背靠背的两条 assistant(tool_calls) 不合并 → 上游 -// deepseek 系判 11148(正是 mergeAdjacentToolCalls 要挡的形态,条件漏了 [])。 -// 非空数组仍视为有内容:宁可漏合并,也不丢内容。 -func emptyContent(v any) bool { - switch c := v.(type) { - case nil: - return true - case string: - return c == "" - case []any: - return len(c) == 0 - } - return false -} +// tool_pairing.go 出站请求体的孤儿 tool_call↔tool 配对清理 + tool 结果块重排 +// (吸收参考仓库 sse.ts:91-123 resolveToolPairing 语义,适配网关的 OpenAI wire 消息形态)。 +// +// 背景:OpenAI 兼容协议要求带 tool_calls 的 assistant 消息,其每一个 tool_call id +// 都必须有对应的一条 role:tool 结果消息;反之 role:tool 消息也必须有对应的前置 +// tool_call。缺任一侧,上游都会以 HTTP 400 拒绝整个请求。 +// +// 工具执行失败时(参数非法、超时、工具不存在……)客户端会把 assistant 的 tool_calls +// 持久化进会话历史,却写不回结果消息。这条坏历史随后被每次请求原样重放——上游对之后 +// 每一条用户消息都返回 400,整条会话报废。网关是最后一道防线:发出请求前剔除无法配对 +// 的条目让会话自愈,宁可丢一轮工具上下文,也好过整条会话死亡。 +package upstream + +import "strings" + +// repackToolResultBlocks 把插在 assistant.tool_calls 与其 tool 结果之间的非 tool 消息 +// 挪到整组之后,保证同一批 tool_call 的结果在 wire 上连续。 +// +// 背景:Codex 的 image_resize_notice 特性会把 作为一条 +// developer/system 消息插在 tool 输出后面。并行调用时它插在两份 tool 结果中间: +// +// assistant tool_calls=[c00 c01] +// tool c00 +// developer <- 插在中间 +// tool c01 +// +// OpenAI 兼容协议要求 tool 结果紧跟 assistant,中间插任何消息都算配对断裂,上游判 +// 11148(tool_call_sequence_broken)并顶死整条会话。这里只调顺序、不改内容: +// +// assistant tool_calls=[c00 c01] | tool c00 | X | tool c01 +// → assistant tool_calls=[c00 c01] | tool c00 | tool c01 | X +// +// 结果顺序保持不变(同批 tool_call 的原相对顺序 = 结果顺序),不引入新的顺序敏感 +// 问题。无插入消息时零改动零分配(返回原 slice)。 +func repackToolResultBlocks(messages []any) ([]any, bool) { + if len(messages) < 3 { + return messages, false + } + out := make([]any, 0, len(messages)) + changed := false + i := 0 + for i < len(messages) { + m, ok := messages[i].(map[string]any) + if !ok || m["role"] != "assistant" { + out = append(out, messages[i]) + i++ + continue + } + tcs, hasCalls := m["tool_calls"].([]any) + if !hasCalls || len(tcs) == 0 { + out = append(out, messages[i]) + i++ + continue + } + want := map[string]bool{} + for _, tci := range tcs { + if tc, ok := tci.(map[string]any); ok { + if id, _ := tc["id"].(string); id != "" { + want[id] = true + } + } + } + // 收集紧随其后(允许被其他消息打断)的同批 tool 结果,按原相对顺序。 + out = append(out, messages[i]) + i++ + var results []any + var between []any + sawNonTool := false + for i < len(messages) { + mm, ok := messages[i].(map[string]any) + if !ok { + break + } + role, _ := mm["role"].(string) + if role == "tool" { + id, _ := mm["tool_call_id"].(string) + if !want[id] { + break + } + results = append(results, messages[i]) + if sawNonTool { + changed = true + } + i++ + continue + } + if len(results) == 0 { + break // assistant 后没有结果:交由 cleanupOrphanToolCalls 处理 + } + // 下一组 assistant.tool_calls 是新的组头,绝不能当插入物吞掉:一旦被收进 + // between,它永远不再被外层循环当作组头处理,它自己那批结果也就永远得不 + // 到重排(真实会话 msg[181] 正是这样漏掉的)。必须 break 交还外层循环。 + if role == "assistant" { + if next, _ := mm["tool_calls"].([]any); len(next) > 0 { + break + } + } + // 同批结果尚未收齐时,中间消息视为插入物,暂存待后移。 + between = append(between, messages[i]) + sawNonTool = true + i++ + } + out = append(out, results...) + out = append(out, between...) + } + if !changed { + return messages, false + } + return out, true +} + +// cleanupOrphanToolCalls 剔除无法配对的 tool_call 与 tool 结果(所有模型,独立于 +// deepseek-only 的 sanitize 开关)。语义对齐参考仓库 resolveToolPairing: +// +// - 收集全线 role:tool 消息的 tool_call_id(结果集)与 assistant.tool_calls[].id(调用集); +// - 一批 assistant.tool_calls 按 keepCalls 对称裁剪:只留有结果配对的调用(部分保留 +// 不会留下无结果的 tool_call),过滤后为空才删掉整个 tool_calls 键; +// - role:tool 只在对应 tool_call 被保留时才保留,否则删除整条消息; +// - 无任何工具流量 → 原 slice 原样返回,changed=false(零分配零改动)。 +// +// 这是「让请求通过」的安全网:只要存在合法配对就整段保留这些字段,绝不吞掉正确配对。 +// 返回清理后的 slice(无改动时等于原 slice,勿依赖其是否新分配)及是否发生删除。 +func cleanupOrphanToolCalls(messages []any) ([]any, bool) { + if len(messages) == 0 { + return messages, false + } + callIDs := map[string]bool{} + resultIDs := map[string]bool{} + nameBadIDs := map[string]bool{} + hasTraffic := false + for _, m := range messages { + msg, ok := m.(map[string]any) + if !ok { + continue + } + switch msg["role"] { + case "tool": + if id, ok := msg["tool_call_id"].(string); ok && id != "" { + resultIDs[id] = true + hasTraffic = true + } + case "assistant": + if tcs, ok := msg["tool_calls"].([]any); ok { + for _, tci := range tcs { + tc, ok := tci.(map[string]any) + if !ok { + continue + } + if id, ok := tc["id"].(string); ok && id != "" { + callIDs[id] = true + if toolCallNameMissing(tc) { + nameBadIDs[id] = true + } + hasTraffic = true + } + } + } + } + } + if !hasTraffic { + return messages, false + } + // keepCalls:调用 id 是否双侧齐全(调用存在且结果存在)。重复 id 与乱序均按集合处理。 + // + // 追加否决条件:没有可用功能名(无 function 键 / 无 name 键 / name 空白)的调用一律 + // 不保留。上游对这类条目直接判 11133 model_param_invalid(tool_calls[i].function.name + // must be a non-empty string),**带不带配对结果都拒**——带结果的脏条目原本会命中 + // keepCalls 原样出站,正是线上「整条会话每轮 400、只能手动清空历史」的成因。删除动作 + // 完全复用两侧对称裁剪(调用与其结果成对剔除),配对对称不变式照常成立。 + keepCalls := map[string]bool{} + for id := range callIDs { + if nameBadIDs[id] { + continue + } + if resultIDs[id] { + keepCalls[id] = true + } + } + changed := false + // 1) assistant.tool_calls:按 keepCalls 对称裁剪——只留有结果的调用,过滤后为空则删键。 + // + // 历史实现是「批内每个 id 都齐才整批保留,否则删掉整个 tool_calls 键」。那会留下 + // 无主结果:批 [c1,c2] 只回了 c1 时,调用侧整批被删,而 tool{c1} 仍按 id 命中 + // keepCalls 得以保留 —— 出站载荷于是变成「无 tool_calls 的 assistant + 孤儿 tool」, + // 上游判 11148(tool calls and tool results do not match)并顶死整条会话。 + // 现在两侧共用同一份 keepCalls 按 id 对称裁剪(与 2) 的删除侧同口径), + // 任何输入都不会再产生半截配对。 + for _, m := range messages { + msg, ok := m.(map[string]any) + if !ok { + continue + } + if role, _ := msg["role"].(string); role != "assistant" { + continue + } + tcs, ok := msg["tool_calls"].([]any) + if !ok || len(tcs) == 0 { + continue + } + keptCalls := make([]any, 0, len(tcs)) + for _, tci := range tcs { + tc, ok := tci.(map[string]any) + if !ok { + continue + } + if id, _ := tc["id"].(string); keepCalls[id] { + keptCalls = append(keptCalls, tc) + } + } + if len(keptCalls) == len(tcs) { + continue // 整批齐全:零改动 + } + changed = true + if len(keptCalls) == 0 { + delete(msg, "tool_calls") + continue + } + msg["tool_calls"] = keptCalls + } + // 2) role:tool 结果:只有对应 tool_call 被保留才保留;孤儿结果整条删除。 + kept := make([]any, 0, len(messages)) + for _, m := range messages { + msg, ok := m.(map[string]any) + if !ok { + kept = append(kept, m) + continue + } + if role, _ := msg["role"].(string); role == "tool" { + id, _ := msg["tool_call_id"].(string) + if !keepCalls[id] { + changed = true + continue + } + } + kept = append(kept, m) + } + if !changed { + return messages, false + } + return kept, true +} + +// toolCallNameMissing 报告 assistant.tool_calls[] 单项是否缺少可用的功能名: +// function 对象缺失、name 字段缺失、name 为空白串,三者皆判真。 +// +// 为什么比「function 在、name 键存在且为空」宽一格:本网关自己就能产出另两种形状—— +// 流在 name 分片到达前断掉时,聚合器落下的占位条目是 `{"id":..,"type":"function"}` +// (无 function 键)或 `{"id":..,"function":{}}`(有 function 无 name 键),实测见 +// Aggregate。这类条目客户端无从派发、上游无从校验,留着只会把整条会话顶死。 +// OpenAI schema 本就要求 function.name 非空,故不存在「合法但缺名」的入站历史, +// 判脏不会误伤正确配对——代价只是丢一轮工具上下文,正是本文件的既定取舍。 +func toolCallNameMissing(tc map[string]any) bool { + fn, ok := tc["function"].(map[string]any) + if !ok { + return true + } + name, ok := fn["name"].(string) + if !ok { + return true + } + return strings.TrimSpace(name) == "" +} diff --git a/internal/upstream/tool_pairing_test.go b/internal/upstream/tool_pairing_test.go index a31725d9c2420b2b0d07d5797b081475949e2b49..9b5405204f7876c53fbc64eae55b6cd5a119cb73 100644 --- a/internal/upstream/tool_pairing_test.go +++ b/internal/upstream/tool_pairing_test.go @@ -1,424 +1,111 @@ -// tool_pairing_test.go 出站工具配对三步(merge/repack/cleanup)的行为钉桩。 -// -// 断言口径来自 2026-09-20 的线上实机定位:上游对「声明 tool_calls 的 assistant 之后必须 -// 紧跟它自己的结果」有硬校验,违反即 400 code=11148(tool_call_sequence_broken)并顶死整条 -// 会话(换号无效)。对照实验见 mergeAdjacentToolCalls 注释。 -package upstream - -import ( - "encoding/json" - "strings" - "testing" -) - -// msgs 解析测试用的 messages JSON 数组。 -func msgs(t *testing.T, s string) []any { - t.Helper() - var v []any - if err := json.Unmarshal([]byte(s), &v); err != nil { - t.Fatalf("parse messages: %v", err) - } - return v -} - -// summarize 把消息序列压成可读摘要:assistant 带 tool_calls 记 "assistant(id1,id2)", -// 其余记 "role(-)"。用于逐条比对「合并后长什么样」。 -func summarize(messages []any) []string { - out := make([]string, 0, len(messages)) - for _, m := range messages { - msg, ok := m.(map[string]any) - if !ok { - out = append(out, "") - continue - } - role, _ := msg["role"].(string) - if role == "tool" { - id, _ := msg["tool_call_id"].(string) - out = append(out, "tool("+id+")") - continue - } - ids := []string{} - if tcs, ok := msg["tool_calls"].([]any); ok { - for _, tci := range tcs { - if tc, ok := tci.(map[string]any); ok { - id, _ := tc["id"].(string) - ids = append(ids, id) - } - } - } - if len(ids) > 0 { - out = append(out, role+"("+strings.Join(ids, ",")+")") - continue - } - out = append(out, role+"(-)") - } - return out -} - -func assertSummary(t *testing.T, got, want []string) { - t.Helper() - if len(got) != len(want) { - t.Fatalf("消息数不符:\n got %v\nwant %v", got, want) - } - for i := range got { - if got[i] != want[i] { - t.Errorf("消息[%d] = %s want %s\n got %v\nwant %v", i, got[i], want[i], got, want) - } - } -} - -// TestMergeAdjacentToolCalls 背靠背的两条 assistant.tool_calls 必须合成一条。 -// -// 这是部分 OpenAI 兼容 agent 客户端回放并行工具调用的报文形状(同一批调用 -// 拆成多条独立 assistant 消息),上游 deepseek 系模型对它判 11148。 -func TestMergeAdjacentToolCalls(t *testing.T) { - const ( - aNil = `{"role":"assistant","content":null,"tool_calls":[{"id":"c00","type":"function","function":{"name":"f","arguments":"{}"}}]}` - aC01 = `{"role":"assistant","content":null,"tool_calls":[{"id":"c01","type":"function","function":{"name":"f","arguments":"{}"}}]}` - tC00 = `{"role":"tool","tool_call_id":"c00","content":"r0"}` - tC01 = `{"role":"tool","tool_call_id":"c01","content":"r1"}` - ) - - t.Run("并行两条合成一条(修复目标形态)", func(t *testing.T) { - // 输入即线上复现 11148 的报文:assistant(c00) 之后紧跟 assistant(c01)。 - in := msgs(t, "["+aNil+","+aC01+","+tC00+","+tC01+"]") - out, changed := mergeAdjacentToolCalls(in) - if !changed { - t.Fatal("changed=false,期望发生合并") - } - assertSummary(t, summarize(out), []string{"assistant(c00,c01)", "tool(c00)", "tool(c01)"}) - // 拼接顺序必须是声明顺序(= 结果的 wire 顺序),不得反转。 - tcs := out[0].(map[string]any)["tool_calls"].([]any) - if id, _ := tcs[0].(map[string]any)["id"].(string); id != "c00" { - t.Errorf("合并后首个 tool_call = %q want c00", id) - } - }) - - t.Run("三条连续全并", func(t *testing.T) { - aC02 := `{"role":"assistant","content":null,"tool_calls":[{"id":"c02","type":"function","function":{"name":"f","arguments":"{}"}}]}` - in := msgs(t, "["+aNil+","+aC01+","+aC02+"]") - out, changed := mergeAdjacentToolCalls(in) - if !changed { - t.Fatal("changed=false,期望发生合并") - } - assertSummary(t, summarize(out), []string{"assistant(c00,c01,c02)"}) - }) - - t.Run("已是规范形态原样返回且零改动", func(t *testing.T) { - // chat 规范形态(一条 assistant 带全部 tool_calls):不得改动,便于上层判断 no-op。 - merged := `{"role":"assistant","content":null,"tool_calls":[{"id":"c00"},{"id":"c01"}]}` - in := msgs(t, "["+merged+","+tC00+","+tC01+"]") - out, changed := mergeAdjacentToolCalls(in) - if changed { - t.Error("changed=true,规范形态不应被改动") - } - assertSummary(t, summarize(out), []string{"assistant(c00,c01)", "tool(c00)", "tool(c01)"}) - }) - - t.Run("中间隔着消息不合并(非背靠背)", func(t *testing.T) { - // 隔了 user 消息 = 两条独立声明,不是同一批;擅自合并会改变语义。 - in := msgs(t, "["+aNil+`,{"role":"user","content":"x"},`+aC01+","+tC00+","+tC01+"]") - out, changed := mergeAdjacentToolCalls(in) - if changed { - t.Error("changed=true,非相邻不应合并") - } - assertSummary(t, summarize(out), []string{"assistant(c00)", "user(-)", "assistant(c01)", "tool(c00)", "tool(c01)"}) - }) - - t.Run("后一条 content 非空不合并", func(t *testing.T) { - // content 非空无法无损拼接:不猜语义,原样交给上游。 - in := msgs(t, "["+aNil+`,{"role":"assistant","content":"text","tool_calls":[{"id":"c01"}]}`+"]") - out, changed := mergeAdjacentToolCalls(in) - if changed { - t.Error("changed=true,content 非空不应合并") - } - assertSummary(t, summarize(out), []string{"assistant(c00)", "assistant(c01)"}) - }) - - t.Run("前一条无 tool_calls 不合并", func(t *testing.T) { - in := msgs(t, `[{"role":"assistant","content":"hi"},`+aNil+"]") - out, changed := mergeAdjacentToolCalls(in) - if changed { - t.Error("changed=true,前一条无 tool_calls 不应合并") - } - assertSummary(t, summarize(out), []string{"assistant(-)", "assistant(c00)"}) - }) - - t.Run("reasoning_content 逐条保留(换行拼接)", func(t *testing.T) { - // deepseek 多轮要求 assistant 带回填思维链,丢弃会换一个错误,故必须搬过去。 - in := msgs(t, `[{"role":"assistant","content":null,"reasoning_content":"r1","tool_calls":[{"id":"c00"}]},{"role":"assistant","content":null,"reasoning_content":"r2","tool_calls":[{"id":"c01"}]}]`) - out, changed := mergeAdjacentToolCalls(in) - if !changed { - t.Fatal("changed=false,期望合并") - } - rc, _ := out[0].(map[string]any)["reasoning_content"].(string) - if rc != "r1\nr2" { - t.Errorf("reasoning_content = %q want %q", rc, "r1\nr2") - } - }) - - t.Run("首条即 assistant.tool_calls 不越界", func(t *testing.T) { - out, changed := mergeAdjacentToolCalls(msgs(t, "["+aNil+"]")) - if changed { - t.Error("单条消息不应改动") - } - assertSummary(t, summarize(out), []string{"assistant(c00)"}) - }) - - t.Run("非对象元素原样保留且不阻断后续合并", func(t *testing.T) { - in := msgs(t, `["str",`+aNil+","+aC01+"]") - out, changed := mergeAdjacentToolCalls(in) - if !changed { - t.Fatal("changed=false,期望 aNil/aC01 合并") - } - assertSummary(t, summarize(out), []string{"", "assistant(c00,c01)"}) - }) -} - -// TestPrepareBodyMergesSplitParallelToolCalls 全链路:出站管线必须把「拆开的并行调用」 -// 归一到上游认可的形态。 -// -// 断言的正是线上对照实验的结论:合成一条 assistant(本测试期望的输出形态)→ 200; -// 拆成两条 → deepseek 系模型 503/11148。 -func TestPrepareBodyMergesSplitParallelToolCalls(t *testing.T) { - body := `{"model":"deepseek-v4.1-flash","messages":[ - {"role":"user","content":"跑两个命令"}, - {"role":"assistant","content":null,"tool_calls":[{"id":"call_00_a","type":"function","function":{"name":"exec_command","arguments":"{\"cmd\":\"pwd\"}"}}]}, - {"role":"assistant","content":null,"tool_calls":[{"id":"call_01_b","type":"function","function":{"name":"exec_command","arguments":"{\"cmd\":\"ls\"}"}}]}, - {"role":"tool","tool_call_id":"call_00_a","content":"/opt"}, - {"role":"tool","tool_call_id":"call_01_b","content":"a b c"} - ]}` - out := PrepareBodyOptWithEfforts([]byte(body), false, nil) - var obj map[string]any - if err := json.Unmarshal(out, &obj); err != nil { - t.Fatalf("unmarshal 出站 body: %v", err) - } - messages, _ := obj["messages"].([]any) - assertSummary(t, summarize(messages), []string{ - "user(-)", "assistant(call_00_a,call_01_b)", "tool(call_00_a)", "tool(call_01_b)", - }) - // 逐条复核:不得出现「带 tool_calls 的 assistant 紧跟另一条带 tool_calls 的 assistant」。 - prevHadCalls := false - for i, m := range messages { - msg, _ := m.(map[string]any) - hasCalls := false - if tcs, ok := msg["tool_calls"].([]any); ok && len(tcs) > 0 { - hasCalls = true - } - if prevHadCalls && hasCalls { - t.Fatalf("消息[%d] 仍是两条相邻的 assistant.tool_calls(上游判 11148): %v", i, summarize(messages)) - } - prevHadCalls = hasCalls - } -} - -// TestRepackToolResultBlocks 结果之间的插入消息必须挪到整组之后(上游判配对断裂的另一形态)。 -func TestRepackToolResultBlocks(t *testing.T) { - t.Run("插在结果中间的消息后移", func(t *testing.T) { - in := msgs(t, `[ - {"role":"assistant","content":null,"tool_calls":[{"id":"c00"},{"id":"c01"}]}, - {"role":"tool","tool_call_id":"c00","content":"r0"}, - {"role":"system","content":""}, - {"role":"tool","tool_call_id":"c01","content":"r1"} - ]`) - out, changed := repackToolResultBlocks(in) - if !changed { - t.Fatal("changed=false,期望重排") - } - assertSummary(t, summarize(out), []string{"assistant(c00,c01)", "tool(c00)", "tool(c01)", "system(-)"}) - }) - - t.Run("下一组组头不被吞掉", func(t *testing.T) { - // 真实会话漏排的形态:第一组结果后跟着插入消息、再接第二组组头。组头必须交还外层 - // 循环当组头处理——否则它会被当成插入物挪走,它自己那批结果(t(c10) 与 t(c11) - // 之间夹着 system)永远得不到重排,上游判配对断裂。 - in := msgs(t, `[ - {"role":"assistant","content":null,"tool_calls":[{"id":"c00"}]}, - {"role":"tool","tool_call_id":"c00","content":"r0"}, - {"role":"system","content":"notice1"}, - {"role":"assistant","content":null,"tool_calls":[{"id":"c10"},{"id":"c11"}]}, - {"role":"tool","tool_call_id":"c10","content":"r10"}, - {"role":"system","content":"notice2"}, - {"role":"tool","tool_call_id":"c11","content":"r11"} - ]`) - out, changed := repackToolResultBlocks(in) - if !changed { - t.Fatal("changed=false,第二组的插入消息应被后移") - } - assertSummary(t, summarize(out), []string{ - "assistant(c00)", "tool(c00)", "system(-)", - "assistant(c10,c11)", "tool(c10)", "tool(c11)", "system(-)", - }) - }) - - t.Run("无可重排内容时零改动", func(t *testing.T) { - in := msgs(t, `[ - {"role":"assistant","content":null,"tool_calls":[{"id":"c00"}]}, - {"role":"tool","tool_call_id":"c00","content":"r0"} - ]`) - _, changed := repackToolResultBlocks(in) - if changed { - t.Error("changed=true,规范形态不应重排") - } - }) -} - -// TestCleanupOrphanToolCalls 缺一侧的配对必须两侧同口径剔除(否则残留半截配对 → 11148)。 -func TestCleanupOrphanToolCalls(t *testing.T) { - t.Run("批内部分缺结果:调用侧对称裁剪", func(t *testing.T) { - // 历史缺陷形态:批 [c1,c2] 只回了 c1 时整批删调用、却留下 tool{c1}, - // 出站变成「无 tool_calls 的 assistant + 孤儿 tool」→ 11148。 - in := msgs(t, `[ - {"role":"assistant","content":null,"tool_calls":[{"id":"c1"},{"id":"c2"}]}, - {"role":"tool","tool_call_id":"c1","content":"r1"} - ]`) - out, changed := cleanupOrphanToolCalls(in) - if !changed { - t.Fatal("changed=false,期望裁剪") - } - assertSummary(t, summarize(out), []string{"assistant(c1)", "tool(c1)"}) - }) - - t.Run("调用无任何结果:删 tool_calls 键", func(t *testing.T) { - in := msgs(t, `[{"role":"assistant","content":"hi","tool_calls":[{"id":"c1"}]}]`) - out, changed := cleanupOrphanToolCalls(in) - if !changed { - t.Fatal("changed=false,期望删除 tool_calls") - } - msg := out[0].(map[string]any) - if _, has := msg["tool_calls"]; has { - t.Error("孤儿调用应删除整个 tool_calls 键") - } - if msg["content"] != "hi" { - t.Errorf("content 被误改: %v", msg["content"]) - } - }) - - t.Run("孤儿结果整条删除", func(t *testing.T) { - in := msgs(t, `[{"role":"user","content":"x"},{"role":"tool","tool_call_id":"c9","content":"r"}]`) - out, changed := cleanupOrphanToolCalls(in) - if !changed { - t.Fatal("changed=false,期望删除孤儿结果") - } - assertSummary(t, summarize(out), []string{"user(-)"}) - }) - - t.Run("完整配对零改动", func(t *testing.T) { - in := msgs(t, `[ - {"role":"assistant","content":null,"tool_calls":[{"id":"c1"},{"id":"c2"}]}, - {"role":"tool","tool_call_id":"c1","content":"r1"}, - {"role":"tool","tool_call_id":"c2","content":"r2"} - ]`) - out, changed := cleanupOrphanToolCalls(in) - if changed { - t.Error("changed=true,完整配对不应改动") - } - assertSummary(t, summarize(out), []string{"assistant(c1,c2)", "tool(c1)", "tool(c2)"}) - }) - - t.Run("无工具流量零改动", func(t *testing.T) { - if _, changed := cleanupOrphanToolCalls(msgs(t, `[{"role":"user","content":"x"}]`)); changed { - t.Error("changed=true,无工具流量不应改动") - } - }) - - t.Run("空 id 双侧不识别为工具流量", func(t *testing.T) { - // 已知边界:id 为空的配对无法按 id 判定,两侧都不计入工具流量 → 原样透传。 - // 这是刻意保留的行为(不猜哪条结果属于哪条调用),此处钉桩以免被误改。 - in := msgs(t, `[ - {"role":"assistant","content":null,"tool_calls":[{"id":""}]}, - {"role":"tool","tool_call_id":"","content":"r"} - ]`) - if _, changed := cleanupOrphanToolCalls(in); changed { - t.Error("changed=true,空 id 形态当前按原样透传处理") - } - }) -} - -// TestMergeAdjacentToolCallsEmptyArrayContent 空数组 content 也必须触发合并: -// 有客户端把"没有正文"发成 `content: []`(而不是 null),此前 emptyContent 只认 -// nil / 空串 → 背靠背的 assistant(tool_calls) 不合并 → 上游 deepseek 系判 11148。 -func TestMergeAdjacentToolCallsEmptyArrayContent(t *testing.T) { - in := msgs(t, `[ - {"role":"assistant","content":[],"tool_calls":[{"id":"c1","type":"function","function":{"name":"A","arguments":"{}"}}]}, - {"role":"assistant","content":[],"tool_calls":[{"id":"c2","type":"function","function":{"name":"B","arguments":"{}"}}]}, - {"role":"tool","tool_call_id":"c1","content":"r1"}, - {"role":"tool","tool_call_id":"c2","content":"r2"} - ]`) - out, changed := mergeAdjacentToolCalls(in) - if !changed { - t.Fatal("content:[] 的两条 assistant(tool_calls) 未合并(11148 残留形态)") - } - if len(out) != 3 { - t.Fatalf("合并后长度 = %d, want 3", len(out)) - } - tcs, _ := out[0].(map[string]any)["tool_calls"].([]any) - if len(tcs) != 2 { - t.Fatalf("首条 tool_calls = %d, want 2", len(tcs)) - } - - // 合并只以后一条(被并入方)的 content 是否为空为判据:并入不会覆盖前一条的 - // content,所以前一条是**非空数组**时同样应当合并,且内容必须原样保留。 - in2 := msgs(t, `[ - {"role":"assistant","content":[{"type":"text","text":"hi"}],"tool_calls":[{"id":"c1","type":"function","function":{"name":"A","arguments":"{}"}}]}, - {"role":"assistant","content":[],"tool_calls":[{"id":"c2","type":"function","function":{"name":"B","arguments":"{}"}}]} - ]`) - out2, changed2 := mergeAdjacentToolCalls(in2) - if !changed2 { - t.Fatal("后一条 content 为空数组时应合并") - } - first, _ := out2[0].(map[string]any) - if c, ok := first["content"].([]any); !ok || len(c) != 1 { - t.Fatalf("合并后前一条 content 丢失: %#v", first["content"]) - } - if tcs, _ := first["tool_calls"].([]any); len(tcs) != 2 { - t.Fatalf("合并后 tool_calls = %d, want 2", len(tcs)) - } -} - -// TestFoldTextIntoPrevToolCall 反向形态:前一条是带 tool_calls 但没正文的 assistant, -// 本条是纯正文 assistant(正文排在工具调用之后)——折进前一条,合成 -// assistant(正文 + tool_calls),让"工具调用紧跟自己的结果"在两种拆分顺序下都成立。 -func TestFoldTextIntoPrevToolCall(t *testing.T) { - in := msgs(t, `[ - {"role":"assistant","content":null,"tool_calls":[{"id":"c1","type":"function","function":{"name":"A","arguments":"{}"}}]}, - {"role":"assistant","content":"我来解释一下"}, - {"role":"tool","tool_call_id":"c1","content":"r1"} - ]`) - out, changed := mergeAdjacentToolCalls(in) - if !changed { - t.Fatal("正文未折进前一条工具调用") - } - if len(out) != 2 { - t.Fatalf("合并后长度 = %d, want 2", len(out)) - } - first, _ := out[0].(map[string]any) - if first["content"] != "我来解释一下" { - t.Fatalf("content = %#v, want 正文", first["content"]) - } - if tcs, _ := first["tool_calls"].([]any); len(tcs) != 1 { - t.Fatalf("tool_calls = %d, want 1", len(tcs)) - } - // 结果紧跟其后,顺序合法(上游 11148 校验的关键) - if role, _ := out[1].(map[string]any)["role"].(string); role != "tool" { - t.Fatalf("第二条应为 tool,实际 %q", role) - } - - // 反向守卫:前一条没有 tool_calls 时不得折叠(那是两条独立 assistant 轮次) - in2 := msgs(t, `[ - {"role":"assistant","content":"第一轮"}, - {"role":"assistant","content":"第二轮"} - ]`) - if _, changed2 := mergeAdjacentToolCalls(in2); changed2 { - t.Fatal("前一条无 tool_calls 时不该折叠") - } - - // 反向守卫:正文是数组(可能含多模态块)时不折叠,交给 repack 原样处理 - in3 := msgs(t, `[ - {"role":"assistant","content":[],"tool_calls":[{"id":"c1","type":"function","function":{"name":"A","arguments":"{}"}}]}, - {"role":"assistant","content":[{"type":"text","text":"hi"}]} - ]`) - if _, changed3 := mergeAdjacentToolCalls(in3); changed3 { - t.Fatal("数组正文不该被折叠(会丢结构)") - } -} +package upstream + +import ( + "encoding/json" + "reflect" + "testing" +) + +// TestCleanupOrphanToolCallsNamelessCalls 钉桩「无可用功能名的 tool_call 一律剔除」 +// (线上 11133 model_param_invalid,见 tool_pairing.go 的 keepCalls 否决条件)。 +// +// 触发链:上游流在 tool_call 的 name 分片到达前异常结束(200 空流也算)→ 聚合器/流回程 +// 落下无名条目 → 客户端写进会话历史 → 下一轮原样重发 → 带结果的脏条目命中旧的 keepCalls +// 原样出站 → 上游 400,整条会话每轮报废。 +func TestCleanupOrphanToolCallsNamelessCalls(t *testing.T) { + assistant := func(calls ...any) map[string]any { + return map[string]any{"role": "assistant", "content": "", "tool_calls": calls} + } + call := func(id, name string) map[string]any { + return map[string]any{"id": id, "type": "function", + "function": map[string]any{"name": name, "arguments": "{}"}} + } + // callNoNameKey 有 function 但无 name 键;callNoFunc 连 function 键都没有—— + // 两种形状都是本网关聚合器在 name 分片缺失时真实产出的占位条目。 + callNoNameKey := func(id string) map[string]any { + return map[string]any{"id": id, "type": "function", "function": map[string]any{}} + } + callNoFunc := func(id string) map[string]any { + return map[string]any{"id": id, "type": "function"} + } + tool := func(id, out string) map[string]any { + return map[string]any{"role": "tool", "tool_call_id": id, "content": out} + } + + cases := []struct { + name string + in []any + want []any // 期望出站 messages + change bool + }{ + { + name: "空 name + 配对结果:调用与结果成对剔除,assistant 消息保留", + in: []any{assistant(call("c1", "")), tool("c1", "ok")}, + want: []any{map[string]any{"role": "assistant", "content": ""}}, + change: true, + }, + { + name: "纯空白 name 同样判脏", + in: []any{assistant(call("c1", " ")), tool("c1", "ok")}, + want: []any{map[string]any{"role": "assistant", "content": ""}}, + change: true, + }, + { + name: "有 function 无 name 键 + 配对结果:剔除", + in: []any{assistant(callNoNameKey("c1")), tool("c1", "ok")}, + want: []any{map[string]any{"role": "assistant", "content": ""}}, + change: true, + }, + { + name: "无 function 键 + 配对结果:剔除", + in: []any{assistant(callNoFunc("c1")), tool("c1", "ok")}, + want: []any{map[string]any{"role": "assistant", "content": ""}}, + change: true, + }, + { + name: "空 name 且无结果:仍走既有孤儿路径(回归位,不得早退漏出站)", + in: []any{assistant(call("c1", ""))}, + want: []any{map[string]any{"role": "assistant", "content": ""}}, + change: true, + }, + { + name: "批内混合:只剔脏项,干净调用与其结果原样保留", + in: []any{ + assistant(call("c1", ""), call("c2", "Bash")), + tool("c1", "ok1"), tool("c2", "ok2"), + }, + want: []any{ + assistant(call("c2", "Bash")), + tool("c2", "ok2"), + }, + change: true, + }, + { + name: "健康流量(有 name + 配对):零改动", + in: []any{assistant(call("c1", "Bash")), tool("c1", "ok")}, + want: []any{assistant(call("c1", "Bash")), tool("c1", "ok")}, + change: false, + }, + } + + for _, tc := range cases { + got, changed := cleanupOrphanToolCalls(tc.in) + if changed != tc.change { + t.Errorf("%s: changed=%v, want %v", tc.name, changed, tc.change) + } + if !reflect.DeepEqual(normalize(got), normalize(tc.want)) { + gb, _ := json.Marshal(got) + wb, _ := json.Marshal(tc.want) + t.Errorf("%s:\n got %s\nwant %s", tc.name, gb, wb) + } + } +} + +// normalize 把 messages 转成 map 便于 DeepEqual(入参可能是 []map[string]any 或已改写的 +// []any,比较只关心内容)。 +func normalize(m []any) []map[string]any { + b, _ := json.Marshal(m) + var out []map[string]any + _ = json.Unmarshal(b, &out) + return out +} diff --git a/internal/upstream/tools_survive_test.go b/internal/upstream/tools_survive_test.go new file mode 100644 index 0000000000000000000000000000000000000000..1ecbd4fc217856587bdca24afc841cfb2a844c54 --- /dev/null +++ b/internal/upstream/tools_survive_test.go @@ -0,0 +1,56 @@ +package upstream + +import ( + "encoding/json" + "testing" +) + +// TestToolsSurviveForClientShapes 检查各种 tool_choice / tools 形态出站后工具还在不在。 +// +// 背景:线上 31% 的「声明了 tools」请求最后 finish_reason=stop 且零 tool_calls, +// 其中 83% 正文不足 20 token —— 用户看到的就是「模型说一句『现在我来改…』然后停了」。 +// 最可疑的网关侧成因是工具被 normalizeToolChoice 整段删掉(客户端说不了话就只能干讲)。 +func TestToolsSurviveForClientShapes(t *testing.T) { + tools := `[{"type":"function","name":"read_file","description":"读文件","parameters":{"type":"object","properties":{"path":{"type":"string"}},"required":["path"]}}, + {"type":"function","name":"run_command","description":"跑命令","parameters":{"type":"object","properties":{"command":{"type":"string"}},"required":["command"]}}]` + cases := []struct { + name string + toolChoice string // 原样塞进 body 的 tool_choice 片段;空 = 不带该字段 + wantTools bool + why string + }{ + {"无 tool_choice", "", true, "客户端没说,工具必须原样出站"}, + {"auto 字符串", `"auto"`, true, "最常见的自动选择"}, + {"required 字符串", `"required"`, true, "强制调用"}, + {"none 字符串", `"none"`, false, "客户端明确禁用工具 → 删除 tools(既有契约)"}, + {"{type:auto}", `{"type":"auto"}`, true, "对象形态的 auto"}, + {"{type:required}", `{"type":"required"}`, true, "对象形态的 required"}, + {"{type:none}", `{"type":"none"}`, false, "对象形态的 none → 删除 tools"}, + {"chat 形态指定函数", `{"type":"function","function":{"name":"read_file"}}`, true, "指定单个函数仍需工具定义"}, + {"responses 形态指定函数", `{"type":"function","name":"read_file"}`, true, "Responses API 的函数选择形态"}, + {"未知对象", `{"type":"weird"}`, true, "认不出就只删 tool_choice,工具保留"}, + } + for _, c := range cases { + body := `{"model":"cn:deepseek-v4.1-flash","stream":true,"messages":[{"role":"system","content":"s"},{"role":"user","content":"u"}],"tools":` + tools + if c.toolChoice != "" { + body += `,"tool_choice":` + c.toolChoice + } + body += `}` + out, _ := PrepareBodyOptWithEffortPolicy([]byte(body), false, nil, nil, nil, "cn", nil) + var obj map[string]any + if err := json.Unmarshal(out, &obj); err != nil { + t.Fatalf("%s: 出站 body 非法: %v", c.name, err) + } + gotTools := obj["tools"] != nil + if gotTools != c.wantTools { + t.Errorf("%s: tools 存活=%v want %v(%s)\n 出站: %s", c.name, gotTools, c.wantTools, c.why, truncateForTest(out)) + } + } +} + +func truncateForTest(b []byte) string { + if len(b) > 300 { + return string(b[:300]) + "..." + } + return string(b) +} diff --git a/internal/upstream/transport.go b/internal/upstream/transport.go index adbbc992445f077a544231a9d0b3b9a5f25cdb9d..26e2a0c58df42ef7d78cd9cff8244b0b3fa0bda2 100644 --- a/internal/upstream/transport.go +++ b/internal/upstream/transport.go @@ -1,116 +1,296 @@ -// transport.go 出站 Transport 构造的单一事实来源(连接层加固,吸收 kongjianguan -// 4 连击实测经验的前三件,见 .claude/reports/fork-scan-absorb.md T-2): -// 真正禁 h2 / TLS 握手超时 / 短 keepalive 探测,全参数集中定义可测试可调整。 -// 第四件 DisableKeepAlives 按报告 trade-off 不吸收(每请求 TLS 握手开销与连接 -// 复用意图相反),分析见 .claude/reports/transport-hardening.md。 -package upstream - -import ( - "crypto/tls" - "net" - "net/http" - "time" -) - -// 连接层参数集中定义(与 server/backoff.go 同风格:一处定义,测试可回读断言)。 -const ( - // dialTimeout TCP 连接建立上限。半死连接的第一道闸:连不上就快速失败 - // 轮转换号,不再干等系统 TCP 重传窗口(kongjianguan 实测半开 TCP 单次 - // TTFB 卡 936s——默认 Dialer 无超时上限)。 - dialTimeout = 10 * time.Second - // dialKeepAlive TCP keepalive 探测周期。默认 Dialer 2h 才发首个探测—— - // NAT 黑洞里 2h 足够连接半死且被复用。15s 周期让死连接在 15~30s 内被 - // 内核掐掉(RST/ETIMEDOUT),复用侧立即感知而非卡到重传窗口。 - dialKeepAlive = 15 * time.Second - // tlsHandshakeTimeout TLS 握手上限。现役此前完全缺失——握手挂起时无任何 - // 层兜底(ResponseHeaderTimeout 只在请求写完后才计时),只能干等到 - // HTTP.Client.Timeout(120s)。 - tlsHandshakeTimeout = 10 * time.Second - // idleConnTimeout 空闲连接池保留时长。从 90s 收到 30s:WAF 风暴后上游 - // NGI 常态性掐闲置连接,90s 池里的连接多半已死(kongjianguan 同款取值); - // 复用侧仍有 15s keepalive 兜底识别。 - idleConnTimeout = 30 * time.Second - // responseHeaderTimeout 聊天 SSE 首字节前(响应头)硬上限。从 120s 收到 - // 60s:kongjianguan 笔记实录成功请求 TTFB 曾到 16s(慢模型冷启动), - // 60s ≈ 3.75× 观测最坏健康首包,留足慢冷启动余量;同时把半死连接场景的 - // 单请求卡死从 2 分钟压到 1 分钟(MaxRotate 默认 3 次的最坏轮转从 6 分钟 - // 压到 3 分钟)。不取 kongjianguan 的 20s:其 20s 是 DisableKeepAlives+ - // timedConn 20s 写超时组合的取值,我们保留连接复用,须按自身慢冷启动 - // 观测留余量。语义核对(任务书设计纪律):ResponseHeaderTimeout 只计响应 - // 头到达前的时长,头到达后 SSE 长流不受影响(流中空闲由 IdleTimeout 监控, - // 见 idle.go),不误杀长流——transport_test.go 有显式回归。 - // - // 注意:本常量只是 newTransport 的构造默认,main.go 会按 config - // upstream.header_timeout_seconds 无条件覆盖。因此生产生效值 = config - // 解析值(未配置时 normalize 回落 timeout_seconds,默认 120),本 60s 仅作 - // 「Config 未接线/测试裸用」时的安全网——与 config.example.json 的取值 - // 对齐避免三处口径漂移(transport 60 / config 回落 120 / example 60)。 - responseHeaderTimeout = 60 * time.Second -) - -// maxIdleConns / maxIdleConnsPerHost 连接池容量(既有值,一并集中定义)。 -const ( - maxIdleConns = 100 - maxIdleConnsPerHost = 20 -) - -// newDialer 构造出站拨号器(DialContext 的 Timeout/KeepAlive 参数集中于此, -// 供测试回读断言)。 -func newDialer() *net.Dialer { - return &net.Dialer{ - Timeout: dialTimeout, - KeepAlive: dialKeepAlive, - } -} - -// newTransport 构造共享出站 Transport(HTTP 与 ChatHTTP 同一实例,连接池不重复)。 -// 分两层防半死连接: -// - TLS 层:空 TLSNextProto 真正禁 h2(kongjianguan 二次修正的实证:ForceAttemptHTTP2=false -// 只对自定义 Dial 生效,默认 TLS 经 ALPN 仍协商出 h2,半死 h2 流复用表现为 -// "http2: timeout awaiting response headers"——唯一正确写法是置空映射,让 ALPN -// 完成后无 h2 协议可用,连接退回 HTTP/1.1)。 -// - TCP 层:DialContext 10s 建连上限 + 15s keepalive 探测,半开连接在建立期 -// 和复用期都能被快速识别(见 dialTimeout/dialKeepAlive 注释)。 -func newTransport() *http.Transport { - dialer := newDialer() - return &http.Transport{ - DialContext: dialer.DialContext, - // 空 TLSNextProto(非 nil)真正禁 h2:见函数注释。必须 make 而非 nil—— - // nil 表示「让标准库注入默认 h2 映射」(kongjianguan 实测:设 - // ForceAttemptHTTP2=false 后日志仍报 h2 timeout,正是这个陷阱)。 - TLSNextProto: make(map[string]func(authority string, c *tls.Conn) http.RoundTripper), - TLSHandshakeTimeout: tlsHandshakeTimeout, - MaxIdleConns: maxIdleConns, - MaxIdleConnsPerHost: maxIdleConnsPerHost, - IdleConnTimeout: idleConnTimeout, - ResponseHeaderTimeout: responseHeaderTimeout, - } -} - -// closeIdler 实现该接口的 RoundTripper 支持清空空闲连接池(*http.Transport、 -// http2.Transport 等均满足;测试注入的自定义 RoundTripper 可选择性实现)。 -type closeIdler interface { - CloseIdleConnections() -} - -// roundTripCloseIdle 在传输层请求失败后清掉 rt 所属 Transport 的空闲连接池 -// (kongjianguan 第 4 件:失败连接可能仍留在空闲池里,等 IdleConnTimeout 才 -// 过期,下一个请求会继续捡到它)。 -// -// 挂载点(任务书「评估挂载点:错误分类处理处」的结论):错误分类(Classify) -// 只见业务信封——传输层失败根本没有 body 可分类(见 doJSON/ChatStreamContext -// 对 read body 失败的处理:不进 Classify、不罚号)。这类失败的正确处理正是 -// 连接层的池清理,故挂在与 Do 并列的传输层出口(ChatStreamContext 的 Do 错误 -// 分支),而非 applyErrorPolicy。 -// -// 关闭是 best-effort:rt 为 nil 或未实现 closeIdler(如测试注入的 rtFunc)时 -// 静默跳过。CloseIdleConnections 只关空闲连接,不影响在途请求;瞬时代价是 -// 下个请求多一次 TCP+TLS 握手,与半死连接被复用卡 60s 的风险完全不成比例。 -func roundTripCloseIdle(rt http.RoundTripper) { - if rt == nil { - return - } - if ci, ok := rt.(closeIdler); ok { - ci.CloseIdleConnections() - } -} +// transport.go 出站 Transport 构造的单一事实来源(连接层加固,吸收 kongjianguan +// 4 连击实测经验的前三件,见 .claude/reports/fork-scan-absorb.md T-2): +// 真正禁 h2 / TLS 握手超时 / 短 keepalive 探测,全参数集中定义可测试可调整。 +// 第四件 DisableKeepAlives 按报告 trade-off 不吸收(每请求 TLS 握手开销与连接 +// 复用意图相反),分析见 .claude/reports/transport-hardening.md。 +package upstream + +import ( + "context" + "crypto/tls" + "errors" + "fmt" + "net" + "net/http" + "time" + + utls "github.com/refraction-networking/utls" +) + +// 连接层参数集中定义(与 server/backoff.go 同风格:一处定义,测试可回读断言)。 +const ( + // dialTimeout TCP 连接建立上限。半死连接的第一道闸:连不上就快速失败 + // 轮转换号,不再干等系统 TCP 重传窗口(kongjianguan 实测半开 TCP 单次 + // TTFB 卡 936s——默认 Dialer 无超时上限)。 + dialTimeout = 10 * time.Second + // dialKeepAlive TCP keepalive 探测周期。默认 Dialer 2h 才发首个探测—— + // NAT 黑洞里 2h 足够连接半死且被复用。15s 周期让死连接在 15~30s 内被 + // 内核掐掉(RST/ETIMEDOUT),复用侧立即感知而非卡到重传窗口。 + dialKeepAlive = 15 * time.Second + // tlsHandshakeTimeout TLS 握手上限。现役此前完全缺失——握手挂起时无任何 + // 层兜底(ResponseHeaderTimeout 只在请求写完后才计时),只能干等到 + // HTTP.Client.Timeout(120s)。 + tlsHandshakeTimeout = 10 * time.Second + // idleConnTimeout 空闲连接池保留时长。从 90s 收到 30s:WAF 风暴后上游 + // NGI 常态性掐闲置连接,90s 池里的连接多半已死(kongjianguan 同款取值); + // 复用侧仍有 15s keepalive 兜底识别。 + idleConnTimeout = 30 * time.Second + // responseHeaderTimeout 聊天 SSE 首字节前(响应头)硬上限。从 120s 收到 + // 60s:kongjianguan 笔记实录成功请求 TTFB 曾到 16s(慢模型冷启动), + // 60s ≈ 3.75× 观测最坏健康首包,留足慢冷启动余量;同时把半死连接场景的 + // 单请求卡死从 2 分钟压到 1 分钟(MaxRotate 默认 3 次的最坏轮转从 6 分钟 + // 压到 3 分钟)。不取 kongjianguan 的 20s:其 20s 是 DisableKeepAlives+ + // timedConn 20s 写超时组合的取值,我们保留连接复用,须按自身慢冷启动 + // 观测留余量。语义核对(任务书设计纪律):ResponseHeaderTimeout 只计响应 + // 头到达前的时长,头到达后 SSE 长流不受影响(流中空闲由 IdleTimeout 监控, + // 见 idle.go),不误杀长流——transport_test.go 有显式回归。 + // + // 注意:本常量只是 newTransport 的构造默认,main.go 会按 config + // upstream.header_timeout_seconds 无条件覆盖。因此生产生效值 = config + // 解析值(未配置时 normalize 回落 timeout_seconds,默认 120),本 60s 仅作 + // 「Config 未接线/测试裸用」时的安全网——与 config.example.json 的取值 + // 对齐避免三处口径漂移(transport 60 / config 回落 120 / example 60)。 + responseHeaderTimeout = 60 * time.Second +) + +// maxIdleConns / maxIdleConnsPerHost 连接池容量(既有值,一并集中定义)。 +const ( + maxIdleConns = 100 + maxIdleConnsPerHost = 20 +) + +// newDialer 构造出站拨号器(DialContext 的 Timeout/KeepAlive 参数集中于此, +// 供测试回读断言)。 +func newDialer() *net.Dialer { + return &net.Dialer{ + Timeout: dialTimeout, + KeepAlive: dialKeepAlive, + } +} + +// dnsDialTimeout 单台 DNS 服务器的查询建连上限(多台依次尝试,任一台通即可)。 +const dnsDialTimeout = 5 * time.Second + +// NewDNSDialer 构造使用指定 DNS 服务器的出站拨号器(空列表 = 系统解析器)。 +// +// 为什么需要它:Android 没有 /etc/resolv.conf,Go 的解析器会退回 [::1]:53(或 +// 127.0.0.1:53),所有域名解析直接 connection refused;本地 DNS 被污染/劫持时同理。 +// 传真实 DNS(如 223.5.5.5 / 119.29.29.29)即绕开系统解析器本身。 +// 服务器串可带端口("1.1.1.1:5353"),不带端口按 53 补——多台依次尝试, +// 首台失败换下一台,全失败才返回最后一个错误。 +func NewDNSDialer(servers []string) *net.Dialer { + d := newDialer() + if len(servers) == 0 { + return d + } + d.Resolver = &net.Resolver{ + // PreferGo 是必须的:cgo 解析器无视 Resolver.Dial,会继续走系统配置。 + PreferGo: true, + Dial: func(ctx context.Context, network, _ string) (net.Conn, error) { + dd := net.Dialer{Timeout: dnsDialTimeout} + var lastErr error + for _, s := range servers { + addr := s + if _, _, err := net.SplitHostPort(addr); err != nil { + addr = net.JoinHostPort(s, "53") + } + c, err := dd.DialContext(ctx, network, addr) + if err == nil { + return c, nil + } + lastErr = err + } + if lastErr == nil { + lastErr = errors.New("dns: 未配置服务器") + } + return nil, lastErr + }, + } + return d +} + +// newTLSDialer 构造出站 TLS 拨号函数:TCP →(可选指纹复刻)TLS 握手 → 头序包装。 +// +// 为什么必须接管整个 TLS 拨号(而不是只包 DialContext):http.Transport 在 +// DialContext 之上自己完成 TLS 握手,写进 conn 的是**加密记录**,在那一层 +// 看不到也改不了请求头。只有 DialTLSContext 返回「已完成的 TLS conn」时, +// 上层写入的才是明文 HTTP 字节,headOrderConn 才能重排。 +// +// 同一位置也承担 ClientHello 指纹复刻:fp="node" 时用 uTLS 手搓官方 +// Node/OpenSSL 形态(见 tlsfingerprint.go),fp="go" 时走 crypto/tls 原生。 +// 两件事共用一个拨号钩子,互不干扰。 +// +// 代价:设了 DialTLSContext 之后,Transport 的 TLSHandshakeTimeout 与 +// TLSClientConfig 都不再生效,握手超时与 ServerName 由本函数自行保证。 +// +// cfg 为 nil 时用最小默认配置;测试注入 InsecureSkipVerify 用自签 httptest +// 服务器验证整条链路(生产恒 nil)。 +func newTLSDialer(d *net.Dialer, cfg *tls.Config, fp string) func(context.Context, string, string) (net.Conn, error) { + return func(ctx context.Context, network, addr string) (net.Conn, error) { + raw, err := d.DialContext(ctx, network, addr) + if err != nil { + return nil, err + } + return tlsHandshake(ctx, raw, addr, cfg, fp) + } +} + +// TLSOver 在已建好的原始连接上做与直连完全相同的 TLS 握手(同一指纹档位、同一请求头重排)。 +// 代理池用它包住经代理建立的隧道:Transport 一旦配了代理或自定义 DialContext,就不再 +// 调用直连的 DialTLSContext,经代理的流量会退回 Go 原生握手;SOCKS 时更糟,直连的 +// DialTLSContext 会绕过代理直接出网。raw 由调用方建立,握手失败时由本函数关闭。 +func (c *Client) TLSOver(ctx context.Context, raw net.Conn, addr string) (net.Conn, error) { + return tlsHandshake(ctx, raw, addr, nil, c.TLSFingerprint) +} + +// tlsHandshake 在 raw 上按指纹档位握手,返回包了请求头重排的明文连接;失败时关闭 raw。 +func tlsHandshake(ctx context.Context, raw net.Conn, addr string, cfg *tls.Config, fp string) (net.Conn, error) { + insecure := cfg != nil && cfg.InsecureSkipVerify + // cfg.ServerName 允许调用方显式指定 SNI(测试把连接指到 127.0.0.1 但仍要发 + // 真实域名的 SNI,否则 uTLS 对 IP 地址按 RFC 不发 SNI,抓到的 ClientHello + // 会少一个扩展、JA3/JA4 全跑偏)。生产 cfg 恒 nil,行为不受影响。 + host, _, splitErr := net.SplitHostPort(addr) + if splitErr != nil { + host = addr + } + if cfg != nil && cfg.ServerName != "" { + host = cfg.ServerName + } + hctx, cancel := context.WithTimeout(ctx, tlsHandshakeTimeout) + defer cancel() + + // 复刻路径:uTLS 手搓 ClientHello。ALPN 刻意留空——官方 Node 栈就是 + // 不带 ALPN,这与 Transport 禁 h2 的口径一致(见 newTransport 注释)。 + if useNodeFingerprint(fp) { + uc := utls.UClient(raw, &utls.Config{ + ServerName: host, + InsecureSkipVerify: insecure, + MinVersion: tls.VersionTLS12, + }, utls.HelloCustom) + if perr := uc.ApplyPreset(officialHelloSpec()); perr != nil { + raw.Close() + return nil, fmt.Errorf("tls fingerprint preset: %w", perr) + } + if herr := uc.HandshakeContext(hctx); herr != nil { + raw.Close() + return nil, herr + } + return newHeadOrderConn(uc), nil + } + + // 原生路径:crypto/tls。 + var tc0 *tls.Config + if cfg != nil { + tc0 = cfg.Clone() + } else { + tc0 = &tls.Config{MinVersion: tls.VersionTLS12} + } + tc0.ServerName = host + tc0.NextProtos = nil + tc := tls.Client(raw, tc0) + if herr := tc.HandshakeContext(hctx); herr != nil { + raw.Close() + return nil, herr + } + return newHeadOrderConn(tc), nil +} + +// SetDNSDialer 把拨号器挂到现役两个 http.Client 上(覆盖 DialContext 与 +// DialTLSContext 两条路;TLS 那条要重新生成闭包才能换掉底层 dialer)。 +// nil 或空列表时不动——系统解析器不变。 +func (c *Client) SetDNSDialer(d *net.Dialer) { + if d == nil || d.Resolver == nil { + return + } + c.dialer = d + c.rebuildTLSDialer() +} + +// rebuildTLSDialer 用当前的 dialer + 指纹档位重建两个 client 的拨号闭包。 +// +// SetDNSDialer 与 SetTLSFingerprint 都改同一个闭包的输入,所以统一走这里, +// 避免两处各自拼参数导致其中一项静默失效(比如换了 DNS 却把指纹改回原生)。 +func (c *Client) rebuildTLSDialer() { + d := c.dialer + if d == nil { + d = newDialer() + } + for _, cl := range []*http.Client{c.HTTP, c.ChatHTTP} { + if cl == nil { + continue + } + if t, ok := cl.Transport.(*http.Transport); ok && t.DialTLSContext != nil { + t.DialContext = d.DialContext + t.DialTLSContext = newTLSDialer(d, nil, c.TLSFingerprint) + } + } +} + +// SetTLSFingerprint 切换出站 ClientHello 指纹档位("node" 复刻官方 / "go" 原生)。 +// +// 做成运行期可切换而不是构造期固定:一旦线上出现「换了指纹反而握手失败」的 +// 情况,改一行配置就能回滚到原生形态,不必重新发版。 +func (c *Client) SetTLSFingerprint(fp string) error { + norm, err := validateTLSFingerprint(fp) + if err != nil { + return err + } + c.TLSFingerprint = norm + c.rebuildTLSDialer() + return nil +} + +// newTransport 构造共享出站 Transport(HTTP 与 ChatHTTP 同一实例,连接池不重复)。 +// 分两层防半死连接: +// - TLS 层:空 TLSNextProto 真正禁 h2(kongjianguan 二次修正的实证:ForceAttemptHTTP2=false +// 只对自定义 Dial 生效,默认 TLS 经 ALPN 仍协商出 h2,半死 h2 流复用表现为 +// "http2: timeout awaiting response headers"——唯一正确写法是置空映射,让 ALPN +// 完成后无 h2 协议可用,连接退回 HTTP/1.1)。 +// - TCP 层:DialContext 10s 建连上限 + 15s keepalive 探测,半开连接在建立期 +// 和复用期都能被快速识别(见 dialTimeout/dialKeepAlive 注释)。 +func newTransport() *http.Transport { + dialer := newDialer() + return &http.Transport{ + DialContext: dialer.DialContext, + // DialTLSContext 接管整条 TLS 拨号:返回已握手的 conn(包了 headOrderConn), + // 让上层写入的明文请求头能被重排成官方顺序。见 newTLSDialer 注释。 + DialTLSContext: newTLSDialer(dialer, nil, TLSFingerprintNode), + // 空 TLSNextProto(非 nil)真正禁 h2:见函数注释。必须 make 而非 nil—— + // nil 表示「让标准库注入默认 h2 映射」(kongjianguan 实测:设 + // ForceAttemptHTTP2=false 后日志仍报 h2 timeout,正是这个陷阱)。 + TLSNextProto: make(map[string]func(authority string, c *tls.Conn) http.RoundTripper), + TLSHandshakeTimeout: tlsHandshakeTimeout, + MaxIdleConns: maxIdleConns, + MaxIdleConnsPerHost: maxIdleConnsPerHost, + IdleConnTimeout: idleConnTimeout, + ResponseHeaderTimeout: responseHeaderTimeout, + } +} + +// closeIdler 实现该接口的 RoundTripper 支持清空空闲连接池(*http.Transport、 +// http2.Transport 等均满足;测试注入的自定义 RoundTripper 可选择性实现)。 +type closeIdler interface { + CloseIdleConnections() +} + +// roundTripCloseIdle 在传输层请求失败后清掉 rt 所属 Transport 的空闲连接池 +// (kongjianguan 第 4 件:失败连接可能仍留在空闲池里,等 IdleConnTimeout 才 +// 过期,下一个请求会继续捡到它)。 +// +// 挂载点(任务书「评估挂载点:错误分类处理处」的结论):错误分类(Classify) +// 只见业务信封——传输层失败根本没有 body 可分类(见 doJSON/ChatStreamContext +// 对 read body 失败的处理:不进 Classify、不罚号)。这类失败的正确处理正是 +// 连接层的池清理,故挂在与 Do 并列的传输层出口(ChatStreamContext 的 Do 错误 +// 分支),而非 applyErrorPolicy。 +// +// 关闭是 best-effort:rt 为 nil 或未实现 closeIdler(如测试注入的 rtFunc)时 +// 静默跳过。CloseIdleConnections 只关空闲连接,不影响在途请求;瞬时代价是 +// 下个请求多一次 TCP+TLS 握手,与半死连接被复用卡 60s 的风险完全不成比例。 +func roundTripCloseIdle(rt http.RoundTripper) { + if rt == nil { + return + } + if ci, ok := rt.(closeIdler); ok { + ci.CloseIdleConnections() + } +} diff --git a/internal/upstream/travel.go b/internal/upstream/travel.go index c862f196bc9c5d53f20dad7eb5e501549227508e..157280e4297e7cf037c36fe2bd851e1505fd6315 100644 --- a/internal/upstream/travel.go +++ b/internal/upstream/travel.go @@ -1,166 +1,243 @@ -// travel.go growth 域「猫猫旅行」接口:状态查询 / 派出 / 领奖 / 领养 / 协议。 -// 全部走 chatBase(copilot.tencent.com,不带 /v2 前缀)+ BillingHeaders,信封同 doJSON。 -package upstream - -import ( - "bytes" - "encoding/json" - "errors" - "io" - "net/http" - "strings" - - "github.com/linguo2625469/workbuddy2api-panel/internal/auth" -) - -// growth 域路径(实测)。 -const ( - travelStatusPath = "/activity/growth/buddy/travel/status" - travelDepartPath = "/activity/growth/buddy/travel/depart" - travelClaimPath = "/activity/growth/buddy/travel/claim" - buddyInfoPath = "/activity/growth/buddy/info" - buddyFirstPath = "/activity/growth/buddy/first" - buddyAgreementPath = "/activity/growth/buddy/agreement" - streakPath = "/activity/growth/streak" -) - -// buddyTaskIncompleteMarker 领养门槛未达标的业务错误关键词(HTTP 400 时出现)。 -const buddyTaskIncompleteMarker = "first_buddy task not completed yet" - -// Buddy 账号当前猫档案;nil(data.buddy 为 null)表示无猫。 -type Buddy struct { - ID int64 `json:"id"` - Name string `json:"name"` -} - -// TravelState 猫猫旅行状态。 -type TravelState struct { - State string `json:"state"` // idle / traveling / arrived - DailyLimitReached bool `json:"daily_limit_reached"` // 今日已派出过(自然日 00:00 CST 重置) - RecordID int64 `json:"record_id"` // 在途/到站记录 id,claim 必带 - RewardCredit int64 `json:"reward_credit"` // 到站可领奖励积分 -} - -// growthJSON 发 growth 域请求并解信封;body 为 nil 时不带请求体。 -// 错误语义与 doJSON 一致:HTTP 非 2xx / 业务 code != 0 → *Error。 -func (c *Client) growthJSON(a *auth.Auth, method, path string, body any) (json.RawMessage, error) { - var rdr io.Reader - if body != nil { - raw, err := json.Marshal(body) - if err != nil { - return nil, err - } - rdr = bytes.NewReader(raw) - } - req, err := http.NewRequest(method, c.chatBase(a)+path, rdr) - if err != nil { - return nil, err - } - c.BillingHeaders(req, a) - return c.doJSON(req) -} - -// TravelStatus 查询猫猫旅行状态。 -func (c *Client) TravelStatus(a *auth.Auth) (*TravelState, error) { - data, err := c.growthJSON(a, http.MethodGet, travelStatusPath, nil) - if err != nil { - return nil, err - } - var st TravelState - if err := json.Unmarshal(data, &st); err != nil { - return nil, err - } - return &st, nil -} - -// TravelDepart 派出猫旅行;locationID 实测 1~4(收益/时长区间相同)。 -func (c *Client) TravelDepart(a *auth.Auth, locationID int) error { - _, err := c.growthJSON(a, http.MethodPost, travelDepartPath, map[string]any{"location_id": locationID}) - return err -} - -// TravelClaim 领取到站奖励,返回 reward_credit。 -func (c *Client) TravelClaim(a *auth.Auth, recordID int64) (int64, error) { - data, err := c.growthJSON(a, http.MethodPost, travelClaimPath, map[string]any{"record_id": recordID}) - if err != nil { - return 0, err - } - var resp struct { - RewardCredit int64 `json:"reward_credit"` - } - if len(data) > 0 { - // 奖励字段缺失不视为失败:调用方按 0 记日志即可。 - _ = json.Unmarshal(data, &resp) - } - return resp.RewardCredit, nil -} - -// BuddyInfo 查询当前猫档案;返回 (nil, nil) 表示无猫(data.buddy 为 null)。 -func (c *Client) BuddyInfo(a *auth.Auth) (*Buddy, error) { - data, err := c.growthJSON(a, http.MethodGet, buddyInfoPath, nil) - if err != nil { - return nil, err - } - var resp struct { - Buddy json.RawMessage `json:"buddy"` - } - if err := json.Unmarshal(data, &resp); err != nil { - return nil, err - } - // null / 缺字段 / 空对象都按无猫处理。 - trimmed := strings.TrimSpace(string(resp.Buddy)) - if trimmed == "" || trimmed == "null" { - return nil, nil - } - var b Buddy - if err := json.Unmarshal(resp.Buddy, &b); err != nil { - return nil, err - } - return &b, nil -} - -// BuddyFirst 领养第一只猫。无猫且已过 conversation 门槛时送 300 分。 -// 门槛未达标返回 HTTP 400(见 IsBuddyTaskIncomplete),属预期行为,调用方静默跳过。 -func (c *Client) BuddyFirst(a *auth.Auth) error { - _, err := c.growthJSON(a, http.MethodPost, buddyFirstPath, map[string]any{}) - return err -} - -// BuddyAgreement 同意协议(幂等,重复调用无副作用)。 -func (c *Client) BuddyAgreement(a *auth.Auth) error { - _, err := c.growthJSON(a, http.MethodPost, buddyAgreementPath, map[string]any{"agree": true}) - return err -} - -// GrowthStreak 查询连登天数(只读 oracle)。响应 `data.streak.days`(probe_active.py -// 实测口径:`(s.get("data", {}).get("streak", {}) or {}).get("days")`)。 -// GET 失败(HTTP 非 2xx / 业务 code != 0)返回 *Error;缺 streak/days 字段返回 0 -// (days==0 即活跃自检的「上报 200 但静默丢弃」告警信号)。 -func (c *Client) GrowthStreak(a *auth.Auth) (int, error) { - data, err := c.growthJSON(a, http.MethodGet, streakPath, nil) - if err != nil { - return 0, err - } - var resp struct { - Streak struct { - Days int `json:"days"` - } `json:"streak"` - } - if err := json.Unmarshal(data, &resp); err != nil { - return 0, err - } - return resp.Streak.Days, nil -} - -// IsBuddyTaskIncomplete 判定「领养门槛未达标」:HTTP 400 + first_buddy 关键词。 -// 该错误当日不应重试(避免对上游重试轰炸)。 -func IsBuddyTaskIncomplete(err error) bool { - if err == nil { - return false - } - var ue *Error - if !errors.As(err, &ue) || ue.Status != http.StatusBadRequest { - return false - } - return strings.Contains(strings.ToLower(ue.Msg), buddyTaskIncompleteMarker) -} +// travel.go growth 域「猫猫旅行」与「盲盒」接口:状态查询 / 派出 / 领奖 / 领养 / 协议 / 能量。 +// 全部走 chatBase(缺省 www.workbuddy.cn,不带 /v2 前缀)+ BillingHeaders,信封同 doJSON。 +package upstream + +import ( + "bytes" + "encoding/json" + "errors" + "fmt" + "io" + "net/http" + "strings" + + "github.com/misakano7545/workbuddy2api-panel/internal/auth" +) + +// growth 域路径(实测)。 +const ( + travelStatusPath = "/activity/growth/buddy/travel/status" + travelDepartPath = "/activity/growth/buddy/travel/depart" + travelClaimPath = "/activity/growth/buddy/travel/claim" + buddyInfoPath = "/activity/growth/buddy/info" + buddyFirstPath = "/activity/growth/buddy/first" + buddyAgreementPath = "/activity/growth/buddy/agreement" + buddyQuotaPath = "/activity/growth/buddy/quota" + buddyOpenPath = "/activity/growth/buddy/open" + streakPath = "/activity/growth/streak" +) + +// buddyTaskIncompleteMarker 领养门槛未达标的业务错误关键词(HTTP 400 时出现)。 +const buddyTaskIncompleteMarker = "first_buddy task not completed yet" + +// Buddy 账号当前猫档案;nil(data.buddy 为 null)表示无猫。 +type Buddy struct { + ID int64 `json:"id"` + Name string `json:"name"` +} + +// TravelState 猫猫旅行状态。 +type TravelState struct { + State string `json:"state"` // idle / traveling / arrived + DailyLimitReached bool `json:"daily_limit_reached"` // 今日已派出过(自然日 00:00 CST 重置) + RecordID int64 `json:"record_id"` // 在途/到站记录 id,claim 必带 + RewardCredit int64 `json:"reward_credit"` // 到站可领奖励积分 +} + +// growthJSON 发 growth 域请求并解信封;body 为 nil 时不带请求体。 +// 错误语义与 doJSON 一致:HTTP 非 2xx / 业务 code != 0 → *Error。 +func (c *Client) growthJSON(a *auth.Auth, method, path string, body any) (json.RawMessage, error) { + var rdr io.Reader + if body != nil { + raw, err := json.Marshal(body) + if err != nil { + return nil, err + } + rdr = bytes.NewReader(raw) + } + req, err := http.NewRequest(method, c.chatBase(a)+path, rdr) + if err != nil { + return nil, err + } + c.BillingHeaders(req, a) + return c.doJSON(req, a) +} + +// TravelStatus 查询猫猫旅行状态。 +func (c *Client) TravelStatus(a *auth.Auth) (*TravelState, error) { + data, err := c.growthJSON(a, http.MethodGet, travelStatusPath, nil) + if err != nil { + return nil, err + } + var st TravelState + if err := json.Unmarshal(data, &st); err != nil { + return nil, err + } + return &st, nil +} + +// TravelDepart 派出猫旅行;locationID 实测 1~4(收益/时长区间相同)。 +func (c *Client) TravelDepart(a *auth.Auth, locationID int) error { + _, err := c.growthJSON(a, http.MethodPost, travelDepartPath, map[string]any{"location_id": locationID}) + return err +} + +// TravelClaim 领取到站奖励,返回 reward_credit。 +func (c *Client) TravelClaim(a *auth.Auth, recordID int64) (int64, error) { + data, err := c.growthJSON(a, http.MethodPost, travelClaimPath, map[string]any{"record_id": recordID}) + if err != nil { + return 0, err + } + var resp struct { + RewardCredit int64 `json:"reward_credit"` + } + if len(data) > 0 { + // 奖励字段缺失不视为失败:调用方按 0 记日志即可。 + _ = json.Unmarshal(data, &resp) + } + return resp.RewardCredit, nil +} + +// BuddyInfo 查询当前猫档案;返回 (nil, nil) 表示无猫(data.buddy 为 null)。 +func (c *Client) BuddyInfo(a *auth.Auth) (*Buddy, error) { + data, err := c.growthJSON(a, http.MethodGet, buddyInfoPath, nil) + if err != nil { + return nil, err + } + var resp struct { + Buddy json.RawMessage `json:"buddy"` + } + if err := json.Unmarshal(data, &resp); err != nil { + return nil, err + } + // null / 缺字段 / 空对象都按无猫处理。 + trimmed := strings.TrimSpace(string(resp.Buddy)) + if trimmed == "" || trimmed == "null" { + return nil, nil + } + var b Buddy + if err := json.Unmarshal(resp.Buddy, &b); err != nil { + return nil, err + } + return &b, nil +} + +// BuddyFirst 领养第一只猫。无猫且已过 conversation 门槛时送 300 分。 +// 门槛未达标返回 HTTP 400(见 IsBuddyTaskIncomplete),属预期行为,调用方静默跳过。 +func (c *Client) BuddyFirst(a *auth.Auth) error { + _, err := c.growthJSON(a, http.MethodPost, buddyFirstPath, map[string]any{}) + return err +} + +// BuddyAgreement 同意协议(幂等,重复调用无副作用)。 +func (c *Client) BuddyAgreement(a *auth.Auth) error { + _, err := c.growthJSON(a, http.MethodPost, buddyAgreementPath, map[string]any{"agree": true}) + return err +} + +// GrowthStreak 查询连登天数(只读 oracle)。响应 `data.streak.days`(probe_active.py +// 实测口径:`(s.get("data", {}).get("streak", {}) or {}).get("days")`)。 +// GET 失败(HTTP 非 2xx / 业务 code != 0)返回 *Error;缺 streak/days 字段返回 0 +// (days==0 即活跃自检的「上报 200 但静默丢弃」告警信号)。 +func (c *Client) GrowthStreak(a *auth.Auth) (int, error) { + data, err := c.growthJSON(a, http.MethodGet, streakPath, nil) + if err != nil { + return 0, err + } + var resp struct { + Streak struct { + Days int `json:"days"` + } `json:"streak"` + } + if err := json.Unmarshal(data, &resp); err != nil { + return 0, err + } + return resp.Streak.Days, nil +} + +// IsBuddyTaskIncomplete 判定「领养门槛未达标」:HTTP 400 + first_buddy 关键词。 +// 该错误当日不应重试(避免对上游重试轰炸)。 +func IsBuddyTaskIncomplete(err error) bool { + if err == nil { + return false + } + var ue *Error + if !errors.As(err, &ue) || ue.Status != http.StatusBadRequest { + return false + } + return strings.Contains(strings.ToLower(ue.Msg), buddyTaskIncompleteMarker) +} + +// BuddyQuota 盲盒能量额度:Balance 剩余能量,Affordable 现在还能开几次。 +// 上游每开一次扣 10 能量,Affordable 即 balance/10 的口径值,直接用它比自己算稳 +// (阈值若变不必跟着改)。 +type BuddyQuota struct { + Balance int `json:"balance"` + Affordable int `json:"affordable"` +} + +// BlindBoxItem 一次开出的道具(名字 + 稀有度)。BuddyOpen 拿不到明细时返回 nil。 +type BlindBoxItem struct { + Name string + Rarity string +} + +func (b *BlindBoxItem) String() string { + if b == nil { + return "?" + } + if b.Rarity == "" { + return b.Name + } + return fmt.Sprintf("%s(%s)", b.Name, b.Rarity) +} + +// BuddyQuota 查询盲盒可用次数。 +func (c *Client) BuddyQuota(a *auth.Auth) (*BuddyQuota, error) { + data, err := c.growthJSON(a, http.MethodGet, buddyQuotaPath, nil) + if err != nil { + return nil, err + } + var q BuddyQuota + if err := json.Unmarshal(data, &q); err != nil { + return nil, err + } + return &q, nil +} + +// BuddyOpen 开一个盲盒(count 恒 1:一次 10 能量,多开由调用方循环控制节奏)。 +// 明细缺失不视为失败——道具已经开出来了,只有请求本身失败才算。 +func (c *Client) BuddyOpen(a *auth.Auth) (*BlindBoxItem, error) { + data, err := c.growthJSON(a, http.MethodPost, buddyOpenPath, map[string]any{"count": 1}) + if err != nil { + return nil, err + } + var resp struct { + Results []struct { + Instance struct { + Name string `json:"name"` + Rarity string `json:"rarity"` + } `json:"instance"` + Template struct { + Name string `json:"name"` + Rarity string `json:"rarity"` + } `json:"template"` + } `json:"results"` + } + if len(data) == 0 { + return nil, nil + } + if err := json.Unmarshal(data, &resp); err != nil || len(resp.Results) == 0 { + return nil, nil + } + it := resp.Results[0] + // instance 是开出的实例,template 是它的模板:实例缺字段时用模板补。 + name, rarity := it.Instance.Name, it.Instance.Rarity + if name == "" { + name = it.Template.Name + } + if rarity == "" { + rarity = it.Template.Rarity + } + return &BlindBoxItem{Name: name, Rarity: rarity}, nil +} diff --git a/internal/upstream/travel_test.go b/internal/upstream/travel_test.go index b2c5e3f7e1e83c65029414dd679f2879c1e1e061..e78f12edfaafc983dfe143b1919eed26346f000c 100644 --- a/internal/upstream/travel_test.go +++ b/internal/upstream/travel_test.go @@ -1,227 +1,227 @@ -package upstream - -import ( - "bytes" - "encoding/json" - "errors" - "io" - "net/http" - "testing" - - "github.com/linguo2625469/workbuddy2api-panel/internal/auth" -) - -// travelPath 断言请求打到 growth 域的正确路径(BASE 走 chatBase,无 /v2 前缀)。 -func travelPath(r *http.Request, want string) error { - if r.URL.Path != want { - return errors.New("wrong path: " + r.URL.Path) - } - if r.Header.Get("Authorization") != "Bearer at" { - return errors.New("missing Authorization") - } - if r.Header.Get("X-User-Id") != "u1" { - return errors.New("missing X-User-Id") - } - return nil -} - -func TestTravelStatusParsesFields(t *testing.T) { - c := testClient(func(r *http.Request) (*http.Response, error) { - if r.Method != http.MethodGet { - return nil, errors.New("want GET") - } - if err := travelPath(r, "/activity/growth/buddy/travel/status"); err != nil { - return nil, err - } - return jsonResp(200, `{"code":0,"msg":"ok","data":{"state":"arrived","daily_limit_reached":true,"record_id":42,"reward_credit":7}}`), nil - }) - st, err := c.TravelStatus(&auth.Auth{AccessToken: "at", UID: "u1"}) - if err != nil { - t.Fatalf("travel status: %v", err) - } - if st.State != "arrived" || !st.DailyLimitReached || st.RecordID != 42 || st.RewardCredit != 7 { - t.Errorf("state=%+v", st) - } -} - -// TestTravelStatusBusinessError 上游 400 且 body 仍是 {code,msg,data} 信封时, -// 应被 doJSON 归一为 *Error(带 HTTP 状态码),而不是解析失败。 -func TestTravelStatusBusinessError(t *testing.T) { - c := testClient(func(r *http.Request) (*http.Response, error) { - return jsonResp(400, `{"code":400,"msg":"no active buddy","data":null}`), nil - }) - _, err := c.TravelStatus(&auth.Auth{AccessToken: "at", UID: "u1"}) - var ue *Error - if !errors.As(err, &ue) { - t.Fatalf("want *Error, got %T %v", err, err) - } - if ue.Status != 400 || ue.Kind != ErrClient { - t.Errorf("status=%d kind=%v", ue.Status, ue.Kind) - } -} - -func TestTravelDepartSendsLocationID(t *testing.T) { - var got []byte - c := testClient(func(r *http.Request) (*http.Response, error) { - if r.Method != http.MethodPost { - return nil, errors.New("want POST") - } - if err := travelPath(r, "/activity/growth/buddy/travel/depart"); err != nil { - return nil, err - } - got, _ = io.ReadAll(r.Body) - return jsonResp(200, `{"code":0,"msg":"ok","data":{}}`), nil - }) - if err := c.TravelDepart(&auth.Auth{AccessToken: "at", UID: "u1"}, 4); err != nil { - t.Fatalf("depart: %v", err) - } - var body map[string]any - if err := json.Unmarshal(got, &body); err != nil { - t.Fatalf("depart body: %v (%s)", err, got) - } - if n, _ := body["location_id"].(float64); int(n) != 4 { - t.Errorf("location_id=%v want 4 (body=%s)", body["location_id"], got) - } -} - -func TestTravelClaimReturnsReward(t *testing.T) { - var got []byte - c := testClient(func(r *http.Request) (*http.Response, error) { - if r.Method != http.MethodPost { - return nil, errors.New("want POST") - } - if err := travelPath(r, "/activity/growth/buddy/travel/claim"); err != nil { - return nil, err - } - got, _ = io.ReadAll(r.Body) - return jsonResp(200, `{"code":0,"msg":"ok","data":{"reward_credit":9}}`), nil - }) - reward, err := c.TravelClaim(&auth.Auth{AccessToken: "at", UID: "u1"}, 42) - if err != nil { - t.Fatalf("claim: %v", err) - } - if reward != 9 { - t.Errorf("reward=%d want 9", reward) - } - if !bytes.Contains(got, []byte(`"record_id":42`)) { - t.Errorf("claim body missing record_id: %s", got) - } -} - -// TestBuddyInfoNullMeansNoBuddy data.buddy 为 null → 返回 nil 表示无猫。 -func TestBuddyInfoNullMeansNoBuddy(t *testing.T) { - c := testClient(func(r *http.Request) (*http.Response, error) { - if r.Method != http.MethodGet { - return nil, errors.New("want GET") - } - if err := travelPath(r, "/activity/growth/buddy/info"); err != nil { - return nil, err - } - return jsonResp(200, `{"code":0,"msg":"ok","data":{"buddy":null}}`), nil - }) - b, err := c.BuddyInfo(&auth.Auth{AccessToken: "at", UID: "u1"}) - if err != nil { - t.Fatalf("buddy info: %v", err) - } - if b != nil { - t.Errorf("buddy=%+v want nil (无猫)", b) - } -} - -func TestBuddyInfoPresent(t *testing.T) { - c := testClient(func(r *http.Request) (*http.Response, error) { - return jsonResp(200, `{"code":0,"data":{"buddy":{"id":7,"name":"档案喵 R"}}}`), nil - }) - b, err := c.BuddyInfo(&auth.Auth{AccessToken: "at", UID: "u1"}) - if err != nil || b == nil { - t.Fatalf("buddy=%+v err=%v", b, err) - } - if b.Name != "档案喵 R" || b.ID != 7 { - t.Errorf("buddy=%+v", b) - } -} - -func TestBuddyAgreementIdempotent(t *testing.T) { - var got []byte - c := testClient(func(r *http.Request) (*http.Response, error) { - if r.Method != http.MethodPost { - return nil, errors.New("want POST") - } - if err := travelPath(r, "/activity/growth/buddy/agreement"); err != nil { - return nil, err - } - got, _ = io.ReadAll(r.Body) - return jsonResp(200, `{"code":0,"msg":"ok","data":{"agreed":true}}`), nil - }) - if err := c.BuddyAgreement(&auth.Auth{AccessToken: "at", UID: "u1"}); err != nil { - t.Fatalf("agreement: %v", err) - } - if !bytes.Contains(got, []byte(`"agree":true`)) { - t.Errorf("agreement body=%s", got) - } -} - -func TestBuddyFirstPath(t *testing.T) { - var got []byte - c := testClient(func(r *http.Request) (*http.Response, error) { - if r.Method != http.MethodPost { - return nil, errors.New("want POST") - } - if err := travelPath(r, "/activity/growth/buddy/first"); err != nil { - return nil, err - } - got, _ = io.ReadAll(r.Body) - return jsonResp(200, `{"code":0,"msg":"ok","data":{"buddy":{"id":1}}}`), nil - }) - if err := c.BuddyFirst(&auth.Auth{AccessToken: "at", UID: "u1"}); err != nil { - t.Fatalf("first: %v", err) - } - if string(bytes.TrimSpace(got)) != "{}" { - t.Errorf("first body=%q want {}", got) - } -} - -// TestIsBuddyTaskIncomplete conversation 门槛未达标:HTTP 400 + first_buddy 关键词。 -func TestIsBuddyTaskIncomplete(t *testing.T) { - c := testClient(func(r *http.Request) (*http.Response, error) { - return jsonResp(400, `{"code":400,"msg":"first_buddy task not completed yet"}`), nil - }) - err := c.BuddyFirst(&auth.Auth{AccessToken: "at", UID: "u1"}) - if err == nil { - t.Fatal("want error") - } - if !IsBuddyTaskIncomplete(err) { - t.Errorf("err=%v should be classified as 门槛未达标", err) - } -} - -func TestIsBuddyTaskIncompleteNegative(t *testing.T) { - cases := []struct { - name string - err error - want bool - }{ - {"nil", nil, false}, - {"普通错误", errors.New("boom"), false}, - {"400 其他业务错误", &Error{Kind: ErrClient, Status: 400, Msg: "no active buddy"}, false}, - {"500 含关键词也不认", &Error{Kind: ErrServer, Status: 500, Msg: "first_buddy task not completed yet"}, false}, - {"401 会话失效", &Error{Kind: ErrSessionDead, Status: 401, Msg: "Offline user session not found"}, false}, - } - for _, c := range cases { - if got := IsBuddyTaskIncomplete(c.err); got != c.want { - t.Errorf("%s: got %v want %v", c.name, got, c.want) - } - } -} - -// TestTravel401ClassifiedSessionDead 401 交由调用方跳过本轮(巡检不强刷 token)。 -func TestTravel401ClassifiedSessionDead(t *testing.T) { - c := testClient(func(r *http.Request) (*http.Response, error) { - return jsonResp(401, `{"code":12153,"msg":"Offline user session not found"}`), nil - }) - _, err := c.TravelStatus(&auth.Auth{AccessToken: "at", UID: "u1"}) - var ue *Error - if !errors.As(err, &ue) || ue.Kind != ErrSessionDead { - t.Fatalf("err=%v want ErrSessionDead", err) - } -} +package upstream + +import ( + "bytes" + "encoding/json" + "errors" + "io" + "net/http" + "testing" + + "github.com/misakano7545/workbuddy2api-panel/internal/auth" +) + +// travelPath 断言请求打到 growth 域的正确路径(BASE 走 chatBase,无 /v2 前缀)。 +func travelPath(r *http.Request, want string) error { + if r.URL.Path != want { + return errors.New("wrong path: " + r.URL.Path) + } + if r.Header.Get("Authorization") != "Bearer at" { + return errors.New("missing Authorization") + } + if r.Header.Get("X-User-Id") != "u1" { + return errors.New("missing X-User-Id") + } + return nil +} + +func TestTravelStatusParsesFields(t *testing.T) { + c := testClient(func(r *http.Request) (*http.Response, error) { + if r.Method != http.MethodGet { + return nil, errors.New("want GET") + } + if err := travelPath(r, "/activity/growth/buddy/travel/status"); err != nil { + return nil, err + } + return jsonResp(200, `{"code":0,"msg":"ok","data":{"state":"arrived","daily_limit_reached":true,"record_id":42,"reward_credit":7}}`), nil + }) + st, err := c.TravelStatus(&auth.Auth{AccessToken: "at", UID: "u1"}) + if err != nil { + t.Fatalf("travel status: %v", err) + } + if st.State != "arrived" || !st.DailyLimitReached || st.RecordID != 42 || st.RewardCredit != 7 { + t.Errorf("state=%+v", st) + } +} + +// TestTravelStatusBusinessError 上游 400 且 body 仍是 {code,msg,data} 信封时, +// 应被 doJSON 归一为 *Error(带 HTTP 状态码),而不是解析失败。 +func TestTravelStatusBusinessError(t *testing.T) { + c := testClient(func(r *http.Request) (*http.Response, error) { + return jsonResp(400, `{"code":400,"msg":"no active buddy","data":null}`), nil + }) + _, err := c.TravelStatus(&auth.Auth{AccessToken: "at", UID: "u1"}) + var ue *Error + if !errors.As(err, &ue) { + t.Fatalf("want *Error, got %T %v", err, err) + } + if ue.Status != 400 || ue.Kind != ErrClient { + t.Errorf("status=%d kind=%v", ue.Status, ue.Kind) + } +} + +func TestTravelDepartSendsLocationID(t *testing.T) { + var got []byte + c := testClient(func(r *http.Request) (*http.Response, error) { + if r.Method != http.MethodPost { + return nil, errors.New("want POST") + } + if err := travelPath(r, "/activity/growth/buddy/travel/depart"); err != nil { + return nil, err + } + got, _ = io.ReadAll(r.Body) + return jsonResp(200, `{"code":0,"msg":"ok","data":{}}`), nil + }) + if err := c.TravelDepart(&auth.Auth{AccessToken: "at", UID: "u1"}, 4); err != nil { + t.Fatalf("depart: %v", err) + } + var body map[string]any + if err := json.Unmarshal(got, &body); err != nil { + t.Fatalf("depart body: %v (%s)", err, got) + } + if n, _ := body["location_id"].(float64); int(n) != 4 { + t.Errorf("location_id=%v want 4 (body=%s)", body["location_id"], got) + } +} + +func TestTravelClaimReturnsReward(t *testing.T) { + var got []byte + c := testClient(func(r *http.Request) (*http.Response, error) { + if r.Method != http.MethodPost { + return nil, errors.New("want POST") + } + if err := travelPath(r, "/activity/growth/buddy/travel/claim"); err != nil { + return nil, err + } + got, _ = io.ReadAll(r.Body) + return jsonResp(200, `{"code":0,"msg":"ok","data":{"reward_credit":9}}`), nil + }) + reward, err := c.TravelClaim(&auth.Auth{AccessToken: "at", UID: "u1"}, 42) + if err != nil { + t.Fatalf("claim: %v", err) + } + if reward != 9 { + t.Errorf("reward=%d want 9", reward) + } + if !bytes.Contains(got, []byte(`"record_id":42`)) { + t.Errorf("claim body missing record_id: %s", got) + } +} + +// TestBuddyInfoNullMeansNoBuddy data.buddy 为 null → 返回 nil 表示无猫。 +func TestBuddyInfoNullMeansNoBuddy(t *testing.T) { + c := testClient(func(r *http.Request) (*http.Response, error) { + if r.Method != http.MethodGet { + return nil, errors.New("want GET") + } + if err := travelPath(r, "/activity/growth/buddy/info"); err != nil { + return nil, err + } + return jsonResp(200, `{"code":0,"msg":"ok","data":{"buddy":null}}`), nil + }) + b, err := c.BuddyInfo(&auth.Auth{AccessToken: "at", UID: "u1"}) + if err != nil { + t.Fatalf("buddy info: %v", err) + } + if b != nil { + t.Errorf("buddy=%+v want nil (无猫)", b) + } +} + +func TestBuddyInfoPresent(t *testing.T) { + c := testClient(func(r *http.Request) (*http.Response, error) { + return jsonResp(200, `{"code":0,"data":{"buddy":{"id":7,"name":"档案喵 R"}}}`), nil + }) + b, err := c.BuddyInfo(&auth.Auth{AccessToken: "at", UID: "u1"}) + if err != nil || b == nil { + t.Fatalf("buddy=%+v err=%v", b, err) + } + if b.Name != "档案喵 R" || b.ID != 7 { + t.Errorf("buddy=%+v", b) + } +} + +func TestBuddyAgreementIdempotent(t *testing.T) { + var got []byte + c := testClient(func(r *http.Request) (*http.Response, error) { + if r.Method != http.MethodPost { + return nil, errors.New("want POST") + } + if err := travelPath(r, "/activity/growth/buddy/agreement"); err != nil { + return nil, err + } + got, _ = io.ReadAll(r.Body) + return jsonResp(200, `{"code":0,"msg":"ok","data":{"agreed":true}}`), nil + }) + if err := c.BuddyAgreement(&auth.Auth{AccessToken: "at", UID: "u1"}); err != nil { + t.Fatalf("agreement: %v", err) + } + if !bytes.Contains(got, []byte(`"agree":true`)) { + t.Errorf("agreement body=%s", got) + } +} + +func TestBuddyFirstPath(t *testing.T) { + var got []byte + c := testClient(func(r *http.Request) (*http.Response, error) { + if r.Method != http.MethodPost { + return nil, errors.New("want POST") + } + if err := travelPath(r, "/activity/growth/buddy/first"); err != nil { + return nil, err + } + got, _ = io.ReadAll(r.Body) + return jsonResp(200, `{"code":0,"msg":"ok","data":{"buddy":{"id":1}}}`), nil + }) + if err := c.BuddyFirst(&auth.Auth{AccessToken: "at", UID: "u1"}); err != nil { + t.Fatalf("first: %v", err) + } + if string(bytes.TrimSpace(got)) != "{}" { + t.Errorf("first body=%q want {}", got) + } +} + +// TestIsBuddyTaskIncomplete conversation 门槛未达标:HTTP 400 + first_buddy 关键词。 +func TestIsBuddyTaskIncomplete(t *testing.T) { + c := testClient(func(r *http.Request) (*http.Response, error) { + return jsonResp(400, `{"code":400,"msg":"first_buddy task not completed yet"}`), nil + }) + err := c.BuddyFirst(&auth.Auth{AccessToken: "at", UID: "u1"}) + if err == nil { + t.Fatal("want error") + } + if !IsBuddyTaskIncomplete(err) { + t.Errorf("err=%v should be classified as 门槛未达标", err) + } +} + +func TestIsBuddyTaskIncompleteNegative(t *testing.T) { + cases := []struct { + name string + err error + want bool + }{ + {"nil", nil, false}, + {"普通错误", errors.New("boom"), false}, + {"400 其他业务错误", &Error{Kind: ErrClient, Status: 400, Msg: "no active buddy"}, false}, + {"500 含关键词也不认", &Error{Kind: ErrServer, Status: 500, Msg: "first_buddy task not completed yet"}, false}, + {"401 会话失效", &Error{Kind: ErrSessionDead, Status: 401, Msg: "Offline user session not found"}, false}, + } + for _, c := range cases { + if got := IsBuddyTaskIncomplete(c.err); got != c.want { + t.Errorf("%s: got %v want %v", c.name, got, c.want) + } + } +} + +// TestTravel401ClassifiedSessionDead 401 交由调用方跳过本轮(巡检不强刷 token)。 +func TestTravel401ClassifiedSessionDead(t *testing.T) { + c := testClient(func(r *http.Request) (*http.Response, error) { + return jsonResp(401, `{"code":12153,"msg":"Offline user session not found"}`), nil + }) + _, err := c.TravelStatus(&auth.Auth{AccessToken: "at", UID: "u1"}) + var ue *Error + if !errors.As(err, &ue) || ue.Kind != ErrSessionDead { + t.Fatalf("err=%v want ErrSessionDead", err) + } +} diff --git a/internal/upstream/trial.go b/internal/upstream/trial.go index 3c760ac954d71ff4cc82bb7338cba08d99a0e005..8317f014a4895f94eec59fe2ec659b82c42d3f02 100644 --- a/internal/upstream/trial.go +++ b/internal/upstream/trial.go @@ -1,49 +1,49 @@ -// trial.go global 专属「一次性 trial 加油包」领取:POST {billingBase}/billing/ide/trial。 -// 仅 global 账号适用(CN 无此端点);幂等码 14051 = 已领过(视为正常,非错误)。 -// 这是 global 唯一天然的积分增益动作(无签到/任务中心,见 PLAN D4)。 -package upstream - -import ( - "errors" - "fmt" - "net/http" - "strings" - - "github.com/linguo2625469/workbuddy2api-panel/internal/auth" -) - -// trialPath global trial 加油包端点(Maquer/workbuddy-checkin 实测)。 -const trialPath = "/billing/ide/trial" - -// trialAlreadyMarkers 幂等码 14051「已领取过」的两种指纹: -// - "code=14051":doJSON 对 HTTP 200 + 业务 code 非 0 时拼出的 Msg 格式; -// - `"code":14051`:HTTP ≥400 时 doJSON 把原始 JSON body 直接塞进 Msg。 -var trialAlreadyMarkers = []string{"code=14051", `"code":14051`} - -// ClaimTrial 领取一次性 trial 加油包。仅 global 账号可调(CN 无此端点): -// 非 global → 直接报错(工具层还会再拦一道,这里是客户端侧防线)。 -// 返回 claimed:true=成功新领;false=已领过(幂等,不算失败)。 -func (c *Client) ClaimTrial(a *auth.Auth) (claimed bool, err error) { - if a == nil || a.Realm() != "global" { - return false, fmt.Errorf("claim trial: only global accounts") - } - _, err = c.billingJSON(a, http.MethodPost, trialPath, nil) - if err != nil { - var ue *Error - if errors.As(err, &ue) && trialAlreadyErr(ue.Msg) { - return false, nil // 已领过:幂等成功,非错误 - } - return false, err - } - return true, nil -} - -// trialAlreadyErr 判定错误 Msg 是否携带幂等码 14051(已领取过)。 -func trialAlreadyErr(msg string) bool { - for _, m := range trialAlreadyMarkers { - if strings.Contains(msg, m) { - return true - } - } - return false -} +// trial.go global 专属「一次性 trial 加油包」领取:POST {billingBase}/billing/ide/trial。 +// 仅 global 账号适用(CN 无此端点);幂等码 14051 = 已领过(视为正常,非错误)。 +// 这是 global 唯一天然的积分增益动作(无签到/任务中心,见 PLAN D4)。 +package upstream + +import ( + "errors" + "fmt" + "net/http" + "strings" + + "github.com/misakano7545/workbuddy2api-panel/internal/auth" +) + +// trialPath global trial 加油包端点(Maquer/workbuddy-checkin 实测)。 +const trialPath = "/billing/ide/trial" + +// trialAlreadyMarkers 幂等码 14051「已领取过」的两种指纹: +// - "code=14051":doJSON 对 HTTP 200 + 业务 code 非 0 时拼出的 Msg 格式; +// - `"code":14051`:HTTP ≥400 时 doJSON 把原始 JSON body 直接塞进 Msg。 +var trialAlreadyMarkers = []string{"code=14051", `"code":14051`} + +// ClaimTrial 领取一次性 trial 加油包。仅 global 账号可调(CN 无此端点): +// 非 global → 直接报错(工具层还会再拦一道,这里是客户端侧防线)。 +// 返回 claimed:true=成功新领;false=已领过(幂等,不算失败)。 +func (c *Client) ClaimTrial(a *auth.Auth) (claimed bool, err error) { + if a == nil || a.Realm() != "global" { + return false, fmt.Errorf("claim trial: only global accounts") + } + _, err = c.billingJSON(a, http.MethodPost, trialPath, nil) + if err != nil { + var ue *Error + if errors.As(err, &ue) && trialAlreadyErr(ue.Msg) { + return false, nil // 已领过:幂等成功,非错误 + } + return false, err + } + return true, nil +} + +// trialAlreadyErr 判定错误 Msg 是否携带幂等码 14051(已领取过)。 +func trialAlreadyErr(msg string) bool { + for _, m := range trialAlreadyMarkers { + if strings.Contains(msg, m) { + return true + } + } + return false +} diff --git a/internal/upstream/trim_history_test.go b/internal/upstream/trim_history_test.go new file mode 100644 index 0000000000000000000000000000000000000000..f0186ac57b684468508ea45784b25cfbec633841 --- /dev/null +++ b/internal/upstream/trim_history_test.go @@ -0,0 +1,134 @@ +package upstream + +import ( + "encoding/json" + "strings" + "testing" +) + +// TestTrimHistoryKeepsLastRounds 一轮 = 一条 user 消息及其后的 assistant/tool 回复; +// 更早的整轮丢掉,system 全留(issue #99)。 +func TestTrimHistoryKeepsLastRounds(t *testing.T) { + body := map[string]any{ + "messages": []any{ + msg("system", "你是助手"), + msg("user", "第一轮"), + msg("assistant", "回一"), + msg("user", "第二轮"), + msg("assistant", "回二"), + msg("user", "第三轮"), + }, + } + trimHistory(body, 2) + roles := rolesOf(body) + want := "system,user,assistant,user" + if roles != want { + t.Fatalf("保留最近 2 轮应为 %s,实际 %s", want, roles) + } + // 首条保留的必须是第二轮的用户消息,不能是残留的旧 assistant。 + if m := firstContent(body); m != "第二轮" { + t.Fatalf("保留段应从「第二轮」开始,实际 %q", m) + } +} + +// TestTrimHistoryKeepsSystemBeforeCut cut 之前出现的 system 必须提上来保留: +// 客户端把 system 插在中间时,裁掉它就是裁掉协议。 +func TestTrimHistoryKeepsSystemBeforeCut(t *testing.T) { + body := map[string]any{ + "messages": []any{ + msg("system", "旧人格"), + msg("user", "第一轮"), + msg("system", "补充约束"), + msg("assistant", "回一"), + msg("user", "第二轮"), + }, + } + trimHistory(body, 1) + if roles := rolesOf(body); roles != "system,system,user" { + t.Fatalf("system 必须全留,实际 %s", roles) + } +} + +// TestTrimHistoryNoOp 关闭(<=0)与「轮数不足」都必须原样不动:不打乱 tool 配对, +// 也不因为开关关着就改 body 的字段顺序。 +func TestTrimHistoryNoOp(t *testing.T) { + body := map[string]any{ + "messages": []any{msg("system", "s"), msg("user", "u1"), msg("assistant", "a1"), msg("user", "u2")}, + } + before, _ := json.Marshal(body) + trimHistory(body, 0) + trimHistory(body, -3) + trimHistory(body, 5) + after, _ := json.Marshal(body) + if string(before) != string(after) { + t.Fatalf("不该改动 body:\n before=%s\n after=%s", before, after) + } +} + +// TestTrimHistoryKeepsToolPairing 保留段开头不能是孤立 tool 结果:cut 只落在 user +// 下标上,所以带 tool_calls 的一整轮被完整保留或完整丢弃。 +func TestTrimHistoryKeepsToolPairing(t *testing.T) { + body := map[string]any{ + "messages": []any{ + msg("system", "s"), + msg("user", "旧轮"), + toolCallMsg("call_old"), + toolResult("call_old"), + msg("assistant", "回旧"), + msg("user", "新轮"), + toolCallMsg("call_new"), + toolResult("call_new"), + }, + } + trimHistory(body, 1) + roles := rolesOf(body) + if roles != "system,user,assistant,tool" { + t.Fatalf("应保留 system + 完整一轮(含 tool 配对),实际 %s", roles) + } + // 旧的 tool 调用与结果必须一起消失,新的必须都在。 + raw, _ := json.Marshal(body["messages"]) + s := string(raw) + if strings.Contains(s, "call_old") { + t.Errorf("旧轮的 tool 调用/结果没清干净: %s", s) + } + if !strings.Contains(s, "call_new") { + t.Errorf("新轮的 tool 调用/结果被误删: %s", s) + } +} + +func msg(role, content string) map[string]any { + return map[string]any{"role": role, "content": content} +} + +func toolCallMsg(id string) map[string]any { + return map[string]any{"role": "assistant", "content": nil, "tool_calls": []any{ + map[string]any{"id": id, "type": "function", + "function": map[string]any{"name": "f", "arguments": "{}"}}, + }} +} + +func toolResult(id string) map[string]any { + return map[string]any{"role": "tool", "tool_call_id": id, "content": "ok"} +} + +func rolesOf(body map[string]any) string { + out := "" + for _, m := range body["messages"].([]any) { + if out != "" { + out += "," + } + out += m.(map[string]any)["role"].(string) + } + return out +} + +func firstContent(body map[string]any) string { + for _, m := range body["messages"].([]any) { + mm := m.(map[string]any) + if mm["role"] == "user" { + s, _ := mm["content"].(string) + return s + } + } + return "" +} diff --git a/internal/upstream/truncation.go b/internal/upstream/truncation.go index 339da497da7e4cda3bfe9e07ca919626685370d7..26268d4751eee27091e9988c7fcf416905702210 100644 --- a/internal/upstream/truncation.go +++ b/internal/upstream/truncation.go @@ -1,47 +1,47 @@ -// truncation.go 工具调用的残缺参数检测(吸收参考仓库 sse.ts:158-167 -// isTruncatedArguments 语义)。 -// -// 背景:SSE 流被截断(连接中断 / finish_reason==length)时,工具调用的 arguments -// 会只剩半截 JSON。此时网关若把脏参数原样交给客户端,客户端解析会报非法 JSON 并卡死会话。 -// 参考仓库的处置是丢弃残缺调用并触发重试(报告 max-tokens),而非补成 {} 伪造合法外观。 -// -// 关键区分:只把「非空但无法解析」视为截断。空串是合法的无参数工具;能解析但类型不对 -// (标量 / 数组)属于模型输出错误,交给客户端 schema 校验回传即可,不在此判定。 -package upstream - -import ( - "encoding/json" - "strings" -) - -// isTruncatedArguments 判定工具参数字符串是否因分片丢失而残缺(区别于「该工具本就无参数」)。 -// - 空串 / 纯空白 → false(合法无参工具); -// - 非空但 JSON 解析失败 → true(截断); -// - 能解析(含 null/标量/数组等任何合法 JSON)→ false。 -func isTruncatedArguments(raw string) bool { - trimmed := strings.TrimSpace(raw) - if trimmed == "" { - return false - } - var v any - return json.Unmarshal([]byte(trimmed), &v) != nil -} - -// dropTruncatedToolCalls 过滤出 arguments 完整的 tool_call(返回新 slice)。 -// 只依据 isTruncatedArguments 判定,不改动任何保留的调用(正例零改动)。 -func dropTruncatedToolCalls(calls []map[string]any) []map[string]any { - kept := make([]map[string]any, 0, len(calls)) - for _, call := range calls { - fn, _ := call["function"].(map[string]any) - if fn == nil { - kept = append(kept, call) - continue - } - args, _ := fn["arguments"].(string) - if isTruncatedArguments(args) { - continue - } - kept = append(kept, call) - } - return kept -} +// truncation.go 工具调用的残缺参数检测(吸收参考仓库 sse.ts:158-167 +// isTruncatedArguments 语义)。 +// +// 背景:SSE 流被截断(连接中断 / finish_reason==length)时,工具调用的 arguments +// 会只剩半截 JSON。此时网关若把脏参数原样交给客户端,客户端解析会报非法 JSON 并卡死会话。 +// 参考仓库的处置是丢弃残缺调用并触发重试(报告 max-tokens),而非补成 {} 伪造合法外观。 +// +// 关键区分:只把「非空但无法解析」视为截断。空串是合法的无参数工具;能解析但类型不对 +// (标量 / 数组)属于模型输出错误,交给客户端 schema 校验回传即可,不在此判定。 +package upstream + +import ( + "encoding/json" + "strings" +) + +// isTruncatedArguments 判定工具参数字符串是否因分片丢失而残缺(区别于「该工具本就无参数」)。 +// - 空串 / 纯空白 → false(合法无参工具); +// - 非空但 JSON 解析失败 → true(截断); +// - 能解析(含 null/标量/数组等任何合法 JSON)→ false。 +func isTruncatedArguments(raw string) bool { + trimmed := strings.TrimSpace(raw) + if trimmed == "" { + return false + } + var v any + return json.Unmarshal([]byte(trimmed), &v) != nil +} + +// dropTruncatedToolCalls 过滤出 arguments 完整的 tool_call(返回新 slice)。 +// 只依据 isTruncatedArguments 判定,不改动任何保留的调用(正例零改动)。 +func dropTruncatedToolCalls(calls []map[string]any) []map[string]any { + kept := make([]map[string]any, 0, len(calls)) + for _, call := range calls { + fn, _ := call["function"].(map[string]any) + if fn == nil { + kept = append(kept, call) + continue + } + args, _ := fn["arguments"].(string) + if isTruncatedArguments(args) { + continue + } + kept = append(kept, call) + } + return kept +} diff --git a/internal/upstream/truncation_test.go b/internal/upstream/truncation_test.go new file mode 100644 index 0000000000000000000000000000000000000000..79694b3c3d9e3e8177f769ca24869a05e489c9ba --- /dev/null +++ b/internal/upstream/truncation_test.go @@ -0,0 +1,48 @@ +package upstream + +import ( + "strings" + "testing" +) + +// TestAggregateMarksCutAsTruncated 非流式(Aggregate)路径的同一根因:上游既没给 +// finish_reason 也没给 data: [DONE] 就 EOF(断流)时,此前下发的是初始默认值 +// "stop"——等于告诉客户端「模型正常说完了」,半截正文被当完整结果。判据与同文件 +// 处理残缺 tool_calls 的 !sawDone 保持一致。 +func TestAggregateMarksCutAsTruncated(t *testing.T) { + const content = `data: {"id":"c1","model":"m","choices":[{"index":0,"delta":{"content":"半截正文"}}]}` + "\n\n" + cases := []struct { + name string + in string + want string + }{ + {"断流(无 finish、无 [DONE])", content, TruncationFinishReason}, + {"正常收尾 [DONE]", content + "data: [DONE]\n\n", "stop"}, + {"显式 finish_reason(无 [DONE])", + content + `data: {"id":"c1","choices":[{"index":0,"delta":{},"finish_reason":"stop"}]}` + "\n\n", "stop"}, + {"显式 length(无 [DONE])", + content + `data: {"id":"c1","choices":[{"index":0,"delta":{},"finish_reason":"length"}]}` + "\n\n", "length"}, + } + for _, tc := range cases { + resp, err := Aggregate(strings.NewReader(tc.in)) + if err != nil { + t.Fatalf("%s: %v", tc.name, err) + } + choices, _ := resp["choices"].([]any) + if len(choices) != 1 { + t.Fatalf("%s: choices=%v", tc.name, resp["choices"]) + } + c0, _ := choices[0].(map[string]any) + if got := c0["finish_reason"]; got != tc.want { + t.Errorf("%s: finish_reason=%v want %v", tc.name, got, tc.want) + } + } +} + +// TestAggregateEmptyStreamStillErrors 空流(0 有效帧)必须仍是错误,不能被截断终态 +// 伪装成「有内容的 200」——客户端与运维都靠它区分「上游空转」与「流被切」。 +func TestAggregateEmptyStreamStillErrors(t *testing.T) { + if _, err := Aggregate(strings.NewReader("data: [DONE]\n\n")); err == nil { + t.Fatal("仅 [DONE] 的空流应报 errEmptyStream,不得合成截断响应") + } +} diff --git a/internal/upstream/ua_family_test.go b/internal/upstream/ua_family_test.go new file mode 100644 index 0000000000000000000000000000000000000000..f913d12cd56714f7ee7ae6380191c1955c9b80d7 --- /dev/null +++ b/internal/upstream/ua_family_test.go @@ -0,0 +1,99 @@ +// ua_family_test.go 2026-10-30 双版本真机抓包固化的「UA 分族」与「XRW 归属」结论。 +// +// 同一台机器、同一个已登录会话里,官方客户端同时发两种 UA 与两种 XRW 形态, +// 由**哪条代码路径发的**决定,不是按 realm 切: +// +// UA XRW +// chat(SDK) WorkBuddy/ / CLI/ 有 +// RPC/REST / / CLI/ 无 +// +// 网关两处都发错过一次:RPC 用了 chat 的首段(驼峰),chat 继承了 RPC 的头族。 +package upstream + +import ( + "net/http" + "net/http/httptest" + "testing" + + "github.com/misakano7545/workbuddy2api-panel/internal/auth" +) + +// TestRPCUAFirstSegmentIsSlug RPC/REST 族 UA 首段是品牌 slug;国际个人号必须 +// 发 `workbuddy-ai/…`,不能发 chat 那种驼峰首段。 +func TestRPCUAFirstSegmentIsSlug(t *testing.T) { + c := &Client{} + gl := &auth.Auth{UID: "u3", AccessToken: "at", Domain: "www.workbuddy.ai"} + cn := &auth.Auth{UID: "u1", AccessToken: "at"} + + if got, want := c.rpcUAFor(gl), "workbuddy-ai/5.9.4 workbuddy-ai/5.9.4 CLI/2.165.0"; got != want { + t.Errorf("国际 RPC UA=%q want %q", got, want) + } + // CN 下 RPC 与 chat 同值(品牌段本来就是驼峰),这是唯一允许相等的组合。 + if got, want := c.rpcUAFor(cn), "WorkBuddy/5.9.3 WorkBuddy/5.9.3 CLI/2.165.0"; got != want { + t.Errorf("国内 RPC UA=%q want %q", got, want) + } + + // 国际版两族必须**不同**:首段 slug vs 驼峰。 + if c.rpcUAFor(gl) == c.userAgent(gl) { + t.Errorf("国际版 RPC UA 与 chat UA 不应相等,都是 %q", c.rpcUAFor(gl)) + } + if got, want := c.userAgent(gl), "WorkBuddy/5.9.4 workbuddy-ai/5.9.4 CLI/2.165.0"; got != want { + t.Errorf("国际 chat UA=%q want %q", got, want) + } +} + +// TestXRequestedWithOnlyChat X-Requested-With 只属于 chat 那条链。 +// +// 全量抓包(125 条路径)按 UA 族切开后:RPC 族 56/56 无此头,渲染器族 10/10 有, +// chat 5/5 有。网关曾经在 CommonHeaders 里全局注入,等于给 refresh / report / +// busy / console-as 全部多盖一个客户端不发的头。 +func TestXRequestedWithOnlyChat(t *testing.T) { + c := &Client{} + a := &auth.Auth{UID: "u1", AccessToken: "at"} + + chat := httptest.NewRequest(http.MethodPost, "https://example.invalid/v2/chat/completions", nil) + c.ChatHeaders(chat, a, "", ChatMeta{ConversationID: "c1"}) + if got := chat.Header.Get("X-Requested-With"); got != "XMLHttpRequest" { + t.Errorf("chat X-Requested-With=%q want XMLHttpRequest", got) + } + + for _, path := range []string{ + "/v2/report", "/v2/chat/busy", "/console/as/conversations/", "/v2/plugin/auth/token/refresh", + } { + req := httptest.NewRequest(http.MethodPost, "https://example.invalid"+path, nil) + c.CommonHeaders(req, a) + if got := req.Header.Get("X-Requested-With"); got != "" { + t.Errorf("%s X-Requested-With=%q want 空(RPC 族从不发)", path, got) + } + } +} + +// TestCommonHeadersRESTShape RPC/REST 公共头族:宽松 Accept + X-Product,无浏览器痕迹。 +func TestCommonHeadersRESTShape(t *testing.T) { + c := &Client{} + a := &auth.Auth{UID: "u1", AccessToken: "at"} + req := httptest.NewRequest(http.MethodPost, "https://example.invalid/v2/report", nil) + c.CommonHeaders(req, a) + + if got, want := req.Header.Get("Accept"), "application/json, text/plain, */*"; got != want { + t.Errorf("Accept=%q want %q", got, want) + } + if got := req.Header.Get("X-Product"); got != "SaaS" { + t.Errorf("X-Product=%q want SaaS", got) + } + for _, h := range []string{"Origin", "Referer", "Accept-Language", "X-CodeBuddy-Request"} { + if got := req.Header.Get(h); got != "" { + t.Errorf("%s=%q want 空(RPC 族从不发)", h, got) + } + } +} + +// TestChatAcceptIsNarrow chat 只发 application/json(REST 那个宽松值不适用于 SSE 那条链)。 +func TestChatAcceptIsNarrow(t *testing.T) { + c := &Client{} + req := httptest.NewRequest(http.MethodPost, "https://example.invalid/v2/chat/completions", nil) + c.ChatHeaders(req, &auth.Auth{UID: "u1", AccessToken: "at"}, "", ChatMeta{ConversationID: "c1"}) + if got := req.Header.Get("Accept"); got != "application/json" { + t.Errorf("chat Accept=%q want application/json", got) + } +} diff --git a/internal/upstream/usage.go b/internal/upstream/usage.go index 74c18da4d940a00258b4a2dad3001cd95a2bafb2..3b20a1f672f3a13ef554b953ca5caf9833b976f8 100644 --- a/internal/upstream/usage.go +++ b/internal/upstream/usage.go @@ -1,149 +1,99 @@ -package upstream - -import "encoding/json" - -// normalizeUsageCacheAliases keeps cache-hit aliases consistent before the -// response leaves the gateway. Some WorkBuddy responses carry the real hit in -// prompt_tokens_details.cached_tokens while also emitting -// cache_read_input_tokens: 0 and cached_tokens: 0 compatibility aliases. -// Strict downstream parsers may prefer those zero aliases and lose the hit. -func normalizeUsageCacheAliases(usage map[string]any) map[string]any { - best, ok := bestUsageCacheHitTokens(usage) - if !ok || best <= 0 { - return usage - } - - out := cloneUsageMap(usage) - out["cache_read_input_tokens"] = best - out["cached_tokens"] = best - out["prompt_cache_hit_tokens"] = best - - promptDetails := cloneUsageDetails(out, "prompt_tokens_details") - promptDetails["cached_tokens"] = best - out["prompt_tokens_details"] = promptDetails - - // Responses API consumers use this nested form. Preserve it when the - // upstream already supplies it, but do not invent it for Chat-only clients. - if _, exists := out["input_tokens_details"]; exists { - inputDetails := cloneUsageDetails(out, "input_tokens_details") - inputDetails["cached_tokens"] = best - out["input_tokens_details"] = inputDetails - } - - return out -} - -func bestUsageCacheHitTokens(usage map[string]any) (float64, bool) { - paths := []struct { - section string - key string - }{ - {"prompt_tokens_details", "cached_tokens"}, - {"", "prompt_cache_hit_tokens"}, - {"", "cache_read_input_tokens"}, - {"", "cached_tokens"}, - {"input_tokens_details", "cached_tokens"}, - } - - for _, path := range paths { - var value any - if path.section == "" { - value = usage[path.key] - } else if details, ok := usage[path.section].(map[string]any); ok { - value = details[path.key] - } - if tokens, ok := positiveUsageNumber(value); ok { - return tokens, true - } - } - return 0, false -} - -func positiveUsageNumber(value any) (float64, bool) { - switch n := value.(type) { - case float64: - return n, n > 0 - case float32: - value := float64(n) - return value, value > 0 - case int: - return float64(n), n > 0 - case int64: - return float64(n), n > 0 - case int32: - return float64(n), n > 0 - case uint: - return float64(n), n > 0 - case uint64: - return float64(n), n > 0 - case uint32: - return float64(n), n > 0 - default: - return 0, false - } -} - -func cloneUsageMap(usage map[string]any) map[string]any { - out := make(map[string]any, len(usage)) - for key, value := range usage { - out[key] = value - } - return out -} - -func cloneUsageDetails(usage map[string]any, key string) map[string]any { - out := make(map[string]any) - details, _ := usage[key].(map[string]any) - for detailKey, value := range details { - out[detailKey] = value - } - return out -} - -// UsageCacheHitTokens 返回 usage 里的缓存命中 token 数(多别名取最优,口径与 -// 回写给客户端的 normalizeUsageCacheAliases 一致)。供网关统计层(usage 桶 / -// reqlog)观测命中率使用;usage 缺失该维度时 ok=false。 -func UsageCacheHitTokens(usage map[string]any) (float64, bool) { - if usage == nil { - return 0, false - } - return bestUsageCacheHitTokens(usage) -} - -// UsageCacheMissTokens 返回 usage 里的缓存未命中 token 数:优先读上游显式的 -// prompt_cache_miss_tokens,缺失时按 prompt_tokens - 命中 推导(推导值为负时 -// 视为不可信,返回 ok=false)。 -func UsageCacheMissTokens(usage map[string]any) (float64, bool) { - if usage == nil { - return 0, false - } - if miss, ok := usageNumber(usage, "prompt_cache_miss_tokens"); ok { - return miss, true - } - prompt, okP := usageNumber(usage, "prompt_tokens") - hit, okH := UsageCacheHitTokens(usage) - if okP && okH && prompt-hit >= 0 { - return prompt - hit, true - } - return 0, false -} - -// usageNumber 从 usage 顶层取数值字段(JSON 数字可能是 float64 / json.Number 形态)。 -func usageNumber(usage map[string]any, key string) (float64, bool) { - v, ok := usage[key] - if !ok { - return 0, false - } - switch n := v.(type) { - case float64: - return n, true - case int: - return float64(n), true - case int64: - return float64(n), true - case json.Number: - f, err := n.Float64() - return f, err == nil - } - return 0, false -} +package upstream + +// normalizeUsageCacheAliases keeps cache-hit aliases consistent before the +// response leaves the gateway. Some WorkBuddy responses carry the real hit in +// prompt_tokens_details.cached_tokens while also emitting +// cache_read_input_tokens: 0 and cached_tokens: 0 compatibility aliases. +// Strict downstream parsers may prefer those zero aliases and lose the hit. +func normalizeUsageCacheAliases(usage map[string]any) map[string]any { + best, ok := bestUsageCacheHitTokens(usage) + if !ok || best <= 0 { + return usage + } + + out := cloneUsageMap(usage) + out["cache_read_input_tokens"] = best + out["cached_tokens"] = best + out["prompt_cache_hit_tokens"] = best + + promptDetails := cloneUsageDetails(out, "prompt_tokens_details") + promptDetails["cached_tokens"] = best + out["prompt_tokens_details"] = promptDetails + + // Responses API consumers use this nested form. Preserve it when the + // upstream already supplies it, but do not invent it for Chat-only clients. + if _, exists := out["input_tokens_details"]; exists { + inputDetails := cloneUsageDetails(out, "input_tokens_details") + inputDetails["cached_tokens"] = best + out["input_tokens_details"] = inputDetails + } + + return out +} + +func bestUsageCacheHitTokens(usage map[string]any) (float64, bool) { + paths := []struct { + section string + key string + }{ + {"prompt_tokens_details", "cached_tokens"}, + {"", "prompt_cache_hit_tokens"}, + {"", "cache_read_input_tokens"}, + {"", "cached_tokens"}, + {"input_tokens_details", "cached_tokens"}, + } + + for _, path := range paths { + var value any + if path.section == "" { + value = usage[path.key] + } else if details, ok := usage[path.section].(map[string]any); ok { + value = details[path.key] + } + if tokens, ok := positiveUsageNumber(value); ok { + return tokens, true + } + } + return 0, false +} + +func positiveUsageNumber(value any) (float64, bool) { + switch n := value.(type) { + case float64: + return n, n > 0 + case float32: + value := float64(n) + return value, value > 0 + case int: + return float64(n), n > 0 + case int64: + return float64(n), n > 0 + case int32: + return float64(n), n > 0 + case uint: + return float64(n), n > 0 + case uint64: + return float64(n), n > 0 + case uint32: + return float64(n), n > 0 + default: + return 0, false + } +} + +func cloneUsageMap(usage map[string]any) map[string]any { + out := make(map[string]any, len(usage)) + for key, value := range usage { + out[key] = value + } + return out +} + +func cloneUsageDetails(usage map[string]any, key string) map[string]any { + out := make(map[string]any) + details, _ := usage[key].(map[string]any) + for detailKey, value := range details { + out[detailKey] = value + } + return out +} diff --git a/internal/upstream/useragent_test.go b/internal/upstream/useragent_test.go index 096eaffff8b2fc7c8800281d4cdcb170526be9f5..da9d2a0d57b398263ee7a0e8af1d00744554bc46 100644 --- a/internal/upstream/useragent_test.go +++ b/internal/upstream/useragent_test.go @@ -1,336 +1,339 @@ -package upstream - -import ( - "io" - "net/http" - "strings" - "testing" - - "github.com/linguo2625469/workbuddy2api-panel/internal/auth" -) - -// uaCaptureTransport 记录出站请求的 User-Agent。 -type uaCaptureTransport struct { - ua *string -} - -func (t uaCaptureTransport) RoundTrip(r *http.Request) (*http.Response, error) { - *t.ua = r.Header.Get("User-Agent") - return jsonResp(200, `{"code":0}`), nil -} - -// TestUserAgentDefaultEmptyKeepsClientUA 默认(UserAgent/client_name 空)行为: -// chat/refresh 路径 UA=默认 WorkBuddy 三段式;billing 路径(report/travel/balance) -// 单段 WorkBuddy/(对齐官方 banner 白名单头组,默认伪造桌面端指纹); -// 显式 client_name="SaaS" 才还原"billing 不设 UA"的旧行为。 -func TestUserAgentDefaultEmptyKeepsClientUA(t *testing.T) { - for _, tc := range []struct { - name string - call func(c *Client) error - wantUA string - }{ - { - name: "chat", - call: func(c *Client) error { - rc, status, _, err := c.ChatStream(&auth.Auth{AccessToken: "at", UID: "u1"}, []byte(`{"model":"glm-5.2","messages":[]}`), "", ChatMeta{}) - if status != 200 { - t.Fatalf("chat status=%d", status) - } - if rc != nil { - rc.Close() - } - return err - }, - wantUA: defaultUAString, - }, - { - name: "billing_report", - call: func(c *Client) error { - return c.ReportChatActivity(&auth.Auth{AccessToken: "at", UID: "u1"}, "cid", "") - }, - wantUA: "WorkBuddy/5.5.4", - }, - } { - t.Run(tc.name, func(t *testing.T) { - var ua string - c := &Client{ - HTTP: &http.Client{Transport: uaCaptureTransport{ua: &ua}}, - ChatHTTP: &http.Client{Transport: uaCaptureTransport{ua: &ua}}, - ChatBaseCN: "https://chat.example", - BillingBaseCN: "https://billing.example", - } - if err := tc.call(c); err != nil { - t.Fatalf("call: %v", err) - } - if ua != tc.wantUA { - t.Errorf("UA = %q want %q", ua, tc.wantUA) - } - }) - } -} - -// TestUserAgentOverrideAllOutbound 显式设置后 chat/billing/refresh 全路径覆盖。 -// 用 env 别名直接验证 fields 传输到 headers 的行为。 -func TestUserAgentOverrideAllOutbound(t *testing.T) { - a := &auth.Auth{AccessToken: "at", UID: "u1", RefreshToken: "rt"} - ua := "WorkBuddy/9.9.9" - c := &Client{ - HTTP: &http.Client{Transport: rtFunc(func(r *http.Request) (*http.Response, error) { - if got := r.Header.Get("User-Agent"); got != ua { - t.Errorf("UA = %q want %q (path=%s)", got, ua, r.URL.Path) - } - return jsonResp(200, `{"code":0}`), nil - })}, - ChatHTTP: &http.Client{Transport: rtFunc(func(r *http.Request) (*http.Response, error) { - if got := r.Header.Get("User-Agent"); got != ua { - t.Errorf("Chat UA = %q want %q", got, ua) - } - return jsonResp(200, `{"code":0}`), nil - })}, - ChatBaseCN: "https://chat.example", - BillingBaseCN: "https://billing.example", - UserAgent: ua, - } - // chat - if rc, status, _, err := c.ChatStream(a, []byte(`{"model":"deepseek-v4-flash","messages":[]}`), "", ChatMeta{}); status != 200 || err != nil { - t.Errorf("chat: status=%d err=%v", status, err) - } else if rc != nil { - rc.Close() - } - // refresh(RefreshHeaders→CommonHeaders) - c.HTTP.Transport = rtFunc(func(r *http.Request) (*http.Response, error) { - if got := r.Header.Get("User-Agent"); got != ua { - t.Errorf("Refresh UA = %q want %q", got, ua) - } - return jsonResp(200, `{"code":0,"data":{"accessToken":"nat","refreshToken":"nrt"}}`), nil - }) - if err := c.RefreshToken(a); err != nil { - t.Errorf("refresh: %v", err) - } -} - -// TestUserAgentOverrideBilling 余额/签到类 billing 请求同样覆盖。 -func TestUserAgentOverrideBilling(t *testing.T) { - a := &auth.Auth{AccessToken: "at", UID: "u1"} - c := &Client{ - HTTP: &http.Client{Transport: rtFunc(func(r *http.Request) (*http.Response, error) { - if got := r.Header.Get("User-Agent"); got != "CustomAgent/1" { - t.Errorf("Billing UA = %q want CustomAgent/1", got) - } - return jsonResp(200, `{"code":0,"data":{"response":{"data":{"accounts":[{"PackageName":"x","CycleCapacitySize":100,"CycleCapacityUsed":0}]}}}}`), nil - })}, - ChatBaseCN: "https://chat.example", - BillingBaseCN: "https://billing.example", - UserAgent: "CustomAgent/1", - } - if _, _, err := c.UserResource(a); err != nil { - t.Errorf("userResource: %v", err) - } -} - -// TestFetchModelsUsesConfiguredUA FetchModels 手工 Set UA 也走覆盖。 -func TestFetchModelsUsesConfiguredUA(t *testing.T) { - a := &auth.Auth{AccessToken: "at", UID: "u1"} - c := &Client{ - HTTP: &http.Client{Transport: rtFunc(func(r *http.Request) (*http.Response, error) { - switch { - case strings.HasSuffix(r.URL.Path, "/console/enterprises/personal/models"): - if got := r.Header.Get("User-Agent"); got != "FetchAgent/2" { - t.Errorf("personal/models UA = %q want FetchAgent/2", got) - } - case strings.HasSuffix(r.URL.Path, "/v3/config"): - if got := r.Header.Get("User-Agent"); got != codeBuddyIDEUA { - t.Errorf("v3/config UA = %q want %s", got, codeBuddyIDEUA) - } - return jsonResp(200, `{"code":0,"data":{"models":[]}}`), nil - default: - t.Errorf("path=%s", r.URL.Path) - } - return jsonResp(200, `{"code":0,"data":{"models":[{"id":"glm-5.2","name":"GLM","maxInputTokens":131072,"maxOutputTokens":8192,"reasoning":{"effort":"high","supportedEfforts":[]},"disabled":false}],"agents":[{"name":"cli","models":["glm-5.2"]}]}}`), nil - })}, - ChatBaseCN: "https://chat.example", - BillingBaseCN: "https://billing.example", - UserAgent: "FetchAgent/2", - } - if _, err := c.FetchModels(a); err != nil { - t.Errorf("fetchModels: %v", err) - } -} - -// --- A 段:UA 对齐官方 WorkBuddy 三段式 --- - -const ( - defaultUAString = "WorkBuddy/5.5.4 WorkBuddy/5.5.4 CLI/2.137.1" - explicitString = "MyCustomAgent/3.1" - clientVerUAString = "WorkBuddy/6.0.0 WorkBuddy/6.0.0 CLI/2.137.1" - billingUAWorkBuddy = "WorkBuddy/5.5.4" - billingUACustomVer = "WorkBuddy/6.0.0" - billingUAAgentString = "BillingAgent/1" -) - -// TestUserAgentDefaultWorkBuddyShape 默认(无任何配置)聊天/刷新出站 UA = -// 官方 WorkBuddy 三段式,旧值 `CLI/2.63.2 CodeBuddy/2.63.2` 已被对齐替换。 -func TestUserAgentDefaultWorkBuddyShape(t *testing.T) { - a := &auth.Auth{AccessToken: "at", UID: "u1"} - c := &Client{ - HTTP: &http.Client{Transport: uaCaptureTransport{ua: new(string)}}, - ChatHTTP: &http.Client{Transport: uaCaptureTransport{ua: new(string)}}, - ChatBaseCN: "https://chat.example", - BillingBaseCN: "https://billing.example", - } - rc, status, _, err := c.ChatStream(a, []byte(`{"model":"deepseek-v4-flash","messages":[]}`), "", ChatMeta{}) - if status != 200 || err != nil { - t.Fatalf("chat: status=%d err=%v", status, err) - } - if ua := c.chatLastUA(); ua != defaultUAString { - t.Errorf("chat UA = %q want %q", ua, defaultUAString) - } - if rc != nil { - rc.Close() - } -} - -// chatLastUA 从最近一次聊天请求捕获 UA(当前测试 Client 的 ChatHTTP transport 记录)。 -func (c *Client) chatLastUA() string { - if t, ok := c.ChatHTTP.Transport.(uaCaptureTransport); ok && t.ua != nil { - return *t.ua - } - return "" -} - -// TestUserAgentExplicitOverride config user_agent 非空时以用户显式值为准(兼容旧覆盖逻辑)。 -func TestUserAgentExplicitOverride(t *testing.T) { - a := &auth.Auth{AccessToken: "at", UID: "u1", RefreshToken: "rt"} - c := &Client{ - HTTP: &http.Client{Transport: rtFunc(func(r *http.Request) (*http.Response, error) { - if got := r.Header.Get("User-Agent"); got != explicitString { - t.Errorf("UA = %q want %q (path=%s)", got, explicitString, r.URL.Path) - } - return jsonResp(200, `{"code":0,"data":{"accessToken":"nat","refreshToken":"nrt"}}`), nil - })}, - ChatHTTP: &http.Client{Transport: uaCaptureTransport{ua: new(string)}}, - ChatBaseCN: "https://chat.example", - BillingBaseCN: "https://billing.example", - UserAgent: explicitString, - } - if rc, status, _, err := c.ChatStream(a, []byte(`{"model":"deepseek-v4-flash","messages":[]}`), "", ChatMeta{}); status != 200 || err != nil { - t.Errorf("chat: status=%d err=%v", status, err) - } else if rc != nil { - rc.Close() - } - if got := c.chatLastUA(); got != explicitString { - t.Errorf("chat UA = %q want %q", got, explicitString) - } - if err := c.RefreshToken(a); err != nil { - t.Errorf("refresh: %v", err) - } -} - -// TestUserAgentClientVersionOverride config client_version 生效:UA 的 WorkBuddy 段跟随 -// 且成对相同(platform 段 = applicationName 段),CLI 段保持默认。 -func TestUserAgentClientVersionOverride(t *testing.T) { - a := &auth.Auth{AccessToken: "at", UID: "u1"} - c := &Client{ - HTTP: &http.Client{Transport: uaCaptureTransport{ua: new(string)}}, - ChatHTTP: &http.Client{Transport: uaCaptureTransport{ua: new(string)}}, - ChatBaseCN: "https://chat.example", - BillingBaseCN: "https://billing.example", - ClientVersion: "6.0.0", - } - rc, status, _, err := c.ChatStream(a, []byte(`{"model":"deepseek-v4-flash","messages":[]}`), "", ChatMeta{}) - if status != 200 || err != nil { - t.Fatalf("chat: status=%d err=%v", status, err) - } - if got := c.chatLastUA(); got != clientVerUAString { - t.Errorf("UA = %q want %q", got, clientVerUAString) - } - if rc != nil { - rc.Close() - } -} - -// TestBillingUA_WhenClientNameSet billing/checkin 路径:client_name 非空时用单段 -// `WorkBuddy/`(不带 CLI 段,对齐官方 banner/check-in 显式头组)。 -func TestBillingUA_WhenClientNameSet(t *testing.T) { - a := &auth.Auth{AccessToken: "at", UID: "u1"} - // 默认 client_version → WorkBuddy/5.5.4 - c := &Client{ - HTTP: &http.Client{Transport: rtFunc(func(r *http.Request) (*http.Response, error) { - if got := r.Header.Get("User-Agent"); got != billingUAWorkBuddy { - t.Errorf("billing UA = %q want %q (path=%s)", got, billingUAWorkBuddy, r.URL.Path) - } - return jsonResp(200, `{"code":0,"data":{"response":{"data":{"accounts":[{"PackageName":"x","CycleCapacitySize":100,"CycleCapacityUsed":0}]}}}}`), nil - })}, - ChatBaseCN: "https://chat.example", - BillingBaseCN: "https://billing.example", - ClientName: "WorkBuddy", - } - if _, _, err := c.UserResource(a); err != nil { - t.Errorf("userResource: %v", err) - } - // 自定义 client_version → WorkBuddy/6.0.0 - c2 := &Client{ - HTTP: &http.Client{Transport: rtFunc(func(r *http.Request) (*http.Response, error) { - if got := r.Header.Get("User-Agent"); got != billingUACustomVer { - t.Errorf("billing UA = %q want %q", got, billingUACustomVer) - } - return jsonResp(200, `{"code":0,"data":{"response":{"data":{"accounts":[{"PackageName":"x","CycleCapacitySize":100,"CycleCapacityUsed":0}]}}}}`), nil - })}, - ChatBaseCN: "https://chat.example", - BillingBaseCN: "https://billing.example", - ClientName: "WorkBuddy", - ClientVersion: "6.0.0", - } - if _, _, err := c2.UserResource(a); err != nil { - t.Errorf("userResource v2: %v", err) - } - // 显式 user_agent 仍优先于 billingUA - c3 := &Client{ - HTTP: &http.Client{Transport: rtFunc(func(r *http.Request) (*http.Response, error) { - if got := r.Header.Get("User-Agent"); got != billingUAAgentString { - t.Errorf("billing UA = %q want %q", got, billingUAAgentString) - } - return jsonResp(200, `{"code":0,"data":{"response":{"data":{"accounts":[{"PackageName":"x","CycleCapacitySize":100,"CycleCapacityUsed":0}]}}}}`), nil - })}, - ChatBaseCN: "https://chat.example", - BillingBaseCN: "https://billing.example", - ClientName: "WorkBuddy", - UserAgent: billingUAAgentString, - } - if _, _, err := c3.UserResource(a); err != nil { - t.Errorf("userResource v3: %v", err) - } -} - -// TestBillingUA_WhenClientNameEmpty client_name 空 = 默认对齐官方桌面端: -// billing UA 单段 WorkBuddy/;显式 client_name="SaaS" 才不设 UA。 -func TestBillingUA_WhenClientNameEmpty(t *testing.T) { - a := &auth.Auth{AccessToken: "at", UID: "u1"} - var ua string - const fullResp = `{"code":0,"data":{"response":{"data":{"accounts":[{"PackageName":"x","CycleCapacitySize":100,"CycleCapacityUsed":0}]}}}}` - c := &Client{ - HTTP: &http.Client{Transport: rtFunc(func(r *http.Request) (*http.Response, error) { - ua = r.Header.Get("User-Agent") - return jsonResp(200, fullResp), nil - })}, - ChatBaseCN: "https://chat.example", - BillingBaseCN: "https://billing.example", - ClientVersion: "6.0.0", - } - if _, _, err := c.UserResource(a); err != nil { - t.Errorf("userResource: %v", err) - } - if ua != "WorkBuddy/6.0.0" { - t.Errorf("billing UA = %q want WorkBuddy/6.0.0 (default desktop fingerprint)", ua) - } - if got := c.billingUA(); got != "WorkBuddy/6.0.0" { - t.Errorf("billingUA() = %q want WorkBuddy/6.0.0", got) - } - // 显式 SaaS 还原旧行为(不设 UA)。 - c.ClientName = "SaaS" - if got := c.billingUA(); got != "" { - t.Errorf("billingUA() SaaS = %q want empty", got) - } -} - -var _ = io.Discard +package upstream + +import ( + "io" + "net/http" + "strings" + "testing" + + "github.com/misakano7545/workbuddy2api-panel/internal/auth" +) + +// uaCaptureTransport 记录出站请求的 User-Agent。 +type uaCaptureTransport struct { + ua *string +} + +func (t uaCaptureTransport) RoundTrip(r *http.Request) (*http.Response, error) { + *t.ua = r.Header.Get("User-Agent") + return jsonResp(200, `{"code":0}`), nil +} + +// TestUserAgentDefaultEmptyKeepsClientUA 默认(UserAgent/client_name 空)行为: +// chat/refresh 路径 UA=默认 WorkBuddy 三段式;activities 上报(/v2/report)自 +// 2026-10-28 起改走 **chatBase**,UA 也随之变成同样的三段式——5.9.3 真机 /v2/report +// 实测 UA 是 `WorkBuddy/5.9.3 WorkBuddy/5.9.3 CLI/2.165.0`,不是 billing 的 axios。 +// 真正的 billing 端点(checkin / balance / 明细)仍走 axios/1.16.1(billingUA)。 +// 显式 client_name="SaaS" 才还原"billing 不设 UA"的旧行为。 +func TestUserAgentDefaultEmptyKeepsClientUA(t *testing.T) { + for _, tc := range []struct { + name string + call func(c *Client) error + wantUA string + }{ + { + name: "chat", + call: func(c *Client) error { + rc, status, _, err := c.ChatStream(&auth.Auth{AccessToken: "at", UID: "u1"}, []byte(`{"model":"glm-5.2","messages":[]}`), "", ChatMeta{}) + if status != 200 { + t.Fatalf("chat status=%d", status) + } + if rc != nil { + rc.Close() + } + return err + }, + wantUA: defaultUAString, + }, + { + // /v2/report 走 chat 域,UA 用 WorkBuddy 三段式(真机口径)。 + name: "chat_report", + call: func(c *Client) error { + return c.ReportChatActivity(&auth.Auth{AccessToken: "at", UID: "u1"}, "cid", "") + }, + wantUA: defaultUAString, + }, + } { + t.Run(tc.name, func(t *testing.T) { + var ua string + c := &Client{ + HTTP: &http.Client{Transport: uaCaptureTransport{ua: &ua}}, + ChatHTTP: &http.Client{Transport: uaCaptureTransport{ua: &ua}}, + ChatBaseCN: "https://chat.example", + BillingBaseCN: "https://billing.example", + } + if err := tc.call(c); err != nil { + t.Fatalf("call: %v", err) + } + if ua != tc.wantUA { + t.Errorf("UA = %q want %q", ua, tc.wantUA) + } + }) + } +} + +// TestUserAgentOverrideAllOutbound 显式设置后 chat/billing/refresh 全路径覆盖。 +// 用 env 别名直接验证 fields 传输到 headers 的行为。 +func TestUserAgentOverrideAllOutbound(t *testing.T) { + a := &auth.Auth{AccessToken: "at", UID: "u1", RefreshToken: "rt"} + ua := "WorkBuddy/9.9.9" + c := &Client{ + HTTP: &http.Client{Transport: rtFunc(func(r *http.Request) (*http.Response, error) { + if got := r.Header.Get("User-Agent"); got != ua { + t.Errorf("UA = %q want %q (path=%s)", got, ua, r.URL.Path) + } + return jsonResp(200, `{"code":0}`), nil + })}, + ChatHTTP: &http.Client{Transport: rtFunc(func(r *http.Request) (*http.Response, error) { + if got := r.Header.Get("User-Agent"); got != ua { + t.Errorf("Chat UA = %q want %q", got, ua) + } + return jsonResp(200, `{"code":0}`), nil + })}, + ChatBaseCN: "https://chat.example", + BillingBaseCN: "https://billing.example", + UserAgent: ua, + } + // chat + if rc, status, _, err := c.ChatStream(a, []byte(`{"model":"deepseek-v4-flash","messages":[]}`), "", ChatMeta{}); status != 200 || err != nil { + t.Errorf("chat: status=%d err=%v", status, err) + } else if rc != nil { + rc.Close() + } + // refresh(RefreshHeaders→CommonHeaders) + c.HTTP.Transport = rtFunc(func(r *http.Request) (*http.Response, error) { + if got := r.Header.Get("User-Agent"); got != ua { + t.Errorf("Refresh UA = %q want %q", got, ua) + } + return jsonResp(200, `{"code":0,"data":{"accessToken":"nat","refreshToken":"nrt"}}`), nil + }) + if err := c.RefreshToken(a); err != nil { + t.Errorf("refresh: %v", err) + } +} + +// TestUserAgentOverrideBilling 余额/签到类 billing 请求同样覆盖。 +func TestUserAgentOverrideBilling(t *testing.T) { + a := &auth.Auth{AccessToken: "at", UID: "u1"} + c := &Client{ + HTTP: &http.Client{Transport: rtFunc(func(r *http.Request) (*http.Response, error) { + if got := r.Header.Get("User-Agent"); got != "CustomAgent/1" { + t.Errorf("Billing UA = %q want CustomAgent/1", got) + } + return jsonResp(200, `{"code":0,"data":{"response":{"data":{"accounts":[{"PackageName":"x","CycleCapacitySize":100,"CycleCapacityUsed":0}]}}}}`), nil + })}, + ChatBaseCN: "https://chat.example", + BillingBaseCN: "https://billing.example", + UserAgent: "CustomAgent/1", + } + if _, _, err := c.UserResource(a); err != nil { + t.Errorf("userResource: %v", err) + } +} + +// TestFetchModelsUsesConfiguredUA FetchModels 手工 Set UA 也走覆盖。 +func TestFetchModelsUsesConfiguredUA(t *testing.T) { + a := &auth.Auth{AccessToken: "at", UID: "u1"} + c := &Client{ + HTTP: &http.Client{Transport: rtFunc(func(r *http.Request) (*http.Response, error) { + switch { + case strings.HasSuffix(r.URL.Path, "/console/enterprises/personal/models"): + if got := r.Header.Get("User-Agent"); got != "FetchAgent/2" { + t.Errorf("personal/models UA = %q want FetchAgent/2", got) + } + case strings.HasSuffix(r.URL.Path, "/v3/config"): + if got := r.Header.Get("User-Agent"); got != v3ProbeUACNForTest { + t.Errorf("v3/config UA = %q want %s", got, v3ProbeUACNForTest) + } + return jsonResp(200, `{"code":0,"data":{"models":[]}}`), nil + default: + t.Errorf("path=%s", r.URL.Path) + } + return jsonResp(200, `{"code":0,"data":{"models":[{"id":"glm-5.2","name":"GLM","maxInputTokens":131072,"maxOutputTokens":8192,"reasoning":{"effort":"high","supportedEfforts":[]},"disabled":false}],"agents":[{"name":"cli","models":["glm-5.2"]}]}}`), nil + })}, + ChatBaseCN: "https://chat.example", + BillingBaseCN: "https://billing.example", + UserAgent: "FetchAgent/2", + } + if _, err := c.FetchModels(a); err != nil { + t.Errorf("fetchModels: %v", err) + } +} + +// --- A 段:UA 对齐官方 WorkBuddy 三段式 --- + +const ( + defaultUAString = "WorkBuddy/5.9.3 WorkBuddy/5.9.3 CLI/2.165.0" + explicitString = "MyCustomAgent/3.1" + clientVerUAString = "WorkBuddy/6.0.0 WorkBuddy/6.0.0 CLI/2.165.0" + billingUAWorkBuddy = "axios/1.16.1" + billingUACustomVer = "axios/1.16.1" + billingUAAgentString = "BillingAgent/1" +) + +// TestUserAgentDefaultWorkBuddyShape 默认(无任何配置)聊天/刷新出站 UA = +// 官方 WorkBuddy 三段式,旧值 `CLI/2.63.2 CodeBuddy/2.63.2` 已被对齐替换。 +func TestUserAgentDefaultWorkBuddyShape(t *testing.T) { + a := &auth.Auth{AccessToken: "at", UID: "u1"} + c := &Client{ + HTTP: &http.Client{Transport: uaCaptureTransport{ua: new(string)}}, + ChatHTTP: &http.Client{Transport: uaCaptureTransport{ua: new(string)}}, + ChatBaseCN: "https://chat.example", + BillingBaseCN: "https://billing.example", + } + rc, status, _, err := c.ChatStream(a, []byte(`{"model":"deepseek-v4-flash","messages":[]}`), "", ChatMeta{}) + if status != 200 || err != nil { + t.Fatalf("chat: status=%d err=%v", status, err) + } + if ua := c.chatLastUA(); ua != defaultUAString { + t.Errorf("chat UA = %q want %q", ua, defaultUAString) + } + if rc != nil { + rc.Close() + } +} + +// chatLastUA 从最近一次聊天请求捕获 UA(当前测试 Client 的 ChatHTTP transport 记录)。 +func (c *Client) chatLastUA() string { + if t, ok := c.ChatHTTP.Transport.(uaCaptureTransport); ok && t.ua != nil { + return *t.ua + } + return "" +} + +// TestUserAgentExplicitOverride config user_agent 非空时以用户显式值为准(兼容旧覆盖逻辑)。 +func TestUserAgentExplicitOverride(t *testing.T) { + a := &auth.Auth{AccessToken: "at", UID: "u1", RefreshToken: "rt"} + c := &Client{ + HTTP: &http.Client{Transport: rtFunc(func(r *http.Request) (*http.Response, error) { + if got := r.Header.Get("User-Agent"); got != explicitString { + t.Errorf("UA = %q want %q (path=%s)", got, explicitString, r.URL.Path) + } + return jsonResp(200, `{"code":0,"data":{"accessToken":"nat","refreshToken":"nrt"}}`), nil + })}, + ChatHTTP: &http.Client{Transport: uaCaptureTransport{ua: new(string)}}, + ChatBaseCN: "https://chat.example", + BillingBaseCN: "https://billing.example", + UserAgent: explicitString, + } + if rc, status, _, err := c.ChatStream(a, []byte(`{"model":"deepseek-v4-flash","messages":[]}`), "", ChatMeta{}); status != 200 || err != nil { + t.Errorf("chat: status=%d err=%v", status, err) + } else if rc != nil { + rc.Close() + } + if got := c.chatLastUA(); got != explicitString { + t.Errorf("chat UA = %q want %q", got, explicitString) + } + if err := c.RefreshToken(a); err != nil { + t.Errorf("refresh: %v", err) + } +} + +// TestUserAgentClientVersionOverride config client_version 生效:UA 的 WorkBuddy 段跟随 +// 且成对相同(platform 段 = applicationName 段),CLI 段保持默认。 +func TestUserAgentClientVersionOverride(t *testing.T) { + a := &auth.Auth{AccessToken: "at", UID: "u1"} + c := &Client{ + HTTP: &http.Client{Transport: uaCaptureTransport{ua: new(string)}}, + ChatHTTP: &http.Client{Transport: uaCaptureTransport{ua: new(string)}}, + ChatBaseCN: "https://chat.example", + BillingBaseCN: "https://billing.example", + ClientVersion: "6.0.0", + } + rc, status, _, err := c.ChatStream(a, []byte(`{"model":"deepseek-v4-flash","messages":[]}`), "", ChatMeta{}) + if status != 200 || err != nil { + t.Fatalf("chat: status=%d err=%v", status, err) + } + if got := c.chatLastUA(); got != clientVerUAString { + t.Errorf("UA = %q want %q", got, clientVerUAString) + } + if rc != nil { + rc.Close() + } +} + +// TestBillingUA_WhenClientNameSet billing/checkin 路径:client_name 非空时用单段 +// `axios/1.16.1`(真机实测:billing 域走 axios 实例,与客户端 UA 无关,也不随 client_version 变)。 +func TestBillingUA_WhenClientNameSet(t *testing.T) { + a := &auth.Auth{AccessToken: "at", UID: "u1"} + // 默认 client_version → axios/1.16.1 + c := &Client{ + HTTP: &http.Client{Transport: rtFunc(func(r *http.Request) (*http.Response, error) { + if got := r.Header.Get("User-Agent"); got != billingUAWorkBuddy { + t.Errorf("billing UA = %q want %q (path=%s)", got, billingUAWorkBuddy, r.URL.Path) + } + return jsonResp(200, `{"code":0,"data":{"response":{"data":{"accounts":[{"PackageName":"x","CycleCapacitySize":100,"CycleCapacityUsed":0}]}}}}`), nil + })}, + ChatBaseCN: "https://chat.example", + BillingBaseCN: "https://billing.example", + ClientName: "WorkBuddy", + } + if _, _, err := c.UserResource(a); err != nil { + t.Errorf("userResource: %v", err) + } + // 自定义 client_version 不影响 billing UA(仍是 axios/1.16.1) + c2 := &Client{ + HTTP: &http.Client{Transport: rtFunc(func(r *http.Request) (*http.Response, error) { + if got := r.Header.Get("User-Agent"); got != billingUACustomVer { + t.Errorf("billing UA = %q want %q", got, billingUACustomVer) + } + return jsonResp(200, `{"code":0,"data":{"response":{"data":{"accounts":[{"PackageName":"x","CycleCapacitySize":100,"CycleCapacityUsed":0}]}}}}`), nil + })}, + ChatBaseCN: "https://chat.example", + BillingBaseCN: "https://billing.example", + ClientName: "WorkBuddy", + ClientVersion: "6.0.0", + } + if _, _, err := c2.UserResource(a); err != nil { + t.Errorf("userResource v2: %v", err) + } + // 显式 user_agent 仍优先于 billingUA + c3 := &Client{ + HTTP: &http.Client{Transport: rtFunc(func(r *http.Request) (*http.Response, error) { + if got := r.Header.Get("User-Agent"); got != billingUAAgentString { + t.Errorf("billing UA = %q want %q", got, billingUAAgentString) + } + return jsonResp(200, `{"code":0,"data":{"response":{"data":{"accounts":[{"PackageName":"x","CycleCapacitySize":100,"CycleCapacityUsed":0}]}}}}`), nil + })}, + ChatBaseCN: "https://chat.example", + BillingBaseCN: "https://billing.example", + ClientName: "WorkBuddy", + UserAgent: billingUAAgentString, + } + if _, _, err := c3.UserResource(a); err != nil { + t.Errorf("userResource v3: %v", err) + } +} + +// TestBillingUA_WhenClientNameEmpty client_name 空 = 默认对齐官方桌面端: +// billing UA 单段 WorkBuddy/;显式 client_name="SaaS" 才不设 UA。 +func TestBillingUA_WhenClientNameEmpty(t *testing.T) { + a := &auth.Auth{AccessToken: "at", UID: "u1"} + var ua string + const fullResp = `{"code":0,"data":{"response":{"data":{"accounts":[{"PackageName":"x","CycleCapacitySize":100,"CycleCapacityUsed":0}]}}}}` + c := &Client{ + HTTP: &http.Client{Transport: rtFunc(func(r *http.Request) (*http.Response, error) { + ua = r.Header.Get("User-Agent") + return jsonResp(200, fullResp), nil + })}, + ChatBaseCN: "https://chat.example", + BillingBaseCN: "https://billing.example", + ClientVersion: "6.0.0", + } + if _, _, err := c.UserResource(a); err != nil { + t.Errorf("userResource: %v", err) + } + if ua != "axios/1.16.1" { + t.Errorf("billing UA = %q want axios/1.16.1 (billing 层走 axios,无品牌段)", ua) + } + if got := c.billingUA(a); got != "axios/1.16.1" { + t.Errorf("billingUA() = %q want axios/1.16.1", got) + } + // 显式 SaaS 还原旧行为(不设 UA)。 + c.ClientName = "SaaS" + if got := c.billingUA(a); got != "" { + t.Errorf("billingUA() SaaS = %q want empty", got) + } +} + +var _ = io.Discard diff --git a/internal/upstream/verify.go b/internal/upstream/verify.go new file mode 100644 index 0000000000000000000000000000000000000000..baddaec4f62e05e1aa37a3190300f68db22719e4 --- /dev/null +++ b/internal/upstream/verify.go @@ -0,0 +1,87 @@ +package upstream + +import ( + "errors" + "net/http" + + "github.com/misakano7545/workbuddy2api-panel/internal/auth" +) + +// VerifyVerdict 网关 401 的求证结论。 +// +// 为什么需要这个枚举(20261024 两次踩坑):网关 401 的响应体是 APISIX/openresty +// 的 HTML 页,**「token 真失效」与「瞬时拦截」的响应完全一样**,单看 401 分不出来。 +// 同一个坑在两处各踩了一次(chat 路径 issue #66、面板探活),故把判据收敛到这里, +// 任何新加的 401 处理都走同一套口径,不再各自发明。 +type VerifyVerdict int + +const ( + // VerifyAlive 会话仍有效:401 属瞬时拦截(风控 / 边缘抖动 / 并发限流),不该罚。 + VerifyAlive VerifyVerdict = iota + // VerifyDead 登录态确实失效:refresh 被上游应用层明确拒绝,需重登。 + VerifyDead + // VerifyInconclusive 无明确判词:网络 / 5xx / 429 / refresh 端点自身也被拦截。 + // 这种既不能判活也不能判死 —— 计入 session dead 就等于换个地方复发同一个误杀。 + VerifyInconclusive +) + +func (v VerifyVerdict) String() string { + switch v { + case VerifyAlive: + return "alive" + case VerifyDead: + return "dead" + default: + return "inconclusive" + } +} + +// SessionDeadButUsable 报告「refresh 判死,但账号此刻仍能用」。 +// +// refresh token 失效与账号不可用是两件事:AT 未过期时上游 chat 仍正常。2026-10-25 +// 生产实测(issue #83):29 个账号里 4 个 refresh 恒回 12153,AT 却还有 26~333 天, +// /v2/chat/completions 全 200。把这种号计 session dead 会在连续 3 次保活后永久禁用 +// 一个完全健康的账号,正是「面板一片橙色、对话却秒回」的成因。 +// +// 注意判据不是上游文案("Session doesn't have required client" 只是同一次失败的措辞, +// 同一账号重试就变成 "Invalid refresh token"),也不是 JWT 的 azp:实测 29 个账号 +// azp 全是 console,其中 25 个 plugin 源 refresh 正常。唯一稳定判据是 AT 是否还能用。 +// +// 只适用于「AT 尚未被上游拒绝」的路径(保活 / 余额探测 / 发请求前的预刷新):那些 +// 地方 refresh 失败只说明 RT 死了,AT 还能干活。chat 路径拿到网关 401 时 AT 已被 +// 上游拒过,那里 refresh 判死就该计死,不适用本函数。 +func SessionDeadButUsable(a *auth.Auth) bool { + return a != nil && !a.NeedsRefresh(0) +} + +// VerifySessionByRefresh 用 refresh 求证会话是否仍有效(网关 401 的唯一可靠判据)。 +// +// 判据: +// - refresh 成功 → VerifyAlive(会话活,401 只是那次被拦) +// - refresh 被应用层明确拒绝(4xx 业务) → VerifyDead(token 真失效) +// - 其它(网络错 / 5xx / 429 / refresh 端点自己也被 WAF 拦)→ VerifyInconclusive +// +// ⚠️ 第三条是关键:refresh 端点同样挂在 /v2/* 上,边缘拦截时它也回 HTML 页。 +// 把「refresh 也失败」一律当死号,就等于在同一层再误杀一次。 +// +// 调用方职责(本函数不做):成功时落盘(上游会轮换 RT,不落盘重启即真死)、 +// 按结论决定罚不罚。 +func (c *Client) VerifySessionByRefresh(a *auth.Auth) VerifyVerdict { + if c == nil || a == nil || a.RefreshTokenValue() == "" { + return VerifyInconclusive + } + err := c.RefreshToken(a) + if err == nil { + return VerifyAlive + } + var re *Error + if !errors.As(err, &re) { + return VerifyInconclusive // 传输层错误:没有判词 + } + // refresh 端点自身被拦截 / 上游抖动:都不是「token 失效」的证据。 + if re.Status >= 500 || re.Status == http.StatusTooManyRequests || + IsGatewayUnauthorized(re.Status, re.Msg) || IsWafBlocked(re.Status, re.Msg) { + return VerifyInconclusive + } + return VerifyDead +} diff --git a/internal/upstream/verify_test.go b/internal/upstream/verify_test.go new file mode 100644 index 0000000000000000000000000000000000000000..5ec4f44551a87adcba881c2a9746b5351fb0a126 --- /dev/null +++ b/internal/upstream/verify_test.go @@ -0,0 +1,113 @@ +package upstream + +import ( + "io" + "net/http" + "strings" + "testing" + "time" + + "github.com/misakano7545/workbuddy2api-panel/internal/auth" +) + +// VerifySessionByRefresh 的三分支判据。 +// +// 为什么值得测:网关 401 的「封禁 / 瞬时拦截 / 登录失效」三种成因,响应体完全一样 +// (APISIX HTML 页),只能靠 refresh 的结果区分。判错的代价是把健康号永久禁用 +// (本仓踩过两次:chat 路径 issue #66、面板探活)。 + +// verifyProbe 构造一个只处理 refresh 端点的假上游。 +type verifyProbe struct { + status int + body string + ct string +} + +func (v verifyProbe) client() *Client { + return &Client{ + ChatBaseCN: "https://fake.test", + HTTP: &http.Client{Transport: rtFunc(func(r *http.Request) (*http.Response, error) { + return &http.Response{ + StatusCode: v.status, + Header: http.Header{"Content-Type": []string{v.ct}}, + Body: io.NopCloser(strings.NewReader(v.body)), + }, nil + })}, + } +} + +func newAuthForVerify() *auth.Auth { + return &auth.Auth{UID: "u1", AccessToken: "at", RefreshToken: "rt", ExpiresAt: 9999999999} +} + +// TestVerifyAliveOnRefreshOK refresh 成功 → VerifyAlive(会话活,401 只是那次被拦)。 +func TestVerifyAliveOnRefreshOK(t *testing.T) { + c := verifyProbe{200, `{"code":0,"data":{"accessToken":"new","refreshToken":"new-rt","expiresIn":7200}}`, "application/json"}.client() + if got := c.VerifySessionByRefresh(newAuthForVerify()); got != VerifyAlive { + t.Fatalf("verdict = %v, want VerifyAlive", got) + } +} + +// TestVerifyDeadOnAppReject refresh 被应用层明确拒绝(invalid_grant)→ VerifyDead。 +func TestVerifyDeadOnAppReject(t *testing.T) { + c := verifyProbe{400, `{"error":"invalid_grant"}`, "application/json"}.client() + if got := c.VerifySessionByRefresh(newAuthForVerify()); got != VerifyDead { + t.Fatalf("verdict = %v, want VerifyDead", got) + } +} + +// TestVerifyInconclusiveOnGateway401 ⭐ 关键分支:refresh 端点**自己也回 401 HTML** +// (边缘拦截)时不得判死 —— 那是「拦截」不是「判词」。 +// +// 这条是两次误杀的同一个根因:把 refresh 的失败一律当死号,等于在同一层再杀一次。 +func TestVerifyInconclusiveOnGateway401(t *testing.T) { + html := "\r\n401 Authorization Required\r\n
openresty
" + c := verifyProbe{401, html, "text/html"}.client() + if got := c.VerifySessionByRefresh(newAuthForVerify()); got != VerifyInconclusive { + t.Fatalf("verdict = %v, want VerifyInconclusive(refresh 自己也被拦,没有判词)", got) + } +} + +// TestVerifyInconclusiveOn5xx 上游 5xx 不是 token 失效的证据。 +func TestVerifyInconclusiveOn5xx(t *testing.T) { + c := verifyProbe{503, "service unavailable", "text/plain"}.client() + if got := c.VerifySessionByRefresh(newAuthForVerify()); got != VerifyInconclusive { + t.Fatalf("verdict = %v, want VerifyInconclusive", got) + } +} + +// TestVerifyInconclusiveOn429 限流也不是 token 失效。 +func TestVerifyInconclusiveOn429(t *testing.T) { + c := verifyProbe{429, `{"error":"rate limit"}`, "application/json"}.client() + if got := c.VerifySessionByRefresh(newAuthForVerify()); got != VerifyInconclusive { + t.Fatalf("verdict = %v, want VerifyInconclusive", got) + } +} + +// TestSessionDeadButUsable 判据只看 AT 是否还有效,不看上游文案/azp(issue #83)。 +func TestSessionDeadButUsable(t *testing.T) { + future := &auth.Auth{UID: "u1", AccessToken: "at", ExpiresAt: time.Now().Add(26 * 24 * time.Hour).Unix()} + if !SessionDeadButUsable(future) { + t.Error("AT 还剩 26 天 → 应判定仍可用") + } + expired := &auth.Auth{UID: "u2", AccessToken: "at", ExpiresAt: 1} + if SessionDeadButUsable(expired) { + t.Error("AT 已过期 → 不可用,应计 session dead") + } + noExpiry := &auth.Auth{UID: "u3", AccessToken: "at"} // ExpiresAt=0:NeedsRefresh 为 true + if SessionDeadButUsable(noExpiry) { + t.Error("无过期时间 → 按需刷新语义视为不可用") + } + if SessionDeadButUsable(nil) { + t.Error("nil 应判 false") + } +} + +// TestVerifyInconclusiveWithoutRefreshToken 无 RT 时无从求证,不得盲判死。 +func TestVerifyInconclusiveWithoutRefreshToken(t *testing.T) { + a := &auth.Auth{UID: "u1", AccessToken: "at", ExpiresAt: 9999999999} + c := verifyProbe{200, "{}", "application/json"}.client() + if got := c.VerifySessionByRefresh(a); got != VerifyInconclusive { + t.Fatalf("verdict = %v, want VerifyInconclusive(无 RT 无法求证)", got) + } +} diff --git a/internal/upstream/videos.go b/internal/upstream/videos.go new file mode 100644 index 0000000000000000000000000000000000000000..03e4ac183e0ab78b3390d955031d208e9c9dbdec --- /dev/null +++ b/internal/upstream/videos.go @@ -0,0 +1,215 @@ +// videos.go 出视频 / 查任务:POST {chatBase}/v2/videos/generations 与 /v2/videos/tasks。 +// +// 协议来源:WorkBuddy 桌面端 VideoService(DSH 插件 src/video-gen.ts 注释标注 2026-10-25 +// 真机实测,二进制 WorkBuddy/resources/app.asar.unpacked/cli/dist/codebuddy-lite-wb.mjs), +// 并由本仓库 2026-11-04 直连 cn 池复核(minimax-video-h3 / kling-video-v3 各跑通一次): +// +// 提交 POST /v2/videos/generations +// +// {prompt, model, seconds, negative_prompt, watermark:true, +// image_url / last_image_url(图生视频、首尾帧), +// extra_parameters:{resolution, enable_audio, aspect_ratio(仅文生视频)}} +// → 信封 {code,msg,data},data 解包后形如 +// {"id":"1312831544-WandVideo-","status":"queued","created_at":1793801279, +// "request_id":""} +// +// 查询 POST /v2/videos/tasks {task_id} +// +// → data 解包后形如 +// {"id":..,"status":"completed","created_at":..,"completed_at":.., +// "data":[{"url":"https://.../xxx_0.mp4?q-signature=..."}], +// "usage":{"output_video_duration":4,"output_video_tokens":200000, +// "total_tokens":200000,"output_video_coefficient":1,"credit":57.14}, +// "size":"768P"} +// +// 两个容易踩错的点: +// - 任务 id 在**顶层**(信封 data 的 id),不是 data.data.id。插件侧看到的是完整信封的 +// data.id;网关侧 growthJSON 已经把信封拆掉,所以顶层 id 就是 task id——同一字段两种视角。 +// - 成品是 COS 签名直链(实测 q-sign-time 跨度 43200s ≈ 12h),与图片通道同款:网关只转发 +// URL,不转存字节。想让链接长期可用请客户端自己落盘。 +// +// 实测计费(2026-11-04,cn 池):minimax-video-h3 4s = 57.14 credit、size=768P、约 124s 出片; +// kling-video-v3 请求 4s 实际出 5s = 102.86 credit、回执不带 size、约 473s 出片(慢一个量级)。 +// 时长/模型越界由上游拒:400 code=14407「unsupported video duration: 1 seconds, +// supported range: 4-15 seconds」、「Video model [x] route config not found」;缺 prompt +// 也是上游拒(code=10001)。网关不做每模型区间校验,只做转发与账号处置。 +package upstream + +import ( + "encoding/json" + "net/http" + + "github.com/misakano7545/workbuddy2api-panel/internal/auth" +) + +// 视频通道(chatBase 域,与 images/growth 同 base 同头)。 +const ( + videoGenerationsPath = "/v2/videos/generations" + videoTasksPath = "/v2/videos/tasks" +) + +// VideoGenerations 提交出视频任务,返回上游信封(data.id 即任务 id)。 +func (c *Client) VideoGenerations(a *auth.Auth, body any) (json.RawMessage, error) { + return c.growthJSON(a, http.MethodPost, videoGenerationsPath, body) +} + +// VideoTask 查询视频任务:{task_id} → data.status / data[].url。 +// +// 任务只能被**提交它的账号**看到,故调用方必须传入同一账号(见 server 侧任务台账)。 +func (c *Client) VideoTask(a *auth.Auth, taskID string) (json.RawMessage, error) { + return c.growthJSON(a, http.MethodPost, videoTasksPath, map[string]any{"task_id": taskID}) +} + +// VideoTaskState 轮询回执的解析结果(宽容解析:上游缺字段按零值,不编造)。 +type VideoTaskState struct { + ID string + Status string // queued / running / completed / failed(原样保留,不归一化) + CreatedAt int64 + CompletedAt int64 + // URLs 成品地址(签名直链,completed 才有,可能多段)。 + URLs []string + // Size 分辨率档位(如 "768P";kling 回执不带)。 + Size string + // 用量:视频按 output_video_tokens 计费,credit 为实扣积分。 + Duration int64 + Tokens int64 + Coefficient float64 + Credit float64 + // ErrorText 上游失败原因(msg 或 error 字段原文)。 + ErrorText string +} + +// Done 报告是否终态(completed/failed,兼容历史拼写 succeeded/success)。 +func (s VideoTaskState) Done() bool { + switch s.Status { + case "completed", "failed", "succeeded", "success": + return true + } + return false +} + +// Succeeded 报告终态是否成功。 +func (s VideoTaskState) Succeeded() bool { + switch s.Status { + case "completed", "succeeded", "success": + return true + } + return false +} + +// ParseVideoTask 解析轮询回执(入参是 growthJSON 返回的、已解包的 data 原文)。 +// +// 宽容点:成品地址支持 data[].url(实测形态)与顶层 url/video_url;usage 缺失时全零 +// (调用方据此不记账)。 +func ParseVideoTask(raw []byte) VideoTaskState { + var st VideoTaskState + var env struct { + ID string `json:"id"` + TaskID string `json:"task_id"` + Status string `json:"status"` + CreatedAt int64 `json:"created_at"` + CompletedAt int64 `json:"completed_at"` + Size string `json:"size"` + URL string `json:"url"` + VideoURL string `json:"video_url"` + Msg string `json:"msg"` + Message string `json:"message"` + Error json.RawMessage `json:"error"` + Data []struct { + URL string `json:"url"` + } `json:"data"` + Usage struct { + Duration int64 `json:"output_video_duration"` + Tokens int64 `json:"output_video_tokens"` + Coefficient float64 `json:"output_video_coefficient"` + Credit float64 `json:"credit"` + } `json:"usage"` + } + if err := json.Unmarshal(raw, &env); err != nil { + return st + } + st.ID = env.ID + if st.ID == "" { + st.ID = env.TaskID + } + st.Status = env.Status + st.CreatedAt, st.CompletedAt = env.CreatedAt, env.CompletedAt + st.Size = env.Size + st.Duration = env.Usage.Duration + st.Tokens = env.Usage.Tokens + st.Coefficient = env.Usage.Coefficient + st.Credit = env.Usage.Credit + st.ErrorText = env.Msg + if st.ErrorText == "" { + st.ErrorText = env.Message + } + if st.ErrorText == "" && len(env.Error) > 0 { + // error 可能是字符串或对象({"message":...}):两种都取原文。 + var s string + if json.Unmarshal(env.Error, &s) == nil { + st.ErrorText = s + } else { + var obj struct { + Message string `json:"message"` + } + if json.Unmarshal(env.Error, &obj) == nil { + st.ErrorText = obj.Message + } + } + } + for _, d := range env.Data { + if d.URL != "" { + st.URLs = append(st.URLs, d.URL) + } + } + if len(st.URLs) == 0 { + if env.VideoURL != "" { + st.URLs = append(st.URLs, env.VideoURL) + } else if env.URL != "" { + st.URLs = append(st.URLs, env.URL) + } + } + return st +} + +// ParseVideoSubmit 从提交回执取 task id 与初始状态(顶层 id 优先,兼容 task_id 字段)。 +func ParseVideoSubmit(raw []byte) (taskID, status string) { + var env struct { + ID string `json:"id"` + TaskID string `json:"task_id"` + Status string `json:"status"` + } + if json.Unmarshal(raw, &env) != nil { + return "", "" + } + taskID = env.ID + if taskID == "" { + taskID = env.TaskID + } + return taskID, env.Status +} + +// videoRouteRealm 已实测的「视频模型 → 有路由的域」。 +// +// 与 imageRouteRealm 同一条教训:目录里出现的媒体模型不一定在本域有路由,列给客户端等于 +// 引诱它选一个必然 400 的模型。只写**实测过**的组合,未知模型照旧列出(不猜)。 +// +// 2026-11-04 实测(cn 池直连): +// +// cn:minimax-video-h3 4s → 200, credit 57.14, size 768P +// cn:kling-video-v3 4s → 200, credit 102.86(实际出 5s) +// cn:not-a-video-model → 400 code=14407「Video model [...] route config not found」 +// +// 2026-11-05 复测:minimax-video-h3 与 kling-video-v3 在 **cn / global 两池都有路由** +// (global:kling 时长下限 3s、global:minimax 4s,cn 都是 4s;global 出片落在 ap-hongkong +// COS,4s 768P = 27.4 credit)。所以当前没有「只在一个域可用」的视频模型; +// 出现单域模型时在这里写 model -> 唯一有路由的域,列表就自动只在那一域出现。 +// +// 必须是 nil 而不是 map[string]string{}:实测写成空字面量时,同包的 imageRouteRealm +// 在整个进程里读成空表(/v1/models 把 global 的 hy-image-3.5 列进 cn,三条路由断言 +// 全红),换成 nil 后复现不出。读 nil map 返回零值,语义与空表相同(= 无单域模型)。 +var videoRouteRealm map[string]string + +// videoDeadModels 上游已下架、两域都没有路由的视频模型(同 imageDeadModels 口径: +// 只写实测下架的;模型回来时删一行即可)。 +var videoDeadModels = map[string]bool{} diff --git a/internal/upstream/videos_test.go b/internal/upstream/videos_test.go new file mode 100644 index 0000000000000000000000000000000000000000..7bc336e723af420f2e56ed73aa748a6da46218f8 --- /dev/null +++ b/internal/upstream/videos_test.go @@ -0,0 +1,109 @@ +package upstream + +import "testing" + +// 回执样例来自 2026-11-04 直连实测(cn 池 minimax-video-h3 4s / kling-video-v3 4s)。 +const ( + videoSubmitRaw = `{"id":"1312831544-WandVideo-9f2c","status":"queued","created_at":1793801279,"request_id":"8f0c"}` + videoTaskRaw = `{"id":"1312831544-WandVideo-9f2c","status":"completed","created_at":1793801279,` + + `"completed_at":1793801403,"data":[{"url":"https://aigc-output-video.cos.example/x_0.mp4?q-signature=abc"}],` + + `"usage":{"output_tokens":200000,"output_video_tokens":200000,"total_tokens":200000,` + + `"output_video_duration":4,"output_video_coefficient":1,"credit":57.14},"size":"768P"}` + videoTaskFailRaw = `{"id":"t-fail","status":"failed","msg":"content blocked by safety checker"}` +) + +func TestParseVideoSubmit(t *testing.T) { + id, status := ParseVideoSubmit([]byte(videoSubmitRaw)) + if id != "1312831544-WandVideo-9f2c" { + t.Fatalf("任务 id 应在顶层(不是 data.id):%q", id) + } + if status != "queued" { + t.Fatalf("status=%q want queued", status) + } + // 兼容个别网关形态的 task_id 字段 + if id, _ := ParseVideoSubmit([]byte(`{"task_id":"t-2","status":"pending"}`)); id != "t-2" { + t.Fatalf("task_id 字段应兼容,got %q", id) + } + // 坏 JSON 不能 panic,也不能编 id + if id, status := ParseVideoSubmit([]byte(``)); id != "" || status != "" { + t.Fatalf("坏 JSON 应回空:%q %q", id, status) + } +} + +func TestParseVideoTaskDone(t *testing.T) { + st := ParseVideoTask([]byte(videoTaskRaw)) + if st.Status != "completed" || !st.Done() || !st.Succeeded() { + t.Fatalf("终态解析错:%+v", st) + } + if len(st.URLs) != 1 || st.URLs[0] != "https://aigc-output-video.cos.example/x_0.mp4?q-signature=abc" { + t.Fatalf("成品 URL 解析错:%v", st.URLs) + } + if st.Credit != 57.14 || st.Tokens != 200000 || st.Duration != 4 || st.Size != "768P" { + t.Fatalf("用量解析错:%+v", st) + } + if st.CompletedAt != 1793801403 { + t.Fatalf("completed_at=%d", st.CompletedAt) + } +} + +func TestParseVideoTaskFailedAndRunning(t *testing.T) { + fail := ParseVideoTask([]byte(videoTaskFailRaw)) + if !fail.Done() || fail.Succeeded() { + t.Fatalf("failed 应 Done 但不算成功:%+v", fail) + } + if fail.ErrorText == "" { + t.Fatalf("failed 应带出上游原因:%+v", fail) + } + running := ParseVideoTask([]byte(`{"id":"t","status":"running"}`)) + if running.Done() { + t.Fatal("running 不是终态") + } + // 顶层 url 形态(宽容解析) + alt := ParseVideoTask([]byte(`{"id":"t","status":"completed","video_url":"https://x/v.mp4"}`)) + if len(alt.URLs) != 1 || alt.URLs[0] != "https://x/v.mp4" { + t.Fatalf("顶层 video_url 应识别:%v", alt.URLs) + } +} + +// TestGenerationModelsVideoRouteFilter 视频模型与图片同一条口径:只在实测有路由的域列出, +// 别的域不列(列出来等于引诱客户端选一个必然 400 的模型)。 +func TestGenerationModelsVideoRouteFilter(t *testing.T) { + c := New() + c.stashGenerationModels("cn", []ModelInfo{ + {ID: "minimax-video-h3", Tags: []string{"text-to-video", "image-to-video"}}, + {ID: "kling-video-v3", Tags: []string{"text-to-video", "image-to-video"}}, + {ID: "hunyuan-image-alpha", Tags: []string{"text-to-image"}}, + {ID: "hy-image-3.5", Tags: []string{"text-to-image"}}, + {ID: "unknown-video-model", Tags: []string{"text-to-video"}}, + }) + cn := map[string]string{} + for _, m := range c.GenerationModels("cn") { + cn[m.ID] = m.GenerationKind + } + if cn["minimax-video-h3"] != "video" || cn["kling-video-v3"] != "video" { + t.Fatalf("cn 应列出两个实测视频模型:%v", cn) + } + if cn["hunyuan-image-alpha"] != "image" { + t.Fatalf("cn 的出图模型不能被视频逻辑弄丢:%v", cn) + } + if _, ok := cn["hy-image-3.5"]; ok { + t.Fatalf("hy-image-3.5 只有 global 路由,不该出现在 cn:%v", cn) + } + if cn["unknown-video-model"] != "video" { + t.Fatalf("未知视频模型照旧列出(不猜路由):%v", cn) + } + + c.stashGenerationModels("global", []ModelInfo{ + {ID: "minimax-video-h3", Tags: []string{"text-to-video"}}, + {ID: "hy-image-3.5", Tags: []string{"text-to-image"}}, + }) + // 2026-11-05 复测推翻旧前提:minimax-video-h3 在 global 池也有路由 + // (global 提交 4s 真出片,27.4 credit),所以 global 目录列出它是对的。 + global := map[string]string{} + for _, m := range c.GenerationModels("global") { + global[m.ID] = m.GenerationKind + } + if global["minimax-video-h3"] != "video" { + t.Fatalf("global 也有 minimax 路由,应列出:%v", global) + } +} diff --git a/internal/upstream/webagent.go b/internal/upstream/webagent.go new file mode 100644 index 0000000000000000000000000000000000000000..99cc44065f4c76c4e41d64b0d2bc20ed173d8dd2 --- /dev/null +++ b/internal/upstream/webagent.go @@ -0,0 +1,505 @@ +// webagent.go 国际版「网页通道」每日活跃:把一条 console/as 云 agent 会话真正跑起来。 +// +// 为什么需要(2026-10-29 实测 + issue #111 复核):国际版官方每日活跃奖励只认 +// **跑完的网页 agent 会话**: +// +// - 桌面身分发 /v2/chat/completions:不计数(能点亮 growth 连登,但拿不到每日积分); +// - 只发 /v2/report:同样不计数(同上,连登会涨、积分不动); +// - 只建会话不接沙箱:会话永远停在 CREATING/working,零输出,也不算一次有效对话 +// (上游 issue #90 抓到的就是这个坑)。 +// +// 网页端真实链路(本文件实现的全部): +// +// POST {base}/console/as/conversations/ 建会话 → data.id(只是排队) +// GET .../{id}/session 取沙箱 link / token / sessionId / cwd +// GET Accept: text/event-stream SSE 通道,响应头 Acp-Connection-Id +// POST Acp-Connection-Id: JSON-RPC:initialize → session/load +// → session/set_model → session/prompt +// GET .../{id} 轮询 data.status 到 completed +// POST .../{id}/stop(失败再 /delete) 收尾,释放上游的活跃会话名额 +// +// 三个**必须照抄客户端**的细节,每一条写错都会静默失效: +// +// 1. ACP 的 Authorization 用 /session 返回的**沙箱 token**,不是账号的 access token。 +// 用账号 token 一律 401 `12801:鉴权失败`——SSE 那一步照样 200 并给出 +// Acp-Connection-Id,只有真正的 JSON-RPC 请求才暴露鉴权错,很容易被误判成 +// 「链路搭好了只是没输出」。 +// 2. ACP 的 JSON-RPC 走沙箱 link(带会话 token),UA 沿用 web 形态;但**建会话 / +// 取 session / 轮询状态这三个 console 接口不是浏览器身份**——2026-10-30 国内 +// 5.9.3 真机实测它们是桌面端 RPC 三段式 UA + 无 Origin/Referer(见 webReq)。 +// 3. 上游对每个账号同时存在的活跃会话有硬上限(10 条,超了 429/code 10105)。 +// 每条会话跑完必须 stop/delete,否则每天漏一条,攒满就再也建不出会话。 +package upstream + +import ( + "bufio" + "bytes" + "context" + "encoding/json" + "fmt" + "io" + "net/http" + "sort" + "strings" + "time" + + "github.com/misakano7545/workbuddy2api-panel/internal/auth" + "github.com/misakano7545/workbuddy2api-panel/internal/session" +) + +const ( + // webConversationsPath console/as 会话集合(结尾斜杠是上游要求,缺了会 404)。 + webConversationsPath = "/console/as/conversations/" + // webConversationOrigin 建会话时必须带的口径值:网页端 app 身份。 + // 桌面端自己建的是 legacy_workbuddy_local(本机会话),两者在上游是不同通道。 + webConversationOrigin = "workbuddy-app" + // webDailyModel 每日活跃用的模型:deepseek-v4.1-flash 在国际版倍率 x0.00 + // (2026-10-29 目录实测),跑一轮不扣积分——打卡不能自己烧钱。 + webDailyModel = "deepseek-v4.1-flash" + // webDailyPrompt 会话内容。取最短的寒暄:网页端历史里留着它也不刺眼。 + webDailyPrompt = "Hi" + // webActiveConversationLimit 上游单账号活跃会话硬上限(超限 429/code 10105)。 + webActiveConversationLimit = 10 + // webPollInterval 轮询会话状态的间隔(实测一轮「Hi」约 7 秒跑完)。 + webPollInterval = 3 * time.Second + // webTurnTimeout 单轮从建会话到 completed 的总预算。 + webTurnTimeout = 120 * time.Second + // webSessionWait 等沙箱 link/token 就绪的上限:刚建会话时会话状态可能还是 + // CREATING,/session 偶尔先回空 link,重试几次比直接判失败更接近真实时序。 + webSessionWait = 15 * time.Second +) + +// acpProtocolVersion ACP 协议版本(客户端 initialize 报 1)。 +const acpProtocolVersion = 1 + +// WebSession 一条网页会话的沙箱接入信息(GET .../{id}/session 的 data)。 +type WebSession struct { + Link string `json:"link"` + Token string `json:"token"` + SessionID string `json:"sessionId"` + Cwd string `json:"cwd"` +} + +// WebTurnResult 一轮网页会话的执行结果(供调度器落日志)。 +type WebTurnResult struct { + Conversation string + Status string + Events int // session/update 通知条数 + Chunks int // agent_message_chunk 段数(>0 = 真的说了话) + Elapsed time.Duration + // SetModelFailed session/set_model 失败:本轮仍跑完了,但用的不是请求的模型。 + // 单独记一个旗标而不是把 Events 弄成负数——调用方要能同时读事件数与这个状态。 + SetModelFailed bool +} + +// webReq 构造 console/as 网页通道请求:桌面端 RPC 身份 + Bearer + X-User-Id。 +// +// 2026-10-30 国内 5.9.3 真机复核(/console/as/conversations/、/console/as/projects/*、 +// /console/as/conversation-sync/*、/console/as/support/scenes):这条「网页通道」在 +// 5.9.3 上**根本不是浏览器身份**——UA 是桌面端 RPC 三段式,**没有 Origin / Referer** +// (全部 242 条 console/as 请求无一携带),另带 X-Product / X-Request-ID / X-Domain。 +// +// 旧实现按「网页前端」发了浏览器 UA + Origin + Referer,等于把两个前端指纹糊成一个 +// (两边都不像)。注意本文件后段 SSE / ACP JSON-RPC 两条走的是沙箱 link +// (另一个服务,带会话 token),仍沿用 globalWebUA——本轮抓包未覆盖该 link, +// 不做无证据改动。 +func (c *Client) webReq(ctx context.Context, a *auth.Auth, method, url string, body any) (*http.Request, error) { + var rdr io.Reader + if body != nil { + raw, err := json.Marshal(body) + if err != nil { + return nil, err + } + rdr = bytes.NewReader(raw) + } + req, err := http.NewRequestWithContext(ctx, method, url, rdr) + if err != nil { + return nil, err + } + req.Header.Set("User-Agent", c.rpcUAFor(a)) + req.Header.Set("Accept", "application/json, text/plain, */*") + req.Header.Set("X-Product", "SaaS") + req.Header.Set("X-Request-ID", session.NewTraceID()) + req.Header.Set("X-Domain", c.chatHost(a)) + req.Header.Set("Authorization", "Bearer "+a.AccessTokenValue()) + if a.UID != "" { + req.Header.Set("X-User-Id", a.UID) + } + if body != nil { + req.Header.Set("Content-Type", "application/json") + } + return req, nil +} + +// webConversationsURL 会话集合 URL(base 按 realm:国际版 workbuddy.ai / codebuddy.ai, +// 国内版 workbuddy.cn——CN 也有同一套 console/as 端点)。 +func (c *Client) webConversationsURL(a *auth.Auth) string { + return c.chatBase(a) + webConversationsPath +} + +// webJSON 发一次网页通道 JSON 请求并把信封解到 out(可为 nil)。 +// 非 2xx 与业务 code!=0 都返回 *Error,错误里带上游 message 便于定位 phase。 +func (c *Client) webJSON(ctx context.Context, a *auth.Auth, method, url string, body any, out any) error { + req, err := c.webReq(ctx, a, method, url, body) + if err != nil { + return err + } + resp, err := c.do(req, a, false) + if err != nil { + return err + } + defer resp.Body.Close() + raw, err := io.ReadAll(io.LimitReader(resp.Body, 1<<20)) + if err != nil { + return fmt.Errorf("read body: %w", err) + } + if resp.StatusCode < 200 || resp.StatusCode >= 300 { + // 网页通道的失败**不进 pool 冷却状态机**:它是每日活跃的旁路调用,与 chat + // 通道的账号健康无关(同 /v1/models 拉取失败不 NoteError 的理由)。故这里用 + // 普通 error 而不是 *Error——后者会被上层当成账号级信号去做冷却/禁号。 + return fmt.Errorf("web %s %s: HTTP %d: %s", method, url, resp.StatusCode, truncate(string(raw), 160)) + } + if out == nil { + return nil + } + var env struct { + Code int `json:"code"` + Msg string `json:"msg"` + Data json.RawMessage `json:"data"` + } + if err := json.Unmarshal(raw, &env); err != nil { + return fmt.Errorf("web %s %s parse: %w", method, url, err) + } + if env.Code != 0 { + return fmt.Errorf("web %s %s: code=%d msg=%s", method, url, env.Code, env.Msg) + } + if len(env.Data) == 0 { + return nil + } + return json.Unmarshal(env.Data, out) +} + +// CreateWebConversation 建一条网页会话,返回会话 id(上游只**排队**,不代表已跑)。 +// +// 请求体照抄网页端:prompt + model + conversationOrigin + plugins(weixinpay 是网页端 +// 建会话时固定带的内置插件,缺了不影响跑但形态与客户端不一致)。model 只写进会话 +// manifest,真正决定这一轮用哪个模型的是后面的 session/set_model。 +func (c *Client) CreateWebConversation(ctx context.Context, a *auth.Auth, prompt, model string) (string, error) { + if strings.TrimSpace(prompt) == "" { + prompt = webDailyPrompt + } + if strings.TrimSpace(model) == "" { + model = webDailyModel + } + body := map[string]any{ + "prompt": prompt, + "model": model, + "conversationOrigin": webConversationOrigin, + "plugins": []map[string]string{{"name": "weixinpay", "marketplace": "codebuddy-builtin"}}, + } + var data struct { + ID string `json:"id"` + } + if err := c.webJSON(ctx, a, http.MethodPost, c.webConversationsURL(a), body, &data); err != nil { + return "", err + } + if strings.TrimSpace(data.ID) == "" { + return "", fmt.Errorf("web conversation create: 上游未返回会话 id") + } + return data.ID, nil +} + +// WebConversationSession 取沙箱接入信息;link 为空时短暂重试(刚建会话时上游 +// 会话状态可能仍是 CREATING,沙箱还没分配)。 +func (c *Client) WebConversationSession(ctx context.Context, a *auth.Auth, id string) (WebSession, error) { + url := c.webConversationsURL(a) + id + "/session" + deadline := time.Now().Add(webSessionWait) + var last WebSession + for { + var s WebSession + err := c.webJSON(ctx, a, http.MethodGet, url, nil, &s) + if err == nil && s.Link != "" && s.Token != "" { + return s, nil + } + if err == nil { + last = s + err = fmt.Errorf("沙箱未就绪(link/token 为空)") + } + if time.Now().After(deadline) { + return last, fmt.Errorf("web session: %w", err) + } + select { + case <-ctx.Done(): + return last, ctx.Err() + case <-time.After(time.Second): + } + } +} + +// WebConversationStatus 读会话当前状态(completed = 这一轮真的跑完了)。 +func (c *Client) WebConversationStatus(ctx context.Context, a *auth.Auth, id string) (string, error) { + var data struct { + Status string `json:"status"` + } + if err := c.webJSON(ctx, a, http.MethodGet, c.webConversationsURL(a)+id, nil, &data); err != nil { + return "", err + } + return data.Status, nil +} + +// webConversationAction 对会话执行收尾动作(stop / delete)。 +// +// 收尾失败不上抛:一轮已经跑完的活跃不能因为清理失败被改判成失败。上游对同一 +// 会话重复 stop 是幂等的(状态已经是 completed 也回 code 0)。 +func (c *Client) webConversationAction(ctx context.Context, a *auth.Auth, id, action string) error { + if id == "" { + return nil + } + url := c.webConversationsURL(a) + id + "/" + action + return c.webJSON(ctx, a, http.MethodPost, url, map[string]any{}, nil) +} + +// StopWebConversation 结束会话(状态 working → completed,释放活跃名额)。 +func (c *Client) StopWebConversation(ctx context.Context, a *auth.Auth, id string) error { + return c.webConversationAction(ctx, a, id, "stop") +} + +// DeleteWebConversation 删掉会话(失败轮次没保留价值,免得网页端历史堆满「Hi」)。 +func (c *Client) DeleteWebConversation(ctx context.Context, a *auth.Auth, id string) error { + return c.webConversationAction(ctx, a, id, "delete") +} + +// IsWebConversationLimit 判定建会话被「活跃会话已达上限」拒绝(code 10105)。 +// 上游对单账号同时存在的活跃会话有硬上限(webActiveConversationLimit 条)。 +func IsWebConversationLimit(err error) bool { + return err != nil && strings.Contains(err.Error(), "10105") +} + +// WebConversationRow 会话列表里的一条(只取清理要用的字段)。 +type WebConversationRow struct { + ID string `json:"id"` + Name string `json:"name"` + Status string `json:"status"` + CreatedAt string `json:"createdAt"` +} + +// webActiveStatuses 占活跃名额的会话状态(小写比较:本通道实测回的是大写 +// CREATING/working,写法不统一)。 +var webActiveStatuses = map[string]bool{"working": true, "creating": true, "pending": true} + +// ListWebConversations 列账号的网页会话(第一页,够清理用)。 +// +// shortcut: 只取第一页 50 条、字段形状取自 webchat 端抓包(conversations 数组 + +// id/name/status/createdAt),/console/as/ 路径未逐字段实测;形状不符时清理会 +// 静默返回 0 条(不误删),升级时机是第一次真在生产 global 号上触发 10105。 +func (c *Client) ListWebConversations(ctx context.Context, a *auth.Auth) ([]WebConversationRow, error) { + url := c.webConversationsURL(a) + "?page=1&pageSize=50" + var data struct { + Conversations []WebConversationRow `json:"conversations"` + } + if err := c.webJSON(ctx, a, http.MethodGet, url, nil, &data); err != nil { + return nil, err + } + return data.Conversations, nil +} + +// PruneWebConversations 撞 10105 后的自救:停掉最旧的活跃会话,把活跃条数降到 keep +// 以内,返回实际停掉的条数。 +// +// 上限是**账号级**的,不能按任务名/前缀分组清理(跨任务累计到 10 条时按前缀永远 +// 清不掉)。会话只在确认处于活跃状态时才停,completed 的不动。 +func (c *Client) PruneWebConversations(ctx context.Context, a *auth.Auth, keep int) (int, error) { + rows, err := c.ListWebConversations(ctx, a) + if err != nil { + return 0, err + } + active := make([]WebConversationRow, 0, len(rows)) + for _, r := range rows { + if webActiveStatuses[strings.ToLower(strings.TrimSpace(r.Status))] && r.ID != "" { + active = append(active, r) + } + } + // createdAt 是 RFC3339 一类的可比较字符串,升序即最旧在前。 + sort.Slice(active, func(i, j int) bool { return active[i].CreatedAt < active[j].CreatedAt }) + stopped := 0 + for _, r := range active { + if len(active)-stopped <= keep { + break + } + if err := c.StopWebConversation(ctx, a, r.ID); err != nil { + continue // 单条失败不影响继续清下一条 + } + stopped++ + } + return stopped, nil +} + +// RunWebAgentTurn 接上沙箱把这一轮跑完:ACP 四步 + 轮询状态到 completed。 +// +// 只有「status 变成 completed」才算成功——SSE 收到 session/endTurn 也在里面判一次 +// 提前收工的依据,但最终以 console 状态为准(hub 的判据同口径:只建会话不接沙箱、 +// 或接了沙箱没等它跑完,上游都不计为一次有效对话)。 +func (c *Client) RunWebAgentTurn(ctx context.Context, a *auth.Auth, id string, sess WebSession, prompt, model string) (WebTurnResult, error) { + res := WebTurnResult{Conversation: id} + started := time.Now() + if strings.TrimSpace(prompt) == "" { + prompt = webDailyPrompt + } + if strings.TrimSpace(model) == "" { + model = webDailyModel + } + if sess.SessionID == "" { + sess.SessionID = id + } + if sess.Cwd == "" { + sess.Cwd = "/workspace" + } + + // SSE 通道:用 chatHTTP(无总时长上限,共享连接池)。首字节前由 ctx 约束。 + streamReq, err := http.NewRequestWithContext(ctx, http.MethodGet, sess.Link, nil) + if err != nil { + return res, err + } + streamReq.Header.Set("Accept", "text/event-stream") + streamReq.Header.Set("Authorization", "Bearer "+sess.Token) + streamReq.Header.Set("User-Agent", globalWebUA) + stream, err := c.do(streamReq, a, true) + if err != nil { + return res, fmt.Errorf("acp sse: %w", err) + } + defer stream.Body.Close() + if stream.StatusCode != http.StatusOK { + return res, fmt.Errorf("acp sse: HTTP %d", stream.StatusCode) + } + connID := stream.Header.Get("Acp-Connection-Id") + if connID == "" { + return res, fmt.Errorf("acp sse: 响应头没有 Acp-Connection-Id") + } + + // 读 SSE:只统计,不解析 update 内容(打卡不关心说了什么)。 + // 流结束(或 ctx 取消)时 goroutine 自然退出,不阻塞主流程。 + done := make(chan struct{}) + go func() { + defer close(done) + sc := bufio.NewScanner(stream.Body) + sc.Buffer(make([]byte, 0, 64*1024), 1<<20) + for sc.Scan() { + line := strings.TrimSpace(sc.Text()) + if !strings.HasPrefix(line, "data:") { + continue + } + payload := strings.TrimSpace(strings.TrimPrefix(line, "data:")) + if payload == "" || payload == "[DONE]" { + continue + } + var msg struct { + Method string `json:"method"` + Params struct { + Update struct { + SessionUpdate string `json:"sessionUpdate"` + } `json:"update"` + } `json:"params"` + } + if json.Unmarshal([]byte(payload), &msg) != nil { + continue + } + switch msg.Method { + case "session/update": + res.Events++ + if msg.Params.Update.SessionUpdate == "agent_message_chunk" { + res.Chunks++ + } + case "session/endTurn": + res.Events++ + } + } + }() + + rpc := func(rid int, method string, params any) error { + return c.acpPost(ctx, a, sess, connID, rid, method, params) + } + if err := rpc(1, "initialize", map[string]any{ + "protocolVersion": acpProtocolVersion, + "clientCapabilities": map[string]any{ + "fs": map[string]any{"readTextFile": false, "writeTextFile": false}, + "terminal": false, + }, + }); err != nil { + return res, fmt.Errorf("acp initialize: %w", err) + } + if err := rpc(2, "session/load", map[string]any{ + "sessionId": sess.SessionID, "cwd": sess.Cwd, "mcpServers": []any{}, + }); err != nil { + return res, fmt.Errorf("acp session/load: %w", err) + } + // session/set_model 是 ACP 扩展方法,**非致命**:失败时这一轮仍会跑完,只是 + // 可能落到账号默认档(国际版默认 Auto,按付费模型计费)——所以失败要能看到 + // 日志里的原因,但不能因此把整轮判失败。 + if err := rpc(3, "session/set_model", map[string]any{"sessionId": sess.SessionID, "modelId": model}); err != nil { + res.SetModelFailed = true + } + if err := rpc(4, "session/prompt", map[string]any{ + "sessionId": sess.SessionID, + "prompt": []map[string]string{{"type": "text", "text": prompt}}, + }); err != nil { + return res, fmt.Errorf("acp session/prompt: %w", err) + } + + // 轮询到 completed:上游跑完这一轮才会把状态从 working 改掉。 + deadline := time.Now().Add(webTurnTimeout) + for { + st, err := c.WebConversationStatus(ctx, a, id) + if err == nil { + res.Status = st + switch strings.ToLower(st) { + case "completed": + res.Elapsed = time.Since(started) + return res, nil + case "failed", "error", "deleted": + res.Elapsed = time.Since(started) + return res, fmt.Errorf("web conversation status=%s", st) + } + } + if time.Now().After(deadline) { + res.Elapsed = time.Since(started) + return res, fmt.Errorf("web conversation 在 %s 内没有跑完(status=%s)", webTurnTimeout, res.Status) + } + select { + case <-ctx.Done(): + res.Elapsed = time.Since(started) + return res, ctx.Err() + case <-time.After(webPollInterval): + } + } +} + +// acpPost 发一条 ACP JSON-RPC 请求。 +// +// 注意 Authorization 用的是**沙箱 token**(sess.Token),不是账号 access token: +// 用账号 token 会 401 `12801:鉴权失败`,而 SSE 通道照样 200——这是本实现第一次 +// 落地时踩的坑(见文件头第 1 条)。 +func (c *Client) acpPost(ctx context.Context, a *auth.Auth, sess WebSession, connID string, rid int, method string, params any) error { + body, err := json.Marshal(map[string]any{"jsonrpc": "2.0", "id": rid, "method": method, "params": params}) + if err != nil { + return err + } + req, err := http.NewRequestWithContext(ctx, http.MethodPost, sess.Link, bytes.NewReader(body)) + if err != nil { + return err + } + req.Header.Set("Content-Type", "application/json") + req.Header.Set("Accept", "application/json, text/event-stream") + req.Header.Set("Acp-Connection-Id", connID) + req.Header.Set("Authorization", "Bearer "+sess.Token) + req.Header.Set("User-Agent", globalWebUA) + resp, err := c.do(req, a, false) + if err != nil { + return err + } + defer resp.Body.Close() + raw, _ := io.ReadAll(io.LimitReader(resp.Body, 1<<20)) + if resp.StatusCode < 200 || resp.StatusCode >= 300 { + return fmt.Errorf("HTTP %d: %s", resp.StatusCode, truncate(strings.TrimSpace(string(raw)), 120)) + } + return nil +} diff --git a/internal/upstream/webagent_test.go b/internal/upstream/webagent_test.go new file mode 100644 index 0000000000000000000000000000000000000000..694ab0688a14e554cf13b593179c4f4f47b0b27b --- /dev/null +++ b/internal/upstream/webagent_test.go @@ -0,0 +1,220 @@ +// webagent_test.go 网页通道(console/as 云 agent 会话)的协议钉。 +// +// 三个钉对应三条「写错就静默失效」的细节(见 webagent.go 文件头): +// +// 1. ACP 的 Authorization 必须是 /session 返回的**沙箱 token**; +// 用账号 access token 会 401 `12801:鉴权失败`,而 SSE 那步照样 200—— +// 最容易误判成「链路通了只是没输出」。 +// 2. 网页通道用浏览器身份(Chromium UA + Origin/Referer /app + X-User-Id), +// 不是桌面端 RPC 指纹(WorkBuddy UA + X-Requested-With、无 Origin)。 +// 3. 刚建会话时沙箱可能还没分配(link/token 为空),要短暂重试而不是判死。 +package upstream + +import ( + "context" + "encoding/json" + "fmt" + "io" + "net/http" + "net/http/httptest" + "strings" + "sync" + "testing" + + "github.com/misakano7545/workbuddy2api-panel/internal/auth" +) + +type acpFake struct { + srv *httptest.Server + mu sync.Mutex + auth []string + ua []string + referer []string + origin []string + methods []string + bodies []string + sessHit int + status string +} + +func newACPFake(t *testing.T) *acpFake { + t.Helper() + f := &acpFake{status: "completed"} + f.srv = httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { + f.mu.Lock() + f.ua = append(f.ua, r.Header.Get("User-Agent")) + f.referer = append(f.referer, r.Header.Get("Referer")) + f.origin = append(f.origin, r.Header.Get("Origin")) + f.mu.Unlock() + switch { + case r.URL.Path == "/acp": + if r.Method == http.MethodGet { + w.Header().Set("Content-Type", "text/event-stream") + w.Header().Set("Acp-Connection-Id", "conn-1") + w.WriteHeader(200) + fmt.Fprint(w, "data: {\"method\":\"session/update\",\"params\":{\"update\":{\"sessionUpdate\":\"agent_message_chunk\"}}}\n\n") + return + } + raw, _ := io.ReadAll(r.Body) + var msg struct { + Method string `json:"method"` + } + _ = json.Unmarshal(raw, &msg) + f.mu.Lock() + f.auth = append(f.auth, r.Header.Get("Authorization")) + f.methods = append(f.methods, msg.Method) + f.bodies = append(f.bodies, string(raw)) + f.mu.Unlock() + w.WriteHeader(202) + return + case strings.HasSuffix(r.URL.Path, "/session"): + f.mu.Lock() + f.sessHit++ + hit := f.sessHit + f.mu.Unlock() + if hit == 1 { + // 第一次:沙箱还没分配(真实时序里刚建会话时会这样)。 + fmt.Fprint(w, `{"code":0,"data":{"sessionId":"c1","cwd":"/workspace"}}`) + return + } + fmt.Fprintf(w, `{"code":0,"data":{"link":%q,"token":"sandbox-token","sessionId":"c1","cwd":"/workspace"}}`, f.srv.URL+"/acp") + return + case r.URL.Path == "/console/as/conversations/": + f.mu.Lock() + f.bodies = append(f.bodies, readAllString(r.Body)) + f.mu.Unlock() + fmt.Fprint(w, `{"code":0,"data":{"id":"c1"}}`) + return + default: + f.mu.Lock() + st := f.status + f.mu.Unlock() + fmt.Fprintf(w, `{"code":0,"data":{"status":%q}}`, st) + return + } + })) + t.Cleanup(f.srv.Close) + return f +} + +func readAllString(r io.Reader) string { + raw, _ := io.ReadAll(r) + return string(raw) +} + +func webTestAuth() *auth.Auth { + return &auth.Auth{UID: "u-web", AccessToken: "app-token", ExpiresAt: 9999999999} +} + +// TestCreateWebConversationUsesWebIdentity 建会话必须用网页身份的请求头与请求体。 +// +// 反向代价:混用桌面端指纹(WorkBuddy UA + X-Requested-With)会让上游把两个前端 +// 的流量糊成一个,两边都不像——这是本仓库反复踩过的坑(见 headers.go 的注释史)。 +func TestCreateWebConversationUsesWebIdentity(t *testing.T) { + f := newACPFake(t) + c := &Client{HTTP: f.srv.Client(), ChatBaseCN: f.srv.URL} + a := webTestAuth() + + id, err := c.CreateWebConversation(context.Background(), a, "Hi", "deepseek-v4.1-flash") + if err != nil { + t.Fatalf("create: %v", err) + } + if id != "c1" { + t.Fatalf("id=%q want c1", id) + } + f.mu.Lock() + defer f.mu.Unlock() + if len(f.ua) == 0 || !strings.HasPrefix(f.ua[0], "WorkBuddy/") { + t.Errorf("UA=%q want 桌面端 RPC UA(真机 console/as 不是浏览器身份)", f.ua) + } + if f.origin[0] != "" { + t.Errorf("Origin=%q want 空(真机 242 条 console/as 请求无一携带)", f.origin[0]) + } + if f.referer[0] != "" { + t.Errorf("Referer=%q want 空(同上)", f.referer[0]) + } + var body map[string]any + if err := json.Unmarshal([]byte(f.bodies[0]), &body); err != nil { + t.Fatalf("body parse: %v (%q)", err, f.bodies[0]) + } + if body["conversationOrigin"] != webConversationOrigin { + t.Errorf("conversationOrigin=%v want %s(桌面端自己建的是 legacy_workbuddy_local,"+ + "不是网页通道,不算每日活跃)", body["conversationOrigin"], webConversationOrigin) + } + if _, ok := body["plugins"]; !ok { + t.Error("缺 plugins:网页端建会话固定带 weixinpay 内置插件") + } +} + +// TestRunWebAgentTurnUsesSandboxToken ACP 每一步都必须用沙箱 token 鉴权。 +func TestRunWebAgentTurnUsesSandboxToken(t *testing.T) { + f := newACPFake(t) + c := &Client{HTTP: f.srv.Client(), ChatBaseCN: f.srv.URL} + a := webTestAuth() + + sess, err := c.WebConversationSession(context.Background(), a, "c1") + if err != nil { + t.Fatalf("session(首次空 link 应重试成功): %v", err) + } + if sess.Token != "sandbox-token" { + t.Fatalf("token=%q", sess.Token) + } + res, err := c.RunWebAgentTurn(context.Background(), a, "c1", sess, "Hi", "deepseek-v4.1-flash") + if err != nil { + t.Fatalf("turn: %v", err) + } + if res.Status != "completed" || res.Chunks == 0 { + t.Fatalf("res=%+v want completed 且 chunks>0", res) + } + f.mu.Lock() + defer f.mu.Unlock() + if len(f.auth) != 4 { + t.Fatalf("ACP 请求数=%d want 4(initialize/load/set_model/prompt): %v", len(f.auth), f.methods) + } + for i, got := range f.auth { + if got != "Bearer sandbox-token" { + t.Errorf("%s Authorization=%q want \"Bearer sandbox-token\"(账号 token 会 401 12801)", f.methods[i], got) + } + } + want := []string{"initialize", "session/load", "session/set_model", "session/prompt"} + for i, m := range want { + if f.methods[i] != m { + t.Errorf("第 %d 个 ACP 方法=%q want %q(顺序固定)", i+1, f.methods[i], m) + } + } +} + +// TestWebConversationSessionRetriesSandbox 刚建会话时 link/token 可能为空: +// 必须重试到就绪,而不是当场判失败(真实时序里会话状态还是 CREATING)。 +func TestWebConversationSessionRetriesSandbox(t *testing.T) { + f := newACPFake(t) + c := &Client{HTTP: f.srv.Client(), ChatBaseCN: f.srv.URL} + if _, err := c.WebConversationSession(context.Background(), webTestAuth(), "c1"); err != nil { + t.Fatalf("session: %v", err) + } + f.mu.Lock() + defer f.mu.Unlock() + if f.sessHit < 2 { + t.Fatalf("session 查询次数=%d want >=2(首次空 link 要重试)", f.sessHit) + } +} + +// TestRunWebAgentTurnFailsOnFailedStatus 会话状态 failed 时必须立刻返回错误, +// 不能一直等到超时(调度器是遍历型任务,卡住会拖住整轮)。 +func TestRunWebAgentTurnFailsOnFailedStatus(t *testing.T) { + f := newACPFake(t) + f.status = "failed" + c := &Client{HTTP: f.srv.Client(), ChatBaseCN: f.srv.URL} + a := webTestAuth() + sess, err := c.WebConversationSession(context.Background(), a, "c1") + if err != nil { + t.Fatalf("session: %v", err) + } + _, err = c.RunWebAgentTurn(context.Background(), a, "c1", sess, "Hi", "deepseek-v4.1-flash") + if err == nil { + t.Fatal("status=failed 必须返回错误") + } + if !strings.Contains(err.Error(), "failed") { + t.Errorf("错误信息应带上游状态: %v", err) + } +} diff --git a/internal/usage/rollup_cap_test.go b/internal/usage/rollup_cap_test.go new file mode 100644 index 0000000000000000000000000000000000000000..e6582a81186a9b333fb14a9b8a7d8d4bef44e69a --- /dev/null +++ b/internal/usage/rollup_cap_test.go @@ -0,0 +1,44 @@ +package usage + +import ( + "fmt" + "testing" + "time" +) + +// TestRollupEnforcesBucketCap 桶数硬上限此前是空转:Start 超限时调的 Rollup 只折 90 天 +// 前的小时桶,异常流量下新桶全在保留窗口内 → 一个也折不掉。现在超限时从最旧的小时桶 +// 逐个折,直到回到上限内;折叠无损(请求数不变),到龄折叠的细粒度口径不变。 +func TestRollupEnforcesBucketCap(t *testing.T) { + old := maxBuckets + maxBuckets = 10 + defer func() { maxBuckets = old }() + + r := New("") + now := time.Now() + for m := 0; m < 3; m++ { + for h := 0; h < 10; h++ { // 3 个模型 × 近 10 小时,全在 hourlyKeep 窗口内 + r.Add(now.Add(-time.Duration(h)*time.Hour), "cn", "u1", fmt.Sprintf("m%d", m), + Delta{PromptTokens: 1, HasPromptTokens: true}, true) + } + } + if got := len(r.buckets); got != 30 { + t.Fatalf("前置条件:应累积 30 个小时桶,实际 %d", got) + } + + r.Rollup(now) + if got := len(r.buckets); got > maxBuckets { + t.Fatalf("桶数硬上限未生效:%d 桶(上限 %d),守卫空转", got, maxBuckets) + } + if got := r.Snapshot(0, nil).Totals.Requests; got != 30 { + t.Fatalf("折叠必须无损:请求数 = %d, want 30", got) + } + // 幂等:再折一次不应改变总量,也不应超上限。 + r.Rollup(now) + if got := len(r.buckets); got > maxBuckets { + t.Fatalf("二次折叠仍超上限:%d", got) + } + if got := r.Snapshot(0, nil).Totals.Requests; got != 30 { + t.Fatalf("二次折叠后请求数 = %d, want 30(幂等被破坏)", got) + } +} diff --git a/internal/usage/usage.go b/internal/usage/usage.go index 40bd8213053aca0669091a658326eeb7e3cf9883..20a64c07a80fb51185ffa46826f2adf94ed12d8d 100644 --- a/internal/usage/usage.go +++ b/internal/usage/usage.go @@ -1,795 +1,855 @@ -// Package usage 记录并聚合逐请求 token 用量,供面板「用量」视图展示。 -// -// 与 internal/pool 的 TokenUsage 的区别: -// - pool 的 TokenUsage 是**每账号一个累计计数器**,只保留总量与「最近一次」, -// 没有时间维度,也无法按模型/时间下钻; -// - 本包按 (时间片, realm, uid, model, rate) 分桶累计,因此可以出「今天各模型各用了多少」 -// 「这一小时 prompt 涨得多快」这类问题,且能长期保留。 -// -// 保留策略(分片粒度自动降级,总量因此有界): -// - 近 hourlyKeep 小时内:小时桶(细粒度,看尖峰) -// - 更早:折叠为日桶,**永久保留**(看长期趋势) -// -// 落盘:data/usage.json,原子替换 + 防抖刷新(默认 30s),重启不丢。 -// 桶数上界 ≈ 账号数 × 模型数 × (hourlyKeep + 已过天数),实测单桶约 90 字节。 -package usage - -import ( - "encoding/json" - "fmt" - "log" - "os" - "path/filepath" - "sort" - "strings" - "sync" - "time" -) - -// hourlyKeep 小时桶的保留时长;超出后折叠为日桶。 -const hourlyKeep = 90 * 24 * time.Hour - -// flushInterval 防抖落盘间隔。 -const flushInterval = 30 * time.Second - -// maxBuckets 桶数硬上限。超过时立即触发一次折叠,避免异常流量把内存/文件撑爆。 -const maxBuckets = 400_000 - -// hourLayout / dayLayout 分片键的时间格式(本地时区,与用户直觉一致)。 -const ( - hourLayout = "2006-01-02T15" - dayLayout = "2006-01-02" -) - -// fileVersion 是 usage.json 的当前格式版本。版本 2 增加积分观测字段,版本 3 -// 增加模型生效倍率分区,版本 4 增加前缀缓存命中/未命中累计; -// 旧版本缺失字段按零值加载,旧数据不会丢弃。 -const fileVersion = 4 - -// bucket 一个 (时间片, realm, uid, model, rate) 的累计量。 -// JSON 字段名刻意取短,因为桶数量会随时间增长。 -type bucket struct { - Scope string `json:"s"` // "h:2006-01-02T15" 或 "d:2006-01-02" - Realm string `json:"r"` // cn / global - UID string `json:"u"` // 账号 uid - Model string `json:"m"` // 上游裸模型名 - Rate string `json:"x,omitempty"` // 请求时生效积分倍率(规范化数值;旧桶为空) - Req int64 `json:"q"` // 请求数(含失败) - Err int64 `json:"e"` // 失败数 - PT int64 `json:"p"` // prompt tokens - CT int64 `json:"c"` // completion tokens - TT int64 `json:"t"` // total tokens(上游给什么用什么的合计) - LatMs int64 `json:"l"` // 延迟累计(ms) - LatN int64 `json:"ln"` // 延迟样本数 - TPS float64 `json:"v"` // 吐字速率累计 - TPSN int64 `json:"vn"` // 速率样本数 - CR float64 `json:"cr,omitempty"` // usage.credit 累计(仅明确存在的观测) - CRN int64 `json:"cn,omitempty"` // usage.credit 样本数(区分缺字段与真实 0) - CRT int64 `json:"ct,omitempty"` // 同时具备 credit 与 token 的 Token 合计 - CH int64 `json:"ch,omitempty"` // 前缀缓存命中 token 累计(上游回该维度才累计) - CM int64 `json:"cm,omitempty"` // 前缀缓存未命中 token 累计 -} - -// file 落盘结构。 -type file struct { - Version int `json:"version"` - Saved string `json:"saved"` - Buckets []bucket `json:"buckets"` -} - -// Recorder 并发安全的用量记录器。 -type Recorder struct { - mu sync.Mutex - path string - buckets map[string]*bucket // key: scope|realm|uid|model|rate - dirty bool - started time.Time - - stopOnce sync.Once - stop chan struct{} - done chan struct{} -} - -// New 创建记录器。path 为空时禁用落盘(纯内存,测试用)。 -func New(path string) *Recorder { - r := &Recorder{ - path: path, - buckets: make(map[string]*bucket), - started: time.Now(), - stop: make(chan struct{}), - done: make(chan struct{}), - } - if path != "" { - if err := r.load(); err != nil { - log.Printf("[usage] 读取 %s 失败(从零开始): %v", path, err) - } - } - return r -} - -// Start 启动后台防抖落盘与折叠。Stop 前一直运行。 -func (r *Recorder) Start() { - go func() { - defer close(r.done) - t := time.NewTicker(flushInterval) - defer t.Stop() - for { - select { - case <-r.stop: - r.flush(true) - return - case <-t.C: - r.mu.Lock() - n := len(r.buckets) - r.mu.Unlock() - if n > maxBuckets { - r.Rollup(time.Now()) - } - r.flush(false) - } - } - }() -} - -// Stop 停止后台循环并做最后一次落盘。 -func (r *Recorder) Stop() { - r.stopOnce.Do(func() { close(r.stop) }) - <-r.done -} - -// Delta 一次请求尝试的用量增量(与 pool.TokenUsageDelta 同形,避免包间依赖)。 -type Delta struct { - PromptTokens int64 - HasPromptTokens bool - CompletionTokens int64 - HasCompletion bool - TotalTokens int64 - HasTotal bool - Credit float64 - HasCredit bool - ModelRate string - // CacheHitTokens / CacheMissTokens 前缀缓存命中/未命中观测(issue #92)。 - HasCacheTokens bool - CacheHitTokens int64 - CacheMissTokens int64 - LatencyMs int64 - HasLatency bool - TokensPerSecond float64 - HasTPS bool -} - -// Add 记录一次请求尝试。 -// -// ok=false 表示该次尝试失败(传输错误 / 上游 >=400 / 解析失败)。失败尝试通常 -// 没有 usage,但**仍要计入请求数与失败数**——重试放大正是靠这一列才看得出来。 -func (r *Recorder) Add(now time.Time, realm, uid, model string, d Delta, ok bool) { - if r == nil { - return - } - if realm == "" { - realm = "cn" - } - if model == "" { - model = "(unknown)" - } - scope := "h:" + now.Format(hourLayout) - key := scope + "|" + realm + "|" + uid + "|" + model + "|" + d.ModelRate - - r.mu.Lock() - defer r.mu.Unlock() - - b := r.buckets[key] - if b == nil { - b = &bucket{Scope: scope, Realm: realm, UID: uid, Model: model, Rate: d.ModelRate} - r.buckets[key] = b - } - b.Req++ - if !ok { - b.Err++ - } - if d.HasPromptTokens { - b.PT += d.PromptTokens - } - if d.HasCompletion { - b.CT += d.CompletionTokens - } - if d.HasTotal { - b.TT += d.TotalTokens - } else if d.HasPromptTokens || d.HasCompletion { - // 上游没给 total:用 pt+ct 兜底,保证总量口径连续。 - b.TT += d.PromptTokens + d.CompletionTokens - } - if d.HasCredit { - b.CR += d.Credit - b.CRN++ - // 比例只使用同一次请求同时具备 credit 与 token 的样本,避免把 - // 仅 token 的旧记录或仅 credit 的观测混进分母。 - if d.HasTotal { - b.CRT += d.TotalTokens - } else if d.HasPromptTokens || d.HasCompletion { - b.CRT += d.PromptTokens + d.CompletionTokens - } - } - if d.HasCacheTokens { - b.CH += d.CacheHitTokens - b.CM += d.CacheMissTokens - } - if d.HasLatency { - b.LatMs += d.LatencyMs - b.LatN++ - } - if d.HasTPS { - b.TPS += d.TokensPerSecond - b.TPSN++ - } - r.dirty = true -} - -// Rollup 把超出 hourlyKeep 的小时桶折叠为日桶(按本地日历日)。 -// 幂等:同一小时反复折叠不会重复计数(先累加再删源桶)。 -func (r *Recorder) Rollup(now time.Time) { - if r == nil { - return - } - cutoff := now.Add(-hourlyKeep) - - r.mu.Lock() - defer r.mu.Unlock() - - type move struct{ from, to string } - var moves []move - for k, b := range r.buckets { - if !strings.HasPrefix(b.Scope, "h:") { - continue - } - ts, err := time.ParseInLocation(hourLayout, strings.TrimPrefix(b.Scope, "h:"), time.Local) - if err != nil || !ts.Before(cutoff) { - continue - } - day := "d:" + ts.Format(dayLayout) - moves = append(moves, move{from: k, to: day + "|" + b.Realm + "|" + b.UID + "|" + b.Model + "|" + b.Rate}) - } - for _, m := range moves { - src := r.buckets[m.from] - if src == nil { - continue - } - dst := r.buckets[m.to] - if dst == nil { - cp := *src - cp.Scope = strings.SplitN(m.to, "|", 2)[0] - dst = &cp - r.buckets[m.to] = dst - } else { - dst.Req += src.Req - dst.Err += src.Err - dst.PT += src.PT - dst.CT += src.CT - dst.TT += src.TT - dst.LatMs += src.LatMs - dst.LatN += src.LatN - dst.TPS += src.TPS - dst.TPSN += src.TPSN - dst.CR += src.CR - dst.CRN += src.CRN - dst.CRT += src.CRT - dst.CH += src.CH - dst.CM += src.CM - } - delete(r.buckets, m.from) - } - if len(moves) > 0 { - r.dirty = true - log.Printf("[usage] 折叠 %d 个小时桶为日桶(保留 %v 细粒度)", len(moves), hourlyKeep) - } -} - -// ---------------------------------------------------------------- 持久化 ---- - -func (r *Recorder) load() error { - raw, err := os.ReadFile(r.path) - if err != nil { - if os.IsNotExist(err) { - return nil - } - return err - } - var f file - if err := json.Unmarshal(raw, &f); err != nil { - return err - } - for i := range f.Buckets { - b := f.Buckets[i] - r.buckets[b.Scope+"|"+b.Realm+"|"+b.UID+"|"+b.Model+"|"+b.Rate] = &b - } - log.Printf("[usage] 已恢复 %d 个用量桶(%s)", len(r.buckets), r.path) - return nil -} - -func (r *Recorder) flush(force bool) { - if r == nil || r.path == "" { - return - } - r.mu.Lock() - if !r.dirty && !force { - r.mu.Unlock() - return - } - snap := file{Version: fileVersion, Saved: time.Now().Format(time.RFC3339), Buckets: make([]bucket, 0, len(r.buckets))} - for _, b := range r.buckets { - snap.Buckets = append(snap.Buckets, *b) - } - r.dirty = false - r.mu.Unlock() - - raw, err := json.Marshal(snap) - if err != nil { - log.Printf("[usage] 序列化失败: %v", err) - return - } - if err := os.MkdirAll(filepath.Dir(r.path), 0o755); err != nil { - log.Printf("[usage] 建目录失败: %v", err) - return - } - tmp := r.path + ".tmp" - if err := os.WriteFile(tmp, raw, 0o600); err != nil { - log.Printf("[usage] 写临时文件失败: %v", err) - return - } - if err := os.Rename(tmp, r.path); err != nil { - log.Printf("[usage] 原子替换失败: %v", err) - } -} - -// Save 立即落盘(面板「刷新」或关闭前调用)。 -func (r *Recorder) Save() { r.flush(true) } - -// ---------------------------------------------------------------- 聚合 ---- - -// Agg 一组累计量。 -type Agg struct { - Requests int64 `json:"requests"` - Errors int64 `json:"errors"` - PromptTokens int64 `json:"prompt_tokens"` - CompletionTok int64 `json:"completion_tokens"` - TotalTokens int64 `json:"total_tokens"` - Credits float64 `json:"credits"` - CreditSamples int64 `json:"credit_samples"` - CreditTokens int64 `json:"credit_tokens"` - CreditsPer1MTokens float64 `json:"credits_per_1m_tokens"` - CacheHitTokens int64 `json:"cache_hit_tokens,omitempty"` - CacheMissTokens int64 `json:"cache_miss_tokens,omitempty"` - CacheHitRate float64 `json:"cache_hit_rate,omitempty"` - AvgLatencyMs float64 `json:"avg_latency_ms"` - AvgTPS float64 `json:"avg_tokens_per_second"` -} - -// aggAcc 是聚合过程中的累加器:Agg 只放已算好的结果,均值需要样本数才能 -// 正确加权(不能对每桶的均值再取平均),所以样本数留在这里。 -type aggAcc struct { - Agg - latSum int64 - latSamples int64 - tpsSum float64 - tpsSamples int64 -} - -func (g *aggAcc) add(b *bucket) { - g.Requests += b.Req - g.Errors += b.Err - g.PromptTokens += b.PT - g.CompletionTok += b.CT - g.TotalTokens += b.TT - g.Credits += b.CR - g.CreditSamples += b.CRN - g.CreditTokens += b.CRT - g.CacheHitTokens += b.CH - g.CacheMissTokens += b.CM - g.latSum += b.LatMs - g.latSamples += b.LatN - g.tpsSum += b.TPS - g.tpsSamples += b.TPSN -} - -func (g *aggAcc) finish() Agg { - a := g.Agg - if g.latSamples > 0 { - a.AvgLatencyMs = float64(g.latSum) / float64(g.latSamples) - } - if g.tpsSamples > 0 { - a.AvgTPS = g.tpsSum / float64(g.tpsSamples) - } - if g.CreditTokens > 0 { - a.CreditsPer1MTokens = g.Credits / float64(g.CreditTokens) * 1_000_000 - } - if total := g.CacheHitTokens + g.CacheMissTokens; total > 0 { - a.CacheHitRate = float64(g.CacheHitTokens) / float64(total) * 100 - } - return a -} - -// KeyedAgg 按某个维度聚合的一行。 -type KeyedAgg struct { - Key string `json:"key"` - Realm string `json:"realm,omitempty"` - Extra string `json:"extra,omitempty"` // 账号行放昵称 - Agg -} - -// Point 时序上的一个点。 -type Point struct { - T string `json:"t"` - Scope string `json:"scope"` // "hour" | "day" - Agg -} - -// CreditAgg 积分扣除统计的一行。Key 在账号维度是 UID,在模型维度是裸模型名; -// Rate 仅模型维度使用;比例分母只统计与 credit 同时存在的 Token 样本。 -type CreditAgg struct { - Key string `json:"key"` - Realm string `json:"realm,omitempty"` - Nickname string `json:"nickname,omitempty"` - Rate string `json:"rate,omitempty"` - Requests int64 `json:"requests"` - Credits float64 `json:"credits"` - CreditSamples int64 `json:"credit_samples"` - CreditTokens int64 `json:"credit_tokens"` - CreditsPer1MTokens float64 `json:"credits_per_1m_tokens"` - CacheHitTokens int64 `json:"cache_hit_tokens,omitempty"` - CacheMissTokens int64 `json:"cache_miss_tokens,omitempty"` - CacheHitRate float64 `json:"cache_hit_rate,omitempty"` -} - -type creditAcc struct { - CreditAgg -} - -func (a *creditAcc) add(b *bucket) { - a.Requests += b.Req - a.Credits += b.CR - a.CreditSamples += b.CRN - a.CreditTokens += b.CRT - a.CacheHitTokens += b.CH - a.CacheMissTokens += b.CM -} - -func (a *creditAcc) finish() CreditAgg { - out := a.CreditAgg - if a.CreditTokens > 0 { - out.CreditsPer1MTokens = a.Credits / float64(a.CreditTokens) * 1_000_000 - } - if total := a.CacheHitTokens + a.CacheMissTokens; total > 0 { - out.CacheHitRate = float64(a.CacheHitTokens) / float64(total) * 100 - } - return out -} - -// Snapshot 面板一次拉取的全部用量视图数据。 -type Snapshot struct { - Totals Agg `json:"totals"` - ByRealm []KeyedAgg `json:"by_realm"` - ByAccount []KeyedAgg `json:"by_account"` - ByModel []KeyedAgg `json:"by_model"` - Series []Point `json:"series"` - CreditByAccount []CreditAgg `json:"credit_by_account"` - CreditByModel []CreditAgg `json:"credit_by_model"` - Buckets int `json:"buckets"` - FileBytes int64 `json:"file_bytes"` - Since string `json:"since,omitempty"` - // WindowFrom/WindowTo 本次实际生效的统计区间(本地时间,RFC3339),供面板 - // 回显口径——「自定义」区间下用户必须能确认服务端到底按哪段算的。 - // 空串 = 该侧不设界(全部历史 / 到今天为止)。 - WindowFrom string `json:"window_from,omitempty"` - WindowTo string `json:"window_to,omitempty"` - Generated string `json:"generated"` -} - -// Window 用量统计窗口。三种口径按优先级解析(见 bounds): -// - From/To 任一非零 → 显式区间 [From, To](To 零值 = 不设上界) -// - 否则 Hours>0 → 滚动窗口:当前整点往回 Hours-1 小时 -// - 否则 → 全部历史 -// -// 为什么显式区间用「桶起点落在 [From, To] 内」判定而不是求交集:小时桶的粒度 -// 就是一小时,用户选到 14:00 时把 14:00 这一小时的桶算进来符合直觉;同时这也 -// 让 Hours 口径与历史行为逐位一致(原实现就是 ts.Before(from) 即跳过)。 -type Window struct { - Hours int - From time.Time - To time.Time -} - -// bounds 解析出实际生效的 [from, to];零值表示该侧不设界。 -func (w Window) bounds() (time.Time, time.Time) { - if !w.From.IsZero() || !w.To.IsZero() { - return w.From, w.To - } - if w.Hours <= 0 { - return time.Time{}, time.Time{} - } - h := w.Hours - if h > 24*60 { - h = 24 * 60 - } - return time.Now().Truncate(time.Hour).Add(-time.Duration(h-1) * time.Hour), time.Time{} -} - -// bucketTime 把桶 scope 解析成本地时间;脏 scope 返回 false(不进任何口径)。 -func bucketTime(scope string) (time.Time, bool) { - if strings.HasPrefix(scope, "h:") { - ts, err := time.ParseInLocation(hourLayout, strings.TrimPrefix(scope, "h:"), time.Local) - return ts, err == nil - } - ts, err := time.ParseInLocation(dayLayout, strings.TrimPrefix(scope, "d:"), time.Local) - return ts, err == nil -} - -// Snapshot 聚合**所选窗口内**的桶,产出面板一次拉取的全部用量视图数据。 -// -// hours>0:窗口 = [当前整点-(hours-1)小时, now],卡片汇总/按域/按账号/按模型/ -// 时序**全部**按同一窗口口径统计——切窗口时所有数字随之变化(曾长期是"卡片为 -// 全部历史累计、hours 只改时序分片"的口径,界面上被读成"筛选没生效",已废弃)。 -// 小时桶按整点入窗;日桶(Rollup 折叠出的长期数据)按日起点入窗,故小时窗口 -// 天然不含更早的日桶。 -// hours<=0:全部历史(含已折叠日桶),供「全部历史」选项看长期趋势。 -// -// nicks 是 uid→昵称映射,仅用于展示。 -func (r *Recorder) Snapshot(hours int, nicks map[string]string) Snapshot { - return r.SnapshotWithRates(hours, nicks, nil) -} - -// SnapshotWithRates 与 Snapshot 相同,但允许为缺少历史倍率的旧桶提供当前 -// 模型倍率回填。currentRate 返回空串时该行按“未知倍率”聚合,不伪造价格。 -func (r *Recorder) SnapshotWithRates(hours int, nicks map[string]string, currentRate func(realm, model string) string) Snapshot { - return r.SnapshotWindow(Window{Hours: hours}, nicks, currentRate) -} - -// SnapshotWindow 聚合**所选窗口内**的桶,产出面板一次拉取的全部用量视图数据。 -// -// 窗口语义见 Window:滚动窗口(Hours)/ 显式区间(From-To)/ 全部历史。卡片汇总、 -// 按域、按账号、按模型、时序**全部**按同一窗口口径统计——切窗口时所有数字随之变化 -// (曾长期是"卡片为全部历史累计、hours 只改时序分片"的口径,界面上被读成"筛选没 -// 生效",已废弃)。小时桶按整点入窗;日桶(Rollup 折叠出的长期数据)按日起点入窗, -// 故小时窗口天然不含更早的日桶。 -func (r *Recorder) SnapshotWindow(w Window, nicks map[string]string, currentRate func(realm, model string) string) Snapshot { - if r == nil { - return Snapshot{Generated: time.Now().Format(time.RFC3339)} - } - from, to := w.bounds() - explicit := !w.From.IsZero() || !w.To.IsZero() - windowed := !from.IsZero() || !to.IsZero() - - r.mu.Lock() - bs := make([]bucket, 0, len(r.buckets)) - for _, b := range r.buckets { - bs = append(bs, *b) - } - r.mu.Unlock() - - var total aggAcc - realmAgg := map[string]*aggAcc{} - acctAgg := map[string]*aggAcc{} - acctRealm := map[string]string{} - modelAgg := map[string]*aggAcc{} - hourSeries := map[string]*aggAcc{} - daySeries := map[string]*aggAcc{} - creditAcctAgg := map[string]*creditAcc{} - creditModelAgg := map[string]*creditAcc{} - rateCache := map[string]string{} - - // 数据起点(全库最早分片):不受窗口影响,表示"记录自何时开始"。scope 字典序 - // 即时间序(同前缀内同格式排序;"d:" 恒早于 "h:"——日桶只来自 90 天前的小时折叠)。 - since := "" - matched := 0 - for i := range bs { - b := &bs[i] - if b.Scope < since || since == "" { - since = b.Scope - } - if windowed { - ts, ok := bucketTime(b.Scope) - // 解析失败的脏桶不进窗口聚合(也不该出现在任何口径里)。 - if !ok { - continue - } - if !from.IsZero() && ts.Before(from) { - continue - } - if !to.IsZero() && ts.After(to) { - continue - } - } - matched++ - total.add(b) - - if realmAgg[b.Realm] == nil { - realmAgg[b.Realm] = &aggAcc{} - } - realmAgg[b.Realm].add(b) - - if acctAgg[b.UID] == nil { - acctAgg[b.UID] = &aggAcc{} - } - acctAgg[b.UID].add(b) - // 一个账号只属于一个 realm,这里记下来供前端展示「域」列; - // keyed() 的 Realm 字段默认是空的(它按 key 分组,不知道 realm)。 - if acctRealm[b.UID] == "" { - acctRealm[b.UID] = b.Realm - } - - if modelAgg[b.Model] == nil { - modelAgg[b.Model] = &aggAcc{} - } - modelAgg[b.Model].add(b) - - if strings.HasPrefix(b.Scope, "h:") { - scope := strings.TrimPrefix(b.Scope, "h:") - if hourSeries[scope] == nil { - hourSeries[scope] = &aggAcc{} - } - hourSeries[scope].add(b) - } else { - scope := strings.TrimPrefix(b.Scope, "d:") - if daySeries[scope] == nil { - daySeries[scope] = &aggAcc{} - } - daySeries[scope].add(b) - } - if b.CRN > 0 { - ca := creditAcctAgg[b.UID] - if ca == nil { - ca = &creditAcc{CreditAgg: CreditAgg{ - Key: b.UID, - Realm: b.Realm, - Nickname: nicks[b.UID], - }} - creditAcctAgg[b.UID] = ca - } - ca.add(b) - - model := canonicalUsageModel(b.Model) - rate := b.Rate - if rate == "" && currentRate != nil { - cacheKey := b.Realm + "\x00" + model - if cached, ok := rateCache[cacheKey]; ok { - rate = cached - } else { - rate = currentRate(b.Realm, model) - rateCache[cacheKey] = rate - } - } - modelKey := model + "\x00" + rate - cm := creditModelAgg[modelKey] - if cm == nil { - cm = &creditAcc{CreditAgg: CreditAgg{Key: model, Rate: rate}} - creditModelAgg[modelKey] = cm - } - cm.add(b) - } - } - - snap := Snapshot{ - Totals: total.finish(), - ByRealm: keyed(realmAgg, func(k string) (string, string) { - return k, "" - }), - ByAccount: keyed(acctAgg, func(k string) (string, string) { - return k, nicks[k] - }), - ByModel: keyed(modelAgg, func(k string) (string, string) { return k, "" }), - CreditByAccount: creditKeyed(creditAcctAgg), - CreditByModel: creditKeyed(creditModelAgg), - Buckets: matched, - Generated: time.Now().Format(time.RFC3339), - } - for i := range snap.ByAccount { - snap.ByAccount[i].Realm = acctRealm[snap.ByAccount[i].Key] - } - - // 日点(升序)+ 小时点(升序)拼成一条连续时序。 - dayKeys := make([]string, 0, len(daySeries)) - for k := range daySeries { - dayKeys = append(dayKeys, k) - } - sort.Strings(dayKeys) - for _, k := range dayKeys { - snap.Series = append(snap.Series, Point{T: k, Scope: "day", Agg: daySeries[k].finish()}) - } - hourKeys := make([]string, 0, len(hourSeries)) - for k := range hourSeries { - hourKeys = append(hourKeys, k) - } - sort.Strings(hourKeys) - for _, k := range hourKeys { - snap.Series = append(snap.Series, Point{T: k, Scope: "hour", Agg: hourSeries[k].finish()}) - } - - if r.path != "" { - if fi, err := os.Stat(r.path); err == nil { - snap.FileBytes = fi.Size() - } - } - // since 去掉 scope 前缀("h:2026-09-16T13" → "2026-09-16T13")给前端展示; - // 无任何桶时保持空(无数据不伪造起点)。 - snap.Since = strings.TrimPrefix(strings.TrimPrefix(since, "h:"), "d:") - // 回显实际生效的区间:**仅显式区间口径**。滚动窗口由 hours 表达(前端自己 - // 知道选的是哪个预设),全部历史没有区间——两者回显都会变成噪音。 - if explicit { - if !w.From.IsZero() { - snap.WindowFrom = w.From.Format(time.RFC3339) - } - if !w.To.IsZero() { - snap.WindowTo = w.To.Format(time.RFC3339) - } - } - return snap -} - -func canonicalUsageModel(model string) string { - model = strings.TrimSpace(model) - for _, prefix := range []string{"cn:", "global:"} { - if strings.HasPrefix(model, prefix) { - model = strings.TrimPrefix(model, prefix) - break - } - } - if model == "" { - return "(unknown)" - } - return model -} - -func creditKeyed(m map[string]*creditAcc) []CreditAgg { - out := make([]CreditAgg, 0, len(m)) - for _, v := range m { - out = append(out, v.finish()) - } - sort.Slice(out, func(i, j int) bool { - if out[i].Credits != out[j].Credits { - return out[i].Credits > out[j].Credits - } - if out[i].CreditTokens != out[j].CreditTokens { - return out[i].CreditTokens > out[j].CreditTokens - } - if out[i].Key != out[j].Key { - return out[i].Key < out[j].Key - } - return out[i].Rate < out[j].Rate - }) - return out -} - -func keyed(m map[string]*aggAcc, label func(string) (string, string)) []KeyedAgg { - out := make([]KeyedAgg, 0, len(m)) - for k, v := range m { - key, extra := label(k) - out = append(out, KeyedAgg{Key: key, Extra: extra, Agg: v.finish()}) - } - // 按总量降序;同量按 key 升序,保证输出稳定(前端 diff 不抖)。 - sort.Slice(out, func(i, j int) bool { - if out[i].TotalTokens != out[j].TotalTokens { - return out[i].TotalTokens > out[j].TotalTokens - } - if out[i].Requests != out[j].Requests { - return out[i].Requests > out[j].Requests - } - return out[i].Key < out[j].Key - }) - return out -} - -// Describe 返回一行人类可读的占用摘要(启动日志用)。 -func (r *Recorder) Describe() string { - if r == nil { - return "disabled" - } - r.mu.Lock() - n := len(r.buckets) - r.mu.Unlock() - var sz int64 - if r.path != "" { - if fi, err := os.Stat(r.path); err == nil { - sz = fi.Size() - } - } - return fmt.Sprintf("%d buckets, file %d bytes", n, sz) -} +// Package usage 记录并聚合逐请求 token 用量,供面板「用量」视图展示。 +// +// 与 internal/pool 的 TokenUsage 的区别: +// - pool 的 TokenUsage 是**每账号一个累计计数器**,只保留总量与「最近一次」, +// 没有时间维度,也无法按模型/时间下钻; +// - 本包按 (时间片, realm, uid, model, rate) 分桶累计,因此可以出「今天各模型各用了多少」 +// 「这一小时 prompt 涨得多快」这类问题,且能长期保留。 +// +// 保留策略(分片粒度自动降级,总量因此有界): +// - 近 hourlyKeep 小时内:小时桶(细粒度,看尖峰) +// - 更早:折叠为日桶,**永久保留**(看长期趋势) +// +// 落盘:data/usage.json,原子替换 + 防抖刷新(默认 30s),重启不丢。 +// 桶数上界 ≈ 账号数 × 模型数 × (hourlyKeep + 已过天数),实测单桶约 90 字节。 +package usage + +import ( + "encoding/json" + "errors" + "fmt" + "io/fs" + "log" + "os" + "path/filepath" + "sort" + "strings" + "sync" + "time" + + "github.com/misakano7545/workbuddy2api-panel/internal/safefile" +) + +// hourlyKeep 小时桶的保留时长;超出后折叠为日桶。 +const hourlyKeep = 90 * 24 * time.Hour + +// flushInterval 防抖落盘间隔。 +const flushInterval = 30 * time.Second + +// maxBuckets 桶数硬上限。超过时立即触发一次折叠,避免异常流量把内存/文件撑爆。 +// var 而非 const:测试要把它调小才能覆盖该守卫。 +var maxBuckets = 400_000 + +// hourLayout / dayLayout 分片键的时间格式(本地时区,与用户直觉一致)。 +const ( + hourLayout = "2006-01-02T15" + dayLayout = "2006-01-02" +) + +// fileVersion 是 usage.json 的当前格式版本。版本 2 增加积分观测字段,版本 3 +// 增加模型生效倍率分区,版本 4 增加前缀缓存命中/未命中累计; +// 旧版本缺失字段按零值加载,旧数据不会丢弃。 +const fileVersion = 4 + +// bucket 一个 (时间片, realm, uid, model, rate) 的累计量。 +// JSON 字段名刻意取短,因为桶数量会随时间增长。 +type bucket struct { + Scope string `json:"s"` // "h:2006-01-02T15" 或 "d:2006-01-02" + Realm string `json:"r"` + UID string `json:"u"` + Model string `json:"m"` + // Rate 请求时生效的积分倍率(规范化数值;旧桶为空)。上游 PR #69 引入: + // 同一模型不同倍率档分开聚合,才能算准「这段倍率下的积分/Token」。 + Rate string `json:"x,omitempty"` + Req int64 `json:"q"` // 请求数(含失败) + Err int64 `json:"e"` // 失败数 + PT int64 `json:"p"` // prompt tokens + CT int64 `json:"c"` // completion tokens + TT int64 `json:"t"` // total tokens(上游给什么用什么的合计) + CH int64 `json:"ch"` // prompt 缓存命中 token + CM int64 `json:"cm"` // prompt 缓存未命中 token + LatMs int64 `json:"l"` // 延迟累计(ms) + LatN int64 `json:"ln"` // 延迟样本数 + TPS float64 `json:"v"` // 吐字速率累计 + TPSN int64 `json:"vn"` // 速率样本数 + // CR 本片实测扣费积分(上游末帧 usage.credit 累计)。仅统计拿到 credit 的请求: + // 免费/限免请求记 0,没观测到 credit 的请求不参与,避免把"没测到"算成"没花钱"。 + CR float64 `json:"cr"` + // CRN/CRT 同一次请求同时拿到 credit 与 token 的样本数/Token 合计(换算比例分母)。 + CRN int64 `json:"cn,omitempty"` + CRT int64 `json:"ct,omitempty"` +} + +// file 落盘结构。 +type file struct { + Version int `json:"version"` + Saved string `json:"saved"` + Buckets []bucket `json:"buckets"` +} + +// Recorder 并发安全的用量记录器。 +type Recorder struct { + mu sync.Mutex + path string + buckets map[string]*bucket // key: scope|realm|uid|model|rate + dirty bool + started time.Time + + // 落盘失败观测(进 Snapshot,面板可见「用量文件已 N 轮没写成功」): + // 失败计数 + 最近一次错误。dirty 在失败后立即置回 true,等下个 tick 重试。 + lastErr string + failedFlushes int + + stopOnce sync.Once + stop chan struct{} + done chan struct{} +} + +// New 创建记录器。path 为空时禁用落盘(纯内存,测试用)。 +func New(path string) *Recorder { + r := &Recorder{ + path: path, + buckets: make(map[string]*bucket), + started: time.Now(), + stop: make(chan struct{}), + done: make(chan struct{}), + } + if path != "" { + if err := r.load(); err != nil { + log.Printf("[usage] 读取 %s 失败(从零开始): %v", path, err) + } + } + return r +} + +// Start 启动后台防抖落盘与折叠。Stop 前一直运行。 +func (r *Recorder) Start() { + go func() { + defer close(r.done) + t := time.NewTicker(flushInterval) + defer t.Stop() + for { + select { + case <-r.stop: + r.flush(true) + return + case <-t.C: + r.mu.Lock() + n := len(r.buckets) + r.mu.Unlock() + if n > maxBuckets { + r.Rollup(time.Now()) + } + r.flush(false) + } + } + }() +} + +// Stop 停止后台循环并做最后一次落盘。 +func (r *Recorder) Stop() { + r.stopOnce.Do(func() { close(r.stop) }) + <-r.done +} + +// Delta 一次请求尝试的用量增量(与 pool.TokenUsageDelta 同形,避免包间依赖)。 +type Delta struct { + PromptTokens int64 + HasPromptTokens bool + CompletionTokens int64 + HasCompletion bool + TotalTokens int64 + HasTotal bool + LatencyMs int64 + HasLatency bool + TokensPerSecond float64 + HasTPS bool + // 上游 usage 的 prompt 缓存命中/未命中 token。 + CacheHitTokens int64 + CacheMissTokens int64 + HasCache bool + // 上游末帧 usage.credit:本次请求的真实扣费积分。没观测到 → HasCredit=false, + // 该次不参与积分累计(与 token 的"有就给"同口径)。 + Credit float64 + HasCredit bool + // ModelRate 请求时生效的积分倍率(规范化数值文本;目录缓存取不到则为空)。 + ModelRate string +} + +// Add 记录一次请求尝试。 +// +// ok=false 表示该次尝试失败(传输错误 / 上游 >=400 / 解析失败)。失败尝试通常 +// 没有 usage,但**仍要计入请求数与失败数**——重试放大正是靠这一列才看得出来。 +func (r *Recorder) Add(now time.Time, realm, uid, model string, d Delta, ok bool) { + if r == nil { + return + } + if realm == "" { + realm = "cn" + } + if model == "" { + model = "(unknown)" + } + scope := "h:" + now.Format(hourLayout) + key := scope + "|" + realm + "|" + uid + "|" + model + "|" + d.ModelRate + + r.mu.Lock() + defer r.mu.Unlock() + + b := r.buckets[key] + if b == nil { + b = &bucket{Scope: scope, Realm: realm, UID: uid, Model: model, Rate: d.ModelRate} + r.buckets[key] = b + } + b.Req++ + if !ok { + b.Err++ + } + if d.HasPromptTokens { + b.PT += d.PromptTokens + } + if d.HasCompletion { + b.CT += d.CompletionTokens + } + if d.HasTotal { + b.TT += d.TotalTokens + } else if d.HasPromptTokens || d.HasCompletion { + // 上游没给 total:用 pt+ct 兜底,保证总量口径连续。 + b.TT += d.PromptTokens + d.CompletionTokens + } + if d.HasCredit { + b.CR += d.Credit + b.CRN++ + // 比例只使用同一次请求同时具备 credit 与 token 的样本,避免把 + // 仅 token 的旧记录或仅 credit 的观测混进分母。 + if d.HasTotal { + b.CRT += d.TotalTokens + } else if d.HasPromptTokens || d.HasCompletion { + b.CRT += d.PromptTokens + d.CompletionTokens + } + } + if d.HasLatency { + b.LatMs += d.LatencyMs + b.LatN++ + } + if d.HasTPS { + b.TPS += d.TokensPerSecond + b.TPSN++ + } + if d.HasCache { + b.CH += d.CacheHitTokens + b.CM += d.CacheMissTokens + } + r.dirty = true +} + +// Rollup 把超出 hourlyKeep 的小时桶折叠为日桶(按本地日历日);桶数超 maxBuckets +// 时额外从最旧的小时桶开始折(否则那个硬上限是空转,见下)。 +// 幂等:同一小时反复折叠不会重复计数(先累加再删源桶)。 +func (r *Recorder) Rollup(now time.Time) { + if r == nil { + return + } + cutoff := now.Add(-hourlyKeep) + + r.mu.Lock() + defer r.mu.Unlock() + + type move struct { + from, to string + ts time.Time + } + // 候选 = 全部小时桶(该不该折在下面的应用循环里判:年龄达标 或 桶数超硬上限)。 + // 上限是硬性的:Start 的守卫超限时调的就是本函数,只折 90 天前的桶在异常流量下 + // 永远折不下来(新桶都在保留窗口内)——那守卫等于空转。 + // 天花板:若每个 (账号,模型,倍率) 每小时都唯一,折叠无损但降不下来,这种情况 + // 只能靠保留策略兜(无损折叠换不来更小的上界)。 + var cand []move + for k, b := range r.buckets { + if !strings.HasPrefix(b.Scope, "h:") { + continue + } + ts, err := time.ParseInLocation(hourLayout, strings.TrimPrefix(b.Scope, "h:"), time.Local) + if err != nil { + continue + } + day := "d:" + ts.Format(dayLayout) + cand = append(cand, move{k, day + "|" + b.Realm + "|" + b.UID + "|" + b.Model + "|" + b.Rate, ts}) + } + sort.Slice(cand, func(i, j int) bool { return cand[i].ts.Before(cand[j].ts) }) + folded := 0 + for _, m := range cand { + src := r.buckets[m.from] + if src == nil { + continue + } + // 没到龄且桶数没超限 → 保留细粒度;超限时逐个折最旧的,直到回到上限内 + // (折一个不一定减少总量:目标日桶可能是新建的,所以按当前桶数判而非折叠次数)。 + if !m.ts.Before(cutoff) && len(r.buckets) <= maxBuckets { + continue + } + dst := r.buckets[m.to] + if dst == nil { + cp := *src + cp.Scope = strings.SplitN(m.to, "|", 2)[0] + dst = &cp + r.buckets[m.to] = dst + } else { + dst.Req += src.Req + dst.Err += src.Err + dst.PT += src.PT + dst.CT += src.CT + dst.TT += src.TT + dst.CH += src.CH + dst.CM += src.CM + dst.CR += src.CR + dst.LatMs += src.LatMs + dst.LatN += src.LatN + dst.TPS += src.TPS + dst.TPSN += src.TPSN + dst.CRN += src.CRN + dst.CRT += src.CRT + } + delete(r.buckets, m.from) + folded++ + } + if folded > 0 { + r.dirty = true + log.Printf("[usage] 折叠 %d 个小时桶为日桶(保留 %v 细粒度,现 %d 桶)", folded, hourlyKeep, len(r.buckets)) + } +} + +// ---------------------------------------------------------------- 持久化 ---- + +func (r *Recorder) load() error { + // safefile.Read:正文坏(掉电留全 0、被截断)时回退 .bak,统计不归零。 + raw, err := safefile.Read(r.path, nil) + if err != nil { + if errors.Is(err, fs.ErrNotExist) { + return nil + } + return err + } + var f file + if err := json.Unmarshal(raw, &f); err != nil { + return err + } + for i := range f.Buckets { + b := f.Buckets[i] + r.buckets[b.Scope+"|"+b.Realm+"|"+b.UID+"|"+b.Model+"|"+b.Rate] = &b + } + log.Printf("[usage] 已恢复 %d 个用量桶(%s)", len(r.buckets), r.path) + return nil +} + +func (r *Recorder) flush(force bool) { + if r == nil || r.path == "" { + return + } + r.mu.Lock() + if !r.dirty && !force { + r.mu.Unlock() + return + } + snap := file{Version: fileVersion, Saved: time.Now().Format(time.RFC3339), Buckets: make([]bucket, 0, len(r.buckets))} + for _, b := range r.buckets { + snap.Buckets = append(snap.Buckets, *b) + } + r.dirty = false + r.mu.Unlock() + + raw, err := json.Marshal(snap) + if err != nil { + r.noteFlushFailure("序列化失败", err) + return + } + if err := os.MkdirAll(filepath.Dir(r.path), 0o755); err != nil { + r.noteFlushFailure("建目录失败", err) + return + } + if err := safefile.WriteKeep(r.path, raw, 0o600); err != nil { + r.noteFlushFailure("原子替换失败", err) + } +} + +// noteFlushFailure 记一次落盘失败并恢复 dirty:此前 dirty 在写盘前就被清掉且 +// 失败不恢复——若无新请求进来,后续每轮 flush 都直接跳过,改动只能等下一次 +// Add 或进程退出兜底,期间进程崩溃即丢一个防抖周期的数据。 +func (r *Recorder) noteFlushFailure(stage string, err error) { + log.Printf("[usage] %s: %v", stage, err) + r.mu.Lock() + r.dirty = true + r.lastErr = stage + ": " + err.Error() + r.failedFlushes++ + r.mu.Unlock() +} + +// Save 立即落盘(面板「刷新」或关闭前调用)。 +func (r *Recorder) Save() { r.flush(true) } + +// ---------------------------------------------------------------- 聚合 ---- + +// Agg 一组累计量。 +type Agg struct { + Requests int64 `json:"requests"` + Errors int64 `json:"errors"` + PromptTokens int64 `json:"prompt_tokens"` + CompletionTok int64 `json:"completion_tokens"` + TotalTokens int64 `json:"total_tokens"` + CacheHitTok int64 `json:"cache_hit_tokens"` + CacheMissTok int64 `json:"cache_miss_tokens"` + AvgLatencyMs float64 `json:"avg_latency_ms"` + AvgTPS float64 `json:"avg_tokens_per_second"` + // Credits 窗口内实测扣费积分合计(上游 usage.credit;未观测到的请求不计)。 + Credits float64 `json:"credits"` + // CreditSamples/CreditTokens:同时拿到 credit 与 token 的样本数与 Token 合计; + // CreditsPer1MTokens 按该分母换算(仅样本非空时有意义)。 + CreditSamples int64 `json:"credit_samples"` + CreditTokens int64 `json:"credit_tokens"` + CreditsPer1MTokens float64 `json:"credits_per_1m_tokens"` + // CacheHitRate 前缀缓存命中率(%,命中/(命中+未命中);无观测样本时 0 省略)。 + CacheHitRate float64 `json:"cache_hit_rate,omitempty"` +} + +// aggAcc 是聚合过程中的累加器:Agg 只放已算好的结果,均值需要样本数才能 +// 正确加权(不能对每桶的均值再取平均),所以样本数留在这里。 +type aggAcc struct { + Agg + latSum int64 + latSamples int64 + tpsSum float64 + tpsSamples int64 +} + +func (g *aggAcc) add(b *bucket) { + g.Requests += b.Req + g.Errors += b.Err + g.PromptTokens += b.PT + g.CompletionTok += b.CT + g.TotalTokens += b.TT + g.CacheHitTok += b.CH + g.CacheMissTok += b.CM + g.Credits += b.CR + g.CreditSamples += b.CRN + g.CreditTokens += b.CRT + g.latSum += b.LatMs + g.latSamples += b.LatN + g.tpsSum += b.TPS + g.tpsSamples += b.TPSN +} + +func (g *aggAcc) finish() Agg { + a := g.Agg + if g.latSamples > 0 { + a.AvgLatencyMs = float64(g.latSum) / float64(g.latSamples) + } + if g.tpsSamples > 0 { + a.AvgTPS = g.tpsSum / float64(g.tpsSamples) + } + if g.CreditTokens > 0 { + a.CreditsPer1MTokens = g.Credits / float64(g.CreditTokens) * 1_000_000 + } + if total := g.CacheHitTok + g.CacheMissTok; total > 0 { + a.CacheHitRate = float64(g.CacheHitTok) / float64(total) * 100 + } + return a +} + +// KeyedAgg 按某个维度聚合的一行。 +type KeyedAgg struct { + Key string `json:"key"` + Realm string `json:"realm,omitempty"` + Extra string `json:"extra,omitempty"` // 账号行放昵称 + Agg +} + +// Point 时序上的一个点。 +type Point struct { + T string `json:"t"` + Scope string `json:"scope"` // "hour" | "day" + Agg +} + +// CreditAgg 积分扣除统计的一行。Key 在账号维度是 UID,在模型维度是「域:模型」 +// (cn:xxx / global:xxx,与 /v1/models 的调用值同形);行按 (域, 模型, 生效倍率) +// 分组;Rate 仅模型维度使用;比例分母只统计与 credit 同时存在的 Token 样本。 +type CreditAgg struct { + Key string `json:"key"` + Realm string `json:"realm,omitempty"` + Nickname string `json:"nickname,omitempty"` + Rate string `json:"rate,omitempty"` + Requests int64 `json:"requests"` + Credits float64 `json:"credits"` + CreditSamples int64 `json:"credit_samples"` + CreditTokens int64 `json:"credit_tokens"` + CreditsPer1MTokens float64 `json:"credits_per_1m_tokens"` + // 前缀缓存维度(issue #92 同步):命中率 = 命中/(命中+未命中),无样本时省略。 + CacheHitTokens int64 `json:"cache_hit_tokens,omitempty"` + CacheMissTokens int64 `json:"cache_miss_tokens,omitempty"` + CacheHitRate float64 `json:"cache_hit_rate,omitempty"` +} + +type creditAcc struct { + CreditAgg +} + +func (a *creditAcc) add(b *bucket) { + a.Requests += b.Req + a.Credits += b.CR + a.CreditSamples += b.CRN + a.CreditTokens += b.CRT + a.CacheHitTokens += b.CH + a.CacheMissTokens += b.CM +} + +func (a *creditAcc) finish() CreditAgg { + out := a.CreditAgg + if a.CreditTokens > 0 { + out.CreditsPer1MTokens = a.Credits / float64(a.CreditTokens) * 1_000_000 + } + if total := a.CacheHitTokens + a.CacheMissTokens; total > 0 { + out.CacheHitRate = float64(a.CacheHitTokens) / float64(total) * 100 + } + return out +} + +// Snapshot 面板一次拉取的全部用量视图数据。 +type Snapshot struct { + Totals Agg `json:"totals"` + ByRealm []KeyedAgg `json:"by_realm"` + ByAccount []KeyedAgg `json:"by_account"` + ByModel []KeyedAgg `json:"by_model"` + Series []Point `json:"series"` + CreditByAccount []CreditAgg `json:"credit_by_account"` + CreditByModel []CreditAgg `json:"credit_by_model"` + Buckets int `json:"buckets"` + FileBytes int64 `json:"file_bytes"` + Since string `json:"since,omitempty"` + // LastError/FailedFlushes 落盘健康观测:失败计数与最近一次错误(面板可显示 + // 「用量文件已 N 轮没写成功」);零值省略,健康时不出现。 + LastError string `json:"last_error,omitempty"` + FailedFlushes int `json:"failed_flushes,omitempty"` + // WindowFrom/WindowTo 本次实际生效的统计区间(本地时间,RFC3339),供面板 + // 回显口径——「自定义」区间下用户必须能确认服务端到底按哪段算的。 + // 空串 = 该侧不设界(全部历史 / 到今天为止)。 + WindowFrom string `json:"window_from,omitempty"` + WindowTo string `json:"window_to,omitempty"` + Generated string `json:"generated"` +} + +// Window 用量统计窗口。三种口径按优先级解析(见 bounds): +// - From/To 任一非零 → 显式区间 [From, To](To 零值 = 不设上界) +// - 否则 Hours>0 → 滚动窗口:当前整点往回 Hours-1 小时 +// - 否则 → 全部历史 +// +// 为什么显式区间用「桶起点落在 [From, To] 内」判定而不是求交集:小时桶的粒度 +// 就是一小时,用户选到 14:00 时把 14:00 这一小时的桶算进来符合直觉;同时这也 +// 让 Hours 口径与历史行为逐位一致(原实现就是 ts.Before(from) 即跳过)。 +type Window struct { + Hours int + From time.Time + To time.Time +} + +// bounds 解析出实际生效的 [from, to];零值表示该侧不设界。 +func (w Window) bounds() (time.Time, time.Time) { + if !w.From.IsZero() || !w.To.IsZero() { + return w.From, w.To + } + if w.Hours <= 0 { + return time.Time{}, time.Time{} + } + h := w.Hours + if h > 24*60 { + h = 24 * 60 + } + return time.Now().Truncate(time.Hour).Add(-time.Duration(h-1) * time.Hour), time.Time{} +} + +// bucketTime 把桶 scope 解析成本地时间;脏 scope 返回 false(不进任何口径)。 +func bucketTime(scope string) (time.Time, bool) { + if strings.HasPrefix(scope, "h:") { + ts, err := time.ParseInLocation(hourLayout, strings.TrimPrefix(scope, "h:"), time.Local) + return ts, err == nil + } + ts, err := time.ParseInLocation(dayLayout, strings.TrimPrefix(scope, "d:"), time.Local) + return ts, err == nil +} + +// Snapshot 聚合**所选窗口内**的桶,产出面板一次拉取的全部用量视图数据。 +// +// hours>0:窗口 = [当前整点-(hours-1)小时, now],卡片汇总/按域/按账号/按模型/ +// 时序**全部**按同一窗口口径统计——切窗口时所有数字随之变化(曾长期是"卡片为 +// 全部历史累计、hours 只改时序分片"的口径,界面上被读成"筛选没生效",已废弃)。 +// 小时桶按整点入窗;日桶(Rollup 折叠出的长期数据)按日起点入窗,故小时窗口 +// 天然不含更早的日桶。 +// hours<=0:全部历史(含已折叠日桶),供「全部历史」选项看长期趋势。 +// +// nicks 是 uid→昵称映射,仅用于展示。 +func (r *Recorder) Snapshot(hours int, nicks map[string]string) Snapshot { + return r.SnapshotWithRates(hours, nicks, nil) +} + +// SnapshotWithRates 与 Snapshot 相同,但允许为缺少历史倍率的旧桶提供当前 +// 模型倍率回填。currentRate 返回空串时该行按“未知倍率”聚合,不伪造价格。 +func (r *Recorder) SnapshotWithRates(hours int, nicks map[string]string, currentRate func(realm, model string) string) Snapshot { + return r.SnapshotWindow(Window{Hours: hours}, nicks, currentRate) +} + +// SnapshotWindow 聚合**所选窗口内**的桶,产出面板一次拉取的全部用量视图数据。 +// +// 窗口语义见 Window:滚动窗口(Hours)/ 显式区间(From-To)/ 全部历史。卡片汇总、 +// 按域、按账号、按模型、时序**全部**按同一窗口口径统计——切窗口时所有数字随之变化 +// (曾长期是"卡片为全部历史累计、hours 只改时序分片"的口径,界面上被读成"筛选没 +// 生效",已废弃)。小时桶按整点入窗;日桶(Rollup 折叠出的长期数据)按日起点入窗, +// 故小时窗口天然不含更早的日桶。 +func (r *Recorder) SnapshotWindow(w Window, nicks map[string]string, currentRate func(realm, model string) string) Snapshot { + if r == nil { + return Snapshot{Generated: time.Now().Format(time.RFC3339)} + } + from, to := w.bounds() + explicit := !w.From.IsZero() || !w.To.IsZero() + windowed := !from.IsZero() || !to.IsZero() + + r.mu.Lock() + bs := make([]bucket, 0, len(r.buckets)) + for _, b := range r.buckets { + bs = append(bs, *b) + } + lastErr, failedFlushes := r.lastErr, r.failedFlushes + r.mu.Unlock() + + var total aggAcc + realmAgg := map[string]*aggAcc{} + acctAgg := map[string]*aggAcc{} + acctRealm := map[string]string{} + modelAgg := map[string]*aggAcc{} + hourSeries := map[string]*aggAcc{} + daySeries := map[string]*aggAcc{} + creditAcctAgg := map[string]*creditAcc{} + creditModelAgg := map[string]*creditAcc{} + rateCache := map[string]string{} + + // 数据起点(全库最早分片):不受窗口影响,表示"记录自何时开始"。scope 字典序 + // 即时间序(同前缀内同格式排序;"d:" 恒早于 "h:"——日桶只来自 90 天前的小时折叠)。 + since := "" + matched := 0 + for i := range bs { + b := &bs[i] + if b.Scope < since || since == "" { + since = b.Scope + } + if windowed { + ts, ok := bucketTime(b.Scope) + // 解析失败的脏桶不进窗口聚合(也不该出现在任何口径里)。 + if !ok { + continue + } + if !from.IsZero() && ts.Before(from) { + continue + } + if !to.IsZero() && ts.After(to) { + continue + } + } + matched++ + total.add(b) + + if realmAgg[b.Realm] == nil { + realmAgg[b.Realm] = &aggAcc{} + } + realmAgg[b.Realm].add(b) + + if acctAgg[b.UID] == nil { + acctAgg[b.UID] = &aggAcc{} + } + acctAgg[b.UID].add(b) + // 一个账号只属于一个 realm,这里记下来供前端展示「域」列; + // keyed() 的 Realm 字段默认是空的(它按 key 分组,不知道 realm)。 + if acctRealm[b.UID] == "" { + acctRealm[b.UID] = b.Realm + } + + if modelAgg[b.Model] == nil { + modelAgg[b.Model] = &aggAcc{} + } + modelAgg[b.Model].add(b) + + if strings.HasPrefix(b.Scope, "h:") { + scope := strings.TrimPrefix(b.Scope, "h:") + if hourSeries[scope] == nil { + hourSeries[scope] = &aggAcc{} + } + hourSeries[scope].add(b) + } else { + scope := strings.TrimPrefix(b.Scope, "d:") + if daySeries[scope] == nil { + daySeries[scope] = &aggAcc{} + } + daySeries[scope].add(b) + } + if b.CRN > 0 { + ca := creditAcctAgg[b.UID] + if ca == nil { + ca = &creditAcc{CreditAgg: CreditAgg{ + Key: b.UID, + Realm: b.Realm, + Nickname: nicks[b.UID], + }} + creditAcctAgg[b.UID] = ca + } + ca.add(b) + + model := canonicalUsageModel(b.Model) + rate := b.Rate + if rate == "" && currentRate != nil { + cacheKey := b.Realm + "\x00" + model + if cached, ok := rateCache[cacheKey]; ok { + rate = cached + } else { + rate = currentRate(b.Realm, model) + rateCache[cacheKey] = rate + } + } + // 行键带域前缀:cn / global 同名模型的倍率和实扣是两笔账,裸模型名会把它们 + // 并成一行,也看不出某行属于哪个域。展示口径与 /v1/models 一致——模型 id + // 就是调用时要填的那个完整值。 + label := b.Realm + ":" + model + modelKey := label + "\x00" + rate + cm := creditModelAgg[modelKey] + if cm == nil { + cm = &creditAcc{CreditAgg: CreditAgg{Key: label, Realm: b.Realm, Rate: rate}} + creditModelAgg[modelKey] = cm + } + cm.add(b) + } + } + + snap := Snapshot{ + Totals: total.finish(), + ByRealm: keyed(realmAgg, func(k string) (string, string) { + return k, "" + }), + ByAccount: keyed(acctAgg, func(k string) (string, string) { + return k, nicks[k] + }), + ByModel: keyed(modelAgg, func(k string) (string, string) { return k, "" }), + CreditByAccount: creditKeyed(creditAcctAgg), + CreditByModel: creditKeyed(creditModelAgg), + Buckets: matched, + Generated: time.Now().Format(time.RFC3339), + LastError: lastErr, + FailedFlushes: failedFlushes, + } + for i := range snap.ByAccount { + snap.ByAccount[i].Realm = acctRealm[snap.ByAccount[i].Key] + } + + // 日点(升序)+ 小时点(升序)拼成一条连续时序。 + dayKeys := make([]string, 0, len(daySeries)) + for k := range daySeries { + dayKeys = append(dayKeys, k) + } + sort.Strings(dayKeys) + for _, k := range dayKeys { + snap.Series = append(snap.Series, Point{T: k, Scope: "day", Agg: daySeries[k].finish()}) + } + hourKeys := make([]string, 0, len(hourSeries)) + for k := range hourSeries { + hourKeys = append(hourKeys, k) + } + sort.Strings(hourKeys) + for _, k := range hourKeys { + snap.Series = append(snap.Series, Point{T: k, Scope: "hour", Agg: hourSeries[k].finish()}) + } + + if r.path != "" { + if fi, err := os.Stat(r.path); err == nil { + snap.FileBytes = fi.Size() + } + } + // since 去掉 scope 前缀("h:2026-09-16T13" → "2026-09-16T13")给前端展示; + // 无任何桶时保持空(无数据不伪造起点)。 + snap.Since = strings.TrimPrefix(strings.TrimPrefix(since, "h:"), "d:") + // 回显实际生效的区间:**仅显式区间口径**。滚动窗口由 hours 表达(前端自己 + // 知道选的是哪个预设),全部历史没有区间——两者回显都会变成噪音。 + if explicit { + if !w.From.IsZero() { + snap.WindowFrom = w.From.Format(time.RFC3339) + } + if !w.To.IsZero() { + snap.WindowTo = w.To.Format(time.RFC3339) + } + } + return snap +} + +func canonicalUsageModel(model string) string { + model = strings.TrimSpace(model) + for _, prefix := range []string{"cn:", "global:"} { + if strings.HasPrefix(model, prefix) { + model = strings.TrimPrefix(model, prefix) + break + } + } + if model == "" { + return "(unknown)" + } + return model +} + +func creditKeyed(m map[string]*creditAcc) []CreditAgg { + out := make([]CreditAgg, 0, len(m)) + for _, v := range m { + out = append(out, v.finish()) + } + sort.Slice(out, func(i, j int) bool { + if out[i].Credits != out[j].Credits { + return out[i].Credits > out[j].Credits + } + if out[i].CreditTokens != out[j].CreditTokens { + return out[i].CreditTokens > out[j].CreditTokens + } + if out[i].Key != out[j].Key { + return out[i].Key < out[j].Key + } + return out[i].Rate < out[j].Rate + }) + return out +} + +func keyed(m map[string]*aggAcc, label func(string) (string, string)) []KeyedAgg { + out := make([]KeyedAgg, 0, len(m)) + for k, v := range m { + key, extra := label(k) + out = append(out, KeyedAgg{Key: key, Extra: extra, Agg: v.finish()}) + } + // 按总量降序;同量按 key 升序,保证输出稳定(前端 diff 不抖)。 + sort.Slice(out, func(i, j int) bool { + if out[i].TotalTokens != out[j].TotalTokens { + return out[i].TotalTokens > out[j].TotalTokens + } + if out[i].Requests != out[j].Requests { + return out[i].Requests > out[j].Requests + } + return out[i].Key < out[j].Key + }) + return out +} + +// Describe 返回一行人类可读的占用摘要(启动日志用)。 +func (r *Recorder) Describe() string { + if r == nil { + return "disabled" + } + r.mu.Lock() + n := len(r.buckets) + r.mu.Unlock() + var sz int64 + if r.path != "" { + if fi, err := os.Stat(r.path); err == nil { + sz = fi.Size() + } + } + return fmt.Sprintf("%d buckets, file %d bytes", n, sz) +} diff --git a/internal/usage/usage_test.go b/internal/usage/usage_test.go index 50cfedec32aa57f115d41dce61e670c7406c3f07..95361e820f5cc4f742e9ecc5b3aaccf32c04c7b9 100644 --- a/internal/usage/usage_test.go +++ b/internal/usage/usage_test.go @@ -1,355 +1,364 @@ -package usage - -import ( - "encoding/json" - "os" - "path/filepath" - "testing" - "time" -) - -// 成功/失败尝试计数、total 的 pt+ct 兜底口径、按域/账号聚合。 -func TestAddAndTotals(t *testing.T) { - r := New("") - now := time.Now() - r.Add(now, "cn", "uid1", "glm-5.2", Delta{PromptTokens: 100, HasPromptTokens: true, CompletionTokens: 50, HasCompletion: true, Credit: 1.5, HasCredit: true, ModelRate: "0.05", LatencyMs: 200, HasLatency: true}, true) - // 失败尝试:无 usage → 只计请求数与失败数,token 不加。 - r.Add(now, "global", "uid1", "claude-4.6", Delta{}, false) - // 上游没给 total 时用 pt+ct 兜底,保证总量口径连续。 - r.Add(now, "cn", "uid1", "glm-5.2", Delta{PromptTokens: 10, HasPromptTokens: true, CompletionTokens: 5, HasCompletion: true}, true) - - s := r.Snapshot(24, nil) - if s.Totals.Requests != 3 || s.Totals.Errors != 1 { - t.Fatalf("requests/errors = %d/%d, want 3/1", s.Totals.Requests, s.Totals.Errors) - } - if s.Totals.PromptTokens != 110 || s.Totals.CompletionTok != 55 { - t.Fatalf("pt/ct = %d/%d, want 110/55", s.Totals.PromptTokens, s.Totals.CompletionTok) - } - if s.Totals.TotalTokens != 165 { - t.Fatalf("tt = %d, want 165(无 total 时按 pt+ct 兜底)", s.Totals.TotalTokens) - } - if s.Totals.Credits != 1.5 || s.Totals.CreditSamples != 1 || s.Totals.CreditTokens != 150 || s.Totals.CreditsPer1MTokens != 10000 { - t.Fatalf("credit totals = %+v, want credits=1.5 samples=1 tokens=150 ratio=10000", s.Totals) - } - if s.Totals.AvgLatencyMs != 200 { - t.Fatalf("avg latency = %v, want 200", s.Totals.AvgLatencyMs) - } - if len(s.ByRealm) != 2 { - t.Fatalf("by_realm = %d 项, want 2", len(s.ByRealm)) - } - if s.ByAccount[0].Realm == "" { - t.Fatal("by_account 行缺 realm 标注") - } - if len(s.CreditByAccount) != 1 || s.CreditByAccount[0].Key != "uid1" || - s.CreditByAccount[0].CreditSamples != 1 || s.CreditByAccount[0].CreditsPer1MTokens != 10000 { - t.Fatalf("credit_by_account = %+v, want one uid1 row", s.CreditByAccount) - } - if len(s.CreditByModel) != 1 || s.CreditByModel[0].Key != "glm-5.2" || - s.CreditByModel[0].Rate != "0.05" || s.CreditByModel[0].CreditsPer1MTokens != 10000 { - t.Fatalf("credit_by_model = %+v, want one glm-5.2 rate=0.05 row", s.CreditByModel) - } -} - -// Rollup 把超出 hourlyKeep 的小时桶折叠为日桶,且幂等:重复折叠不重复计数。 -// 窗口口径:24h 窗口不含 100 天前的日桶;hours=0(全部历史)才含日点。 -func TestRollupIdempotent(t *testing.T) { - r := New("") - old := time.Now().AddDate(0, 0, -100) // 100 天前,超出 90 天小时保留 - r.Add(old, "cn", "u", "m", Delta{PromptTokens: 7, HasPromptTokens: true}, true) - r.Add(old, "cn", "u", "m", Delta{PromptTokens: 7, HasPromptTokens: true}, true) - r.Add(time.Now(), "cn", "u", "m", Delta{PromptTokens: 1, HasPromptTokens: true}, true) - - r.Rollup(time.Now()) - after := r.Snapshot(24, nil) - if after.Totals.Requests != 1 || after.Totals.PromptTokens != 1 { - t.Fatalf("24h 窗口 totals = %d/%d, want 1/1(窗口外日桶不进聚合)", after.Totals.Requests, after.Totals.PromptTokens) - } - if len(after.Series) != 1 || after.Series[0].Scope != "hour" { - t.Fatalf("series = %+v, want 仅当前小时 1 个点", after.Series) - } - - all := r.Snapshot(0, nil) - if all.Totals.Requests != 3 || all.Totals.PromptTokens != 15 { - t.Fatalf("全部历史 totals = %d/%d, want 3/15", all.Totals.Requests, all.Totals.PromptTokens) - } - if len(all.Series) != 2 || all.Series[0].Scope != "day" || all.Series[1].Scope != "hour" { - t.Fatalf("series = %+v, want 日点在前 + 小时点在后", all.Series) - } - - r.Rollup(time.Now()) - again := r.Snapshot(0, nil) - if again.Totals.Requests != 3 || again.Totals.PromptTokens != 15 { - t.Fatalf("二次折叠后 totals = %d/%d, want 3/15(幂等被破坏)", again.Totals.Requests, again.Totals.PromptTokens) - } -} - -// 落盘→新实例恢复,数据不丢;落盘结构带版本号。 -func TestFlushLoadRoundtrip(t *testing.T) { - path := filepath.Join(t.TempDir(), "usage.json") - r1 := New(path) - r1.Add(time.Now(), "cn", "u1", "glm-5.2", Delta{PromptTokens: 42, HasPromptTokens: true, TotalTokens: 42, HasTotal: true}, true) - r1.Save() - - r2 := New(path) - s := r2.Snapshot(24, nil) - if s.Totals.Requests != 1 || s.Totals.TotalTokens != 42 { - t.Fatalf("恢复后 totals = %d/%d, want 1/42", s.Totals.Requests, s.Totals.TotalTokens) - } - raw, _ := os.ReadFile(path) - var f file - if err := json.Unmarshal(raw, &f); err != nil || f.Version != fileVersion || len(f.Buckets) != 1 { - t.Fatalf("落盘文件异常: err=%v buckets=%d", err, len(f.Buckets)) - } -} - -// 版本 1 文件没有积分字段:按零值恢复,旧 Token 数据保持可见且不产生伪比例。 -func TestLoadLegacyWithoutCredit(t *testing.T) { - path := filepath.Join(t.TempDir(), "usage.json") - legacy := `{"version":1,"saved":"2026-09-28T00:00:00+08:00","buckets":[{"s":"h:2026-09-28T10","r":"cn","u":"u1","m":"glm-5.2","q":1,"p":42,"t":42}]}` - if err := os.WriteFile(path, []byte(legacy), 0o600); err != nil { - t.Fatal(err) - } - r := New(path) - s := r.Snapshot(0, nil) - if s.Totals.TotalTokens != 42 || s.Totals.CreditSamples != 0 || s.Totals.CreditsPer1MTokens != 0 { - t.Fatalf("legacy totals = %+v, want token-only history", s.Totals) - } - if len(s.CreditByAccount) != 0 || len(s.CreditByModel) != 0 { - t.Fatalf("legacy credit dimensions = %+v / %+v, want none", s.CreditByAccount, s.CreditByModel) - } -} - -// 小时桶折叠为日桶时必须保留积分、样本数和匹配 Token,比例不能因 Rollup 漂移。 -func TestCreditSurvivesRollup(t *testing.T) { - r := New("") - old := time.Now().AddDate(0, 0, -100) - r.Add(old, "cn", "u", "m", Delta{PromptTokens: 100, HasPromptTokens: true, TotalTokens: 100, HasTotal: true, Credit: 1.25, HasCredit: true, ModelRate: "0.5"}, true) - r.Add(old.Add(2*time.Hour), "cn", "u", "m", Delta{PromptTokens: 300, HasPromptTokens: true, TotalTokens: 300, HasTotal: true, Credit: 3.75, HasCredit: true, ModelRate: "0.5"}, true) - r.Rollup(time.Now()) - s := r.Snapshot(0, nil) - if s.Totals.Credits != 5 || s.Totals.CreditSamples != 2 || s.Totals.CreditTokens != 400 || s.Totals.CreditsPer1MTokens != 12500 { - t.Fatalf("rolled credit totals = %+v, want credits=5 tokens=400 ratio=12500", s.Totals) - } - if len(s.CreditByModel) != 1 || s.CreditByModel[0].Rate != "0.5" || s.CreditByModel[0].CreditsPer1MTokens != 12500 { - t.Fatalf("rolled credit_by_model = %+v, want one rate-preserving row", s.CreditByModel) - } -} - -// 模型维度按“裸模型名 + 生效倍率”合并;同倍率跨账号/时间合并,不同倍率拆行。 -func TestCreditDimensionsRateGrouping(t *testing.T) { - r := New("") - now := time.Now() - r.Add(now, "cn", "u1", "cn:glm-5.2", Delta{TotalTokens: 100, HasTotal: true, Credit: 1, HasCredit: true, ModelRate: "0.5"}, true) - r.Add(now.Add(time.Hour), "cn", "u2", "glm-5.2", Delta{TotalTokens: 200, HasTotal: true, Credit: 2, HasCredit: true, ModelRate: "0.5"}, true) - r.Add(now.Add(2*time.Hour), "cn", "u2", "glm-5.2", Delta{TotalTokens: 300, HasTotal: true, Credit: 6, HasCredit: true, ModelRate: "0.8"}, true) - - s := r.Snapshot(24, nil) - if len(s.CreditByAccount) != 2 || len(s.CreditByModel) != 2 { - t.Fatalf("dimensions accounts=%+v models=%+v, want 2 accounts and 2 model-rate rows", s.CreditByAccount, s.CreditByModel) - } - if s.CreditByModel[0].Key != "glm-5.2" || s.CreditByModel[0].Rate != "0.8" || - s.CreditByModel[0].Credits != 6 || s.CreditByModel[0].CreditTokens != 300 { - t.Fatalf("first model row = %+v, want rate=0.8 credits=6 tokens=300", s.CreditByModel[0]) - } - if s.CreditByModel[1].Rate != "0.5" || s.CreditByModel[1].Credits != 3 || s.CreditByModel[1].CreditTokens != 300 { - t.Fatalf("merged model row = %+v, want rate=0.5 credits=3 tokens=300", s.CreditByModel[1]) - } -} - -// 旧桶缺倍率时由当前目录倍率回填,并与新桶同倍率记录合并;目录缺失时保留未知行。 -func TestCreditLegacyRateFallback(t *testing.T) { - r := New("") - now := time.Now() - r.Add(now, "cn", "u1", "glm-5.2", Delta{TotalTokens: 100, HasTotal: true, Credit: 1, HasCredit: true}, true) - r.Add(now.Add(time.Hour), "cn", "u1", "glm-5.2", Delta{TotalTokens: 200, HasTotal: true, Credit: 2, HasCredit: true, ModelRate: "0.79"}, true) - - s := r.SnapshotWithRates(24, nil, func(realm, model string) string { - if realm == "cn" && model == "glm-5.2" { - return "0.79" - } - return "" - }) - if len(s.CreditByModel) != 1 || s.CreditByModel[0].Rate != "0.79" || - s.CreditByModel[0].Credits != 3 || s.CreditByModel[0].CreditTokens != 300 { - t.Fatalf("fallback model rows = %+v, want legacy merged into rate=0.79", s.CreditByModel) - } -} - -// Snapshot 全口径窗口过滤:窗口外的数据不进**任何**聚合(卡片/表格/时序), -// 切窗口数字随之变化;hours=0 全部历史。Buckets 为窗口内命中的桶数。 -func TestSnapshotWindowFilter(t *testing.T) { - r := New("") - now := time.Now() - r.Add(now.Add(-48*time.Hour), "cn", "u", "m", Delta{PromptTokens: 5, HasPromptTokens: true}, true) // 窗口(24h)外 - r.Add(now, "cn", "u", "m", Delta{PromptTokens: 3, HasPromptTokens: true}, true) // 窗口内 - s := r.Snapshot(24, nil) - if s.Totals.Requests != 1 || s.Totals.PromptTokens != 3 { - t.Fatalf("24h 窗口 totals = %d/%d, want 1/3(48h 前的数据应被过滤)", s.Totals.Requests, s.Totals.PromptTokens) - } - if len(s.Series) != 1 || s.Series[0].Scope != "hour" || s.Series[0].PromptTokens != 3 { - t.Fatalf("series = %+v, want 仅窗口内 1 个小时点", s.Series) - } - if s.Buckets != 1 { - t.Fatalf("buckets = %d, want 1(窗口内命中桶数)", s.Buckets) - } - - all := r.Snapshot(0, nil) - if all.Totals.Requests != 2 || all.Totals.PromptTokens != 8 { - t.Fatalf("全部历史 totals = %d/%d, want 2/8", all.Totals.Requests, all.Totals.PromptTokens) - } - // since 是全库数据起点,不受窗口影响。 - if all.Since == "" || s.Since != all.Since { - t.Fatalf("since 应为全库起点且不随窗口变化: all=%q windowed=%q", all.Since, s.Since) - } -} - -// 显式区间(「今天」/「自定义」)与滚动窗口走同一套全口径过滤;区间是闭区间 -// (桶起点落在 [From, To] 内即命中),且 From/To 会回显给面板确认口径。 -func TestSnapshotExplicitWindow(t *testing.T) { - r := New("") - base := time.Now().Truncate(time.Hour).Add(-5 * time.Hour) - for i := 0; i < 6; i++ { - r.Add(base.Add(time.Duration(i)*time.Hour), "cn", "u", "m", - Delta{PromptTokens: 10, HasPromptTokens: true}, true) - } - // 只取中间两小时(base+2h、base+3h)。 - s := r.SnapshotWindow(Window{ - From: base.Add(2 * time.Hour), - To: base.Add(3 * time.Hour), - }, nil, nil) - if s.Totals.Requests != 2 || s.Totals.PromptTokens != 20 { - t.Fatalf("显式区间 totals = %d/%d, want 2/20", s.Totals.Requests, s.Totals.PromptTokens) - } - if len(s.Series) != 2 || s.Buckets != 2 { - t.Fatalf("显式区间 series/buckets = %d/%d, want 2/2", len(s.Series), s.Buckets) - } - if s.WindowFrom == "" || s.WindowTo == "" { - t.Fatalf("显式区间应回显 window_from/window_to: %+v", s) - } - if _, err := time.Parse(time.RFC3339, s.WindowFrom); err != nil { - t.Fatalf("window_from 不是 RFC3339: %q", s.WindowFrom) - } - - // 只有 From(「今天」的形态):从该点起到最新,全量命中。 - only := r.SnapshotWindow(Window{From: base.Add(4 * time.Hour)}, nil, nil) - if only.Totals.Requests != 2 { - t.Fatalf("仅 From 的 totals = %d, want 2", only.Totals.Requests) - } - if only.WindowFrom == "" || only.WindowTo != "" { - t.Fatalf("仅 From 时 window_to 应为空: %+v", only) - } - - // 空窗口(From/To 全零且 Hours<=0)= 全部历史,与 Snapshot(0) 等价。 - all := r.SnapshotWindow(Window{}, nil, nil) - if all.Totals.Requests != 6 { - t.Fatalf("全零窗口 totals = %d, want 6(全部历史)", all.Totals.Requests) - } - if all.WindowFrom != "" || all.WindowTo != "" { - t.Fatalf("全部历史不应回显区间: %+v", all) - } -} - -// 滚动窗口的上限仍是 60 天,且与显式区间互不干扰(From/To 优先)。 -func TestWindowBounds(t *testing.T) { - // From/To 优先于 Hours。 - from := time.Now().Add(-2 * time.Hour) - gotFrom, gotTo := Window{Hours: 720, From: from}.bounds() - if !gotFrom.Equal(from) || !gotTo.IsZero() { - t.Fatalf("From 应优先于 Hours: from=%v to=%v", gotFrom, gotTo) - } - // 只有 Hours:起点 = 当前整点往回 Hours-1 小时。 - f, to := Window{Hours: 24}.bounds() - want := time.Now().Truncate(time.Hour).Add(-23 * time.Hour) - if !f.Equal(want) || !to.IsZero() { - t.Fatalf("24h bounds = %v/%v, want %v/零值", f, to, want) - } - // Hours<=0 且无 From/To = 全部历史。 - if f, to := (Window{}).bounds(); !f.IsZero() || !to.IsZero() { - t.Fatalf("空窗口 bounds = %v/%v, want 零值/零值", f, to) - } - // 上限 60 天。 - f60, _ := Window{Hours: 100000}.bounds() - want60 := time.Now().Truncate(time.Hour).Add(-(24*60 - 1) * time.Hour) - if !f60.Equal(want60) { - t.Fatalf("超限 Hours 未被夹到 60 天: %v want %v", f60, want60) - } -} - -// 脏 scope(解析失败)不进任何口径,也不会让整次快照失败。 -func TestBucketTimeRejectsGarbage(t *testing.T) { - if _, ok := bucketTime("h:not-a-time"); ok { - t.Fatal("脏小时 scope 应判定失败") - } - if _, ok := bucketTime("d:2026-13-45"); ok { - t.Fatal("脏日 scope 应判定失败") - } - if ts, ok := bucketTime("h:2026-09-30T13"); !ok || ts.Hour() != 13 { - t.Fatalf("合法小时 scope 解析失败: %v %v", ts, ok) - } - if ts, ok := bucketTime("d:2026-09-30"); !ok || ts.Day() != 30 { - t.Fatalf("合法日 scope 解析失败: %v %v", ts, ok) - } -} - -// Stop 触发最终落盘(Start 后未到防抖间隔也要落)。 -func TestLifecycleFlush(t *testing.T) { - path := filepath.Join(t.TempDir(), "usage.json") - r := New(path) - r.Start() - r.Add(time.Now(), "cn", "u", "m", Delta{PromptTokens: 9, HasPromptTokens: true}, true) - r.Stop() - if _, err := os.Stat(path); err != nil { - t.Fatalf("Stop 后应有落盘文件: %v", err) - } -} - -// TestCacheHitRateAccumulation(issue #92):桶累计 hit/miss,credit_by_model -// 与 totals 输出命中率;无缓存观测的桶不参与(rate 零值省略)。 -func TestCacheHitRateAccumulation(t *testing.T) { - r := New(t.TempDir() + "/usage.json") - base := time.Date(2026, 10, 1, 10, 0, 0, 0, time.Local) - r.Add(base, "cn", "u1", "glm-5.3", Delta{ - PromptTokens: 1000, HasPromptTokens: true, - Credit: 1, HasCredit: true, TotalTokens: 1005, HasTotal: true, - HasCacheTokens: true, CacheHitTokens: 900, CacheMissTokens: 100, - }, true) - r.Add(base.Add(time.Minute), "cn", "u1", "glm-5.3", Delta{ - PromptTokens: 1000, HasPromptTokens: true, - Credit: 2, HasCredit: true, TotalTokens: 1004, HasTotal: true, - HasCacheTokens: true, CacheHitTokens: 100, CacheMissTokens: 900, - }, true) - snap := r.Snapshot(0, nil) - if got := snap.CreditByModel[0].CacheHitRate; got != 50 { - t.Fatalf("cache_hit_rate=%v want 50", got) - } - if snap.Totals.CacheHitRate != 50 { - t.Fatalf("totals cache_hit_rate=%v want 50", snap.Totals.CacheHitRate) - } - if snap.CreditByModel[0].CacheHitTokens != 1000 || snap.CreditByModel[0].CacheMissTokens != 1000 { - t.Fatalf("hit/miss 累计错误: %+v", snap.CreditByModel[0]) - } - - // 无缓存观测的桶:rate 零值。 - r2 := New(t.TempDir() + "/usage2.json") - r2.Add(base, "cn", "u1", "m", Delta{PromptTokens: 10, HasPromptTokens: true, Credit: 1, HasCredit: true, TotalTokens: 12, HasTotal: true}, true) - if got := r2.Snapshot(0, nil).CreditByModel[0].CacheHitRate; got != 0 { - t.Fatalf("无缓存观测应 rate=0, got %v", got) - } -} - -// TestCacheTokensPersistRoundtrip:ch/cm 落盘 v4 并无损恢复。 -func TestCacheTokensPersistRoundtrip(t *testing.T) { - dir := t.TempDir() - r := New(dir + "/usage.json") - base := time.Date(2026, 10, 1, 10, 0, 0, 0, time.Local) - r.Add(base, "cn", "u1", "m", Delta{ - Credit: 1, HasCredit: true, TotalTokens: 100, HasTotal: true, - HasCacheTokens: true, CacheHitTokens: 75, CacheMissTokens: 25, - }, true) - r.Save() - r2 := New(dir + "/usage.json") - snap := r2.Snapshot(0, nil) - if snap.CreditByModel[0].CacheHitRate != 75 { - t.Fatalf("恢复后 cache_hit_rate=%v want 75", snap.CreditByModel[0].CacheHitRate) - } -} +package usage + +import ( + "encoding/json" + "os" + "path/filepath" + "testing" + "time" +) + +// 成功/失败尝试计数、total 的 pt+ct 兜底口径、按域/账号聚合。 +func TestAddAndTotals(t *testing.T) { + r := New("") + now := time.Now() + r.Add(now, "cn", "uid1", "glm-5.2", Delta{PromptTokens: 100, HasPromptTokens: true, CompletionTokens: 50, HasCompletion: true, Credit: 1.5, HasCredit: true, ModelRate: "0.05", LatencyMs: 200, HasLatency: true}, true) + // 失败尝试:无 usage → 只计请求数与失败数,token 不加。 + r.Add(now, "global", "uid1", "claude-4.6", Delta{}, false) + // 上游没给 total 时用 pt+ct 兜底,保证总量口径连续。 + r.Add(now, "cn", "uid1", "glm-5.2", Delta{PromptTokens: 10, HasPromptTokens: true, CompletionTokens: 5, HasCompletion: true}, true) + + // 缓存命中/未命中随桶累计,并出现在按账号/按模型的聚合行里(面板命中率列的来源)。 + r.Add(now, "cn", "uid1", "glm-5.2", Delta{CacheHitTokens: 8960, CacheMissTokens: 197, HasCache: true}, true) + + s := r.Snapshot(24, nil) + if s.Totals.Requests != 4 || s.Totals.Errors != 1 { + t.Fatalf("requests/errors = %d/%d, want 4/1", s.Totals.Requests, s.Totals.Errors) + } + if s.Totals.PromptTokens != 110 || s.Totals.CompletionTok != 55 { + t.Fatalf("pt/ct = %d/%d, want 110/55", s.Totals.PromptTokens, s.Totals.CompletionTok) + } + if s.Totals.TotalTokens != 165 { + t.Fatalf("tt = %d, want 165(无 total 时按 pt+ct 兜底)", s.Totals.TotalTokens) + } + if s.Totals.CacheHitTok != 8960 || s.Totals.CacheMissTok != 197 { + t.Fatalf("cache = %d/%d, want 8960/197", s.Totals.CacheHitTok, s.Totals.CacheMissTok) + } + if s.Totals.Credits != 1.5 || s.Totals.CreditSamples != 1 || s.Totals.CreditTokens != 150 || s.Totals.CreditsPer1MTokens != 10000 { + t.Fatalf("credit totals = %+v, want credits=1.5 samples=1 tokens=150 ratio=10000", s.Totals) + } + if s.Totals.AvgLatencyMs != 200 { + t.Fatalf("avg latency = %v, want 200", s.Totals.AvgLatencyMs) + } + if len(s.ByRealm) != 2 { + t.Fatalf("by_realm = %d 项, want 2", len(s.ByRealm)) + } + if s.ByAccount[0].Realm == "" { + t.Fatal("by_account 行缺 realm 标注") + } + if len(s.CreditByAccount) != 1 || s.CreditByAccount[0].Key != "uid1" || + s.CreditByAccount[0].CreditSamples != 1 || s.CreditByAccount[0].CreditsPer1MTokens != 10000 { + t.Fatalf("credit_by_account = %+v, want one uid1 row", s.CreditByAccount) + } + if len(s.CreditByModel) != 1 || s.CreditByModel[0].Key != "cn:glm-5.2" || + s.CreditByModel[0].Rate != "0.05" || s.CreditByModel[0].CreditsPer1MTokens != 10000 { + t.Fatalf("credit_by_model = %+v, want one cn:glm-5.2 rate=0.05 row", s.CreditByModel) + } +} + +// Rollup 把超出 hourlyKeep 的小时桶折叠为日桶,且幂等:重复折叠不重复计数。 +// 窗口口径:24h 窗口不含 100 天前的日桶;hours=0(全部历史)才含日点。 +func TestRollupIdempotent(t *testing.T) { + r := New("") + old := time.Now().AddDate(0, 0, -100) // 100 天前,超出 90 天小时保留 + r.Add(old, "cn", "u", "m", Delta{PromptTokens: 7, HasPromptTokens: true}, true) + r.Add(old, "cn", "u", "m", Delta{PromptTokens: 7, HasPromptTokens: true}, true) + r.Add(time.Now(), "cn", "u", "m", Delta{PromptTokens: 1, HasPromptTokens: true}, true) + + r.Rollup(time.Now()) + after := r.Snapshot(24, nil) + if after.Totals.Requests != 1 || after.Totals.PromptTokens != 1 { + t.Fatalf("24h 窗口 totals = %d/%d, want 1/1(窗口外日桶不进聚合)", after.Totals.Requests, after.Totals.PromptTokens) + } + if len(after.Series) != 1 || after.Series[0].Scope != "hour" { + t.Fatalf("series = %+v, want 仅当前小时 1 个点", after.Series) + } + + all := r.Snapshot(0, nil) + if all.Totals.Requests != 3 || all.Totals.PromptTokens != 15 { + t.Fatalf("全部历史 totals = %d/%d, want 3/15", all.Totals.Requests, all.Totals.PromptTokens) + } + if len(all.Series) != 2 || all.Series[0].Scope != "day" || all.Series[1].Scope != "hour" { + t.Fatalf("series = %+v, want 日点在前 + 小时点在后", all.Series) + } + + r.Rollup(time.Now()) + again := r.Snapshot(0, nil) + if again.Totals.Requests != 3 || again.Totals.PromptTokens != 15 { + t.Fatalf("二次折叠后 totals = %d/%d, want 3/15(幂等被破坏)", again.Totals.Requests, again.Totals.PromptTokens) + } +} + +// 落盘→新实例恢复,数据不丢;落盘结构带版本号。 +func TestFlushLoadRoundtrip(t *testing.T) { + path := filepath.Join(t.TempDir(), "usage.json") + r1 := New(path) + r1.Add(time.Now(), "cn", "u1", "glm-5.2", Delta{PromptTokens: 42, HasPromptTokens: true, TotalTokens: 42, HasTotal: true}, true) + r1.Save() + + r2 := New(path) + s := r2.Snapshot(24, nil) + if s.Totals.Requests != 1 || s.Totals.TotalTokens != 42 { + t.Fatalf("恢复后 totals = %d/%d, want 1/42", s.Totals.Requests, s.Totals.TotalTokens) + } + raw, _ := os.ReadFile(path) + var f file + if err := json.Unmarshal(raw, &f); err != nil || f.Version != fileVersion || len(f.Buckets) != 1 { + t.Fatalf("落盘文件异常: err=%v buckets=%d", err, len(f.Buckets)) + } +} + +// 版本 1 文件没有积分字段:按零值恢复,旧 Token 数据保持可见且不产生伪比例。 +func TestLoadLegacyWithoutCredit(t *testing.T) { + path := filepath.Join(t.TempDir(), "usage.json") + legacy := `{"version":1,"saved":"2026-09-28T00:00:00+08:00","buckets":[{"s":"h:2026-09-28T10","r":"cn","u":"u1","m":"glm-5.2","q":1,"p":42,"t":42}]}` + if err := os.WriteFile(path, []byte(legacy), 0o600); err != nil { + t.Fatal(err) + } + r := New(path) + s := r.Snapshot(0, nil) + if s.Totals.TotalTokens != 42 || s.Totals.CreditSamples != 0 || s.Totals.CreditsPer1MTokens != 0 { + t.Fatalf("legacy totals = %+v, want token-only history", s.Totals) + } + if len(s.CreditByAccount) != 0 || len(s.CreditByModel) != 0 { + t.Fatalf("legacy credit dimensions = %+v / %+v, want none", s.CreditByAccount, s.CreditByModel) + } +} + +// 小时桶折叠为日桶时必须保留积分、样本数和匹配 Token,比例不能因 Rollup 漂移。 +func TestCreditSurvivesRollup(t *testing.T) { + r := New("") + old := time.Now().AddDate(0, 0, -100) + r.Add(old, "cn", "u", "m", Delta{PromptTokens: 100, HasPromptTokens: true, TotalTokens: 100, HasTotal: true, Credit: 1.25, HasCredit: true, ModelRate: "0.5"}, true) + r.Add(old.Add(2*time.Hour), "cn", "u", "m", Delta{PromptTokens: 300, HasPromptTokens: true, TotalTokens: 300, HasTotal: true, Credit: 3.75, HasCredit: true, ModelRate: "0.5"}, true) + r.Rollup(time.Now()) + s := r.Snapshot(0, nil) + if s.Totals.Credits != 5 || s.Totals.CreditSamples != 2 || s.Totals.CreditTokens != 400 || s.Totals.CreditsPer1MTokens != 12500 { + t.Fatalf("rolled credit totals = %+v, want credits=5 tokens=400 ratio=12500", s.Totals) + } + if len(s.CreditByModel) != 1 || s.CreditByModel[0].Rate != "0.5" || s.CreditByModel[0].CreditsPer1MTokens != 12500 { + t.Fatalf("rolled credit_by_model = %+v, want one rate-preserving row", s.CreditByModel) + } +} + +// 模型维度按“域:模型 + 生效倍率”合并;同倍率跨账号/时间合并,不同倍率拆行。 +func TestCreditDimensionsRateGrouping(t *testing.T) { + r := New("") + now := time.Now() + r.Add(now, "cn", "u1", "cn:glm-5.2", Delta{TotalTokens: 100, HasTotal: true, Credit: 1, HasCredit: true, ModelRate: "0.5"}, true) + r.Add(now.Add(time.Hour), "cn", "u2", "glm-5.2", Delta{TotalTokens: 200, HasTotal: true, Credit: 2, HasCredit: true, ModelRate: "0.5"}, true) + r.Add(now.Add(2*time.Hour), "cn", "u2", "glm-5.2", Delta{TotalTokens: 300, HasTotal: true, Credit: 6, HasCredit: true, ModelRate: "0.8"}, true) + + s := r.Snapshot(24, nil) + if len(s.CreditByAccount) != 2 || len(s.CreditByModel) != 2 { + t.Fatalf("dimensions accounts=%+v models=%+v, want 2 accounts and 2 model-rate rows", s.CreditByAccount, s.CreditByModel) + } + if s.CreditByModel[0].Key != "cn:glm-5.2" || s.CreditByModel[0].Rate != "0.8" || + s.CreditByModel[0].Credits != 6 || s.CreditByModel[0].CreditTokens != 300 { + t.Fatalf("first model row = %+v, want rate=0.8 credits=6 tokens=300", s.CreditByModel[0]) + } + if s.CreditByModel[1].Rate != "0.5" || s.CreditByModel[1].Credits != 3 || s.CreditByModel[1].CreditTokens != 300 { + t.Fatalf("merged model row = %+v, want rate=0.5 credits=3 tokens=300", s.CreditByModel[1]) + } +} + +// 同名模型跨域不合并:cn / global 的倍率与实扣是两笔账,行键带域前缀(面板「按模型」 +// 列显示的就是 cn:/global:)。此前按裸模型名聚合,两域被并成一行、也看不出行属哪个域。 +func TestCreditModelRowsSplitByRealm(t *testing.T) { + r := New("") + now := time.Now() + r.Add(now, "cn", "u1", "glm-5.2", Delta{TotalTokens: 100, HasTotal: true, Credit: 1, HasCredit: true, ModelRate: "0.5"}, true) + r.Add(now, "global", "g1", "glm-5.2", Delta{TotalTokens: 100, HasTotal: true, Credit: 2, HasCredit: true, ModelRate: "0.5"}, true) + + s := r.Snapshot(24, nil) + if len(s.CreditByModel) != 2 { + t.Fatalf("credit_by_model = %+v, want 2 rows(同倍率的 cn / global 也不合并)", s.CreditByModel) + } + got := map[string]float64{} + for _, row := range s.CreditByModel { + got[row.Key] = row.Credits + } + if got["cn:glm-5.2"] != 1 || got["global:glm-5.2"] != 2 { + t.Fatalf("rows = %+v, want cn:glm-5.2=1 global:glm-5.2=2", s.CreditByModel) + } +} + +// 旧桶缺倍率时由当前目录倍率回填,并与新桶同倍率记录合并;目录缺失时保留未知行。 +func TestCreditLegacyRateFallback(t *testing.T) { + r := New("") + now := time.Now() + r.Add(now, "cn", "u1", "glm-5.2", Delta{TotalTokens: 100, HasTotal: true, Credit: 1, HasCredit: true}, true) + r.Add(now.Add(time.Hour), "cn", "u1", "glm-5.2", Delta{TotalTokens: 200, HasTotal: true, Credit: 2, HasCredit: true, ModelRate: "0.79"}, true) + + s := r.SnapshotWithRates(24, nil, func(realm, model string) string { + if realm == "cn" && model == "glm-5.2" { + return "0.79" + } + return "" + }) + if len(s.CreditByModel) != 1 || s.CreditByModel[0].Rate != "0.79" || + s.CreditByModel[0].Credits != 3 || s.CreditByModel[0].CreditTokens != 300 { + t.Fatalf("fallback model rows = %+v, want legacy merged into rate=0.79", s.CreditByModel) + } +} + +// Snapshot 全口径窗口过滤:窗口外的数据不进**任何**聚合(卡片/表格/时序), +// 切窗口数字随之变化;hours=0 全部历史。Buckets 为窗口内命中的桶数。 +func TestSnapshotWindowFilter(t *testing.T) { + r := New("") + now := time.Now() + r.Add(now.Add(-48*time.Hour), "cn", "u", "m", Delta{PromptTokens: 5, HasPromptTokens: true}, true) // 窗口(24h)外 + r.Add(now, "cn", "u", "m", Delta{PromptTokens: 3, HasPromptTokens: true}, true) // 窗口内 + s := r.Snapshot(24, nil) + if s.Totals.Requests != 1 || s.Totals.PromptTokens != 3 { + t.Fatalf("24h 窗口 totals = %d/%d, want 1/3(48h 前的数据应被过滤)", s.Totals.Requests, s.Totals.PromptTokens) + } + if len(s.Series) != 1 || s.Series[0].Scope != "hour" || s.Series[0].PromptTokens != 3 { + t.Fatalf("series = %+v, want 仅窗口内 1 个小时点", s.Series) + } + if s.Buckets != 1 { + t.Fatalf("buckets = %d, want 1(窗口内命中桶数)", s.Buckets) + } + + all := r.Snapshot(0, nil) + if all.Totals.Requests != 2 || all.Totals.PromptTokens != 8 { + t.Fatalf("全部历史 totals = %d/%d, want 2/8", all.Totals.Requests, all.Totals.PromptTokens) + } + // since 是全库数据起点,不受窗口影响。 + if all.Since == "" || s.Since != all.Since { + t.Fatalf("since 应为全库起点且不随窗口变化: all=%q windowed=%q", all.Since, s.Since) + } +} + +// 显式区间(「今天」/「自定义」)与滚动窗口走同一套全口径过滤;区间是闭区间 +// (桶起点落在 [From, To] 内即命中),且 From/To 会回显给面板确认口径。 +func TestSnapshotExplicitWindow(t *testing.T) { + r := New("") + base := time.Now().Truncate(time.Hour).Add(-5 * time.Hour) + for i := 0; i < 6; i++ { + r.Add(base.Add(time.Duration(i)*time.Hour), "cn", "u", "m", + Delta{PromptTokens: 10, HasPromptTokens: true}, true) + } + // 只取中间两小时(base+2h、base+3h)。 + s := r.SnapshotWindow(Window{ + From: base.Add(2 * time.Hour), + To: base.Add(3 * time.Hour), + }, nil, nil) + if s.Totals.Requests != 2 || s.Totals.PromptTokens != 20 { + t.Fatalf("显式区间 totals = %d/%d, want 2/20", s.Totals.Requests, s.Totals.PromptTokens) + } + if len(s.Series) != 2 || s.Buckets != 2 { + t.Fatalf("显式区间 series/buckets = %d/%d, want 2/2", len(s.Series), s.Buckets) + } + if s.WindowFrom == "" || s.WindowTo == "" { + t.Fatalf("显式区间应回显 window_from/window_to: %+v", s) + } + if _, err := time.Parse(time.RFC3339, s.WindowFrom); err != nil { + t.Fatalf("window_from 不是 RFC3339: %q", s.WindowFrom) + } + + // 只有 From(「今天」的形态):从该点起到最新,全量命中。 + only := r.SnapshotWindow(Window{From: base.Add(4 * time.Hour)}, nil, nil) + if only.Totals.Requests != 2 { + t.Fatalf("仅 From 的 totals = %d, want 2", only.Totals.Requests) + } + if only.WindowFrom == "" || only.WindowTo != "" { + t.Fatalf("仅 From 时 window_to 应为空: %+v", only) + } + + // 空窗口(From/To 全零且 Hours<=0)= 全部历史,与 Snapshot(0) 等价。 + all := r.SnapshotWindow(Window{}, nil, nil) + if all.Totals.Requests != 6 { + t.Fatalf("全零窗口 totals = %d, want 6(全部历史)", all.Totals.Requests) + } + if all.WindowFrom != "" || all.WindowTo != "" { + t.Fatalf("全部历史不应回显区间: %+v", all) + } +} + +// 滚动窗口的上限仍是 60 天,且与显式区间互不干扰(From/To 优先)。 +func TestWindowBounds(t *testing.T) { + // From/To 优先于 Hours。 + from := time.Now().Add(-2 * time.Hour) + gotFrom, gotTo := Window{Hours: 720, From: from}.bounds() + if !gotFrom.Equal(from) || !gotTo.IsZero() { + t.Fatalf("From 应优先于 Hours: from=%v to=%v", gotFrom, gotTo) + } + // 只有 Hours:起点 = 当前整点往回 Hours-1 小时。 + f, to := Window{Hours: 24}.bounds() + want := time.Now().Truncate(time.Hour).Add(-23 * time.Hour) + if !f.Equal(want) || !to.IsZero() { + t.Fatalf("24h bounds = %v/%v, want %v/零值", f, to, want) + } + // Hours<=0 且无 From/To = 全部历史。 + if f, to := (Window{}).bounds(); !f.IsZero() || !to.IsZero() { + t.Fatalf("空窗口 bounds = %v/%v, want 零值/零值", f, to) + } + // 上限 60 天。 + f60, _ := Window{Hours: 100000}.bounds() + want60 := time.Now().Truncate(time.Hour).Add(-(24*60 - 1) * time.Hour) + if !f60.Equal(want60) { + t.Fatalf("超限 Hours 未被夹到 60 天: %v want %v", f60, want60) + } +} + +// 脏 scope(解析失败)不进任何口径,也不会让整次快照失败。 +func TestBucketTimeRejectsGarbage(t *testing.T) { + if _, ok := bucketTime("h:not-a-time"); ok { + t.Fatal("脏小时 scope 应判定失败") + } + if _, ok := bucketTime("d:2026-13-45"); ok { + t.Fatal("脏日 scope 应判定失败") + } + if ts, ok := bucketTime("h:2026-09-30T13"); !ok || ts.Hour() != 13 { + t.Fatalf("合法小时 scope 解析失败: %v %v", ts, ok) + } + if ts, ok := bucketTime("d:2026-09-30"); !ok || ts.Day() != 30 { + t.Fatalf("合法日 scope 解析失败: %v %v", ts, ok) + } +} + +// Stop 触发最终落盘(Start 后未到防抖间隔也要落)。 +func TestLifecycleFlush(t *testing.T) { + path := filepath.Join(t.TempDir(), "usage.json") + r := New(path) + r.Start() + r.Add(time.Now(), "cn", "u", "m", Delta{PromptTokens: 9, HasPromptTokens: true}, true) + r.Stop() + if _, err := os.Stat(path); err != nil { + t.Fatalf("Stop 后应有落盘文件: %v", err) + } +} + +// 积分历史:扣费积分按桶累计、进聚合(卡片与按小时表的来源), +// 且小时桶折叠成日桶时不能把积分丢掉(丢了就是"看历史漏掉大半")。 +// 没观测到 credit 的请求(HasCredit=false)不参与——"没测到"≠"没花钱"。 +func TestCreditsAggregateAndSurviveRollup(t *testing.T) { + r := New("") + now := time.Now() + old := now.AddDate(0, 0, -100) // 超出 90 天小时保留 → 会被折叠成日桶 + + r.Add(now, "cn", "u", "m", Delta{TotalTokens: 100, HasTotal: true, Credit: 1.5, HasCredit: true}, true) + r.Add(now, "cn", "u", "m", Delta{TotalTokens: 100, HasTotal: true, Credit: 0.5, HasCredit: true}, true) + r.Add(now, "cn", "u", "m", Delta{TotalTokens: 100, HasTotal: true}, true) // 没观测到 credit:不计 + r.Add(old, "cn", "u", "m", Delta{TotalTokens: 200, HasTotal: true, Credit: 4, HasCredit: true}, true) + + win := r.Snapshot(24, nil) + if win.Totals.Credits != 2 { + t.Fatalf("窗口内积分 = %v, want 2(未观测到的不计)", win.Totals.Credits) + } + if len(win.Series) != 1 || win.Series[0].Credits != 2 { + t.Fatalf("窗口内小时点积分 = %+v, want 2", win.Series) + } + + r.Rollup(now) + all := r.Snapshot(0, nil) + if all.Totals.Credits != 6 { + t.Fatalf("折叠后全历史积分 = %v, want 6(4 分来自日桶)", all.Totals.Credits) + } + for _, p := range all.Series { + if p.Scope == "day" && p.Credits != 4 { + t.Fatalf("日点积分 = %v, want 4", p.Credits) + } + } +} diff --git a/login.sh b/login.sh old mode 100644 new mode 100755 index 94d81f9777a90d992b67634c41cf99977a66897f..7c8274b2c8bda9ba9be48820d2f500f71d698951 --- a/login.sh +++ b/login.sh @@ -1,182 +1,236 @@ -#!/usr/bin/env bash -# login.sh — WorkBuddy CN OAuth 登录 → 落盘 auth 文件 -# -# 用法: -# ./login.sh -# -# 流程: -# 1. POST /v2/plugin/auth/state 拿授权 URL(无 PKCE,state 由服务端签发) -# 2. 你在浏览器打开 URL 完成登录 -# 3. 回到这里按 y → poll 拿 token+uid+nickname → 签到 → 落盘 auths/workbuddy-.json -# 4. 重启 workbuddy2api 容器加载新账号 -set -euo pipefail - -cd "$(dirname "$0")" -AUTH_DIR="./auths" -CONTAINER="workbuddy2api" - -mkdir -p "$AUTH_DIR" - -# login 工具:不存在才编译(源码改动后手动 go build -o login ./cmd/login) -LOGIN_BIN="./login" -if [[ ! -x "$LOGIN_BIN" ]]; then - go build -o "$LOGIN_BIN" ./cmd/login -fi - -echo "============================================================" -echo " WorkBuddy OAuth 登录" -echo "============================================================" -echo "" - -AUTH_URL=$("$LOGIN_BIN" url) - -echo "请在浏览器中打开以下链接完成登录:" -echo "" -echo " $AUTH_URL" -echo "" - -if command -v xclip &>/dev/null; then - echo -n "$AUTH_URL" | xclip -selection clipboard 2>/dev/null && echo "(已复制到剪贴板)" -elif command -v xsel &>/dev/null; then - echo -n "$AUTH_URL" | xsel --clipboard 2>/dev/null && echo "(已复制到剪贴板)" -fi - -echo "" -read -rp "完成登录后按 y 继续: " ans -if [[ "$ans" != "y" && "$ans" != "Y" ]]; then - echo "已取消" - exit 1 -fi - -echo "" -echo "正在获取 token..." - -RESULT=$("$LOGIN_BIN" poll) || { - echo "" - echo "获取 token 失败。可能原因:" - echo " - 登录还没完成就按了 y(重新运行 ./login.sh 再试)" - echo " - 登录页报错(把报错截图发出来排查)" - exit 1 -} - -TOKEN=$(echo "$RESULT" | python3 -c "import json,sys; print(json.load(sys.stdin)['access_token'])") -REFRESH=$(echo "$RESULT" | python3 -c "import json,sys; print(json.load(sys.stdin)['refresh_token'])") -EXPIRES_IN=$(echo "$RESULT" | python3 -c "import json,sys; print(json.load(sys.stdin)['expires_in'])") -DOMAIN=$(echo "$RESULT" | python3 -c "import json,sys; print(json.load(sys.stdin).get('domain',''))") -USER_ID=$(echo "$RESULT" | python3 -c "import json,sys; print(json.load(sys.stdin).get('uid',''))") -ENT_ID=$(echo "$RESULT" | python3 -c "import json,sys; print(json.load(sys.stdin).get('enterprise_id',''))") -NICKNAME=$(echo "$RESULT" | python3 -c "import json,sys; print(json.load(sys.stdin).get('nickname',''))") - -if [[ -z "$USER_ID" ]]; then - echo "无法获取 uid,请检查 token 是否有效" - exit 1 -fi - -EXPIRES_AT=$(( $(date +%s) + EXPIRES_IN )) - -# ─── 签到(CN:POST codebuddy.cn/v2/billing/meter/daily-checkin,幂等不阻塞)─── -# OAuth 返回字段一律通过环境变量传入 Python,并用带引号 heredoc: -# 昵称/domain/token 等值可含引号或换行,拼进 Python 源码会造成注入。 -WB2A_LOGIN_TOKEN="$TOKEN" \ -WB2A_LOGIN_USER_ID="$USER_ID" \ -WB2A_LOGIN_ENT_ID="$ENT_ID" \ -WB2A_LOGIN_DOMAIN="$DOMAIN" \ -python3 - <<'PYEOF' -import json, os, urllib.request, urllib.error - -token = os.environ["WB2A_LOGIN_TOKEN"] -user_id = os.environ["WB2A_LOGIN_USER_ID"] -ent_id = os.environ["WB2A_LOGIN_ENT_ID"] -domain = os.environ["WB2A_LOGIN_DOMAIN"] - -req = urllib.request.Request( - "https://www.codebuddy.cn/v2/billing/meter/daily-checkin", - method="POST", data=b"{}", - headers={ - "Authorization": "Bearer " + token, - "Accept": "application/json", - "Content-Type": "application/json", - "X-User-Id": user_id, - **({"X-Enterprise-Id": ent_id, "X-Tenant-Id": ent_id} if ent_id else {}), - **({"X-Domain": domain} if domain else {}), - }) -try: - with urllib.request.urlopen(req, timeout=15) as r: - body = json.loads(r.read().decode() or "{}") - if body.get("code") == 0: - data = body.get("data") or {} - print(f"签到: 成功 {json.dumps(data, ensure_ascii=False)[:150]}") - else: - print(f"签到: {body.get('msg', json.dumps(body)[:150])}") -except urllib.error.HTTPError as e: - # 已签到等业务错误也走 4xx(实测 code=10001 "今天已签到") - try: - body = json.loads(e.read().decode() or "{}") - print(f"签到: {body.get('msg', 'http %d' % e.code)}") - except Exception: - print(f"签到: http {e.code}") -except Exception as e: - print(f"签到: {e}") -PYEOF - -# ─── 落盘 auth 文件(与 internal/auth 读取格式一致)───────────────── -AUTH_FILE="$AUTH_DIR/workbuddy-${USER_ID}.json" -if [[ -f "$AUTH_FILE" ]]; then - echo "账号已存在(uid=${USER_ID}),将覆盖更新凭证" - ACTION="覆盖" -else - echo "新账号(uid=${USER_ID}),新增 auth 文件" - ACTION="新增" -fi -WB2A_LOGIN_TOKEN="$TOKEN" \ -WB2A_LOGIN_REFRESH="$REFRESH" \ -WB2A_LOGIN_EXPIRES_AT="$EXPIRES_AT" \ -WB2A_LOGIN_DOMAIN="$DOMAIN" \ -WB2A_LOGIN_USER_ID="$USER_ID" \ -WB2A_LOGIN_ENT_ID="$ENT_ID" \ -WB2A_LOGIN_NICKNAME="$NICKNAME" \ -WB2A_LOGIN_AUTH_FILE="$AUTH_FILE" \ -WB2A_LOGIN_ACTION="$ACTION" \ -python3 - <<'PYEOF' -import json, os - -auth = { - "account": { - "uid": os.environ["WB2A_LOGIN_USER_ID"], - "enterpriseId": os.environ["WB2A_LOGIN_ENT_ID"], - "nickname": os.environ["WB2A_LOGIN_NICKNAME"], - }, - "auth": { - "accessToken": os.environ["WB2A_LOGIN_TOKEN"], - "refreshToken": os.environ["WB2A_LOGIN_REFRESH"], - "expiresAt": int(os.environ["WB2A_LOGIN_EXPIRES_AT"]), - "domain": os.environ["WB2A_LOGIN_DOMAIN"], - }, -} -with open(os.environ["WB2A_LOGIN_AUTH_FILE"], "w") as f: - json.dump(auth, f, indent=1) -print(f"已保存({os.environ['WB2A_LOGIN_ACTION']}): {os.environ['WB2A_LOGIN_AUTH_FILE']}") -PYEOF - -# ─── 重启服务 ──────────────────────────────────────────── -echo "" -if docker ps --format '{{.Names}}' | grep -q "^${CONTAINER}$"; then - echo "重启 $CONTAINER 加载新账号..." - docker restart "$CONTAINER" >/dev/null - sleep 2 - # API_KEY 从 config.json 读取(该变量在脚本中未定义,fallback 仅为占位,不会通过鉴权) - API_KEY=$(python3 -c "import json; print(json.load(open('config.json')).get('api_key',''))" 2>/dev/null) - COUNT=$(curl -s http://127.0.0.1:7863/status -H "Authorization: Bearer ${API_KEY:-test_key}" 2>/dev/null | python3 -c "import json,sys; print(len(json.load(sys.stdin).get('accounts',[])))" 2>/dev/null || echo "?") - echo "服务已重启,当前账号数: $COUNT" -else - echo "容器 $CONTAINER 未运行,auth 文件已保存,下次启动自动加载" -fi - -echo "" -echo "============================================================" -echo " 登录完成!" -echo " UID: $USER_ID" -echo " Nickname: ${NICKNAME:-(未获取到)}" -echo " Token: ${TOKEN:0:30}..." -echo " 有效期: $(date -d "@$EXPIRES_AT" '+%Y-%m-%d %H:%M' 2>/dev/null || echo "$EXPIRES_AT")" -echo "============================================================" +#!/usr/bin/env bash +# login.sh — WorkBuddy / CodeBuddy OAuth 登录 → 落盘 auth 文件 +# +# 用法: +# ./login.sh # 国内站(cn) +# ./login.sh --site=intl # 官方国际站(www.codebuddy.ai) +# ./login.sh --site=workbuddy # 旧桌面端国际版(www.workbuddy.ai) +# ./login.sh --realm=global # 兼容旧写法,等价 --site=workbuddy +# +# 站点表对齐官方 CLI 2.174.0 的 product.json 域表;--site 优先于 --realm。 +# +# 流程: +# 1. POST /v2/plugin/auth/state 拿授权 URL(无 PKCE,state 由服务端签发) +# 2. 你在浏览器打开 URL 完成登录(链接已带官方 version 参数) +# 3. 回到这里按 y → poll 拿 token+uid+nickname → 签到(仅 CN)→ 落盘 auths/workbuddy-.json +# 4. 重启 workbuddy2api 容器加载新账号 +set -euo pipefail + +cd "$(dirname "$0")" +AUTH_DIR="./auths" +CONTAINER="workbuddy2api" + +# ─── 站点参数(官方域表:cn / intl / workbuddy)───────────────── +SITE="" +REALM="" +for arg in "$@"; do + case "$arg" in + --site=*) SITE="${arg#--site=}" ;; + --realm=*) REALM="${arg#--realm=}" ;; + -h|--help) + sed -n '2,15p' "$0" | sed 's/^# \{0,1\}//' + exit 0 + ;; + *) + echo "未知参数: $arg(可用 --site=cn|intl|workbuddy、--realm=cn|global)" >&2 + exit 1 + ;; + esac +done + +# 站点 → 展示名/上游域名(与 internal/loginsite 的站点表一致) +site_label() { + case "$1" in + intl) echo "官方国际站(www.codebuddy.ai)" ;; + workbuddy) echo "旧桌面端国际版(www.workbuddy.ai)" ;; + *) echo "国内站(copilot.tencent.com)" ;; + esac +} + +mkdir -p "$AUTH_DIR" + +# login 工具:不存在才编译(源码改动后手动 go build -o login ./cmd/login) +LOGIN_BIN="./login" +if [[ ! -x "$LOGIN_BIN" ]]; then + go build -o "$LOGIN_BIN" ./cmd/login +fi + +# 把 --site/--realm 归一化成实际站点(由 login 工具输出,避免脚本里重复维护域表) +if [[ -n "$SITE" ]]; then + SITE_ARGS=(--site="$SITE") +elif [[ -n "$REALM" ]]; then + SITE_ARGS=(--realm="$REALM") +else + SITE_ARGS=() +fi +SITE=$("$LOGIN_BIN" "${SITE_ARGS[@]}" site) + +echo "============================================================" +echo " WorkBuddy OAuth 登录 · $(site_label "$SITE")" +echo "============================================================" +echo "" + +AUTH_URL=$("$LOGIN_BIN" "${SITE_ARGS[@]}" url) + +echo "请在浏览器中打开以下链接完成登录:" +echo "" +echo " $AUTH_URL" +echo "" + +if command -v xclip &>/dev/null; then + echo -n "$AUTH_URL" | xclip -selection clipboard 2>/dev/null && echo "(已复制到剪贴板)" +elif command -v xsel &>/dev/null; then + echo -n "$AUTH_URL" | xsel --clipboard 2>/dev/null && echo "(已复制到剪贴板)" +fi + +echo "" +read -rp "完成登录后按 y 继续: " ans +if [[ "$ans" != "y" && "$ans" != "Y" ]]; then + echo "已取消" + exit 1 +fi + +echo "" +echo "正在获取 token..." + +RESULT=$("$LOGIN_BIN" "${SITE_ARGS[@]}" poll) || { + echo "" + echo "获取 token 失败。可能原因:" + echo " - 登录还没完成就按了 y(重新运行 ./login.sh 再试)" + echo " - 登录页报错(把报错截图发出来排查)" + echo " - 上游返回许可类终态错误(席位满/许可证过期/试用到期)时,上面会直接给出 code 与 msg" + exit 1 +} + +TOKEN=$(echo "$RESULT" | python3 -c "import json,sys; print(json.load(sys.stdin)['access_token'])") +REFRESH=$(echo "$RESULT" | python3 -c "import json,sys; print(json.load(sys.stdin)['refresh_token'])") +EXPIRES_IN=$(echo "$RESULT" | python3 -c "import json,sys; print(json.load(sys.stdin)['expires_in'])") +DOMAIN=$(echo "$RESULT" | python3 -c "import json,sys; print(json.load(sys.stdin).get('domain',''))") +USER_ID=$(echo "$RESULT" | python3 -c "import json,sys; print(json.load(sys.stdin).get('uid',''))") +ENT_ID=$(echo "$RESULT" | python3 -c "import json,sys; print(json.load(sys.stdin).get('enterprise_id',''))") +NICKNAME=$(echo "$RESULT" | python3 -c "import json,sys; print(json.load(sys.stdin).get('nickname',''))") + +if [[ -z "$USER_ID" ]]; then + echo "无法获取 uid,请检查 token 是否有效" + exit 1 +fi + +EXPIRES_AT=$(( $(date +%s) + EXPIRES_IN )) + +# ─── 签到(仅 CN:POST codebuddy.cn/v2/billing/meter/daily-checkin,幂等不阻塞)─── +# 国际站没有 CN 那套成长/签到体系(上游一律 400 code 10001),发起只会写一条 +# 误导性错误,故按站点跳过。 +# OAuth 返回字段一律通过环境变量传入 Python,并用带引号 heredoc: +# 昵称/domain/token 等值可含引号或换行,拼进 Python 源码会造成注入。 +if [[ "$SITE" == "cn" ]]; then +WB2A_LOGIN_TOKEN="$TOKEN" \ +WB2A_LOGIN_USER_ID="$USER_ID" \ +WB2A_LOGIN_ENT_ID="$ENT_ID" \ +WB2A_LOGIN_DOMAIN="$DOMAIN" \ +python3 - <<'PYEOF' +import json, os, urllib.request, urllib.error + +token = os.environ["WB2A_LOGIN_TOKEN"] +user_id = os.environ["WB2A_LOGIN_USER_ID"] +ent_id = os.environ["WB2A_LOGIN_ENT_ID"] +domain = os.environ["WB2A_LOGIN_DOMAIN"] + +req = urllib.request.Request( + "https://www.codebuddy.cn/v2/billing/meter/daily-checkin", + method="POST", data=b"{}", + headers={ + "Authorization": "Bearer " + token, + "Accept": "application/json", + "Content-Type": "application/json", + "X-User-Id": user_id, + **({"X-Enterprise-Id": ent_id, "X-Tenant-Id": ent_id} if ent_id else {}), + **({"X-Domain": domain} if domain else {}), + }) +try: + with urllib.request.urlopen(req, timeout=15) as r: + body = json.loads(r.read().decode() or "{}") + if body.get("code") == 0: + data = body.get("data") or {} + print(f"签到: 成功 {json.dumps(data, ensure_ascii=False)[:150]}") + else: + print(f"签到: {body.get('msg', json.dumps(body)[:150])}") +except urllib.error.HTTPError as e: + # 已签到等业务错误也走 4xx(实测 code=10001 "今天已签到") + try: + body = json.loads(e.read().decode() or "{}") + print(f"签到: {body.get('msg', 'http %d' % e.code)}") + except Exception: + print(f"签到: http {e.code}") +except Exception as e: + print(f"签到: {e}") +PYEOF +else + echo "签到: 跳过(国际站无 CN 签到体系)" +fi + +# ─── 落盘 auth 文件(与 internal/auth 读取格式一致)───────────────── +AUTH_FILE="$AUTH_DIR/workbuddy-${USER_ID}.json" +if [[ -f "$AUTH_FILE" ]]; then + echo "账号已存在(uid=${USER_ID}),将覆盖更新凭证" + ACTION="覆盖" +else + echo "新账号(uid=${USER_ID}),新增 auth 文件" + ACTION="新增" +fi +WB2A_LOGIN_TOKEN="$TOKEN" \ +WB2A_LOGIN_REFRESH="$REFRESH" \ +WB2A_LOGIN_EXPIRES_AT="$EXPIRES_AT" \ +WB2A_LOGIN_DOMAIN="$DOMAIN" \ +WB2A_LOGIN_REALM="$([[ "$SITE" == "cn" ]] && echo cn || echo global)" \ +WB2A_LOGIN_USER_ID="$USER_ID" \ +WB2A_LOGIN_ENT_ID="$ENT_ID" \ +WB2A_LOGIN_NICKNAME="$NICKNAME" \ +WB2A_LOGIN_AUTH_FILE="$AUTH_FILE" \ +WB2A_LOGIN_ACTION="$ACTION" \ +python3 - <<'PYEOF' +import json, os + +auth = { + "account": { + "uid": os.environ["WB2A_LOGIN_USER_ID"], + "enterpriseId": os.environ["WB2A_LOGIN_ENT_ID"], + "nickname": os.environ["WB2A_LOGIN_NICKNAME"], + }, + "auth": { + "accessToken": os.environ["WB2A_LOGIN_TOKEN"], + "refreshToken": os.environ["WB2A_LOGIN_REFRESH"], + "expiresAt": int(os.environ["WB2A_LOGIN_EXPIRES_AT"]), + "domain": os.environ["WB2A_LOGIN_DOMAIN"], + # 显式写 realm:国际站有两个主机名(codebuddy.ai / workbuddy.ai), + # 只靠 domain 后缀推断会让「未来新增域」静默落到 cn,写死更稳。 + "realm": os.environ["WB2A_LOGIN_REALM"], + }, +} +with open(os.environ["WB2A_LOGIN_AUTH_FILE"], "w") as f: + json.dump(auth, f, indent=1) +print(f"已保存({os.environ['WB2A_LOGIN_ACTION']}): {os.environ['WB2A_LOGIN_AUTH_FILE']}") +PYEOF + +# ─── 重启服务 ──────────────────────────────────────────── +echo "" +if docker ps --format '{{.Names}}' | grep -q "^${CONTAINER}$"; then + echo "重启 $CONTAINER 加载新账号..." + docker restart "$CONTAINER" >/dev/null + sleep 2 + # API_KEY 从 config.json 读取(该变量在脚本中未定义,fallback 仅为占位,不会通过鉴权) + API_KEY=$(python3 -c "import json; print(json.load(open('config.json')).get('api_key',''))" 2>/dev/null) + COUNT=$(curl -s http://127.0.0.1:7863/status -H "Authorization: Bearer ${API_KEY:-test_key}" 2>/dev/null | python3 -c "import json,sys; print(len(json.load(sys.stdin).get('accounts',[])))" 2>/dev/null || echo "?") + echo "服务已重启,当前账号数: $COUNT" +else + echo "容器 $CONTAINER 未运行,auth 文件已保存,下次启动自动加载" +fi + +echo "" +echo "============================================================" +echo " 登录完成!" +echo " 站点: $(site_label "$SITE")" +echo " UID: $USER_ID" +echo " Nickname: ${NICKNAME:-(未获取到)}" +echo " Token: ${TOKEN:0:30}..." +echo " 有效期: $(date -d "@$EXPIRES_AT" '+%Y-%m-%d %H:%M' 2>/dev/null || echo "$EXPIRES_AT")" +echo "============================================================" diff --git a/scripts/acp_run.py b/scripts/acp_run.py new file mode 100644 index 0000000000000000000000000000000000000000..9fd69b6647614d549bce12b8150a9f946b33164b --- /dev/null +++ b/scripts/acp_run.py @@ -0,0 +1,121 @@ +#!/usr/bin/env python3 +"""跑一次 Hermes ACP 会话,把思考 / 回复 / 工具调用实时打到 stdout。 + +hermes -z 的设计是「只打印最终答案」,看不到推理过程;ACP 才有逐 token 的 +agent_thought_chunk。CI 里用它替代 -z,日志就是完整的思考链。 +""" +import json +import os +import subprocess +import sys +import threading + + +def text_of(content): + """content 有时是 {type,text},有时是 chunk 数组。""" + if isinstance(content, dict): + return content.get("text") or "" + if isinstance(content, list): + return "".join(c.get("text") or "" for c in content if isinstance(c, dict)) + return "" + + +def main(): + prompt = sys.argv[1] + cwd = os.environ.get("ACP_CWD") or os.getcwd() + p = subprocess.Popen( + ["hermes", "acp", "--accept-hooks"], cwd=cwd, + stdin=subprocess.PIPE, stdout=subprocess.PIPE, stderr=subprocess.PIPE, + text=True, bufsize=1) + err = [] + + def pump_stderr(): + # agent 起不来时原因全在 stderr;只留告警和错误,插件注册那类 INFO 太吵 + for line in p.stderr: + if any(k in line for k in (" ERROR ", " WARNING ", "Traceback", "Error:")): + err.append(line.rstrip()) + print("[acp] " + line.rstrip(), flush=True) + + threading.Thread(target=pump_stderr, daemon=True).start() + + def send(obj): + try: + p.stdin.write(json.dumps(obj) + "\n") + p.stdin.flush() + except BrokenPipeError: + pass + + def read(): + line = p.stdout.readline() + if not line: + return None + try: + return json.loads(line) + except json.JSONDecodeError: + err.append(line.rstrip()) + return {} + + done = False + send({"jsonrpc": "2.0", "id": 1, "method": "initialize", + "params": {"protocolVersion": 1, "clientCapabilities": {}}}) + while True: + m = read() + if m is None: + print("\n[ACP 通道断开]", flush=True) + break + mid = m.get("id") + method = m.get("method") + if mid == 1: + send({"jsonrpc": "2.0", "id": 2, "method": "session/new", + "params": {"cwd": cwd, "mcpServers": []}}) + elif mid == 2: + sid = (m.get("result") or {}).get("sessionId") + if not sid: + print(f"[session/new 失败: {m.get('error')}]", flush=True) + break + # dont_ask:文件编辑不再弹审批(CI 里没人点,默认 ask 会被当拒绝) + send({"jsonrpc": "2.0", "id": 4, "method": "session/set_mode", + "params": {"sessionId": sid, "modeId": "dont_ask"}}) + elif mid == 4: + send({"jsonrpc": "2.0", "id": 3, "method": "session/prompt", + "params": {"sessionId": sid, + "prompt": [{"type": "text", "text": prompt}]}}) + elif method == "session/update": + u = m["params"]["update"] + kind = u.get("sessionUpdate") + text = text_of(u.get("content")) + if kind == "agent_thought_chunk" and text: + print(text, end="", flush=True) + elif kind == "agent_message_chunk" and text: + print(text, end="", flush=True) + elif kind == "tool_call": + title = u.get("title") or u.get("kind") or "tool" + print(f"\n\n[tool] {title}", flush=True) + elif kind == "tool_call_update" and u.get("status"): + print(f"[tool {u.get('status')}]", flush=True) + elif method == "session/request_permission": + # yolo 下本该没有;真出现就一律允许。响应必须是 + # {"outcome":{"outcome":"selected","optionId":..}} —— 少这层包装 + # Hermes 会当成「被拒绝」,文件写入直接失败(真踩过)。 + opts = (m["params"].get("options") or [{}]) + picked = next((o for o in opts if "allow" in str(o.get("optionId", "")).lower()), opts[0]) + send({"jsonrpc": "2.0", "id": m["id"], + "result": {"outcome": {"outcome": "selected", + "optionId": picked.get("optionId")}}}) + elif mid == 3: + done = True + print(f"\n\n[结束 stopReason={(m.get('result') or {}).get('stopReason')}]", flush=True) + break + try: + p.stdin.close() + except Exception: + pass + p.wait(timeout=30) + if err: + print("[acp stderr 末 5 行] " + " / ".join(err[-5:])[:400], flush=True) + # 没收到 prompt 的 result 就算失败,别让上层当成「跑完了但没产出」 + return 0 if done else 1 + + +if __name__ == "__main__": + sys.exit(main()) diff --git a/scripts/autobot.py b/scripts/autobot.py new file mode 100644 index 0000000000000000000000000000000000000000..2b66ad5983721c4690e7842cbc5177294ad6b72f --- /dev/null +++ b/scripts/autobot.py @@ -0,0 +1,700 @@ +#!/usr/bin/env python3 +"""AutoBot:把参考仓库的实现读成「本仓可以借鉴什么」,写成 PR 供人审。 + +两个阶段,可分开跑也可一次跑完: + analyze 每个参考仓库 clone 到 /tmp/up/,agent 读代码写差异报告 + implement 按报告自评的值得度排序,取前 N 条让 agent 写 Go 实现并开 PR + +硬约束:只推 autobot/* 分支,绝不 push main;提交身份是 GitHub Actions bot。 +""" +import argparse +import hashlib +import json +import os +import re +import shlex +import signal +import subprocess +import sys +import time + +import yaml + +ROOT = os.path.dirname(os.path.dirname(os.path.abspath(__file__))) +REPORT = os.path.join(ROOT, "autobot-report.md") +REPORT_DIR = "/tmp/autobot-reports" +UP_DIR = "/tmp/up" +# 只在自产提交上用 -c 传身份;写 git config 会污染本机手写提交(真出过事故) +BOT = ("-c", "user.name=github-actions[bot]", + "-c", "user.email=41898282+github-actions[bot]@users.noreply.github.com") + + +def run(*args, check=True, timeout=None): + p = subprocess.run(args, cwd=ROOT, capture_output=True, text=True, timeout=timeout) + if check and p.returncode != 0: + raise RuntimeError(f"{' '.join(args)} 失败: {p.stderr.strip()[:400]}") + return p.stdout.strip() if check else (p.returncode, (p.stdout + p.stderr).strip()) + + +def say(lines, text=""): + lines.append(text) + print(text, flush=True) + + +def agent(task, timeout, expect): + """跑一次 Hermes(ACP 模式),思考/回复/工具调用全部实时回显。 + + shortcut: 不用 `hermes -z`——它设计上只打印最终答案(No tool previews), + 看不到逐轮推理。ACP 提供 agent_thought_chunk 等事件流,日志即完整思考链。 + + 429 是限流的常态,退避重试三次再认输。用 Popen.wait 而不是 + subprocess.run(capture_output):后者要读完管道才算完,工具子进程继承管道后 + kill 主进程也不返回(实测挂到 job 超时 48 分钟)。 + + expect 是这一轮必须写出的文件:**有产物就是成功**,不看日志内容。日志里出现 + 「429」完全可能是 agent 在读或写的文本(本仓自己就在处理 429),拿子串判定会 + 把已经跑完的整轮丢掉重放,重试次数一路涨到 5 却每轮都有产出(实测)。 + """ + # CI 里没人点审批弹窗:config 的 approvals.mode=off + HERMES_YOLO_MODE, + # ACP 客户端的 session/request_permission 也一律允许 + cmd = [sys.executable, os.path.join(ROOT, "scripts", "acp_run.py"), task] + tail = "" + for attempt in range(5): + if os.path.isfile(expect): + os.remove(expect) # 上一轮残留不算本轮产出 + log_f = "/tmp/autobot-agent.log" + pipe = " ".join(shlex.quote(c) for c in cmd) + " 2>&1 | tee " + shlex.quote(log_f) + p = subprocess.Popen( + ["bash", "-c", pipe], cwd=ROOT, stdin=subprocess.DEVNULL, + start_new_session=True) + try: + p.wait(timeout=timeout) + except subprocess.TimeoutExpired: + try: + os.killpg(p.pid, signal.SIGKILL) # 连它拉起的工具子进程一起杀 + except ProcessLookupError: + pass + p.wait(30) + out = open(log_f, encoding="utf-8", errors="replace").read() + if not out.strip(): + print("--- agent 无任何输出 ---", flush=True) + code = 124 if (p.returncode is None or p.returncode < 0) else p.returncode + keep = (out.strip().splitlines() or [""])[-3:] + tail = " / ".join(keep)[:300] + # 只看日志不看退出码:agent 吞掉 429 之后仍以 0 退出,按 code==0 放行 + # 会把这轮当成「跑完了但没产出」(真踩过,17 片里 1 片这么挂的)。 + if os.path.isfile(expect) or "429" not in out: + return code, tail + # 免费档是「允许突发 30、持续 10 RPM」:agent 一阵工具调用就会打满, + # 退避要够长才能等到窗口滑过去,30→300s 封顶。 + wait = min(30 * 2 ** attempt, 300) + print(f" 429 限流,{wait}s 后重试({attempt + 1}/5)", flush=True) + time.sleep(wait) + return code, tail + + +def up_clone(src): + """上游仓完整 clone 到 /tmp/up/;已存在就浅拉一次更新。""" + d = os.path.join(UP_DIR, src.replace("/", "__")) + if os.path.isdir(os.path.join(d, ".git")): + run("git", "-C", d, "fetch", "-q", "--depth", "200", "origin", check=False, timeout=600) + return d + os.makedirs(UP_DIR, exist_ok=True) + code, _ = run("git", "clone", "-q", "--depth", "200", + f"https://github.com/{src}.git", d, check=False, timeout=600) + return d if code == 0 else "" + + +def upstream_brief(up): + """上游清单:文件表 + 最近提交 + README 摘要。 + + shortcut: 不让 agent 自己在仓里翻。deepseek 走网关每轮往返几十秒, + 让它探索 100+ 文件的仓 25 分钟也跑不完(实测三次全超时)。 + """ + files = run("git", "-C", up, "ls-files", check=False)[1].splitlines()[:200] + logs = run("git", "-C", up, "log", "--oneline", "-40", "--no-merges", check=False)[1] + readme = "" + for n in ("README.md", "readme.md", "README.zh-CN.md", "README_EN.md"): + f = os.path.join(up, n) + if os.path.isfile(f): + readme = open(f, encoding="utf-8", errors="replace").read()[:2500] + break + return files, logs, readme + + +def report_path(src): + return os.path.join(REPORT_DIR, src.replace("/", "__") + ".md") + + +def report_score(text): + """报告自评的值得度;没写就按 0(宁可不落地)。""" + m = re.search(r"值得度\s*[::]\s*([0-3])", text) + return int(m.group(1)) if m else 0 + + +def policy_hit(files, text, pol): + """policy.never 按路径、policy.off_limits 按内容,命中返回一句说明,否则 ""。 + + 这两张表写在 AutoBot.yml 里,但在 PR #141 之前没有任何代码读它——「硬禁项」没人拦 + 就等于没有(当时脚本里还留着一个没人用的 FORBIDDEN 常量)。所以闸门必须落在代码里。 + """ + for n in (pol.get("never") or []): + if "/" not in n and "." not in n: + continue # push_main / merge 这类是动作,不是路径 + base = n.rstrip("*").rstrip("/") + for f in files: + if f == base or f.startswith(base + "/"): + return f"policy.never 命中 {n}({f})" + low = (text or "").lower() + for r in (pol.get("off_limits") or []): + for k in (r.get("match") or []): + if str(k).lower() in low: + return f"不做清单「{r.get('name')}」命中 {k}" + return "" + + +def ban_brief(pol): + """把 policy 的两张表变成提示词里的几句话。 + + policy.never 原来只在提交前扫一次:agent 花 20 分钟写完改动、最后一步被驳回, + 上一轮两个候选就是这么白干的(都改了 config.example.json)。写之前先说清楚。 + """ + paths = [n for n in (pol.get("never") or []) if "/" in n or "." in n] + rules = pol.get("off_limits") or [] + out = [] + if paths: + out.append("这些路径一个字节都不要改,提交前会被自动驳回:" + "、".join(paths) + "。") + if rules: + out.append("本仓明确不做的能力(值得度一律 0,也不要写进「适配」):\n" + + "\n".join(f"- {r.get('name')}:{r.get('why', '')}" for r in rules)) + return "\n".join(out) + "\n" if out else "" + + +def own_brief(): + """本仓 Go 文件清单:让 agent 判「本仓现状」时有据可依,而不是靠猜。 + + shortcut: 只给路径不给内容,读不读由 agent 自己定(预算内最多 2 个)。 + """ + return run("git", "ls-files", "*.go", check=False)[1].splitlines()[:250] + + +def analyze(src, lines, pol, hist): + """clone → agent 读代码 → 差异报告。返回报告路径(失败为 "")。""" + up = up_clone(src) + if not up: + say(lines, f"{src}: clone 失败") + return "" + os.makedirs(REPORT_DIR, exist_ok=True) + rp = report_path(src) + files, logs, readme = upstream_brief(up) + # 材料写文件、prompt 只留指令:十几 KB 的 prompt 会让 agent 静默超时 + up_f = "/tmp/autobot-upstream.md" + with open(up_f, "w", encoding="utf-8") as f: + f.write(f"# 上游仓库 {src}(clone 在 {up},只读参考)\n\n" + "## 文件清单(最多 6 个,挑最能说明差异的)\n" + "\n".join(files) + "\n\n" + "## 最近提交\n" + logs + "\n") + if readme: + f.write("\n## README 摘要\n" + readme + "\n") + f.write("\n## 本仓 Go 文件清单(写「差异」时对照)\n" + "\n".join(own_brief()) + "\n") + f.write(hist_brief(hist)) + ban = ban_brief(pol) + task = ( + f"先读 {up_f}。本仓是 WorkBuddy 的 Go 网关(当前目录)。\n" + "任务:把这个上游仓库与本仓**逐功能一一对照**——逐个功能点判断本仓有没有、" + "差在哪、要不要借鉴。\n" + "20 分钟内写出报告,只读,不要修改本仓任何文件。\n" + f"报告写进 {rp},结构固定,不要写散文:\n" + "第 1 行:值得度: 0-3(本轮最高分;0=无可借鉴,3=本仓明确缺这个能力)\n" + "然后一张对照表,一个功能一行:\n" + "| 功能 | 上游(文件:函数) | 本仓(文件:函数 或 缺失) | 差距 | 值得度 |\n" + "|---|---|---|---|---|\n" + "表格之后两小节,各不超过 5 行:\n" + "适配: 要落地的那几项,改本仓哪个 文件:函数、怎么改\n" + "影响: 行为/配置/性能风险\n" + "「本仓」列必须点名真实 文件:函数;没有就写「缺失」,没核实就写「未核实」。" + "本仓已有等价实现的项,值得度给 0-1,不要报 3。\n" + "材料里「已经提过、被人关掉的提案」是本仓历史:同样的方向别再提," + "重复得先说清和哪一号 PR 不同,说不清就给 0。\n" + + ban + ) + code, out = agent(task, int(os.environ.get("AGENT_ANALYZE_TIMEOUT") or 1800), rp) + if not os.path.isfile(rp): + say(lines, f"{src}: agent 未产出报告(退出码 {code})|{out}") + return "" + say(lines, f"{src}: 分析完成 值得度={report_score(open(rp, encoding='utf-8').read())}") + return rp + + +def report_head(text, n=60): + """报告一句话摘要:优先取对照表第一条真有差距的行,其次「功能:」行。""" + for line in text.splitlines(): + t = line.strip() + if t.startswith("|") and "---" not in t: + cells = [c.strip() for c in t.strip("|").split("|")] + if len(cells) >= 4 and cells[0] not in ("功能", "") and cells[3] not in ("", "无"): + return " / ".join(cells[:4])[:n] + if t.startswith(("功能:", "功能:")): + return t[3:].strip()[:n] + lines = [x for x in text.strip().splitlines() if x.strip()] + return lines[0][:n] if lines else "" + + +def adapt_brief(idea): + """从报告里只取「功能」和「适配」两段。 + + shortcut: 整篇报告(含 200 行文件表)喂进去后模型会重新理解全仓, + 60 分钟改不完一处(实测超时两次)。 + """ + want = [] + for m in re.finditer(r"^#{2,4}\s*(.+)$", idea, re.M): + title = m.group(1) + start = m.end() + nxt = idea.find("\n#", start) + body = idea[start:nxt if nxt > 0 else len(idea)] + if "适配" in title or "功能" in title or "改动" in title: + want.append(f"{title}\n{body.strip()[:1800]}") + return "\n\n".join(want)[:4000] or idea[:2500] + + +def humanize_hint(): + """PR 正文的「说人话」技能路径。 + + 技能本身 36 KB,塞进 prompt 会让 agent 静默超时(实测十几 KB 的 prompt 30 分钟零输出), + 所以只给路径,让它自己读。CI 由 workflow 把 .github/autobot-skills 拷进 $HERMES_HOME/skills。 + """ + home = os.environ.get("HERMES_HOME") or os.path.expanduser("~/.hermes") + return (f"写正文前先读 {os.path.join(home, 'skills', 'humanizer', 'SKILL.md')}" + "(怎么把话说成人话、哪些 AI 味要删);文件不在就忽略这句。\n") + + +def implement(src, idea, lines, pol): + """两次短调用:先出改动方案,再出 unified diff。 + + shortcut: 一次调用干完「读代码→判断→写实现→写测试→接线」时 7 轮全败 + (只写计划/超时/不接线/抄垃圾/判定无需改动),单次失败要 90 分钟; + 拆成 10 分钟 + 20 分钟两段,失败便宜,方案段还能给 diff 段当输入。 + + 材料一律写文件、prompt 只留几句:十几 KB 的 prompt 让 agent 30 分钟零输出, + 而同样环境下的短 prompt 4 分钟就能跑完(自检)。 + """ + up = up_clone(src) + ban = ban_brief(pol) + brief_f = "/tmp/autobot-brief.md" + with open(brief_f, "w", encoding="utf-8") as f: + f.write(f"# 上游仓库\n{src} clone 在 {up}(只读参考)\n\n" + f"# 分析结论\n{adapt_brief(idea)}\n\n" + f"# 硬线\n{ban}\n" + "# 本仓 Go 文件清单(不要猜路径,就照这个读)\n" + + "\n".join(own_brief()) + "\n") + plan_f = os.path.join(ROOT, "autobot-plan.md") + patch = os.path.join(ROOT, "autobot.patch") + for f in (plan_f, patch): + if os.path.isfile(f): + os.remove(f) + + # 第一段:只出方案,不许写其它文件 + code, out = agent( + f"先读 {brief_f}。本仓是 Go 项目(当前目录)。\n" + f"把改动方案写进 {plan_f}:要改哪个 文件:函数、改成什么、测试加在哪," + "每处给出准确位置与代码。\n" + "不要写实现文件、不要写 diff、不要跑 go build。直接写文件,不要回说明。\n" + + ban, + int(os.environ.get("AGENT_PLAN_TIMEOUT") or 1800), plan_f) + if not os.path.isfile(plan_f): + say(lines, f"{src}: 改动方案未产出(退出码 {code},prompt 材料已落文件)|{out}") + return False, "" + plan_in = "/tmp/autobot-plan-input.md" + with open(plan_in, "w", encoding="utf-8") as f: + f.write(open(plan_f, encoding="utf-8").read()[:12000]) + os.remove(plan_f) + + # 第二段:按方案出 diff + code, out = agent( + f"读 {plan_in}(改动方案)和 {brief_f}(本仓文件清单)。本仓是 Go 项目(当前目录)。\n" + f"把它写成标准 unified diff 存进 {patch},不要动工作区任何文件:\n" + "--- a/internal/foo.go\n+++ b/internal/foo.go\n@@ -10,6 +10,8 @@\n 上下文行\n-旧行\n+新行\n" + "只能修改已存在的文件;测试加进已存在的 _test.go。直接写 patch,不要回说明。\n" + f"写完自己跑 `git apply --check {patch}` 确认能打上(--check 不改工作区)," + "打不上就照文件真实内容重写,别交一个打不上的 patch。\n" + f"写完再写 autobot-pr.md,第一段用人话,四行,然后空一行,再接五行细节:\n" + "人话四行——一句话说清这 PR 干了什么 / 合了之后日常用法有什么变化(没变化就直说)/ 会不会弄坏现在能用的东西(会就说是哪一处) / 要不要我拍板(比如映射是猜的就得人定)\n" + "细节五行:问题 / 改动 / 位置 / 优缺点 / 影响。\n" + + humanize_hint() + ban, + int(os.environ.get("AGENT_IMPLEMENT_TIMEOUT") or 1800), patch) + if not os.path.isfile(patch): + say(lines, f"{src}: 实现未产出(退出码 {code})|{out}") + return False, "" + ok, why = apply_patch(patch) + if ok: + os.remove(patch) + else: + # 留证据:patch 是模型手写的,删掉就查不出是行号漂了、还是内容被剥掉了 + # (上一轮 Buddy2api 那条只留了一句 payload.go:221,无从下手)。 + raw = open(patch, encoding="utf-8", errors="replace").read() + print("--- 应用失败的 patch 原文 ---\n" + raw[:12000], flush=True) + os.remove(patch) + say(lines, f"{src}: patch 应用失败|{why}") + return False, "" + if not run("git", "status", "--porcelain", "-uall", check=False)[1].strip(): + say(lines, f"{src}: patch 应用后没有改动") + return False, "" + return True, read_summary() + + +def apply_patch(patch): + """模型手写的 unified diff 行号常常不准:--recount 重算 hunk 头,-C1 放宽上下文。 + + shortcut: 不做 fuzzy 合并,三次都失败就算这条候选没成(人看的报告还在)。 + """ + # 模型常把 diff 包在 ```diff 里或前面带说明,剥掉再喂 git apply + raw = open(patch, encoding="utf-8").read() + lines = [l for l in raw.splitlines() if not l.startswith("```")] + start = next((i for i, l in enumerate(lines) if l.startswith(("--- ", "diff --git"))), 0) + open(patch, "w", encoding="utf-8").write("\n".join(lines[start:]) + "\n") + err = "" + for extra in (["--recount", "-C1"], ["--recount", "-C1", "--3way"], ["--recount", "-C0"]): + r = subprocess.run(["git", "apply", *extra, patch], cwd=ROOT, + capture_output=True, text=True) + if r.returncode == 0: + return True, "" + err = (r.stderr or r.stdout).strip()[:300] + return False, err + + +def read_summary(): + """agent 写的 PR 正文材料;读完即删,别让它混进提交。""" + f = os.path.join(ROOT, "autobot-pr.md") + if not os.path.isfile(f): + return "" + text = open(f, encoding="utf-8").read().strip() + os.remove(f) + return text + + +def finish(src, pol): + """落地闸:外星文件、孤儿实现、build/vet/test 全绿才提交。返回 (ok, 说明)。""" + status = run("git", "status", "--porcelain", "-uall", check=False)[1].strip() + if not status: + return False, "没有改动" + tracked = set(run("git", "ls-tree", "-r", "--name-only", "HEAD").splitlines()) + changed = [l[3:] for l in status.splitlines()] + # agent 常把上游的 .bat/.sh 一起抄进来。这些本来就不该进本仓,删掉继续, + # 不要因为一条垃圾文件把整条实现丢掉(真丢过一整轮)。 + alien = [f for f in changed if f not in tracked and not f.endswith((".go", ".md"))] + if alien: + run("git", "reset", "-q", "HEAD", "--", *alien, check=False) + for f in alien: + if os.path.isfile(f): + os.remove(f) + changed = [f for f in changed if f not in alien] + if not changed: + return False, "清掉外星文件后没有改动" + status = run("git", "status", "--porcelain", "-uall", check=False)[1].strip() + if not status: + return False, "清掉外星文件后没有改动" + # 只新增文件、没接线到既有代码 = 孤儿实现:能编译过测试,但行为没变 + if all(f not in tracked for f in changed): + return False, f"只新增 {changed[:5]}、未接线到既有文件" + # 先 add 再按 --cached 取 diff:新增文件不在 git diff HEAD 里,而 PR #141 那种 + # 「整包加一张密钥表」正是新增文件,只看工作区 diff 会漏掉一半改动。 + run("git", "add", "-A", check=False) + hit = policy_hit([l[3:] for l in status.splitlines()], + run("git", "diff", "--cached", check=False)[1], pol) + if hit: + return False, f"闸门拦下 —— {hit}" + for cmd in (["go", "build", "./..."], ["go", "vet", "./..."], ["go", "test", "./..."]): + code, out = run(*cmd, check=False) + if code != 0: + return False, f"{' '.join(cmd[1:])} 未通过:{out[-600:]}" + run("git", "add", "-A") + run("git", *BOT, "commit", "-q", "-m", f"autobot: 借鉴 {src} 的实现(agent 改写,非原样移植)") + return True, "" + + +def past_attempts(): + """本仓已关掉(未被合并)的 AutoBot PR:改过哪些文件 + 人给的理由。 + + AutoBot 原先没有任何记忆:yuechuya 那个 tool_call_sequence_broken 提了三次 + (#29/#31 被人关掉,#140 换个 sha 又来一遍 —— 分支名是报告内容的 sha1, + 报告重写一次就绕过去了)。这里一次 graphql 把历史取回来,分析时喂给 agent、 + 落地时当冷却闸。 + + shortcut: 只取近 100 条已关 PR(一次调用),不翻完整历史;真要更早的再说。 + """ + repo = os.environ.get("GITHUB_REPOSITORY") or "" + if "/" not in repo: + return [] + owner, name = repo.split("/", 1) + q = ('query{repository(owner:%s,name:%s){pullRequests(states:CLOSED,first:100,' + 'orderBy:{field:CREATED_AT,direction:DESC})' + '{nodes{number title url mergedAt closedAt headRefName ' + 'files(first:80){nodes{path}} comments(last:3){nodes{body}}}}}}') + code, out = run("gh", "api", "graphql", "-f", + "query=" + (q % (json.dumps(owner), json.dumps(name))), + check=False, timeout=180) + if code != 0: + print(f"历史读取失败(不当致命):{out[:200]}", flush=True) + return [] + try: + nodes = json.loads(out)["data"]["repository"]["pullRequests"]["nodes"] or [] + except (ValueError, KeyError, TypeError): + return [] + hist = [] + for n in nodes: + title = n.get("title") or "" + if n.get("mergedAt") or not title.startswith("autobot:"): + continue + # 关掉的理由取最后一条非空评论(人通常补在末尾);自动关闭的那种也留着 + why = "" + for c in (n.get("comments") or {}).get("nodes") or []: + if (c.get("body") or "").strip(): + why = " ".join(c["body"].split()) + hist.append({ + "number": n["number"], + "title": title, + "closed": (n.get("closedAt") or "")[:10], + "branch": n.get("headRefName") or "", + "files": [f["path"] for f in (n.get("files") or {}).get("nodes") or []], + "why": why[:400], + }) + return hist + + +def hist_brief(hist): + """历史提案写进 agent 的材料文件:跨仓库的重复方向只能靠它拦(同仓库有冷却闸)。""" + if not hist: + return "" + rows = [] + for h in hist[:20]: + rows.append(f"- #{h['number']}({h['closed']} 关){h['title']}\n" + f" 改过: {', '.join(h['files'][:12]) or '(未取到)'}\n" + f" 关掉的理由: {h['why'] or '(没写理由)'}") + return ("\n## 已经提过、被人关掉的提案(同样的方向别再提)\n" + "这些是本仓自己的历史。重复提之前必须在报告里写清楚「这次和 #N 的不同在哪」," + "写不出来就值得度 0。\n" + "\n".join(rows) + "\n") + + +COOLDOWN_DAYS = 14 + + +def cooling_down(hist, repos, days=COOLDOWN_DAYS): + """仓库 → 上次被关的日期(冷却期内)。人关一次 PR 就是一次明确否决。 + + 按仓库而不是按文件冷却:panel.go 这种主文件几乎所有改动都会碰,按文件拦会把 + 正常的新功能一起拦掉;「这个仓库刚被否过」才是稳定的信号。 + + 仓库取自 PR 的分支名而不是标题:标题 38e4f3970 起改成人话第一行,不再含仓库名, + 按标题正则提取的 gate 会让之后每个 PR 都提取不到、冷却永不生效(#145 实测)。 + 分支名是 branch_for 生成的,不随标题口径变。 + """ + cutoff = time.time() - days * 86400 + slugs = {slug_of(r): r for r in repos} + cool = {} + for h in hist: + br = (h.get("branch") or "").rsplit("/", 1)[-1] # 去掉 autobot/ 前缀 + src = next((r for s, r in slugs.items() if br.startswith(s + "-")), "") + if not src: + continue + try: + t = time.mktime(time.strptime(h["closed"], "%Y-%m-%d")) + except ValueError: + continue + if t > cutoff and t > cool.get(src, (0, ""))[0]: + cool[src] = (t, h["number"], h["closed"]) + return {k: (v[1], v[2]) for k, v in cool.items()} + + +def slug_of(src): + """owner/repo → 分支名里的那段 slug(branch_for 与冷却判定共用)。""" + return re.sub(r"[^a-z0-9-]+", "-", src.lower().replace("/", "-")).strip("-") + + +def branch_for(src, idea, pol): + """报告内容相同 → 分支名相同 → 同一件事只推一次(land_max 才能落到新工作上)。 + + shortcut: 去重靠内容 sha1,不比对语义;报告改一个字就是新分支,重复提案只能靠 + 人关 PR 兜住,升级点是给报告加稳定的 feature key。 + """ + return f"{pol['branch_prefix']}{slug_of(src)}-{hashlib.sha1(idea.encode()).hexdigest()[:7]}" + + +def proposal_part(idea): + """只扫报告里「适配:」之后的部分。 + + 对比表必然把上游的多密钥/配额那一行列出来(还常写着「明确不做」),扫全表等于让 + 几乎每份报告都被禁区命中——实测 smart-open/TraeWorkAssistant 就是这么被误拦的。 + """ + i = idea.rfind("\n适配") + return idea[i:] if i >= 0 else idea + + +def pick_candidates(reports, land_max, pol, exists, cool=None): + """按值得度降序取前 land_max 条还没落地过的报告,返回 (picked, dups)。 + + 分支名是报告内容的 sha1:同名分支已存在 = 这份报告上一轮已经推过,必须剔掉再数 + 名额,否则重复报告白占名额且 push 会因远端已存在而失败(实测连跑两次同一批报告, + 第一条就 RuntimeError 退出、后两条根本没跑)。 + """ + fresh, dups, banned = [], set(), {} + for score, path in reports: + if score < 2: + continue + src = os.path.basename(path)[:-3].replace("__", "/") + idea = open(path, encoding="utf-8").read() + hit = policy_hit([], proposal_part(idea), pol) + if hit: + banned[path] = hit + elif (cool or {}).get(src): + n, d = cool[src] + banned[path] = f"同一仓库 #{n} 刚被关({d}),{COOLDOWN_DAYS} 天冷却期内" + elif exists(branch_for(src, idea, pol)): + dups.add(path) + else: + fresh.append((score, path)) + return fresh[:land_max], dups, banned + + +def branch_exists(branch): + return run("git", "ls-remote", "--exit-code", "--heads", "origin", branch, + check=False)[0] == 0 + + +def pr_title(summary, src): + """标题用人话第一行。摘要为空才回落仓库名(旧标题等于没说干什么)。""" + for line in (summary or "").splitlines(): + line = re.sub(r"[*#`]", "", re.sub(r"^[>\-\s]+", "", line)).strip() + if line and not line.startswith(("问题", "改动", "位置", "优缺点", "影响")): + return "autobot: " + line + return f"autobot: 借鉴 {src} 的实现" + + +def land(src, rp, pol, args, lines): + idea = open(rp, encoding="utf-8").read() + branch = branch_for(src, idea, pol) + # 上一条失败可能留下冲突 index,checkout -B 会报「resolve your index first」 + run("git", "reset", "-q", "--hard", "HEAD", check=False) + run("git", "clean", "-qfd", check=False) + run("git", "checkout", "-q", "-B", branch, pol["base"]) + + ok, summary = implement(src, idea, lines, pol) + if not ok: + run("git", "checkout", "-q", pol["base"]) + return 0 + ok, why = finish(src, pol) + if not ok: + say(lines, f"{src}: 闸门拦下 —— {why}") + run("git", "reset", "-q", "--hard", "HEAD") + run("git", "clean", "-qfd", check=False) + run("git", "checkout", "-q", pol["base"]) + return 0 + if args.dry_run: + say(lines, f"{src}: dry-run,不推送(本地分支 {branch})") + run("git", "checkout", "-q", pol["base"]) + return 0 + + # main 是生产环境:自动化只许推 autobot/* 分支 + assert branch.startswith("autobot/"), branch + run("git", "push", "-q", "-u", "origin", branch) + run("gh", "label", "create", pol["label"], "--repo", os.environ["GITHUB_REPOSITORY"], + "--color", "ededed", "--description", "AutoBot 分析后提出的借鉴改动", check=False) + body = (summary or f"分析报告:`{os.path.basename(rp)}`\n") + \ + "\n- `go build` / `go vet` / `go test ./...` 已通过;合并前请人工确认行为等价。\n" + run("gh", "pr", "create", "--repo", os.environ["GITHUB_REPOSITORY"], "--base", pol["base"], + "--head", branch, "--title", pr_title(summary, src)[:120], + "--body", body, "--label", pol["label"]) + say(lines, f"已开 PR:{branch}") + run("git", "checkout", "-q", pol["base"]) + return 1 + + +def shard(seq, spec): + """--shard i/n:按直线切片(matrix 并行用)。""" + if not spec: + return seq + i, n = (int(x) for x in spec.split("/")) + return [x for k, x in enumerate(seq) if k % n == i] + + +def main(): + ap = argparse.ArgumentParser() + ap.add_argument("--phase", choices=["analyze", "implement", "all"], default="all") + ap.add_argument("--shard", default="", help="i/n,只处理该片(matrix 并行用)") + ap.add_argument("--repo", help="只处理这一个仓库") + ap.add_argument("--dry-run", action="store_true") + args = ap.parse_args() + + cfg = yaml.safe_load(open(os.path.join(ROOT, "AutoBot.yml"), encoding="utf-8")) + up, pol = cfg["upstream"], cfg["policy"] + repos = [args.repo] if args.repo else [r["repo"] if isinstance(r, dict) else r + for r in up["repos"]] + lines = ["# AutoBot 报告", ""] + hist = past_attempts() + if hist: + say(lines, f"历史:{len(hist)} 个已关掉的 AutoBot PR(冷却中的仓库 {len(cooling_down(hist, repos))} 个)") + + if args.phase in ("analyze", "all"): + todo = shard(repos, args.shard) + say(lines, f"分析 {len(todo)} 个仓库(共 {len(repos)},分片 {args.shard or '全部'})") + made = 0 + for src in todo: + made += 1 if analyze(src, lines, pol, hist) else 0 + if todo and not made: + # 一个报告都没产出(典型原因:模型额度 429)必须让 job 红,别假装成功 + say(lines, "本片没有产出任何报告") + write_report(lines) + return 1 + + if args.phase in ("implement", "all"): + reports = [] + if os.path.isdir(REPORT_DIR): + for f in os.listdir(REPORT_DIR): + p = os.path.join(REPORT_DIR, f) + reports.append((report_score(open(p, encoding="utf-8").read()), p)) + reports.sort(reverse=True) + if not reports and not args.dry_run: + # 分析阶段全挂 / 报告没传过来时这里一份输入都没有,别把「什么都没干」报成绿 + say(lines, "没有任何输入报告,落地步骤无事可做") + write_report(lines) + return 1 + land_max = int(up.get("land_max") or 2) + picked, dups, banned = pick_candidates(reports, land_max, pol, branch_exists, + cooling_down(hist, repos)) + # 总决策表:每份报告的去向都留痕,人审时不用回头翻 68 个 job + say(lines, f"## 决策表({len(reports)} 份报告,land_max={land_max})") + say(lines, "| 仓库 | 值得度 | 摘要 | 决定 |") + say(lines, "|---|---|---|---|") + kept = {p for _s, p in picked} + for sc, rp in reports: + name = os.path.basename(rp)[:-3].replace("__", "/") + if rp in kept: + why = "落地" + elif sc < 2: + why = "值得度<2" + elif rp in banned: + why = f"禁区:{banned[rp]}" + elif rp in dups: + why = "同报告已落地(分支已存在)" + else: + why = "超出 land_max" + say(lines, f"| {name} | {sc} | {report_head(open(rp, encoding='utf-8').read())} | {why} |") + say(lines, "") + say(lines, "落地候选:" + (", ".join(f"{os.path.basename(p)}({s})" for s, p in picked) or "无")) + landed = sum(1 for _s, p in picked + if land(os.path.basename(p)[:-3].replace("__", "/"), p, pol, args, lines)) + if picked and not landed and not args.dry_run: + # 有候选却一条都没落成(超时/闸门)必须红,别报成功 + say(lines, "有候选但没有任何一条落地") + write_report(lines) + return 1 + + write_report(lines) + return 0 + + +def write_report(lines): + with open(REPORT, "w", encoding="utf-8") as f: + f.write("\n".join(lines) + "\n") + + +if __name__ == "__main__": + sys.exit(main()) \ No newline at end of file diff --git a/scripts/cache_audit.py b/scripts/cache_audit.py new file mode 100644 index 0000000000000000000000000000000000000000..4a7b8856b8316663a3aa5178b157891950aac88f --- /dev/null +++ b/scripts/cache_audit.py @@ -0,0 +1,171 @@ +#!/usr/bin/env python3 +"""cache_audit.py — 按输入大小审计上游前缀缓存的命中率,并拆开「冷启动」与「暖会话」。 + +背景(issue #256 那类报告的根因):只看「各输入档位的平均命中率」会把两件事混在 +一起,读出来的结论通常是错的: + + 1. 冷启动成本 —— 新会话第一跳没有前缀可复用,必然 miss。输入越小,冷启动在一次 + 请求里占的比例越高,所以小档的平均命中率**天然**低(20% 上下不是故障)。 + 2. 暖会话被打断 —— 同一会话的后续轮本该命中 95%+。它掉下来才是故障:会话指纹 + 每轮变化(例如取「整个 body 前 64KiB」算哈希,对话不到 64KiB 时最新一轮也被 + 算进去)→ 每轮换账号 / 换 cache 槽 → 前缀缓存全废。 + +本脚本把两件事分开算,并给出「暖会话打断率」这个能直接定性的指标: +同一 (client_ip, user_agent, model) 上相邻两跳、prompt 只小幅增长 = 同一会话继续; +其中上一跳命中 >=90% 而这一跳 <50% = 暖会话被打断。 + +判据参考(部署后验收): + - 各档「续轮」命中率都应 >=95%;80k+ 应 >=98% + - 暖会话打断率应 <1% + - 各档「全量」命中率低但续轮高 = 冷启动占比高,不是故障 + - 长会话(>=10 跳)里出现 <80% 的,逐个查是不是换号或 prompt_cache_key 漂移 + +用法: + python3 scripts/cache_audit.py /opt/workbuddy2api-panel/data/request-logs + ssh ubuntu@host 'sudo -n python3 -' < scripts/cache_audit.py # 直接把脚本灌过去 +(只读 JSONL,不需要 panel token,也不改任何文件。) +""" +import collections +import glob +import json +import os +import sys + +BUCKETS = [(0, 16_000, "<16k"), (16_000, 40_000, "16-40k"), + (40_000, 80_000, "40-80k"), (80_000, 10**9, "80k+")] + + +def bucket_of(prompt_tokens): + for lo, hi, name in BUCKETS: + if lo <= prompt_tokens < hi: + return name + return "?" + + +def load(dirpath): + files = sorted(glob.glob(os.path.join(dirpath, "requests-*.jsonl"))) + if not files: + raise SystemExit("没有找到 requests-*.jsonl:%s" % dirpath) + out = [] + for f in files: + with open(f, encoding="utf-8") as fh: + for line in fh: + line = line.strip() + if not line: + continue + try: + e = json.loads(line) + except Exception: + continue + pt = int(e.get("prompt_tokens") or 0) + ch = int(e.get("cache_hit_tokens") or 0) + cm = int(e.get("cache_miss_tokens") or 0) + if pt <= 0 or ch + cm == 0: + continue # 没有用量/缓存字段的(非 chat、或上游没给 usage)不参与 + out.append({ + "t": str(e.get("time") or ""), + "ip": e.get("client_ip") or "", + "ua": (e.get("user_agent") or "")[:24], + "model": e.get("model") or "", + "acct": e.get("account") or "", + "pt": pt, "hit": ch, "den": ch + cm, + }) + out.sort(key=lambda x: x["t"]) + return files, out + + +def main(): + if len(sys.argv) < 2: + raise SystemExit("用法: cache_audit.py ") + files, ev = load(sys.argv[1]) + print("files = %d (%s .. %s)" % (len(files), os.path.basename(files[0]), + os.path.basename(files[-1]))) + print("events = %d" % len(ev)) + if not ev: + return + + # 续轮标记:同一 (ip, ua, model) 上相邻两跳、prompt 小幅增长 = 同一会话继续。 + # 阈值 15%/4k 取的是「比一轮正常增长宽、比换会话窄」的经验值;两条都放宽会让 + # 不同会话被误并成一条(把冷启动算进续轮,反而掩盖故障)。 + for i in range(1, len(ev)): + a, b = ev[i - 1], ev[i] + b["cont"] = False + if (a["ip"], a["ua"], a["model"]) != (b["ip"], b["ua"], b["model"]): + continue + grow = b["pt"] - a["pt"] + if 0 < grow < max(4000, a["pt"] * 0.15): + b["cont"] = True + ev[0]["cont"] = False + + n = collections.Counter(); hit = collections.Counter(); den = collections.Counter() + cn = collections.Counter(); chit = collections.Counter(); cden = collections.Counter() + for e in ev: + b = bucket_of(e["pt"]) + n[b] += 1; hit[b] += e["hit"]; den[b] += e["den"] + if e["cont"]: + cn[b] += 1; chit[b] += e["hit"]; cden[b] += e["den"] + + print() + print("%-8s %8s %9s %10s %9s %9s" % ("bucket", "turns", "all%", "continuation", "cont%", "cold%")) + for _, _, b in BUCKETS: + if not den[b]: + continue + cold_hit, cold_den = hit[b] - chit[b], den[b] - cden[b] + print("%-8s %8d %8.1f%% %10d %8.1f%% %8.1f%%" % ( + b, n[b], 100.0 * hit[b] / den[b], cn[b], + 100.0 * chit[b] / cden[b] if cden[b] else 0, + 100.0 * cold_hit / cold_den if cold_den else 0)) + + # 暖会话打断率:上一跳 >=90%,这一跳 <50% + warm = broken = switched = 0 + for a, b in zip(ev, ev[1:]): + if not (a["hit"] / a["den"] >= 0.9): + continue + grow = b["pt"] - a["pt"] + if not (0 < grow < max(4000, a["pt"] * 0.15)): + continue + if (a["ip"], a["ua"], a["model"]) != (b["ip"], b["ua"], b["model"]): + continue + warm += 1 + if b["hit"] / b["den"] < 0.5: + broken += 1 + if a["acct"] != b["acct"]: + switched += 1 + print() + print("暖会话续跳 = %d,被打断 = %d (%.2f%%),其中换号 %d" % ( + warm, broken, 100.0 * broken / warm if warm else 0, switched)) + if warm and broken / warm > 0.01: + print(" ↑ 超过 1%:查会话指纹是否每轮变化(换号 = 粘性键漂移;同号 = cache 槽漂移)") + + # 长会话(>=10 跳)命中率分布:这里出现低值一定有问题,冷启动稀释解释不了 + runs = [] + cur = [] + for e in ev: + if cur and e["cont"] and (cur[-1]["ip"], cur[-1]["ua"], cur[-1]["model"]) == (e["ip"], e["ua"], e["model"]): + cur.append(e) + else: + if cur: + runs.append(cur) + cur = [e] + if cur: + runs.append(cur) + dist = collections.Counter() + long_n = 0 + worst = [] + for r in runs: + if len(r) < 10: + continue + long_n += 1 + h = sum(x["hit"] for x in r[1:]); d = sum(x["den"] for x in r[1:]) + pct = 100.0 * h / d if d else 0 + key = ">=95%" if pct >= 95 else "80-95%" if pct >= 80 else "50-80%" if pct >= 50 else "<50%" + dist[key] += 1 + if pct < 80: + worst.append((pct, len(r), r[0]["ua"], r[0]["model"])) + print("长会话(>=10 跳)= %d,命中分布 %s" % (long_n, dict(dist))) + for pct, ln, ua, model in sorted(worst)[:5]: + print(" 低命中长会话: %.1f%% %d 跳 %s %s" % (pct, ln, ua, model)) + + +if __name__ == "__main__": + main() diff --git a/scripts/probe_active.py b/scripts/probe_active.py index cd9d9e634e80b8254e36bd51cd7df270768800cf..09c365ed557937ccc8b878c83d46c563f9f0986b 100644 --- a/scripts/probe_active.py +++ b/scripts/probe_active.py @@ -1,133 +1,133 @@ -#!/usr/bin/env python3 -"""WorkBuddy 活跃上报探针 / 解冻工具. - -用途 - probe 只读:查某账号 growth 任务状态 + streak - report 写:向 /v2/report 发一条 chat_request_send(点亮活跃/连登 + 解锁 first_buddy) - unlock 写:report -> agreement -> buddy/first(无猫号领免费猫) - -用法 - python3 probe_active.py probe 00e26541 - python3 probe_active.py report 0225284f - python3 probe_active.py unlock 0225284f --yes - python3 probe_active.py report ALL --yes --gap 1.05 # 全池 - -注意 - - 默认 dry-run:写动作必须显式加 --yes - - 单账号同接口间隔 >=1.05s(--gap) - - body 必须含 userId 字段,否则服务端 200 但静默丢弃 -""" -import json, os, sys, time, glob, argparse, urllib.request, urllib.error - -AUTHS = "/root/workbuddy2api/auths" -CHAT_BASE = "https://copilot.tencent.com" # growth / report -BILL_BASE = "https://www.codebuddy.cn" # billing / report - -def cred(prefix): - hits = glob.glob(os.path.join(AUTHS, f"workbuddy-{prefix}*.json")) - if not hits: - raise SystemExit(f"no auth for {prefix}") - d = json.load(open(hits[0])) - a, acc = d["auth"], d["account"] - return {"token": a["accessToken"], "domain": a.get("domain") or "", - "uid": acc["uid"], "nick": acc.get("nickname", ""), - "file": os.path.basename(hits[0])} - -def call(c, method, path, body=None, host=CHAT_BASE, timeout=30): - url = path if path.startswith("http") else host + path - hdr = {"Authorization": "Bearer " + c["token"], "X-User-Id": c["uid"], - "X-Domain": c["domain"], "Accept": "application/json", - "Content-Type": "application/json", - "User-Agent": "CLI/2.63.2 CodeBuddy/2.63.2", - "Origin": "https://www.codebuddy.cn", "Referer": "https://www.codebuddy.cn/"} - data = json.dumps(body).encode() if body is not None else None - req = urllib.request.Request(url, data=data, headers=hdr, method=method) - try: - with urllib.request.urlopen(req, timeout=timeout) as r: - return r.status, json.loads(r.read().decode("utf-8", "replace")) - except urllib.error.HTTPError as e: - t = e.read().decode("utf-8", "replace") - try: return e.code, json.loads(t) - except Exception: return e.code, {"raw": t[:300]} - except Exception as e: - return -1, {"err": repr(e)} - -def chat_event(c, conversation_id=None): - """客户端 chat_request_send 事件形状(照抄 CLI,勿删 userId)。""" - now = int(time.time() * 1000) - cid = conversation_id or f"wb-active-{now}" - return {"eventCode": "chat_request_send", "timestamp": now, "reportDelay": 0, - "mode": "craft", "conversationId": cid, "requestId": cid, - "inputLength": 12, "requestModelId": "deepseek-v4-flash", - "requestModelName": "DeepSeek V4 Flash", "isPlan": False, - "isAutoExecuteTerminal": False, "isAutoModify": False, - "codebaseEnable": False, "maxToken": 0, "maxSteps": 0, "temperature": 0, - "maxRetries": 0, "mentionContexts": [], "knowledgeId": [], - "knowledgeName": [], "codebaseId": "", "mentionContextCount": 0, - "command": "", "expertId": "", "recommendId": "", "skillId": "", - "skillCount": 0, "totalCount": 0, "fileUri": "", "presentAt": now, - "traceId": "", "rootRequestId": cid, "parentConversationId": cid, - "agentName": "default", "agentType": "conversation", "userId": c["uid"]} - -def report_activity(c): - """点亮活跃/连登。返回 (status, code).""" - st, r = call(c, "POST", "/v2/report", [chat_event(c)], host=BILL_BASE) - return st, r.get("code") - -def tasks(c): - st, d = call(c, "GET", "/v2/activity/growth/tasks") - out = {} - for t in (d.get("data", {}).get("tasks") or []): - out[t["task_code"]] = (t["accept_status"], t.get("progress")) - return out - -def unlock(c, n_reports=6): - """无猫号解冻:report -> agreement -> buddy/first -> chat_5""" - st, code = report_activity(c) - print(f" report -> {st} code={code}") - time.sleep(2) - st, ag = call(c, "POST", "/activity/growth/buddy/agreement", {"agree": True}) - print(f" agreement -> {st} code={ag.get('code')}") - st, bf = call(c, "POST", "/activity/growth/buddy/first", {}) - d = bf.get("data") or {} - print(f" buddy/first -> {st} {bf.get('msg')} credit={d.get('credit')} energy={d.get('energy')}") - return bf - -def main(): - ap = argparse.ArgumentParser() - ap.add_argument("action", choices=["probe", "report", "unlock"]) - ap.add_argument("account", help="uid 前缀,或 ALL") - ap.add_argument("--yes", action="store_true", help="确认执行写操作") - ap.add_argument("--gap", type=float, default=1.05) - a = ap.parse_args() - - if a.account.upper() == "ALL": - prefixes = [os.path.basename(p)[10:18] - for p in sorted(glob.glob(AUTHS + "/workbuddy-*.json"))] - else: - prefixes = [a.account] - - for pre in prefixes: - c = cred(pre) - print(f"== {c['uid'][:8]} ({c['nick']}) ==") - if a.action == "probe": - t = tasks(c) - st, s = call(c, "GET", "/activity/growth/streak") - print(" first_buddy:", t.get("first_buddy"), - "| RichMeow_Chat:", t.get("RichMeow_Chat"), - "| chat_5:", t.get("chat_5")) - print(" streak.days:", (s.get("data", {}).get("streak", {}) or {}).get("days")) - elif a.action == "report": - if not a.yes: - print(" [dry-run] 将上报 1 条 chat_request_send(加 --yes 执行)") - else: - print(" report ->", report_activity(c)) - else: # unlock - if not a.yes: - print(" [dry-run] 将 report + agreement + buddy/first(加 --yes 执行)") - else: - unlock(c) - time.sleep(a.gap) - -if __name__ == "__main__": - main() +#!/usr/bin/env python3 +"""WorkBuddy 活跃上报探针 / 解冻工具. + +用途 + probe 只读:查某账号 growth 任务状态 + streak + report 写:向 /v2/report 发一条 chat_request_send(点亮活跃/连登 + 解锁 first_buddy) + unlock 写:report -> agreement -> buddy/first(无猫号领免费猫) + +用法 + python3 probe_active.py probe 00e26541 + python3 probe_active.py report 0225284f + python3 probe_active.py unlock 0225284f --yes + python3 probe_active.py report ALL --yes --gap 1.05 # 全池 + +注意 + - 默认 dry-run:写动作必须显式加 --yes + - 单账号同接口间隔 >=1.05s(--gap) + - body 必须含 userId 字段,否则服务端 200 但静默丢弃 +""" +import json, os, sys, time, glob, argparse, urllib.request, urllib.error + +AUTHS = "/root/workbuddy2api/auths" +CHAT_BASE = "https://copilot.tencent.com" # growth / report +BILL_BASE = "https://www.codebuddy.cn" # billing / report + +def cred(prefix): + hits = glob.glob(os.path.join(AUTHS, f"workbuddy-{prefix}*.json")) + if not hits: + raise SystemExit(f"no auth for {prefix}") + d = json.load(open(hits[0])) + a, acc = d["auth"], d["account"] + return {"token": a["accessToken"], "domain": a.get("domain") or "", + "uid": acc["uid"], "nick": acc.get("nickname", ""), + "file": os.path.basename(hits[0])} + +def call(c, method, path, body=None, host=CHAT_BASE, timeout=30): + url = path if path.startswith("http") else host + path + hdr = {"Authorization": "Bearer " + c["token"], "X-User-Id": c["uid"], + "X-Domain": c["domain"], "Accept": "application/json", + "Content-Type": "application/json", + "User-Agent": "CLI/2.63.2 CodeBuddy/2.63.2", + "Origin": "https://www.codebuddy.cn", "Referer": "https://www.codebuddy.cn/"} + data = json.dumps(body).encode() if body is not None else None + req = urllib.request.Request(url, data=data, headers=hdr, method=method) + try: + with urllib.request.urlopen(req, timeout=timeout) as r: + return r.status, json.loads(r.read().decode("utf-8", "replace")) + except urllib.error.HTTPError as e: + t = e.read().decode("utf-8", "replace") + try: return e.code, json.loads(t) + except Exception: return e.code, {"raw": t[:300]} + except Exception as e: + return -1, {"err": repr(e)} + +def chat_event(c, conversation_id=None): + """客户端 chat_request_send 事件形状(照抄 CLI,勿删 userId)。""" + now = int(time.time() * 1000) + cid = conversation_id or f"wb-active-{now}" + return {"eventCode": "chat_request_send", "timestamp": now, "reportDelay": 0, + "mode": "craft", "conversationId": cid, "requestId": cid, + "inputLength": 12, "requestModelId": "deepseek-v4-flash", + "requestModelName": "DeepSeek V4 Flash", "isPlan": False, + "isAutoExecuteTerminal": False, "isAutoModify": False, + "codebaseEnable": False, "maxToken": 0, "maxSteps": 0, "temperature": 0, + "maxRetries": 0, "mentionContexts": [], "knowledgeId": [], + "knowledgeName": [], "codebaseId": "", "mentionContextCount": 0, + "command": "", "expertId": "", "recommendId": "", "skillId": "", + "skillCount": 0, "totalCount": 0, "fileUri": "", "presentAt": now, + "traceId": "", "rootRequestId": cid, "parentConversationId": cid, + "agentName": "default", "agentType": "conversation", "userId": c["uid"]} + +def report_activity(c): + """点亮活跃/连登。返回 (status, code).""" + st, r = call(c, "POST", "/v2/report", [chat_event(c)], host=BILL_BASE) + return st, r.get("code") + +def tasks(c): + st, d = call(c, "GET", "/v2/activity/growth/tasks") + out = {} + for t in (d.get("data", {}).get("tasks") or []): + out[t["task_code"]] = (t["accept_status"], t.get("progress")) + return out + +def unlock(c, n_reports=6): + """无猫号解冻:report -> agreement -> buddy/first -> chat_5""" + st, code = report_activity(c) + print(f" report -> {st} code={code}") + time.sleep(2) + st, ag = call(c, "POST", "/activity/growth/buddy/agreement", {"agree": True}) + print(f" agreement -> {st} code={ag.get('code')}") + st, bf = call(c, "POST", "/activity/growth/buddy/first", {}) + d = bf.get("data") or {} + print(f" buddy/first -> {st} {bf.get('msg')} credit={d.get('credit')} energy={d.get('energy')}") + return bf + +def main(): + ap = argparse.ArgumentParser() + ap.add_argument("action", choices=["probe", "report", "unlock"]) + ap.add_argument("account", help="uid 前缀,或 ALL") + ap.add_argument("--yes", action="store_true", help="确认执行写操作") + ap.add_argument("--gap", type=float, default=1.05) + a = ap.parse_args() + + if a.account.upper() == "ALL": + prefixes = [os.path.basename(p)[10:18] + for p in sorted(glob.glob(AUTHS + "/workbuddy-*.json"))] + else: + prefixes = [a.account] + + for pre in prefixes: + c = cred(pre) + print(f"== {c['uid'][:8]} ({c['nick']}) ==") + if a.action == "probe": + t = tasks(c) + st, s = call(c, "GET", "/activity/growth/streak") + print(" first_buddy:", t.get("first_buddy"), + "| RichMeow_Chat:", t.get("RichMeow_Chat"), + "| chat_5:", t.get("chat_5")) + print(" streak.days:", (s.get("data", {}).get("streak", {}) or {}).get("days")) + elif a.action == "report": + if not a.yes: + print(" [dry-run] 将上报 1 条 chat_request_send(加 --yes 执行)") + else: + print(" report ->", report_activity(c)) + else: # unlock + if not a.yes: + print(" [dry-run] 将 report + agreement + buddy/first(加 --yes 执行)") + else: + unlock(c) + time.sleep(a.gap) + +if __name__ == "__main__": + main() diff --git a/scripts/probe_max_tokens.py b/scripts/probe_max_tokens.py index c7fb9c79a70ddb26ab3539d6344914d7c75435c7..34eb64595a241486691fba4157845877bcd3cbe6 100644 --- a/scripts/probe_max_tokens.py +++ b/scripts/probe_max_tokens.py @@ -1,425 +1,425 @@ -#!/usr/bin/env python3 -# -*- coding: utf-8 -*- -""" -OpenAI 兼容端点的「真实输出上限」探测工具 -========================================== -背景:许多网关/中转会在 /v1/models 里透出 max_output_tokens,但它常常与实际能力不符 -(实测某网关对 deepseek-v4.1-flash 声称 393216,真实只有 32000)。更麻烦的是**静默钳制**: -请求 max_tokens 超过真实上限时不报错,而是内部截断——从 usage 只能看出"输出到某个值就停了"。 - -本工具用「强制长输出 + 阶梯上探」测出真实上限,关键判据区分两种停止: - - finish=length 且 输出 < 请求 → 上游截断,**输出值即真实上限**(可信,直接得出结果) - finish=length 且 输出 = 请求 → 支持至少这么多,继续上探更高阶梯 - finish=stop 且 输出 < 请求 → 模型自己不想写了,**不可作判据**,需强化提示重试 - -用法: - # 测某网关全部以给定前缀开头的模型(默认 cn:) - python probe_max_tokens.py --base http://211.154.25.123:7863/v1 --key sk-xxx - - # 指定模型 / 多个前缀 / 只看计划 - python probe_max_tokens.py --base ... --key ... --models flash,glm-5.3 - python probe_max_tokens.py --base ... --key ... --prefix cn: --prefix global: - python probe_max_tokens.py --base ... --key ... --dry-run - - # 控制成本与时长 - python probe_max_tokens.py --base ... --key ... --tiers 40000,100000 --retries 2 --timeout 900 - -结果: - - 控制台表格:模型 | 声称上限 | 实测上限 | 判据 | 耗时 - - JSONL 落盘(--out,默认 probe-max-tokens.jsonl),**支持 --resume 断点续测** - - --panel-out PATH 额外写面板契约文件(默认关闭;网关面板「模型与档位」的实测列读它): - {"version":1,"probes":{"cn:glm-5.2":{"claimed":131072,"measured":48000, - "verdict":"clamped|at_least|inconclusive","note":"原始判据文本", - "tested_at":"...","source":"probe_max_tokens.py"}}} - 写入为合并语义:未重测的模型保留旧记录;文件放网关 state 文件同目录 - (默认部署即 data/output_probes.json),面板下次查询即展示,网关零重启。 - - --limit N 只测前 N 个模型(先小批量试跑) - -成本提示:一个模型若真有极大上限,上探到高档位会生成数十万 token,耗时长且消耗额度。 - 默认最高阶梯 40000、上限 160000 已足够识别常见的 32K/48K/64K 钳制。 -""" - -import argparse -import json -import os -import re -import socket -import sys -import time -import urllib.error -import urllib.request -from pathlib import Path - -# 强制长输出的提示:目标值需与被测档位"量级相当"。 -# 实测教训:目标写得过大(数到 999999)模型会判断"不可能完成"而提前收尾(只输出 1~3k); -# 目标设为 12000~20000(能写满但看起来合理)时,模型会持续输出直到被硬截断,4/4 稳定命中。 -# 下面按档位缩放目标值:约 max_tokens/3 个数字(每数字行约 2~3 token,留余量防提前写完)。 -def long_prompt(max_tokens: int) -> str: - target = max(2000, min(200000, max_tokens // 3)) - return ( - f"请从 1 开始,每行输出一个数字,依次递增,一直数到 {target}。" - "严格只输出数字本身,每行一个;不要解释、不要总结、不要省略、不要合并、不要提前结束。" - ) - - -# 强化版(第一次被模型主动收尾时使用,仍保持量级匹配) -def long_prompt_hard(max_tokens: int) -> str: - target = max(2000, min(200000, max_tokens // 3)) - return ( - f"Count from 1 to {target}, one number per line, incrementing by 1. " - "Output digits only, one per line. Do not summarize, do not explain, " - "do not skip numbers, do not stop early — you must reach the target." - ) - - -def fetch_models(base: str, key: str, timeout: int = 20): - """取 /v1/models 列表:[{id, claimed_output, claimed_ctx}, ...]""" - url = base.rstrip("/") + "/models" - req = urllib.request.Request(url, headers={ - "Authorization": f"Bearer {key}", "x-api-key": key, "Accept": "application/json"}) - with urllib.request.urlopen(req, timeout=timeout) as r: - data = json.loads(r.read().decode("utf-8")) - items = data.get("data") if isinstance(data, dict) else data - out = [] - for it in items or []: - if isinstance(it, str): - out.append({"id": it.strip(), "claimed_output": None, "claimed_ctx": None}) - continue - if not isinstance(it, dict): - continue - mid = (it.get("id") or it.get("name") or "").strip() - if not mid: - continue - top = it.get("top_provider") if isinstance(it.get("top_provider"), dict) else {} - out.append({ - "id": mid, - "claimed_output": it.get("max_output_tokens") or it.get("max_completion_tokens") - or top.get("max_completion_tokens"), - "claimed_ctx": it.get("context_length") or it.get("max_input_tokens"), - }) - return out - - -def probe_once(base: str, key: str, model: str, max_tokens: int, prompt: str, timeout: int): - """发一次强制长输出请求,返回 (out_tokens, reasoning_tokens, finish, err)。""" - body = json.dumps({ - "model": model, "stream": True, "max_tokens": max_tokens, - "messages": [{"role": "user", "content": prompt}], - }).encode() - req = urllib.request.Request(base.rstrip("/") + "/chat/completions", data=body, headers={ - "Authorization": f"Bearer {key}", "x-api-key": key, - "Content-Type": "application/json", "Accept": "text/event-stream"}, method="POST") - out = None - reasoning = None - finish = None - try: - with urllib.request.urlopen(req, timeout=timeout) as r: - buf = "" - while True: - piece = r.read(8192) - if not piece: - break - buf += piece.decode("utf-8", "replace") - while "\n" in buf: - line, buf = buf.split("\n", 1) - line = line.strip() - if not line.startswith("data:"): - continue - payload = line[5:].strip() - if not payload or payload == "[DONE]": - continue - try: - obj = json.loads(payload) - except Exception: - continue - u = obj.get("usage") - if isinstance(u, dict): - out = u.get("completion_tokens") - det = u.get("completion_tokens_details") - if isinstance(det, dict): - reasoning = det.get("reasoning_tokens") - for c in obj.get("choices") or []: - if isinstance(c, dict) and c.get("finish_reason"): - finish = c["finish_reason"] - except urllib.error.HTTPError as e: - detail = e.read().decode("utf-8", "replace")[:300] - return None, None, None, f"HTTP {e.code}: {detail}" - except Exception as e: - return None, None, None, f"{type(e).__name__}: {str(e)[:150]}" - return out, reasoning, finish, None - - -def probe_model(base: str, key: str, model: str, tiers: list[int], - retries: int, timeout: int, quiet: bool, budget: int = 0) -> dict: - """阶梯上探单个模型,返回结果字典。 - budget>0 时为单模型总时间预算(秒):超出即中止并记录"未测完",避免个别大上限模型 - 把整体拖到几十分钟(实测某模型生成 40000 token 需 720s,上探 100000 档要半小时)。""" - result = {"model": model, "measured": None, "verdict": None, "evidence": []} - started = time.time() - all_failed = True - for tier in tiers: - if budget and time.time() - started > budget: - result.update(verdict=f"未测完(超出时间预算 {budget}s;已知至少 >{result.get('max_full') or 0})") - result["elapsed"] = round(time.time() - started, 1) - return result - tier_ok = False - for attempt in range(1, retries + 1): - prompt = long_prompt(tier) if attempt == 1 else long_prompt_hard(tier) - # 单次请求也受剩余预算约束,防止单请求无上限地跑 - req_timeout = timeout - if budget: - remain = budget - (time.time() - started) - if remain <= 5: - break - req_timeout = int(min(timeout, remain)) - t0 = time.time() - out, reasoning, finish, err = probe_once(base, key, model, tier, prompt, req_timeout) - dt = time.time() - t0 - if err: - result["evidence"].append(f"tier={tier} 请求失败: {err[:120]}") - if not quiet: - print(f" [{model}] tier={tier}: 失败 {err[:70]}", flush=True) - break - tier_ok = True - all_failed = False - rs = f" 推理{reasoning}" if reasoning else "" - if not quiet: - print(f" [{model}] tier={tier} #{attempt}: 输出 {out} tok{rs} " - f"finish={finish} {dt:.0f}s", flush=True) - - if finish == "length" and out is not None: - if out < tier: - # 上游截断。注意:若上一档已满额通过(max_full),说明真实上限在 - # [max_full, out] 之间,语义是"≥out 附近被钳",用区间表达更准确。 - prev = result.get("max_full") - if prev and out < prev: - verdict = f"≈{out}(钳制;上一档满额 {prev},取值 {out})" - else: - verdict = "钳制" - result.update(measured=out, verdict=verdict, - evidence=result["evidence"] + [f"要 {tier} 只给 {out}(finish=length)"]) - result["elapsed"] = round(time.time() - started, 1) - return result - result["evidence"].append(f"tier={tier}: 输出满额 {out}(支持≥{tier})") - result["max_full"] = out - break - if finish == "stop": - result["evidence"].append(f"tier={tier} #{attempt}: finish=stop(模型主动收尾,输出 {out})") - if out is not None: - result["max_full"] = max(result.get("max_full") or 0, out) - if attempt == retries: - # 已满额通过的档位仍然有效:结论是"≥max_full",不是"无结论" - if result.get("max_full"): - result.update(measured=None, - verdict=f"≥{result['max_full']}(模型主动收尾,未测到钳制点;" - f"声称 {result.get('claimed_output') or '?'})") - else: - result.update(verdict="模型主动停止(未能测出上限,非钳制)") - result["elapsed"] = round(time.time() - started, 1) - return result - continue - result["evidence"].append(f"tier={tier}: 异常返回 out={out} finish={finish}") - break - - if all_failed: - result.update(measured=None, verdict="全部请求失败(模型/账号不可用,无结论)") - result["elapsed"] = round(time.time() - started, 1) - return result - if result.get("max_full"): - result.update(measured=result["max_full"], - verdict=f"≥{result['max_full']}(最高档位仍满额,未触顶)") - result["elapsed"] = round(time.time() - started, 1) - return result - - -def classify(res: dict): - """把一条探测记录映射为面板契约五态之三:clamped / at_least / inconclusive。 - - verdict 原文是自由中文文本,这里按前缀归类: - 钳制 / ≈N(钳制…) → clamped,measured = 截断值(可信) - ≥N(…)/ 未测完(…至少 >N)→ at_least,measured = 已知下界 - 其余(主动停止/全部失败) → inconclusive - 下界取值链:measured → max_full → 文本里的 ≥N / >N。""" - v = res.get("verdict") or "" - meas = res.get("measured") - if v.startswith("钳制") or v.startswith("≈"): - return "clamped", meas - floor = meas if isinstance(meas, int) else res.get("max_full") - if not floor: - m = re.search(r"[≥>]\s*(\d+)", v) - floor = int(m.group(1)) if m else None - if v.startswith("≥") or v.startswith("未测完"): - return ("at_least", floor) if floor else ("inconclusive", None) - return "inconclusive", None - - -def write_panel_out(path: str, results: list) -> None: - """写面板契约文件(合并语义:未重测的模型保留旧记录,上游改限后重跑即覆盖)。""" - p = Path(path) - contract = {"version": 1, "probes": {}} - if p.is_file(): - try: - old = json.loads(p.read_text(encoding="utf-8")) - if isinstance(old.get("probes"), dict): - contract["probes"].update(old["probes"]) - except Exception: - pass # 旧文件损坏则整体重建,不让坏文件卡住新结果 - for r in results: - verdict, meas = classify(r) - contract["probes"][r["model"]] = { - "claimed": r.get("claimed_output"), - "measured": meas, - "verdict": verdict, - "note": r.get("verdict") or "", - "tested_at": r.get("time") or "", - "source": "probe_max_tokens.py", - } - tmp = p.with_suffix(p.suffix + ".tmp") - tmp.parent.mkdir(parents=True, exist_ok=True) - tmp.write_text(json.dumps(contract, ensure_ascii=False, indent=1), encoding="utf-8") - tmp.replace(p) - print(f"面板探测数据已写入 {p}(共 {len(contract['probes'])} 条,合并保留未重测模型)") - - -def main() -> None: - ap = argparse.ArgumentParser( - description="探测 OpenAI 兼容端点的真实输出上限(区分静默钳制与模型主动停止)") - ap.add_argument("--base", required=True, help="接口基址,如 http://host:7863/v1") - ap.add_argument("--key", default=None, help="API Key(也可用环境变量 PROBE_API_KEY)") - ap.add_argument("--prefix", action="append", default=None, - help="只测以此前缀开头的模型(可多次;默认 cn:)") - ap.add_argument("--models", default=None, help="按子串匹配模型 id(逗号分隔,优先级高于 --prefix)") - ap.add_argument("--tiers", default="40000,100000", - help="阶梯请求值,逗号分隔(默认 40000,100000;越高越慢越费额度)") - ap.add_argument("--retries", type=int, default=3, help="finish=stop 时的重试次数(默认 3)") - ap.add_argument("--timeout", type=int, default=900, help="单次请求超时秒数(默认 900)") - ap.add_argument("--limit", type=int, default=0, help="只测前 N 个模型(0=全部)") - ap.add_argument("--out", default="probe-max-tokens.jsonl", help="结果 JSONL 路径") - ap.add_argument("--panel-out", default=None, - help="额外写网关面板契约文件(如 data/output_probes.json;默认关闭)。" - "合并写入:未重测的模型保留旧记录") - ap.add_argument("--resume", action="store_true", help="跳过已有结果的模型(断点续测)") - ap.add_argument("--jobs", type=int, default=4, - help="并行探测的模型数(默认 4;瓶颈是墙钟等待,并行可大幅缩短总时长)") - ap.add_argument("--budget", type=int, default=600, - help="单模型时间预算秒数(默认 600;超出记「未测完」,避免大上限模型拖垮整体)") - ap.add_argument("--dry-run", action="store_true", help="只列出将要测的模型与阶梯,不发请求") - ap.add_argument("--quiet", action="store_true", help="不打印每次尝试明细") - args = ap.parse_args() - - key = args.key or os.environ.get("PROBE_API_KEY") or "" - if not key and not args.dry_run: - raise SystemExit("[!] 需要 --key 或环境变量 PROBE_API_KEY") - - tiers = [int(x) for x in args.tiers.split(",") if x.strip()] - tiers.sort() - - socket.setdefaulttimeout(args.timeout) - - print(f"目标: {args.base}") - all_models = fetch_models(args.base, key) - if args.models: - kws = [k.strip().lower() for k in args.models.split(",") if k.strip()] - def _match(mid: str) -> int: - """返回匹配优先级:0=不匹配,3=带前缀的完整 id,2=后缀精确,1=子串。 - 关键词含 ':' 时按完整 id 比对(cn:xxx 只命中 cn:xxx,不含 global:xxx)。""" - low = mid.lower() - for k in kws: - if ":" in k and low == k: - return 3 - for k in kws: - if ":" not in k and (low == k or low.endswith(":" + k)): - return 2 - for k in kws: - if k in low: - return 1 - return 0 - scored = [(m, _match(m["id"])) for m in all_models] - best = max((s for _, s in scored), default=0) - targets = [m for m, s in scored if s == best and s > 0] - else: - prefixes = args.prefix or ["cn:"] - targets = [m for m in all_models if any(m["id"].startswith(p) for p in prefixes)] - if args.limit: - targets = targets[:args.limit] - if not targets: - raise SystemExit(f"[!] 没有匹配的模型(共 {len(all_models)} 个可测)") - - done = {} - out_path = Path(args.out) - if args.resume and out_path.is_file(): - for line in out_path.read_text(encoding="utf-8").splitlines(): - try: - rec = json.loads(line) - done[rec["model"]] = rec - except Exception: - pass - - print(f"待测模型 {len(targets)} 个 | 阶梯 {tiers} | 声称上限来自 /v1/models") - if args.dry_run: - print("\n[dry-run] 计划:") - for m in targets: - skip = " (已有结果,将跳过)" if m["id"] in done else "" - print(f" {m['id']:44} 声称 {str(m['claimed_output'] or '-'):>8}{skip}") - return - - print() - results = [] - todo = [m for m in targets if m["id"] not in done] - for m in targets: - if m["id"] in done: - results.append(done[m["id"]]) - - # 并行探测:墙钟时间是瓶颈(单模型生成 4 万 token 需数分钟),并发能有效压缩总时长。 - # 结果仍按模型去重,落盘用锁保护。 - import concurrent.futures as cf - import threading - write_lock = threading.Lock() - finished = {"n": 0} - - def _work(m): - res = probe_model(args.base, key, m["id"], tiers, args.retries, args.timeout, - args.quiet, budget=args.budget) - res["claimed_output"] = m["claimed_output"] - res["claimed_ctx"] = m["claimed_ctx"] - res["time"] = time.strftime("%Y-%m-%d %H:%M:%S") - with write_lock: - finished["n"] += 1 - n = finished["n"] - with out_path.open("a", encoding="utf-8") as f: - f.write(json.dumps(res, ensure_ascii=False) + "\n") - measured = res["measured"] if res["measured"] is not None else "-" - print(f"[{n}/{len(todo)}] {m['id']}(声称 {m['claimed_output'] or '-'})" - f" → 实测 {measured} | {res['verdict']} | {res.get('elapsed','-')}s", flush=True) - return res - - if todo: - print(f"开始探测 {len(todo)} 个模型(并行 {args.jobs},单模型预算 {args.budget}s)...\n") - with cf.ThreadPoolExecutor(max_workers=max(1, args.jobs)) as ex: - results.extend(ex.map(_work, todo)) - - # 汇总表 - print("=" * 96) - print(f"{'模型':44} {'声称':>9} {'实测':>9} {'判据':<28} {'耗时':>6}") - print("-" * 96) - for r in results: - claim = r.get("claimed_output") or "-" - meas = r.get("measured") if r.get("measured") is not None else "-" - verdict = (r.get("verdict") or "")[:26] - print(f"{r['model']:44} {str(claim):>9} {str(meas):>9} {verdict:<28} {str(r.get('elapsed','-')):>6}") - print("=" * 96) - - mism = [r for r in results if r.get("measured") and r.get("claimed_output") - and int(r["measured"]) < int(r["claimed_output"])] - if mism: - print(f"\n⚠ {len(mism)} 个模型的声称上限高于实测(静默钳制):") - for r in mism: - print(f" {r['model']}: 声称 {r['claimed_output']} → 实际 {r['measured']}") - print(f"\n结果已写入 {out_path}(--resume 可跳过已测模型继续)") - if args.panel_out: - write_panel_out(args.panel_out, results) - - -if __name__ == "__main__": - main() +#!/usr/bin/env python3 +# -*- coding: utf-8 -*- +""" +OpenAI 兼容端点的「真实输出上限」探测工具 +========================================== +背景:许多网关/中转会在 /v1/models 里透出 max_output_tokens,但它常常与实际能力不符 +(实测某网关对 deepseek-v4.1-flash 声称 393216,真实只有 32000)。更麻烦的是**静默钳制**: +请求 max_tokens 超过真实上限时不报错,而是内部截断——从 usage 只能看出"输出到某个值就停了"。 + +本工具用「强制长输出 + 阶梯上探」测出真实上限,关键判据区分两种停止: + + finish=length 且 输出 < 请求 → 上游截断,**输出值即真实上限**(可信,直接得出结果) + finish=length 且 输出 = 请求 → 支持至少这么多,继续上探更高阶梯 + finish=stop 且 输出 < 请求 → 模型自己不想写了,**不可作判据**,需强化提示重试 + +用法: + # 测某网关全部以给定前缀开头的模型(默认 cn:) + python probe_max_tokens.py --base http://211.154.25.123:7863/v1 --key sk-xxx + + # 指定模型 / 多个前缀 / 只看计划 + python probe_max_tokens.py --base ... --key ... --models flash,glm-5.3 + python probe_max_tokens.py --base ... --key ... --prefix cn: --prefix global: + python probe_max_tokens.py --base ... --key ... --dry-run + + # 控制成本与时长 + python probe_max_tokens.py --base ... --key ... --tiers 40000,100000 --retries 2 --timeout 900 + +结果: + - 控制台表格:模型 | 声称上限 | 实测上限 | 判据 | 耗时 + - JSONL 落盘(--out,默认 probe-max-tokens.jsonl),**支持 --resume 断点续测** + - --panel-out PATH 额外写面板契约文件(默认关闭;网关面板「模型与档位」的实测列读它): + {"version":1,"probes":{"cn:glm-5.2":{"claimed":131072,"measured":48000, + "verdict":"clamped|at_least|inconclusive","note":"原始判据文本", + "tested_at":"...","source":"probe_max_tokens.py"}}} + 写入为合并语义:未重测的模型保留旧记录;文件放网关 state 文件同目录 + (默认部署即 data/output_probes.json),面板下次查询即展示,网关零重启。 + - --limit N 只测前 N 个模型(先小批量试跑) + +成本提示:一个模型若真有极大上限,上探到高档位会生成数十万 token,耗时长且消耗额度。 + 默认最高阶梯 40000、上限 160000 已足够识别常见的 32K/48K/64K 钳制。 +""" + +import argparse +import json +import os +import re +import socket +import sys +import time +import urllib.error +import urllib.request +from pathlib import Path + +# 强制长输出的提示:目标值需与被测档位"量级相当"。 +# 实测教训:目标写得过大(数到 999999)模型会判断"不可能完成"而提前收尾(只输出 1~3k); +# 目标设为 12000~20000(能写满但看起来合理)时,模型会持续输出直到被硬截断,4/4 稳定命中。 +# 下面按档位缩放目标值:约 max_tokens/3 个数字(每数字行约 2~3 token,留余量防提前写完)。 +def long_prompt(max_tokens: int) -> str: + target = max(2000, min(200000, max_tokens // 3)) + return ( + f"请从 1 开始,每行输出一个数字,依次递增,一直数到 {target}。" + "严格只输出数字本身,每行一个;不要解释、不要总结、不要省略、不要合并、不要提前结束。" + ) + + +# 强化版(第一次被模型主动收尾时使用,仍保持量级匹配) +def long_prompt_hard(max_tokens: int) -> str: + target = max(2000, min(200000, max_tokens // 3)) + return ( + f"Count from 1 to {target}, one number per line, incrementing by 1. " + "Output digits only, one per line. Do not summarize, do not explain, " + "do not skip numbers, do not stop early — you must reach the target." + ) + + +def fetch_models(base: str, key: str, timeout: int = 20): + """取 /v1/models 列表:[{id, claimed_output, claimed_ctx}, ...]""" + url = base.rstrip("/") + "/models" + req = urllib.request.Request(url, headers={ + "Authorization": f"Bearer {key}", "x-api-key": key, "Accept": "application/json"}) + with urllib.request.urlopen(req, timeout=timeout) as r: + data = json.loads(r.read().decode("utf-8")) + items = data.get("data") if isinstance(data, dict) else data + out = [] + for it in items or []: + if isinstance(it, str): + out.append({"id": it.strip(), "claimed_output": None, "claimed_ctx": None}) + continue + if not isinstance(it, dict): + continue + mid = (it.get("id") or it.get("name") or "").strip() + if not mid: + continue + top = it.get("top_provider") if isinstance(it.get("top_provider"), dict) else {} + out.append({ + "id": mid, + "claimed_output": it.get("max_output_tokens") or it.get("max_completion_tokens") + or top.get("max_completion_tokens"), + "claimed_ctx": it.get("context_length") or it.get("max_input_tokens"), + }) + return out + + +def probe_once(base: str, key: str, model: str, max_tokens: int, prompt: str, timeout: int): + """发一次强制长输出请求,返回 (out_tokens, reasoning_tokens, finish, err)。""" + body = json.dumps({ + "model": model, "stream": True, "max_tokens": max_tokens, + "messages": [{"role": "user", "content": prompt}], + }).encode() + req = urllib.request.Request(base.rstrip("/") + "/chat/completions", data=body, headers={ + "Authorization": f"Bearer {key}", "x-api-key": key, + "Content-Type": "application/json", "Accept": "text/event-stream"}, method="POST") + out = None + reasoning = None + finish = None + try: + with urllib.request.urlopen(req, timeout=timeout) as r: + buf = "" + while True: + piece = r.read(8192) + if not piece: + break + buf += piece.decode("utf-8", "replace") + while "\n" in buf: + line, buf = buf.split("\n", 1) + line = line.strip() + if not line.startswith("data:"): + continue + payload = line[5:].strip() + if not payload or payload == "[DONE]": + continue + try: + obj = json.loads(payload) + except Exception: + continue + u = obj.get("usage") + if isinstance(u, dict): + out = u.get("completion_tokens") + det = u.get("completion_tokens_details") + if isinstance(det, dict): + reasoning = det.get("reasoning_tokens") + for c in obj.get("choices") or []: + if isinstance(c, dict) and c.get("finish_reason"): + finish = c["finish_reason"] + except urllib.error.HTTPError as e: + detail = e.read().decode("utf-8", "replace")[:300] + return None, None, None, f"HTTP {e.code}: {detail}" + except Exception as e: + return None, None, None, f"{type(e).__name__}: {str(e)[:150]}" + return out, reasoning, finish, None + + +def probe_model(base: str, key: str, model: str, tiers: list[int], + retries: int, timeout: int, quiet: bool, budget: int = 0) -> dict: + """阶梯上探单个模型,返回结果字典。 + budget>0 时为单模型总时间预算(秒):超出即中止并记录"未测完",避免个别大上限模型 + 把整体拖到几十分钟(实测某模型生成 40000 token 需 720s,上探 100000 档要半小时)。""" + result = {"model": model, "measured": None, "verdict": None, "evidence": []} + started = time.time() + all_failed = True + for tier in tiers: + if budget and time.time() - started > budget: + result.update(verdict=f"未测完(超出时间预算 {budget}s;已知至少 >{result.get('max_full') or 0})") + result["elapsed"] = round(time.time() - started, 1) + return result + tier_ok = False + for attempt in range(1, retries + 1): + prompt = long_prompt(tier) if attempt == 1 else long_prompt_hard(tier) + # 单次请求也受剩余预算约束,防止单请求无上限地跑 + req_timeout = timeout + if budget: + remain = budget - (time.time() - started) + if remain <= 5: + break + req_timeout = int(min(timeout, remain)) + t0 = time.time() + out, reasoning, finish, err = probe_once(base, key, model, tier, prompt, req_timeout) + dt = time.time() - t0 + if err: + result["evidence"].append(f"tier={tier} 请求失败: {err[:120]}") + if not quiet: + print(f" [{model}] tier={tier}: 失败 {err[:70]}", flush=True) + break + tier_ok = True + all_failed = False + rs = f" 推理{reasoning}" if reasoning else "" + if not quiet: + print(f" [{model}] tier={tier} #{attempt}: 输出 {out} tok{rs} " + f"finish={finish} {dt:.0f}s", flush=True) + + if finish == "length" and out is not None: + if out < tier: + # 上游截断。注意:若上一档已满额通过(max_full),说明真实上限在 + # [max_full, out] 之间,语义是"≥out 附近被钳",用区间表达更准确。 + prev = result.get("max_full") + if prev and out < prev: + verdict = f"≈{out}(钳制;上一档满额 {prev},取值 {out})" + else: + verdict = "钳制" + result.update(measured=out, verdict=verdict, + evidence=result["evidence"] + [f"要 {tier} 只给 {out}(finish=length)"]) + result["elapsed"] = round(time.time() - started, 1) + return result + result["evidence"].append(f"tier={tier}: 输出满额 {out}(支持≥{tier})") + result["max_full"] = out + break + if finish == "stop": + result["evidence"].append(f"tier={tier} #{attempt}: finish=stop(模型主动收尾,输出 {out})") + if out is not None: + result["max_full"] = max(result.get("max_full") or 0, out) + if attempt == retries: + # 已满额通过的档位仍然有效:结论是"≥max_full",不是"无结论" + if result.get("max_full"): + result.update(measured=None, + verdict=f"≥{result['max_full']}(模型主动收尾,未测到钳制点;" + f"声称 {result.get('claimed_output') or '?'})") + else: + result.update(verdict="模型主动停止(未能测出上限,非钳制)") + result["elapsed"] = round(time.time() - started, 1) + return result + continue + result["evidence"].append(f"tier={tier}: 异常返回 out={out} finish={finish}") + break + + if all_failed: + result.update(measured=None, verdict="全部请求失败(模型/账号不可用,无结论)") + result["elapsed"] = round(time.time() - started, 1) + return result + if result.get("max_full"): + result.update(measured=result["max_full"], + verdict=f"≥{result['max_full']}(最高档位仍满额,未触顶)") + result["elapsed"] = round(time.time() - started, 1) + return result + + +def classify(res: dict): + """把一条探测记录映射为面板契约五态之三:clamped / at_least / inconclusive。 + + verdict 原文是自由中文文本,这里按前缀归类: + 钳制 / ≈N(钳制…) → clamped,measured = 截断值(可信) + ≥N(…)/ 未测完(…至少 >N)→ at_least,measured = 已知下界 + 其余(主动停止/全部失败) → inconclusive + 下界取值链:measured → max_full → 文本里的 ≥N / >N。""" + v = res.get("verdict") or "" + meas = res.get("measured") + if v.startswith("钳制") or v.startswith("≈"): + return "clamped", meas + floor = meas if isinstance(meas, int) else res.get("max_full") + if not floor: + m = re.search(r"[≥>]\s*(\d+)", v) + floor = int(m.group(1)) if m else None + if v.startswith("≥") or v.startswith("未测完"): + return ("at_least", floor) if floor else ("inconclusive", None) + return "inconclusive", None + + +def write_panel_out(path: str, results: list) -> None: + """写面板契约文件(合并语义:未重测的模型保留旧记录,上游改限后重跑即覆盖)。""" + p = Path(path) + contract = {"version": 1, "probes": {}} + if p.is_file(): + try: + old = json.loads(p.read_text(encoding="utf-8")) + if isinstance(old.get("probes"), dict): + contract["probes"].update(old["probes"]) + except Exception: + pass # 旧文件损坏则整体重建,不让坏文件卡住新结果 + for r in results: + verdict, meas = classify(r) + contract["probes"][r["model"]] = { + "claimed": r.get("claimed_output"), + "measured": meas, + "verdict": verdict, + "note": r.get("verdict") or "", + "tested_at": r.get("time") or "", + "source": "probe_max_tokens.py", + } + tmp = p.with_suffix(p.suffix + ".tmp") + tmp.parent.mkdir(parents=True, exist_ok=True) + tmp.write_text(json.dumps(contract, ensure_ascii=False, indent=1), encoding="utf-8") + tmp.replace(p) + print(f"面板探测数据已写入 {p}(共 {len(contract['probes'])} 条,合并保留未重测模型)") + + +def main() -> None: + ap = argparse.ArgumentParser( + description="探测 OpenAI 兼容端点的真实输出上限(区分静默钳制与模型主动停止)") + ap.add_argument("--base", required=True, help="接口基址,如 http://host:7863/v1") + ap.add_argument("--key", default=None, help="API Key(也可用环境变量 PROBE_API_KEY)") + ap.add_argument("--prefix", action="append", default=None, + help="只测以此前缀开头的模型(可多次;默认 cn:)") + ap.add_argument("--models", default=None, help="按子串匹配模型 id(逗号分隔,优先级高于 --prefix)") + ap.add_argument("--tiers", default="40000,100000", + help="阶梯请求值,逗号分隔(默认 40000,100000;越高越慢越费额度)") + ap.add_argument("--retries", type=int, default=3, help="finish=stop 时的重试次数(默认 3)") + ap.add_argument("--timeout", type=int, default=900, help="单次请求超时秒数(默认 900)") + ap.add_argument("--limit", type=int, default=0, help="只测前 N 个模型(0=全部)") + ap.add_argument("--out", default="probe-max-tokens.jsonl", help="结果 JSONL 路径") + ap.add_argument("--panel-out", default=None, + help="额外写网关面板契约文件(如 data/output_probes.json;默认关闭)。" + "合并写入:未重测的模型保留旧记录") + ap.add_argument("--resume", action="store_true", help="跳过已有结果的模型(断点续测)") + ap.add_argument("--jobs", type=int, default=4, + help="并行探测的模型数(默认 4;瓶颈是墙钟等待,并行可大幅缩短总时长)") + ap.add_argument("--budget", type=int, default=600, + help="单模型时间预算秒数(默认 600;超出记「未测完」,避免大上限模型拖垮整体)") + ap.add_argument("--dry-run", action="store_true", help="只列出将要测的模型与阶梯,不发请求") + ap.add_argument("--quiet", action="store_true", help="不打印每次尝试明细") + args = ap.parse_args() + + key = args.key or os.environ.get("PROBE_API_KEY") or "" + if not key and not args.dry_run: + raise SystemExit("[!] 需要 --key 或环境变量 PROBE_API_KEY") + + tiers = [int(x) for x in args.tiers.split(",") if x.strip()] + tiers.sort() + + socket.setdefaulttimeout(args.timeout) + + print(f"目标: {args.base}") + all_models = fetch_models(args.base, key) + if args.models: + kws = [k.strip().lower() for k in args.models.split(",") if k.strip()] + def _match(mid: str) -> int: + """返回匹配优先级:0=不匹配,3=带前缀的完整 id,2=后缀精确,1=子串。 + 关键词含 ':' 时按完整 id 比对(cn:xxx 只命中 cn:xxx,不含 global:xxx)。""" + low = mid.lower() + for k in kws: + if ":" in k and low == k: + return 3 + for k in kws: + if ":" not in k and (low == k or low.endswith(":" + k)): + return 2 + for k in kws: + if k in low: + return 1 + return 0 + scored = [(m, _match(m["id"])) for m in all_models] + best = max((s for _, s in scored), default=0) + targets = [m for m, s in scored if s == best and s > 0] + else: + prefixes = args.prefix or ["cn:"] + targets = [m for m in all_models if any(m["id"].startswith(p) for p in prefixes)] + if args.limit: + targets = targets[:args.limit] + if not targets: + raise SystemExit(f"[!] 没有匹配的模型(共 {len(all_models)} 个可测)") + + done = {} + out_path = Path(args.out) + if args.resume and out_path.is_file(): + for line in out_path.read_text(encoding="utf-8").splitlines(): + try: + rec = json.loads(line) + done[rec["model"]] = rec + except Exception: + pass + + print(f"待测模型 {len(targets)} 个 | 阶梯 {tiers} | 声称上限来自 /v1/models") + if args.dry_run: + print("\n[dry-run] 计划:") + for m in targets: + skip = " (已有结果,将跳过)" if m["id"] in done else "" + print(f" {m['id']:44} 声称 {str(m['claimed_output'] or '-'):>8}{skip}") + return + + print() + results = [] + todo = [m for m in targets if m["id"] not in done] + for m in targets: + if m["id"] in done: + results.append(done[m["id"]]) + + # 并行探测:墙钟时间是瓶颈(单模型生成 4 万 token 需数分钟),并发能有效压缩总时长。 + # 结果仍按模型去重,落盘用锁保护。 + import concurrent.futures as cf + import threading + write_lock = threading.Lock() + finished = {"n": 0} + + def _work(m): + res = probe_model(args.base, key, m["id"], tiers, args.retries, args.timeout, + args.quiet, budget=args.budget) + res["claimed_output"] = m["claimed_output"] + res["claimed_ctx"] = m["claimed_ctx"] + res["time"] = time.strftime("%Y-%m-%d %H:%M:%S") + with write_lock: + finished["n"] += 1 + n = finished["n"] + with out_path.open("a", encoding="utf-8") as f: + f.write(json.dumps(res, ensure_ascii=False) + "\n") + measured = res["measured"] if res["measured"] is not None else "-" + print(f"[{n}/{len(todo)}] {m['id']}(声称 {m['claimed_output'] or '-'})" + f" → 实测 {measured} | {res['verdict']} | {res.get('elapsed','-')}s", flush=True) + return res + + if todo: + print(f"开始探测 {len(todo)} 个模型(并行 {args.jobs},单模型预算 {args.budget}s)...\n") + with cf.ThreadPoolExecutor(max_workers=max(1, args.jobs)) as ex: + results.extend(ex.map(_work, todo)) + + # 汇总表 + print("=" * 96) + print(f"{'模型':44} {'声称':>9} {'实测':>9} {'判据':<28} {'耗时':>6}") + print("-" * 96) + for r in results: + claim = r.get("claimed_output") or "-" + meas = r.get("measured") if r.get("measured") is not None else "-" + verdict = (r.get("verdict") or "")[:26] + print(f"{r['model']:44} {str(claim):>9} {str(meas):>9} {verdict:<28} {str(r.get('elapsed','-')):>6}") + print("=" * 96) + + mism = [r for r in results if r.get("measured") and r.get("claimed_output") + and int(r["measured"]) < int(r["claimed_output"])] + if mism: + print(f"\n⚠ {len(mism)} 个模型的声称上限高于实测(静默钳制):") + for r in mism: + print(f" {r['model']}: 声称 {r['claimed_output']} → 实际 {r['measured']}") + print(f"\n结果已写入 {out_path}(--resume 可跳过已测模型继续)") + if args.panel_out: + write_panel_out(args.panel_out, results) + + +if __name__ == "__main__": + main() diff --git a/scripts/task_chat5.py b/scripts/task_chat5.py old mode 100644 new mode 100755 index cc7024d416280fd606c68f64f6b1107fcdaa490e..2672e3a340eef18d2d6a48de1183a38491ffdf6d --- a/scripts/task_chat5.py +++ b/scripts/task_chat5.py @@ -1,76 +1,76 @@ -#!/usr/bin/env python3 -"""一次性任务脚本:chat_5(和 AI 聊天 5 次,+100 积分 +5 能量). - -通过 {billing}/v2/report 上报 chat_request_send 事件完成进度累计。 -照抄 report.go 的 chatRequestEvent 完整形状(含 userId,缺则静默丢弃)。 -默认 dry-run,--yes 才发真实上报;默认补到 5 次,支持 --count N。 - -用法 - python3 task_chat5.py # dry-run - python3 task_chat5.py --yes # 补齐到 5 次 - python3 task_chat5.py --yes --count 2 # 只补 2 次 -""" -import sys, os, argparse -sys.path.insert(0, os.path.dirname(os.path.abspath(__file__))) -import task_common as tc - -TASK_CODE = "chat_5" -TARGET = 5 - - -def main(): - ap = argparse.ArgumentParser(description="chat_5 任务:上报 N 次对话完成 5/5") - ap.add_argument("account", help="uid 前缀,或 ALL") - ap.add_argument("--yes", action="store_true", help="确认执行写操作") - ap.add_argument("--count", type=int, default=0, - help="本次上报条数(默认自动补到 5 次)") - ap.add_argument("--gap", type=float, default=1.05) - a = ap.parse_args() - - prefixes = [] - if a.account.upper() == "ALL": - import glob - prefixes = [os.path.basename(p)[10:18] - for p in sorted(glob.glob(tc.AUTHS + "/workbuddy-*.json"))] - else: - prefixes = [a.account] - - for pre in prefixes: - c = tc.load_auth(pre) - print(f"== {c['uid'][:8]} ({c['nick']}) ==") - try: - st = tc.task_status(c, TASK_CODE) - except Exception as e: - print(f" [skip] list_tasks 失败: {e}") - continue - if st is None: - print(f" [skip] 无 {TASK_CODE} 任务") - continue - ast = st.get("accept_status") - prog = (st.get("progress") or {}) - cur = prog.get("current", 0) - target = prog.get("target", TARGET) - if ast == "claimed" or cur >= target: - print(f" [skip] 已完成 {cur}/{target} (accept_status={ast})") - continue - need = max(0, target - cur) - if a.count > 0: - need = min(need, a.count) - if need <= 0: - print(" [skip] 无需上报") - continue - if not a.yes: - print(f" [dry-run] 将上报 {need} 条 chat_request_send " - f"(当前 {cur}/{target},加 --yes 生效)") - continue - results = tc.report_activity(c, count=need, gap=a.gap) - # 回读确认 - st2 = tc.task_status(c, TASK_CODE) - prog2 = (st2.get("progress") or {}) if st2 else {} - print(f" report x{need} -> {results}") - print(f" 回读 {TASK_CODE}: {prog2.get('current', 0)}/{prog2.get('target', target)} " - f"accept_status={st2.get('accept_status') if st2 else '?'}") - - -if __name__ == "__main__": +#!/usr/bin/env python3 +"""一次性任务脚本:chat_5(和 AI 聊天 5 次,+100 积分 +5 能量). + +通过 {billing}/v2/report 上报 chat_request_send 事件完成进度累计。 +照抄 report.go 的 chatRequestEvent 完整形状(含 userId,缺则静默丢弃)。 +默认 dry-run,--yes 才发真实上报;默认补到 5 次,支持 --count N。 + +用法 + python3 task_chat5.py # dry-run + python3 task_chat5.py --yes # 补齐到 5 次 + python3 task_chat5.py --yes --count 2 # 只补 2 次 +""" +import sys, os, argparse +sys.path.insert(0, os.path.dirname(os.path.abspath(__file__))) +import task_common as tc + +TASK_CODE = "chat_5" +TARGET = 5 + + +def main(): + ap = argparse.ArgumentParser(description="chat_5 任务:上报 N 次对话完成 5/5") + ap.add_argument("account", help="uid 前缀,或 ALL") + ap.add_argument("--yes", action="store_true", help="确认执行写操作") + ap.add_argument("--count", type=int, default=0, + help="本次上报条数(默认自动补到 5 次)") + ap.add_argument("--gap", type=float, default=1.05) + a = ap.parse_args() + + prefixes = [] + if a.account.upper() == "ALL": + import glob + prefixes = [os.path.basename(p)[10:18] + for p in sorted(glob.glob(tc.AUTHS + "/workbuddy-*.json"))] + else: + prefixes = [a.account] + + for pre in prefixes: + c = tc.load_auth(pre) + print(f"== {c['uid'][:8]} ({c['nick']}) ==") + try: + st = tc.task_status(c, TASK_CODE) + except Exception as e: + print(f" [skip] list_tasks 失败: {e}") + continue + if st is None: + print(f" [skip] 无 {TASK_CODE} 任务") + continue + ast = st.get("accept_status") + prog = (st.get("progress") or {}) + cur = prog.get("current", 0) + target = prog.get("target", TARGET) + if ast == "claimed" or cur >= target: + print(f" [skip] 已完成 {cur}/{target} (accept_status={ast})") + continue + need = max(0, target - cur) + if a.count > 0: + need = min(need, a.count) + if need <= 0: + print(" [skip] 无需上报") + continue + if not a.yes: + print(f" [dry-run] 将上报 {need} 条 chat_request_send " + f"(当前 {cur}/{target},加 --yes 生效)") + continue + results = tc.report_activity(c, count=need, gap=a.gap) + # 回读确认 + st2 = tc.task_status(c, TASK_CODE) + prog2 = (st2.get("progress") or {}) if st2 else {} + print(f" report x{need} -> {results}") + print(f" 回读 {TASK_CODE}: {prog2.get('current', 0)}/{prog2.get('target', target)} " + f"accept_status={st2.get('accept_status') if st2 else '?'}") + + +if __name__ == "__main__": main() \ No newline at end of file diff --git a/scripts/task_common.py b/scripts/task_common.py old mode 100644 new mode 100755 index 091c80c238e8fc7fbdabefa127156a83c7547b9d..63f12b41e12d1cf4e09a36ac55c394391c6470f6 --- a/scripts/task_common.py +++ b/scripts/task_common.py @@ -1,223 +1,223 @@ -#!/usr/bin/env python3 -"""一次性积分任务脚本的共享函数库. - -与 probe_active.py 同风格:从 auths/ 读账号凭证,封装 growth 域 / report 域 -请求,供 task_*.py 复用。全部默认 dry-run(写动作由调用脚本显式 --yes 放行)。 - -端点权威来源(Go 代码实测 + 本次实测确认): - - chat 域(copilot.tencent.com):growth / tasks / buddy / streak / chat/completions - - billing 域(www.codebuddy.cn):/v2/report - - accept : POST /v2/activity/growth/tasks/accept {"task_codes":[code]} - - claim : POST /v2/activity/growth/tasks/reward/claim {"task_code":code} -""" -import json, os, time, glob, urllib.request, urllib.error - -AUTHS = "/root/workbuddy2api/auths" -CHAT_BASE = "https://copilot.tencent.com" # growth / tasks / buddy / streak / chat -BILL_BASE = "https://www.codebuddy.cn" # report / billing - -# growth 域常量(travel.go / report.go 与本次实测对齐) -PATH_LIST_TASKS = "/v2/activity/growth/tasks" -PATH_ACCEPT_TASKS = "/v2/activity/growth/tasks/accept" -PATH_CLAIM_REWARD = "/v2/activity/growth/tasks/reward/claim" -PATH_BUDDY_FIRST = "/activity/growth/buddy/first" -PATH_BUDDY_AGREEMENT = "/activity/growth/buddy/agreement" -PATH_STREAK = "/activity/growth/streak" -PATH_REPORT = "/v2/report" -PATH_CHAT = "/v2/chat/completions" - -CLIENT_UA = "CLI/2.63.2 CodeBuddy/2.63.2" - - -def load_auth(uid_or_file: str) -> dict: - """从 auths/ 加载账号凭证,uid_or_file 为 uid 前缀或 auths 文件名。 - - 返回 {token, uid, domain, nick, file} 五元组。 - """ - if os.path.sep in uid_or_file or uid_or_file.endswith(".json"): - p = uid_or_file - if not os.path.isabs(p): - p = os.path.join(AUTHS, p) - else: - pre = uid_or_file - hits = glob.glob(os.path.join(AUTHS, f"workbuddy-{pre}*.json")) - if not hits: - raise SystemExit(f"no auth for {pre}") - p = hits[0] - # encoding 必须显式指定:Windows 上 open() 默认用 locale 代码页(中文系统为 - # GBK),而 auth 文件是 UTF-8,非 ASCII 昵称会 UnicodeDecodeError 中断全部任务。 - d = json.load(open(p, encoding="utf-8")) - a, acc = d["auth"], d["account"] - return {"token": a["accessToken"], "domain": a.get("domain") or "", - "uid": acc["uid"], "nick": acc.get("nickname", ""), - "file": os.path.basename(p)} - - -def chat_base(auth: dict) -> str: - return auth.get("chat_base") or CHAT_BASE - - -def billing_base(auth: dict) -> str: - return auth.get("billing_base") or BILL_BASE - - -def _headers(auth: dict) -> dict: - hdr = {"Authorization": "Bearer " + auth["token"], - "Accept": "application/json", - "Content-Type": "application/json", - "User-Agent": CLIENT_UA, - "Origin": "https://www.codebuddy.cn", - "Referer": "https://www.codebuddy.cn/"} - if auth.get("uid"): - hdr["X-User-Id"] = auth["uid"] - if auth.get("domain"): - hdr["X-Domain"] = auth["domain"] - return hdr - - -def _request(auth, method, base, path, body=None, headers=None, timeout=30): - url = path if path.startswith("http") else base + path - hdr = _headers(auth) - if headers: - hdr.update(headers) - data = json.dumps(body).encode() if body is not None else None - req = urllib.request.Request(url, data=data, headers=hdr, method=method) - try: - with urllib.request.urlopen(req, timeout=timeout) as r: - return r.status, json.loads(r.read().decode("utf-8", "replace")) - except urllib.error.HTTPError as e: - t = e.read().decode("utf-8", "replace") - try: - return e.code, json.loads(t) - except Exception: - return e.code, {"raw": t[:300]} - except Exception as e: - return -1, {"err": repr(e)} - - -def do_get(auth, base, path, headers=None) -> tuple: - """GET 读请求,返回 (status, dict)。""" - return _request(auth, "GET", base, path, None, headers) - - -def do_post(auth, base, path, body, headers=None) -> tuple: - """POST 写请求,返回 (status, dict)。body 为 dict。""" - return _request(auth, "POST", base, path, body, headers) - - -def list_tasks(auth) -> list: - """GET /v2/activity/growth/tasks 全量任务列表(元素为原始 dict)。""" - st, d = do_get(auth, chat_base(auth), PATH_LIST_TASKS) - if st != 200: - raise RuntimeError(f"list_tasks http={st}") - tasks = (d.get("data", {}) or {}).get("tasks") or [] - return tasks - - -def task_status(auth, task_code) -> dict | None: - """查单个任务当前状态;找不到返回 None。""" - for t in list_tasks(auth): - if t.get("task_code") == task_code: - return t - return None - - -def accept_tasks(auth, task_codes) -> tuple: - """POST accept 任务(not_accepted → accepted)。返回 (status, resp)。""" - return do_post(auth, chat_base(auth), PATH_ACCEPT_TASKS, - {"task_codes": task_codes}) - - -def claim_reward(auth, task_code) -> tuple: - """POST claim 领取奖励(任务已 complete 后可领)。重复领返回业务错误,安全。""" - return do_post(auth, chat_base(auth), PATH_CLAIM_REWARD, - {"task_code": task_code}) - - -def get_streak(auth) -> int: - """GET /activity/growth/streak 连登天数(只读 oracle)。失败返回 -1 记日志。""" - st, d = do_get(auth, chat_base(auth), PATH_STREAK) - if st != 200: - return -1 - return (d.get("data", {}).get("streak", {}) or {}).get("days", 0) - - -def chat_event(auth, conversation_id=None, model_id="deepseek-v4-flash", - model_name="DeepSeek V4 Flash", mode="craft"): - """客户端 chat_request_send 事件完整形状(照抄 report.go / probe_active.py)。 - - 必须带 userId(=账号 uid),缺失则服务端 200 但静默丢弃。 - model_id/name 可换(如 GLM-5.2),供 model_chat 对齐实际模型。 - """ - now = int(time.time() * 1000) - cid = conversation_id or f"task-{now}" - return {"eventCode": "chat_request_send", "timestamp": now, "reportDelay": 0, - "mode": mode, "conversationId": cid, "requestId": cid, - "inputLength": 12, "requestModelId": model_id, - "requestModelName": model_name, "isPlan": False, - "isAutoExecuteTerminal": False, "isAutoModify": False, - "codebaseEnable": False, "maxToken": 0, "maxSteps": 0, "temperature": 0, - "maxRetries": 0, "mentionContexts": [], "knowledgeId": [], - "knowledgeName": [], "codebaseId": "", "mentionContextCount": 0, - "command": "", "expertId": "", "recommendId": "", "skillId": "", - "skillCount": 0, "totalCount": 0, "fileUri": "", "presentAt": now, - "traceId": "", "rootRequestId": cid, "parentConversationId": cid, - "agentName": "default", "agentType": "conversation", "userId": auth["uid"]} - - -def report_activity(auth, count=1, gap=1.05, model_id="deepseek-v4-flash", - model_name="DeepSeek V4 Flash", mode="craft") -> list: - """向 {billing}/v2/report 上报 count 条 chat_request_send。 - - 每次间隔 >= gap 秒(默认 1.05,匹配 probe_active.py 的同接口限速口径)。 - 返回 [(status, code), ...] 汇总。 - """ - out = [] - for i in range(count): - ev = chat_event(auth, model_id=model_id, model_name=model_name, mode=mode) - st, r = do_post(auth, billing_base(auth), PATH_REPORT, [ev]) - out.append((st, r.get("code") if isinstance(r, dict) else None)) - if i < count - 1: - time.sleep(gap) - return out - - -def chat_completion(auth, model_id="glm-5.2", prompt="hi", max_tokens=32, - timeout=60) -> tuple: - """POST {chat}/v2/chat/completions 真实对话一次(stream:true)。 - - 服务端强制流式(payload.go 同款口径),这里逐行读 SSE 直到 done。 - 返回 (status, first_content)。用于 Model_chat_GLM5.2 的“真实对话一次”。 - """ - body = {"model": model_id, "messages": [{"role": "user", "content": prompt}], - "stream": True, "max_tokens": max_tokens} - hdr = {"Accept": "text/event-stream"} # SSE - url = chat_base(auth) + PATH_CHAT - req_headers = _headers(auth) - req_headers.update(hdr) - req = urllib.request.Request(url, data=json.dumps(body).encode(), - headers=req_headers, method="POST") - first = "" - try: - with urllib.request.urlopen(req, timeout=timeout) as r: - status = r.status - for raw in r: - line = raw.decode("utf-8", "replace") - if line.startswith("data: "): - payload = line[6:].strip() - if payload in ("[DONE]", ""): - continue - try: - obj = json.loads(payload) - delta = (obj.get("choices") or [{}])[0].get("delta") or {} - content = delta.get("content") or "" - if content and not first: - first = content - except Exception: - pass - return status, first - except urllib.error.HTTPError as e: - t = e.read().decode("utf-8", "replace") - return e.code, t[:200] - except Exception as e: +#!/usr/bin/env python3 +"""一次性积分任务脚本的共享函数库. + +与 probe_active.py 同风格:从 auths/ 读账号凭证,封装 growth 域 / report 域 +请求,供 task_*.py 复用。全部默认 dry-run(写动作由调用脚本显式 --yes 放行)。 + +端点权威来源(Go 代码实测 + 本次实测确认): + - chat 域(copilot.tencent.com):growth / tasks / buddy / streak / chat/completions + - billing 域(www.codebuddy.cn):/v2/report + - accept : POST /v2/activity/growth/tasks/accept {"task_codes":[code]} + - claim : POST /v2/activity/growth/tasks/reward/claim {"task_code":code} +""" +import json, os, time, glob, urllib.request, urllib.error + +AUTHS = "/root/workbuddy2api/auths" +CHAT_BASE = "https://copilot.tencent.com" # growth / tasks / buddy / streak / chat +BILL_BASE = "https://www.codebuddy.cn" # report / billing + +# growth 域常量(travel.go / report.go 与本次实测对齐) +PATH_LIST_TASKS = "/v2/activity/growth/tasks" +PATH_ACCEPT_TASKS = "/v2/activity/growth/tasks/accept" +PATH_CLAIM_REWARD = "/v2/activity/growth/tasks/reward/claim" +PATH_BUDDY_FIRST = "/activity/growth/buddy/first" +PATH_BUDDY_AGREEMENT = "/activity/growth/buddy/agreement" +PATH_STREAK = "/activity/growth/streak" +PATH_REPORT = "/v2/report" +PATH_CHAT = "/v2/chat/completions" + +CLIENT_UA = "CLI/2.63.2 CodeBuddy/2.63.2" + + +def load_auth(uid_or_file: str) -> dict: + """从 auths/ 加载账号凭证,uid_or_file 为 uid 前缀或 auths 文件名。 + + 返回 {token, uid, domain, nick, file} 五元组。 + """ + if os.path.sep in uid_or_file or uid_or_file.endswith(".json"): + p = uid_or_file + if not os.path.isabs(p): + p = os.path.join(AUTHS, p) + else: + pre = uid_or_file + hits = glob.glob(os.path.join(AUTHS, f"workbuddy-{pre}*.json")) + if not hits: + raise SystemExit(f"no auth for {pre}") + p = hits[0] + # encoding 必须显式指定:Windows 上 open() 默认用 locale 代码页(中文系统为 + # GBK),而 auth 文件是 UTF-8,非 ASCII 昵称会 UnicodeDecodeError 中断全部任务。 + d = json.load(open(p, encoding="utf-8")) + a, acc = d["auth"], d["account"] + return {"token": a["accessToken"], "domain": a.get("domain") or "", + "uid": acc["uid"], "nick": acc.get("nickname", ""), + "file": os.path.basename(p)} + + +def chat_base(auth: dict) -> str: + return auth.get("chat_base") or CHAT_BASE + + +def billing_base(auth: dict) -> str: + return auth.get("billing_base") or BILL_BASE + + +def _headers(auth: dict) -> dict: + hdr = {"Authorization": "Bearer " + auth["token"], + "Accept": "application/json", + "Content-Type": "application/json", + "User-Agent": CLIENT_UA, + "Origin": "https://www.codebuddy.cn", + "Referer": "https://www.codebuddy.cn/"} + if auth.get("uid"): + hdr["X-User-Id"] = auth["uid"] + if auth.get("domain"): + hdr["X-Domain"] = auth["domain"] + return hdr + + +def _request(auth, method, base, path, body=None, headers=None, timeout=30): + url = path if path.startswith("http") else base + path + hdr = _headers(auth) + if headers: + hdr.update(headers) + data = json.dumps(body).encode() if body is not None else None + req = urllib.request.Request(url, data=data, headers=hdr, method=method) + try: + with urllib.request.urlopen(req, timeout=timeout) as r: + return r.status, json.loads(r.read().decode("utf-8", "replace")) + except urllib.error.HTTPError as e: + t = e.read().decode("utf-8", "replace") + try: + return e.code, json.loads(t) + except Exception: + return e.code, {"raw": t[:300]} + except Exception as e: + return -1, {"err": repr(e)} + + +def do_get(auth, base, path, headers=None) -> tuple: + """GET 读请求,返回 (status, dict)。""" + return _request(auth, "GET", base, path, None, headers) + + +def do_post(auth, base, path, body, headers=None) -> tuple: + """POST 写请求,返回 (status, dict)。body 为 dict。""" + return _request(auth, "POST", base, path, body, headers) + + +def list_tasks(auth) -> list: + """GET /v2/activity/growth/tasks 全量任务列表(元素为原始 dict)。""" + st, d = do_get(auth, chat_base(auth), PATH_LIST_TASKS) + if st != 200: + raise RuntimeError(f"list_tasks http={st}") + tasks = (d.get("data", {}) or {}).get("tasks") or [] + return tasks + + +def task_status(auth, task_code) -> dict | None: + """查单个任务当前状态;找不到返回 None。""" + for t in list_tasks(auth): + if t.get("task_code") == task_code: + return t + return None + + +def accept_tasks(auth, task_codes) -> tuple: + """POST accept 任务(not_accepted → accepted)。返回 (status, resp)。""" + return do_post(auth, chat_base(auth), PATH_ACCEPT_TASKS, + {"task_codes": task_codes}) + + +def claim_reward(auth, task_code) -> tuple: + """POST claim 领取奖励(任务已 complete 后可领)。重复领返回业务错误,安全。""" + return do_post(auth, chat_base(auth), PATH_CLAIM_REWARD, + {"task_code": task_code}) + + +def get_streak(auth) -> int: + """GET /activity/growth/streak 连登天数(只读 oracle)。失败返回 -1 记日志。""" + st, d = do_get(auth, chat_base(auth), PATH_STREAK) + if st != 200: + return -1 + return (d.get("data", {}).get("streak", {}) or {}).get("days", 0) + + +def chat_event(auth, conversation_id=None, model_id="deepseek-v4-flash", + model_name="DeepSeek V4 Flash", mode="craft"): + """客户端 chat_request_send 事件完整形状(照抄 report.go / probe_active.py)。 + + 必须带 userId(=账号 uid),缺失则服务端 200 但静默丢弃。 + model_id/name 可换(如 GLM-5.2),供 model_chat 对齐实际模型。 + """ + now = int(time.time() * 1000) + cid = conversation_id or f"task-{now}" + return {"eventCode": "chat_request_send", "timestamp": now, "reportDelay": 0, + "mode": mode, "conversationId": cid, "requestId": cid, + "inputLength": 12, "requestModelId": model_id, + "requestModelName": model_name, "isPlan": False, + "isAutoExecuteTerminal": False, "isAutoModify": False, + "codebaseEnable": False, "maxToken": 0, "maxSteps": 0, "temperature": 0, + "maxRetries": 0, "mentionContexts": [], "knowledgeId": [], + "knowledgeName": [], "codebaseId": "", "mentionContextCount": 0, + "command": "", "expertId": "", "recommendId": "", "skillId": "", + "skillCount": 0, "totalCount": 0, "fileUri": "", "presentAt": now, + "traceId": "", "rootRequestId": cid, "parentConversationId": cid, + "agentName": "default", "agentType": "conversation", "userId": auth["uid"]} + + +def report_activity(auth, count=1, gap=1.05, model_id="deepseek-v4-flash", + model_name="DeepSeek V4 Flash", mode="craft") -> list: + """向 {billing}/v2/report 上报 count 条 chat_request_send。 + + 每次间隔 >= gap 秒(默认 1.05,匹配 probe_active.py 的同接口限速口径)。 + 返回 [(status, code), ...] 汇总。 + """ + out = [] + for i in range(count): + ev = chat_event(auth, model_id=model_id, model_name=model_name, mode=mode) + st, r = do_post(auth, billing_base(auth), PATH_REPORT, [ev]) + out.append((st, r.get("code") if isinstance(r, dict) else None)) + if i < count - 1: + time.sleep(gap) + return out + + +def chat_completion(auth, model_id="glm-5.2", prompt="hi", max_tokens=32, + timeout=60) -> tuple: + """POST {chat}/v2/chat/completions 真实对话一次(stream:true)。 + + 服务端强制流式(payload.go 同款口径),这里逐行读 SSE 直到 done。 + 返回 (status, first_content)。用于 Model_chat_GLM5.2 的“真实对话一次”。 + """ + body = {"model": model_id, "messages": [{"role": "user", "content": prompt}], + "stream": True, "max_tokens": max_tokens} + hdr = {"Accept": "text/event-stream"} # SSE + url = chat_base(auth) + PATH_CHAT + req_headers = _headers(auth) + req_headers.update(hdr) + req = urllib.request.Request(url, data=json.dumps(body).encode(), + headers=req_headers, method="POST") + first = "" + try: + with urllib.request.urlopen(req, timeout=timeout) as r: + status = r.status + for raw in r: + line = raw.decode("utf-8", "replace") + if line.startswith("data: "): + payload = line[6:].strip() + if payload in ("[DONE]", ""): + continue + try: + obj = json.loads(payload) + delta = (obj.get("choices") or [{}])[0].get("delta") or {} + content = delta.get("content") or "" + if content and not first: + first = content + except Exception: + pass + return status, first + except urllib.error.HTTPError as e: + t = e.read().decode("utf-8", "replace") + return e.code, t[:200] + except Exception as e: return -1, repr(e)[:200] \ No newline at end of file diff --git a/scripts/task_first_buddy.py b/scripts/task_first_buddy.py old mode 100644 new mode 100755 index 44cdeb68ff7eb4ad18767f14dc63f7a482f81aa5..4be77016ceb4bdb0ad57e48e3443aa1fccf5bfcc --- a/scripts/task_first_buddy.py +++ b/scripts/task_first_buddy.py @@ -1,68 +1,68 @@ -#!/usr/bin/env python3 -"""一次性任务脚本:first_buddy(领取一只 Buddy,+300 积分 +8 能量). - -链路(照抄 probe_active.py 的 unlock 模式,实测可行): - report(1 条 chat_request_send) -> buddy/agreement -> buddy/first -判据是服务端行为事件,不是 accept 状态。 - -用法 - python3 task_first_buddy.py # dry-run - python3 task_first_buddy.py --yes # 真正执行 - python3 task_first_buddy.py ALL --yes # 全池(跳过已 claimed) -""" -import sys, os, time -sys.path.insert(0, os.path.dirname(os.path.abspath(__file__))) -import task_common as tc - -TASK_CODE = "first_buddy" - - -def main(): - if len(sys.argv) < 2: - print(__doc__) - sys.exit(1) - account = sys.argv[1] - yes = "--yes" in sys.argv - gap = 1.05 - - prefixes = [] - if account.upper() == "ALL": - import glob - prefixes = [os.path.basename(p)[10:18] - for p in sorted(glob.glob(tc.AUTHS + "/workbuddy-*.json"))] - else: - prefixes = [account] - - for pre in prefixes: - c = tc.load_auth(pre) - print(f"== {c['uid'][:8]} ({c['nick']}) ==") - try: - st = tc.task_status(c, TASK_CODE) - except Exception as e: - print(f" [skip] list_tasks 失败: {e}") - continue - if st is None: - print(f" [skip] 无 {TASK_CODE} 任务") - continue - ast = st.get("accept_status") - if ast == "claimed": - print(f" [skip] {TASK_CODE} 已 claimed,无需处理") - continue - if not yes: - print(f" [dry-run] 将执行 report + agreement + buddy/first (加 --yes 生效;当前 accept_status={ast})") - continue - - # 写链路 - st_code, code = tc.report_activity(c, count=1, gap=gap)[0] - print(f" report -> {st_code} code={code}") - time.sleep(2) - st2, ag = tc.do_post(c, tc.chat_base(c), tc.PATH_BUDDY_AGREEMENT, {"agree": True}) - print(f" agreement -> {st2} code={ag.get('code')}") - st3, bf = tc.do_post(c, tc.chat_base(c), tc.PATH_BUDDY_FIRST, {}) - d = bf.get("data") or {} - print(f" buddy/first -> {st3} {bf.get('msg')} credit={d.get('credit')} energy={d.get('energy')}") - time.sleep(gap) - - -if __name__ == "__main__": +#!/usr/bin/env python3 +"""一次性任务脚本:first_buddy(领取一只 Buddy,+300 积分 +8 能量). + +链路(照抄 probe_active.py 的 unlock 模式,实测可行): + report(1 条 chat_request_send) -> buddy/agreement -> buddy/first +判据是服务端行为事件,不是 accept 状态。 + +用法 + python3 task_first_buddy.py # dry-run + python3 task_first_buddy.py --yes # 真正执行 + python3 task_first_buddy.py ALL --yes # 全池(跳过已 claimed) +""" +import sys, os, time +sys.path.insert(0, os.path.dirname(os.path.abspath(__file__))) +import task_common as tc + +TASK_CODE = "first_buddy" + + +def main(): + if len(sys.argv) < 2: + print(__doc__) + sys.exit(1) + account = sys.argv[1] + yes = "--yes" in sys.argv + gap = 1.05 + + prefixes = [] + if account.upper() == "ALL": + import glob + prefixes = [os.path.basename(p)[10:18] + for p in sorted(glob.glob(tc.AUTHS + "/workbuddy-*.json"))] + else: + prefixes = [account] + + for pre in prefixes: + c = tc.load_auth(pre) + print(f"== {c['uid'][:8]} ({c['nick']}) ==") + try: + st = tc.task_status(c, TASK_CODE) + except Exception as e: + print(f" [skip] list_tasks 失败: {e}") + continue + if st is None: + print(f" [skip] 无 {TASK_CODE} 任务") + continue + ast = st.get("accept_status") + if ast == "claimed": + print(f" [skip] {TASK_CODE} 已 claimed,无需处理") + continue + if not yes: + print(f" [dry-run] 将执行 report + agreement + buddy/first (加 --yes 生效;当前 accept_status={ast})") + continue + + # 写链路 + st_code, code = tc.report_activity(c, count=1, gap=gap)[0] + print(f" report -> {st_code} code={code}") + time.sleep(2) + st2, ag = tc.do_post(c, tc.chat_base(c), tc.PATH_BUDDY_AGREEMENT, {"agree": True}) + print(f" agreement -> {st2} code={ag.get('code')}") + st3, bf = tc.do_post(c, tc.chat_base(c), tc.PATH_BUDDY_FIRST, {}) + d = bf.get("data") or {} + print(f" buddy/first -> {st3} {bf.get('msg')} credit={d.get('credit')} energy={d.get('energy')}") + time.sleep(gap) + + +if __name__ == "__main__": main() \ No newline at end of file diff --git a/scripts/task_model_chat.py b/scripts/task_model_chat.py old mode 100644 new mode 100755 index d996b8fd2d7ef25c25456dfe3f4d6e4a0a522c49..48a0e1acaef0a9aa48a78943195d2dc55b1a2b84 --- a/scripts/task_model_chat.py +++ b/scripts/task_model_chat.py @@ -1,91 +1,91 @@ -#!/usr/bin/env python3 -"""一次性任务脚本:Model_chat_GLM5.2(体验「GLM-5.2」模型对话 1 次,+100 积分 +5 能量). - -步骤(实测确认): - 1. accept:POST /v2/activity/growth/tasks/accept {"task_codes":["Model_chat_GLM5.2"]} - (不 accept 也会被行为事件点亮,但进度状态更规范,先 accept) - 2. 真实对话:POST {chat}/v2/chat/completions {model:"glm-5.2", stream:true} - —— 模型列表实测存在 glm-5.2,SSE 200 正常回包 - 3. 上报一条 chat_request_send(requestModelId=glm-5.2)触发 progress - —— 若任务判据靠事件上报,这条即可点亮;真实对话是「使用 GLM-5.2 成功对话」的最直接证据 - 4. 回读 progress;current>=target 后提示 claim - -用法 - python3 task_model_chat.py # dry-run - python3 task_model_chat.py --yes # accept + 真实对话 + 上报 -""" -import sys, os, time, argparse -sys.path.insert(0, os.path.dirname(os.path.abspath(__file__))) -import task_common as tc - -TASK_CODE = "Model_chat_GLM5.2" -MODEL_ID = "glm-5.2" -MODEL_NAME = "GLM-5.2" -TARGET = 1 - - -def main(): - ap = argparse.ArgumentParser(description="Model_chat_GLM5.2 任务") - ap.add_argument("account", help="uid 前缀,或 ALL") - ap.add_argument("--yes", action="store_true", help="确认执行写操作") - ap.add_argument("--prompt", default="hi,请回复一句话", help="发给 GLM-5.2 的提示词") - a = ap.parse_args() - - prefixes = [] - if a.account.upper() == "ALL": - import glob - prefixes = [os.path.basename(p)[10:18] - for p in sorted(glob.glob(tc.AUTHS + "/workbuddy-*.json"))] - else: - prefixes = [a.account] - - for pre in prefixes: - c = tc.load_auth(pre) - print(f"== {c['uid'][:8]} ({c['nick']}) ==") - try: - st = tc.task_status(c, TASK_CODE) - except Exception as e: - print(f" [skip] list_tasks 失败: {e}") - continue - if st is None: - print(f" [skip] 无 {TASK_CODE} 任务") - continue - ast = st.get("accept_status") - prog = (st.get("progress") or {}) - cur = prog.get("current", 0) - target = prog.get("target", TARGET) - if ast == "claimed" or cur >= target: - print(f" [skip] 已完成 {cur}/{target} (accept_status={ast})") - continue - if not a.yes: - print(f" [dry-run] 将 accept + GLM-5.2 真实对话一次 + 上报 chat_request_send " - f"(当前 {cur}/{target},加 --yes 生效)") - continue - - # 1. accept - st_a, r_a = tc.accept_tasks(c, [TASK_CODE]) - print(f" accept -> {st_a} {r_a.get('msg') if isinstance(r_a, dict) else r_a}") - time.sleep(1.05) - - # 2. 真实对话(GLM-5.2) - st_chat, first = tc.chat_completion(c, model_id=MODEL_ID, prompt=a.prompt) - print(f" chat glm-5.2 -> {st_chat} {first[:60]!r}") - - # 3. 上报一条 chat_request_send(模型字段对齐 glm-5.2) - results = tc.report_activity(c, count=1, gap=1.05, - model_id=MODEL_ID, model_name=MODEL_NAME) - print(f" report x1 -> {results}") - time.sleep(1.0) - - # 4. 回读 - st2 = tc.task_status(c, TASK_CODE) - prog2 = (st2.get("progress") or {}) if st2 else {} - cur2 = prog2.get("current", 0) - ast2 = st2.get("accept_status") if st2 else "?" - print(f" 回读 {TASK_CODE}: {cur2}/{prog2.get('target', target)} accept_status={ast2}") - if ast2 not in ("claimed",) and cur2 >= target: - print(" → 任务已满足,可手动或后续调用 claim_reward 领奖") - - -if __name__ == "__main__": +#!/usr/bin/env python3 +"""一次性任务脚本:Model_chat_GLM5.2(体验「GLM-5.2」模型对话 1 次,+100 积分 +5 能量). + +步骤(实测确认): + 1. accept:POST /v2/activity/growth/tasks/accept {"task_codes":["Model_chat_GLM5.2"]} + (不 accept 也会被行为事件点亮,但进度状态更规范,先 accept) + 2. 真实对话:POST {chat}/v2/chat/completions {model:"glm-5.2", stream:true} + —— 模型列表实测存在 glm-5.2,SSE 200 正常回包 + 3. 上报一条 chat_request_send(requestModelId=glm-5.2)触发 progress + —— 若任务判据靠事件上报,这条即可点亮;真实对话是「使用 GLM-5.2 成功对话」的最直接证据 + 4. 回读 progress;current>=target 后提示 claim + +用法 + python3 task_model_chat.py # dry-run + python3 task_model_chat.py --yes # accept + 真实对话 + 上报 +""" +import sys, os, time, argparse +sys.path.insert(0, os.path.dirname(os.path.abspath(__file__))) +import task_common as tc + +TASK_CODE = "Model_chat_GLM5.2" +MODEL_ID = "glm-5.2" +MODEL_NAME = "GLM-5.2" +TARGET = 1 + + +def main(): + ap = argparse.ArgumentParser(description="Model_chat_GLM5.2 任务") + ap.add_argument("account", help="uid 前缀,或 ALL") + ap.add_argument("--yes", action="store_true", help="确认执行写操作") + ap.add_argument("--prompt", default="hi,请回复一句话", help="发给 GLM-5.2 的提示词") + a = ap.parse_args() + + prefixes = [] + if a.account.upper() == "ALL": + import glob + prefixes = [os.path.basename(p)[10:18] + for p in sorted(glob.glob(tc.AUTHS + "/workbuddy-*.json"))] + else: + prefixes = [a.account] + + for pre in prefixes: + c = tc.load_auth(pre) + print(f"== {c['uid'][:8]} ({c['nick']}) ==") + try: + st = tc.task_status(c, TASK_CODE) + except Exception as e: + print(f" [skip] list_tasks 失败: {e}") + continue + if st is None: + print(f" [skip] 无 {TASK_CODE} 任务") + continue + ast = st.get("accept_status") + prog = (st.get("progress") or {}) + cur = prog.get("current", 0) + target = prog.get("target", TARGET) + if ast == "claimed" or cur >= target: + print(f" [skip] 已完成 {cur}/{target} (accept_status={ast})") + continue + if not a.yes: + print(f" [dry-run] 将 accept + GLM-5.2 真实对话一次 + 上报 chat_request_send " + f"(当前 {cur}/{target},加 --yes 生效)") + continue + + # 1. accept + st_a, r_a = tc.accept_tasks(c, [TASK_CODE]) + print(f" accept -> {st_a} {r_a.get('msg') if isinstance(r_a, dict) else r_a}") + time.sleep(1.05) + + # 2. 真实对话(GLM-5.2) + st_chat, first = tc.chat_completion(c, model_id=MODEL_ID, prompt=a.prompt) + print(f" chat glm-5.2 -> {st_chat} {first[:60]!r}") + + # 3. 上报一条 chat_request_send(模型字段对齐 glm-5.2) + results = tc.report_activity(c, count=1, gap=1.05, + model_id=MODEL_ID, model_name=MODEL_NAME) + print(f" report x1 -> {results}") + time.sleep(1.0) + + # 4. 回读 + st2 = tc.task_status(c, TASK_CODE) + prog2 = (st2.get("progress") or {}) if st2 else {} + cur2 = prog2.get("current", 0) + ast2 = st2.get("accept_status") if st2 else "?" + print(f" 回读 {TASK_CODE}: {cur2}/{prog2.get('target', target)} accept_status={ast2}") + if ast2 not in ("claimed",) and cur2 >= target: + print(" → 任务已满足,可手动或后续调用 claim_reward 领奖") + + +if __name__ == "__main__": main() \ No newline at end of file diff --git a/scripts/task_richmeow.py b/scripts/task_richmeow.py old mode 100644 new mode 100755 index 334f4f60534d056c5fc597f6f38f7b0245c44a22..aee44d3fe804ca74bbbcd3bbd2ee3a7de384c805 --- a/scripts/task_richmeow.py +++ b/scripts/task_richmeow.py @@ -1,78 +1,78 @@ -#!/usr/bin/env python3 -"""一次性任务脚本:RichMeow_Chat(桌面端对话 1 次,+100 积分 +5 能量 +限定 Buddy 盲盒). - -任务书:先查 eventCode 是否与 chat_request_send 不同(在 probe_active.py / Go 代码 -搜 RichMeow 相关——未找到专属 eventCode,REPORT §3.2 也标注「桌面端专属(未破)」)。 - -实测结论(REPORT §3.2,2026-09-11): - - accept 后 3 个账号多次 chat_request_send 上报均不计数(progress 0/1 不动)。 - - 怀疑是桌面端变体的另一套上报通道:queuePendingGrowthTelemetry → 把 growthEvent - 挂在 chat 请求的 extra_vars 里随请求上行(REPORT §1.1),而非 /v2/report。 - - 本脚本默认上线尝试 1 次 chat_request_send(成本可忽略);若仍 0/1 → 判为不可脚本化。 - -用法 - python3 task_richmeow.py # dry-run - python3 task_richmeow.py --yes # 上报 1 次并回读 -""" -import sys, os, time -sys.path.insert(0, os.path.dirname(os.path.abspath(__file__))) -import task_common as tc - -TASK_CODE = "RichMeow_Chat" -TARGET = 1 - - -def main(): - if len(sys.argv) < 2: - print(__doc__) - sys.exit(1) - account = sys.argv[1] - yes = "--yes" in sys.argv - - prefixes = [] - if account.upper() == "ALL": - import glob - prefixes = [os.path.basename(p)[10:18] - for p in sorted(glob.glob(tc.AUTHS + "/workbuddy-*.json"))] - else: - prefixes = [account] - - for pre in prefixes: - c = tc.load_auth(pre) - print(f"== {c['uid'][:8]} ({c['nick']}) ==") - try: - st = tc.task_status(c, TASK_CODE) - except Exception as e: - print(f" [skip] list_tasks 失败: {e}") - continue - if st is None: - print(f" [skip] 无 {TASK_CODE} 任务") - continue - ast = st.get("accept_status") - prog = (st.get("progress") or {}) - cur = prog.get("current", 0) - target = prog.get("target", TARGET) - if ast == "claimed" or cur >= target: - print(f" [skip] 已完成 {cur}/{target} (accept_status={ast})") - continue - # not_accepted 先 accept - if ast == "not_accepted" and yes: - st_a, r_a = tc.accept_tasks(c, [TASK_CODE]) - print(f" accept -> {st_a} {r_a.get('msg') if isinstance(r_a, dict) else r_a}") - time.sleep(1.05) - elif ast == "not_accepted": - print(f" [dry-run] 先 accept(当前 not_accepted),再上报 1 条") - if not yes: - print(f" [dry-run] 将上报 1 条 chat_request_send(当前 {cur}/{target},加 --yes 生效)") - continue - results = tc.report_activity(c, count=1, gap=1.05) - print(f" report x1 -> {results}") - time.sleep(1.0) - st2 = tc.task_status(c, TASK_CODE) - prog2 = (st2.get("progress") or {}) if st2 else {} - print(f" 回读 {TASK_CODE}: {prog2.get('current', 0)}/{prog2.get('target', target)} " - f"accept_status={st2.get('accept_status') if st2 else '?'}") - - -if __name__ == "__main__": +#!/usr/bin/env python3 +"""一次性任务脚本:RichMeow_Chat(桌面端对话 1 次,+100 积分 +5 能量 +限定 Buddy 盲盒). + +任务书:先查 eventCode 是否与 chat_request_send 不同(在 probe_active.py / Go 代码 +搜 RichMeow 相关——未找到专属 eventCode,REPORT §3.2 也标注「桌面端专属(未破)」)。 + +实测结论(REPORT §3.2,2026-09-11): + - accept 后 3 个账号多次 chat_request_send 上报均不计数(progress 0/1 不动)。 + - 怀疑是桌面端变体的另一套上报通道:queuePendingGrowthTelemetry → 把 growthEvent + 挂在 chat 请求的 extra_vars 里随请求上行(REPORT §1.1),而非 /v2/report。 + - 本脚本默认上线尝试 1 次 chat_request_send(成本可忽略);若仍 0/1 → 判为不可脚本化。 + +用法 + python3 task_richmeow.py # dry-run + python3 task_richmeow.py --yes # 上报 1 次并回读 +""" +import sys, os, time +sys.path.insert(0, os.path.dirname(os.path.abspath(__file__))) +import task_common as tc + +TASK_CODE = "RichMeow_Chat" +TARGET = 1 + + +def main(): + if len(sys.argv) < 2: + print(__doc__) + sys.exit(1) + account = sys.argv[1] + yes = "--yes" in sys.argv + + prefixes = [] + if account.upper() == "ALL": + import glob + prefixes = [os.path.basename(p)[10:18] + for p in sorted(glob.glob(tc.AUTHS + "/workbuddy-*.json"))] + else: + prefixes = [account] + + for pre in prefixes: + c = tc.load_auth(pre) + print(f"== {c['uid'][:8]} ({c['nick']}) ==") + try: + st = tc.task_status(c, TASK_CODE) + except Exception as e: + print(f" [skip] list_tasks 失败: {e}") + continue + if st is None: + print(f" [skip] 无 {TASK_CODE} 任务") + continue + ast = st.get("accept_status") + prog = (st.get("progress") or {}) + cur = prog.get("current", 0) + target = prog.get("target", TARGET) + if ast == "claimed" or cur >= target: + print(f" [skip] 已完成 {cur}/{target} (accept_status={ast})") + continue + # not_accepted 先 accept + if ast == "not_accepted" and yes: + st_a, r_a = tc.accept_tasks(c, [TASK_CODE]) + print(f" accept -> {st_a} {r_a.get('msg') if isinstance(r_a, dict) else r_a}") + time.sleep(1.05) + elif ast == "not_accepted": + print(f" [dry-run] 先 accept(当前 not_accepted),再上报 1 条") + if not yes: + print(f" [dry-run] 将上报 1 条 chat_request_send(当前 {cur}/{target},加 --yes 生效)") + continue + results = tc.report_activity(c, count=1, gap=1.05) + print(f" report x1 -> {results}") + time.sleep(1.0) + st2 = tc.task_status(c, TASK_CODE) + prog2 = (st2.get("progress") or {}) if st2 else {} + print(f" 回读 {TASK_CODE}: {prog2.get('current', 0)}/{prog2.get('target', target)} " + f"accept_status={st2.get('accept_status') if st2 else '?'}") + + +if __name__ == "__main__": main() \ No newline at end of file diff --git a/signin.sh b/signin.sh old mode 100644 new mode 100755 index 9632561ea552c30de9a8606625f7da10a9aa9227..d469491c500c18b1cdae32bfcd593d0add4bcc99 --- a/signin.sh +++ b/signin.sh @@ -1,13 +1,13 @@ -#!/bin/bash -# 批量签到脚本:遍历 auths/ 下所有 workbuddy-*.json 账号 -# 用法: ./signin.sh [auths_dir] -set -e -cd "$(dirname "$0")" - -BIN=./signin_bin -if [ ! -x "$BIN" ]; then - echo "build signin_bin ..." - go build -o "$BIN" ./cmd/signin -fi - -exec "$BIN" "${1:-auths}" +#!/bin/bash +# 批量签到脚本:遍历 auths/ 下所有 workbuddy-*.json 账号 +# 用法: ./signin.sh [auths_dir] +set -e +cd "$(dirname "$0")" + +BIN=./signin_bin +if [ ! -x "$BIN" ]; then + echo "build signin_bin ..." + go build -o "$BIN" ./cmd/signin +fi + +exec "$BIN" "${1:-auths}"