Compare commits
12 Commits
v1.6.37
...
chore.reco
| Author | SHA1 | Date | |
|---|---|---|---|
|
|
c39b3f5c4e | ||
|
|
2af273b9e2 | ||
|
|
144e0fdd59 | ||
|
|
1565749105 | ||
|
|
e53a8a01b7 | ||
|
|
3afbcfaae5 | ||
|
|
c3b328f91d | ||
|
|
7942c47808 | ||
|
|
46d93e715a | ||
|
|
a9027a8610 | ||
|
|
5853dc63ff | ||
|
|
ca14cb5437 |
@@ -43,7 +43,7 @@ jobs:
|
||||
IMAGE_OVERRIDE: ${{ inputs.docker_image_override }}
|
||||
PLATFORMS_OVERRIDE: ${{ inputs.platforms_override }}
|
||||
with:
|
||||
github-token: ${{ secrets.DOCKER_RELEASE_TOKEN }}
|
||||
github-token: ${{ secrets.SNOWLUMA_TOKEN }}
|
||||
script: |
|
||||
const target = process.env.RELEASE_REPOSITORY;
|
||||
if (!target || !target.includes('/')) {
|
||||
|
||||
245
.github/workflows/promote-dev-to-main.yml
vendored
Normal file
245
.github/workflows/promote-dev-to-main.yml
vendored
Normal file
@@ -0,0 +1,245 @@
|
||||
name: Promote Dev to Main
|
||||
on:
|
||||
push:
|
||||
branches: [dev]
|
||||
tags: ['chore.*']
|
||||
workflow_dispatch:
|
||||
inputs:
|
||||
auto_merge:
|
||||
description: Enable auto-merge on the resulting PR
|
||||
type: choice
|
||||
options: ['true', 'false']
|
||||
default: 'true'
|
||||
merge_method:
|
||||
description: Merge strategy when auto-merging
|
||||
type: choice
|
||||
options: ['merge', 'squash', 'rebase']
|
||||
default: 'merge'
|
||||
|
||||
permissions:
|
||||
contents: read
|
||||
|
||||
concurrency:
|
||||
group: promote-dev-to-main
|
||||
cancel-in-progress: false
|
||||
|
||||
jobs:
|
||||
decide:
|
||||
runs-on: ubuntu-latest
|
||||
outputs:
|
||||
run: ${{ steps.check.outputs.run }}
|
||||
auto_merge: ${{ steps.check.outputs.auto_merge }}
|
||||
merge_method: ${{ steps.check.outputs.merge_method }}
|
||||
reason: ${{ steps.check.outputs.reason }}
|
||||
steps:
|
||||
- name: Decide whether to promote
|
||||
id: check
|
||||
env:
|
||||
EVENT_NAME: ${{ github.event_name }}
|
||||
REF: ${{ github.ref }}
|
||||
REF_TYPE: ${{ github.ref_type }}
|
||||
HEAD_COMMIT_MSG: ${{ github.event.head_commit.message }}
|
||||
INPUT_AUTO_MERGE: ${{ inputs.auto_merge }}
|
||||
INPUT_MERGE_METHOD: ${{ inputs.merge_method }}
|
||||
run: |
|
||||
set -euo pipefail
|
||||
run='false'
|
||||
auto_merge='true'
|
||||
merge_method='merge'
|
||||
reason=''
|
||||
|
||||
case "${EVENT_NAME}" in
|
||||
workflow_dispatch)
|
||||
run='true'
|
||||
auto_merge="${INPUT_AUTO_MERGE:-true}"
|
||||
merge_method="${INPUT_MERGE_METHOD:-merge}"
|
||||
reason='Manual workflow_dispatch'
|
||||
;;
|
||||
push)
|
||||
if [ "${REF_TYPE}" = 'tag' ]; then
|
||||
run='true'
|
||||
merge_method='merge'
|
||||
reason="Tag push: ${REF}"
|
||||
elif [ "${REF}" = 'refs/heads/dev' ]; then
|
||||
msg="${HEAD_COMMIT_MSG:-}"
|
||||
if printf '%s' "${msg}" | grep -qiE '^\[merge\]|^chore\(release\):'; then
|
||||
run='true'
|
||||
merge_method='merge'
|
||||
reason='Commit message prefix on dev ([merge] or chore(release):)'
|
||||
else
|
||||
reason='Commit on dev without [merge] / chore(release): prefix'
|
||||
fi
|
||||
else
|
||||
reason="Push event on unhandled ref: ${REF}"
|
||||
fi
|
||||
;;
|
||||
*)
|
||||
reason="Unhandled event: ${EVENT_NAME}"
|
||||
;;
|
||||
esac
|
||||
|
||||
{
|
||||
echo "run=${run}"
|
||||
echo "auto_merge=${auto_merge}"
|
||||
echo "merge_method=${merge_method}"
|
||||
echo "reason=${reason}"
|
||||
} >> "${GITHUB_OUTPUT}"
|
||||
|
||||
{
|
||||
echo "## Promote decision"
|
||||
echo
|
||||
echo "| Key | Value |"
|
||||
echo "| --- | --- |"
|
||||
echo "| Event | \`${EVENT_NAME}\` |"
|
||||
echo "| Ref | \`${REF}\` |"
|
||||
echo "| Run | \`${run}\` |"
|
||||
echo "| Auto-merge | \`${auto_merge}\` |"
|
||||
echo "| Merge method | \`${merge_method}\` |"
|
||||
echo "| Reason | ${reason} |"
|
||||
} >> "${GITHUB_STEP_SUMMARY}"
|
||||
|
||||
promote:
|
||||
needs: decide
|
||||
if: needs.decide.outputs.run == 'true'
|
||||
runs-on: ubuntu-latest
|
||||
steps:
|
||||
- name: Validate GitHub App credentials
|
||||
env:
|
||||
APP_ID: ${{ secrets.SNOWLUMA_BOT_APP_ID }}
|
||||
PRIVATE_KEY: ${{ secrets.SNOWLUMA_BOT_PRIVATE_KEY }}
|
||||
run: |
|
||||
if [ -z "${APP_ID}" ] || [ -z "${PRIVATE_KEY}" ]; then
|
||||
echo 'Missing SNOWLUMA_BOT_APP_ID and/or SNOWLUMA_BOT_PRIVATE_KEY secrets.' >&2
|
||||
echo 'Configure the same GitHub App used by the nnphook native PR flow.' >&2
|
||||
exit 1
|
||||
fi
|
||||
|
||||
- name: Mint GitHub App installation token
|
||||
id: app-token
|
||||
uses: actions/create-github-app-token@v2
|
||||
with:
|
||||
app-id: ${{ secrets.SNOWLUMA_BOT_APP_ID }}
|
||||
private-key: ${{ secrets.SNOWLUMA_BOT_PRIVATE_KEY }}
|
||||
owner: ${{ github.repository_owner }}
|
||||
repositories: ${{ github.event.repository.name }}
|
||||
|
||||
- name: Resolve bot identity
|
||||
id: bot
|
||||
env:
|
||||
GH_TOKEN: ${{ steps.app-token.outputs.token }}
|
||||
APP_SLUG: ${{ steps.app-token.outputs.app-slug }}
|
||||
run: |
|
||||
set -euo pipefail
|
||||
bot_login="${APP_SLUG}[bot]"
|
||||
bot_id="$(gh api "/users/${bot_login}" --jq .id)"
|
||||
bot_email="${bot_id}+${bot_login}@users.noreply.github.com"
|
||||
{
|
||||
echo "login=${bot_login}"
|
||||
echo "id=${bot_id}"
|
||||
echo "email=${bot_email}"
|
||||
} >> "${GITHUB_OUTPUT}"
|
||||
echo "Resolved bot: ${bot_login} <${bot_email}>"
|
||||
|
||||
- name: Checkout main
|
||||
uses: actions/checkout@v6
|
||||
with:
|
||||
ref: main
|
||||
fetch-depth: 0
|
||||
token: ${{ steps.app-token.outputs.token }}
|
||||
|
||||
- name: Compare dev to main
|
||||
id: diff
|
||||
run: |
|
||||
set -euo pipefail
|
||||
git fetch origin dev:dev
|
||||
ahead="$(git rev-list --count main..dev)"
|
||||
behind="$(git rev-list --count dev..main)"
|
||||
dev_sha="$(git rev-parse dev)"
|
||||
dev_short="$(git rev-parse --short dev)"
|
||||
{
|
||||
echo "ahead=${ahead}"
|
||||
echo "behind=${behind}"
|
||||
echo "dev_sha=${dev_sha}"
|
||||
echo "dev_short=${dev_short}"
|
||||
} >> "${GITHUB_OUTPUT}"
|
||||
if [ "${ahead}" = '0' ]; then
|
||||
echo "skip=true" >> "${GITHUB_OUTPUT}"
|
||||
echo "::notice::dev has no commits ahead of main; nothing to promote."
|
||||
else
|
||||
echo "skip=false" >> "${GITHUB_OUTPUT}"
|
||||
echo "dev is ${ahead} ahead, ${behind} behind main."
|
||||
fi
|
||||
|
||||
- name: Ensure automation label exists
|
||||
if: steps.diff.outputs.skip != 'true'
|
||||
env:
|
||||
GH_TOKEN: ${{ steps.app-token.outputs.token }}
|
||||
run: |
|
||||
gh label create automation --color 0E8A16 --description 'Automated bot PRs' 2>/dev/null || true
|
||||
|
||||
- name: Create or update Pull Request
|
||||
id: pr
|
||||
if: steps.diff.outputs.skip != 'true'
|
||||
env:
|
||||
GH_TOKEN: ${{ steps.app-token.outputs.token }}
|
||||
DEV_SHA: ${{ steps.diff.outputs.dev_sha }}
|
||||
DEV_SHORT: ${{ steps.diff.outputs.dev_short }}
|
||||
AHEAD: ${{ steps.diff.outputs.ahead }}
|
||||
BEHIND: ${{ steps.diff.outputs.behind }}
|
||||
REASON: ${{ needs.decide.outputs.reason }}
|
||||
REF: ${{ github.ref }}
|
||||
RUN_URL: ${{ github.server_url }}/${{ github.repository }}/actions/runs/${{ github.run_id }}
|
||||
run: |
|
||||
set -euo pipefail
|
||||
title="chore: promote dev → main (${DEV_SHORT})"
|
||||
|
||||
{
|
||||
echo "Automated promotion of \`dev\` into \`main\`."
|
||||
echo
|
||||
echo "| Key | Value |"
|
||||
echo "| --- | --- |"
|
||||
echo "| Source | \`dev\` @ \`${DEV_SHA}\` |"
|
||||
echo "| Trigger ref | \`${REF}\` |"
|
||||
echo "| Trigger reason | ${REASON} |"
|
||||
echo "| Workflow run | ${RUN_URL} |"
|
||||
echo "| Ahead / Behind | ${AHEAD} / ${BEHIND} |"
|
||||
echo
|
||||
echo "Created by SnowLuma Bot."
|
||||
} > pr-body.md
|
||||
|
||||
existing="$(gh pr list --base main --head dev --state open --json number --jq '.[0].number' 2>/dev/null || true)"
|
||||
if [ -n "${existing}" ]; then
|
||||
gh pr edit "${existing}" --title "${title}" --body-file pr-body.md
|
||||
pr_number="${existing}"
|
||||
echo "Updated existing PR #${pr_number}"
|
||||
else
|
||||
url="$(gh pr create --base main --head dev --title "${title}" --body-file pr-body.md --label automation)"
|
||||
pr_number="${url##*/}"
|
||||
echo "Opened new PR #${pr_number} (${url})"
|
||||
fi
|
||||
|
||||
echo "number=${pr_number}" >> "${GITHUB_OUTPUT}"
|
||||
{
|
||||
echo "## Promote PR"
|
||||
echo
|
||||
echo "- Number: #${pr_number}"
|
||||
echo "- Source: \`dev@${DEV_SHORT}\`"
|
||||
echo "- Ahead/Behind: ${AHEAD}/${BEHIND}"
|
||||
} >> "${GITHUB_STEP_SUMMARY}"
|
||||
|
||||
- name: Enable auto-merge
|
||||
if: steps.diff.outputs.skip != 'true' && needs.decide.outputs.auto_merge == 'true'
|
||||
env:
|
||||
GH_TOKEN: ${{ steps.app-token.outputs.token }}
|
||||
PR_NUMBER: ${{ steps.pr.outputs.number }}
|
||||
MERGE_METHOD: ${{ needs.decide.outputs.merge_method }}
|
||||
run: |
|
||||
set -euo pipefail
|
||||
method_flag='--merge'
|
||||
case "${MERGE_METHOD}" in
|
||||
squash) method_flag='--squash' ;;
|
||||
rebase) method_flag='--rebase' ;;
|
||||
*) method_flag='--merge' ;;
|
||||
esac
|
||||
gh pr merge "${PR_NUMBER}" --auto ${method_flag}
|
||||
echo "::notice::Auto-merge enabled on PR #${PR_NUMBER} with strategy: ${MERGE_METHOD}"
|
||||
2
.github/workflows/release.yml
vendored
2
.github/workflows/release.yml
vendored
@@ -181,7 +181,7 @@ jobs:
|
||||
DOCKER_WORKFLOW: ${{ vars.DOCKER_WORKFLOW }}
|
||||
DOCKER_REF: ${{ vars.DOCKER_REF }}
|
||||
with:
|
||||
github-token: ${{ secrets.DOCKER_RELEASE_TOKEN }}
|
||||
github-token: ${{ secrets.SNOWLUMA_TOKEN }}
|
||||
script: |
|
||||
const target = process.env.RELEASE_REPOSITORY;
|
||||
if (!target || !target.includes('/')) {
|
||||
|
||||
106
CONTRIBUTING.md
Normal file
106
CONTRIBUTING.md
Normal file
@@ -0,0 +1,106 @@
|
||||
# 贡献指南
|
||||
|
||||
## 分支模型
|
||||
|
||||
SnowLuma 使用 **`main` + `dev`** 双分支模型:
|
||||
|
||||
- **`main`** — 受保护的稳定分支,仅接收来自 `dev` 的合并 PR。**禁止直接 push**。
|
||||
- **`dev`** — 日常开发分支。所有功能、修复、文档变更都先提交到 `dev`。
|
||||
- **`native/auto-update-*`** — 由 `SnowLuma Bot` 自动创建的原生产物更新分支(来自 `SnowLumaNative`,不需要手动维护)。
|
||||
|
||||
## 把 `dev` 合并到 `main`
|
||||
|
||||
新增工作流 `.github/workflows/promote-dev-to-main.yml` 会以 `SnowLuma Bot` 身份开 / 更新一个 `dev → main` 的 PR,并可选地自动合并。三种触发方式:
|
||||
|
||||
无论使用哪种触发方式,工作流都会调用 `gh pr merge --auto`:**只有 `main` 分支保护中所有 required status checks(typecheck + 各架构 build)都通过后,机器人才会真正合并**。失败的工作流会卡住合并。
|
||||
|
||||
### 1. 提交信息前缀(推荐日常使用)
|
||||
|
||||
向 `dev` push 一个提交,提交信息**以**以下任一前缀**开头**即触发(不区分大小写):
|
||||
|
||||
- `[merge]` — 例如 `[merge] fix: hotfix for OneBot mention`
|
||||
- `chore(release):` — 例如 `chore(release): v1.7.0`,符合 conventional commits 的发版习惯
|
||||
|
||||
> 注意:是**前缀**匹配,不是任意位置。`fix: something [merge]` 不会触发,必须把 `[merge]` 写在最前面。
|
||||
|
||||
### 2. 推送 `chore.*` Tag
|
||||
|
||||
任何符合 `chore.*` 的 tag(如 `chore.merge-20240509`、`chore.promote-v1.7.0`)被推送时也会触发本工作流。这是和发布 tag 解耦的「合并触发 tag」:
|
||||
|
||||
- `chore.*` → 仅触发 `promote-dev-to-main.yml`(开 PR,自动合并)
|
||||
- `v*` → 仅触发 `release.yml`(构建发布产物)
|
||||
|
||||
推荐流程:先用 `chore.*` tag 把 `dev` 合入 `main`,待合并完成后再在 `main` 上打 `v*` tag 触发发布。这样 `release.yml` 始终基于已经过完所有检查的 `main` HEAD 构建。
|
||||
|
||||
### 3. 手动触发
|
||||
|
||||
打开仓库 Actions 页面 → `Promote Dev to Main` → `Run workflow`。可选输入:
|
||||
|
||||
- `auto_merge`:是否启用 auto-merge(默认 `true`)。
|
||||
- `merge_method`:`merge` / `squash` / `rebase`(默认 `merge`)。
|
||||
|
||||
工作流会按照当前 `dev` 与 `main` 的差异开 / 更新 PR。
|
||||
|
||||
## 启用 `main` 分支保护(必做)
|
||||
|
||||
仓库管理员需要在 GitHub 上为 `main` 配置一条规则集(Repository Rules)或经典分支保护,至少满足:
|
||||
|
||||
1. **Settings → Rules → Rulesets**(推荐)或 **Settings → Branches → Branch protection rules**。
|
||||
2. 选择 `main` 作为目标分支。
|
||||
3. 勾选:
|
||||
- **Restrict deletions** — 禁止删除 `main`。
|
||||
- **Require a pull request before merging** — 所有合并必须走 PR。
|
||||
- **Block force pushes** — 禁止强推。
|
||||
- **Require status checks to pass before merging(必勾)** — 把以下来自 `dev-build.yml` 的 check 全部加为 required:
|
||||
- `typecheck`
|
||||
- `build (win-x64)`
|
||||
- `build (linux-x64)`
|
||||
- `build (linux-arm64)`
|
||||
- **Require branches to be up to date before merging** — 保证 PR 合并前已 rebase 过最新 `main`。
|
||||
4. 在 **Bypass list / Allow specified actors to bypass** 中加入 `SnowLuma Bot` GitHub App。这样 `gh pr merge --auto` 才能在所有 required check 通过后由机器人自动完成合并;否则 PR 会一直卡在 auto-merge 等待人工 review。
|
||||
5. **不要**把任何用户加入 push 白名单,确保「禁止向 `main` 直接提交」的约束生效。第一次设置完后,连仓库管理员也只能通过 PR 改 `main`。
|
||||
|
||||
效果:任何对 `dev` 的推送都会先在 `dev-build.yml` 上跑 typecheck + 三个架构的 build;只有全部成功,promote 工作流的 `--auto` 合并才会真正发生。失败时 PR 会保留在 open 状态,修复后再次推到 `dev` 即可重新触发检查。
|
||||
|
||||
## 必需的 Secrets
|
||||
|
||||
`promote-dev-to-main.yml` 复用 `SnowLumaNative/build-native.yml` 同一个 GitHub App。请确认 SnowLuma 仓库(或 organization)级别已经配置:
|
||||
|
||||
- `SNOWLUMA_BOT_APP_ID` — 数字类型的 App ID。
|
||||
- `SNOWLUMA_BOT_PRIVATE_KEY` — 该 App 的 PEM 私钥。
|
||||
|
||||
App 必须在本仓库已安装,且授予 **Contents: Read+Write**、**Pull requests: Read+Write**。
|
||||
|
||||
## 本地工作流速查
|
||||
|
||||
```bash
|
||||
# 切到 dev 开发
|
||||
git checkout dev
|
||||
git pull
|
||||
|
||||
# 写代码 / 跑测试
|
||||
pnpm install
|
||||
pnpm typecheck
|
||||
pnpm -s --filter @snowluma/core test
|
||||
|
||||
# 普通提交(不会触发 promote)
|
||||
git commit -m "fix: something"
|
||||
git push
|
||||
|
||||
# 把 dev 合入 main(三选一)
|
||||
|
||||
# 方式 A:commit-msg 前缀
|
||||
git commit -m "chore(release): v1.7.0" # 或 "[merge] fix: hotfix"
|
||||
git push # → 触发 promote-dev-to-main
|
||||
|
||||
# 方式 B:chore.* 合并 tag(与发布 tag 解耦)
|
||||
git tag chore.merge-20240509 # 或 chore.promote-v1.7.0 等
|
||||
git push origin chore.merge-20240509 # → 触发 promote-dev-to-main
|
||||
|
||||
# 方式 C:在 Actions 页面手动 Run workflow
|
||||
|
||||
# 合并完成后,发布版本(在 main 上打 v* tag)
|
||||
git checkout main && git pull
|
||||
git tag v1.7.0
|
||||
git push origin v1.7.0 # → 仅触发 release.yml
|
||||
```
|
||||
@@ -3,7 +3,7 @@
|
||||
|
||||
|
||||
## 关于项目
|
||||
项目处于开发初期,仅支持部分功能,持续高速迭代中,仅支持有头。
|
||||
项目处于开发初期,仅支持部分功能,高速迭代中,随时可能出现破坏性更新。
|
||||
|
||||
## 鸣谢
|
||||
[LagrangeV2](https://github.com/LagrangeDev/LagrangeV2) - Proto
|
||||
|
||||
@@ -81,8 +81,7 @@ import {
|
||||
} from './web-actions';
|
||||
import type { GroupFilesResult } from './bridge-actions';
|
||||
import type { MediaIndexNode } from './bridge-actions';
|
||||
|
||||
export type BridgeEventCallback = (event: QQEventVariant) => void;
|
||||
import { BridgeEventBus } from './event-bus';
|
||||
|
||||
type CmdParser = (pkt: PacketInfo, qqInfo: QQInfo) => QQEventVariant[];
|
||||
|
||||
@@ -116,7 +115,12 @@ export class Bridge {
|
||||
|
||||
private qqInfo_: QQInfo;
|
||||
private pids_ = new Set<number>();
|
||||
private eventCallback_: BridgeEventCallback | null = null;
|
||||
/**
|
||||
* Per-kind event subscription. Replaces the legacy single-callback
|
||||
* firehose: downstream consumers now register exactly the kinds they
|
||||
* care about and `emitEvent` fans out in parallel.
|
||||
*/
|
||||
readonly events = new BridgeEventBus();
|
||||
private cmdHandlers_ = new Map<string, CmdParser[]>();
|
||||
private packetClient_: PacketSender | null = null;
|
||||
private memberRefreshTasks_ = new Map<number, Promise<void>>();
|
||||
@@ -155,10 +159,6 @@ export class Bridge {
|
||||
this.cmdHandlers_.set(cmd, arr);
|
||||
}
|
||||
|
||||
setEventCallback(cb: BridgeEventCallback): void {
|
||||
this.eventCallback_ = cb;
|
||||
}
|
||||
|
||||
handlesCmd(cmd: string): boolean {
|
||||
return this.cmdHandlers_.has(cmd);
|
||||
}
|
||||
@@ -199,11 +199,9 @@ export class Bridge {
|
||||
}
|
||||
|
||||
private emitEvent(event: QQEventVariant): void {
|
||||
if (this.eventCallback_) {
|
||||
try { this.eventCallback_(event); } catch (e) {
|
||||
log.error('event callback error: %s', e instanceof Error ? (e.stack ?? e.message) : String(e));
|
||||
}
|
||||
}
|
||||
// Fire-and-forget: errors inside subscribers are surfaced via the bus's
|
||||
// own onError hook so one bad listener never blocks the others.
|
||||
void this.events.emit(event);
|
||||
}
|
||||
|
||||
private triggerMemberCacheRefresh(event: QQEventVariant): void {
|
||||
|
||||
@@ -14,6 +14,7 @@ import {
|
||||
MarkdownDataSchema,
|
||||
} from '../proto/action';
|
||||
import { uploadImageMsgInfo } from '../highway/image-upload';
|
||||
import { uploadPttMsgInfo } from '../highway/ptt-upload';
|
||||
|
||||
type ProtoElem = Partial<ProtoDecoded<typeof ElemSchema>>;
|
||||
|
||||
@@ -151,10 +152,28 @@ async function makeImageElem(ctx: SendContext, element: MessageElement): Promise
|
||||
};
|
||||
}
|
||||
|
||||
async function makePttElem(ctx: SendContext, element: MessageElement): Promise<ProtoElem> {
|
||||
const isGroup = ctx.groupId !== undefined;
|
||||
const targetIdOrUid = isGroup ? ctx.groupId! : (ctx.userUid ?? '');
|
||||
if (!isGroup && !targetIdOrUid) {
|
||||
throw new Error('private record target uid is missing');
|
||||
}
|
||||
|
||||
const msgInfo = await uploadPttMsgInfo(ctx.bridge, isGroup, targetIdOrUid, element);
|
||||
|
||||
return {
|
||||
commonElem: {
|
||||
serviceType: 48,
|
||||
pbElem: msgInfo,
|
||||
businessType: 22,
|
||||
} as any,
|
||||
};
|
||||
}
|
||||
|
||||
/**
|
||||
* Build proto Elem objects from an array of MessageElements.
|
||||
* Supports: text, face, at, reply, json, xml, markdown, image.
|
||||
* Image elements trigger highway upload via the SendContext.
|
||||
* Supports: text, face, at, reply, json, xml, markdown, image, record, forward.
|
||||
* Image and record elements trigger NTV2 highway upload via the SendContext.
|
||||
*/
|
||||
export async function buildSendElems(elements: MessageElement[], ctx?: SendContext): Promise<ProtoElem[]> {
|
||||
const result: ProtoElem[] = [];
|
||||
@@ -202,6 +221,13 @@ export async function buildSendElems(elements: MessageElement[], ctx?: SendConte
|
||||
break;
|
||||
|
||||
case 'record':
|
||||
if (ctx) {
|
||||
result.push(await makePttElem(ctx, elem));
|
||||
} else {
|
||||
console.warn('[ElemBuilder] record send requires SendContext');
|
||||
}
|
||||
break;
|
||||
|
||||
case 'video':
|
||||
console.warn(`[ElemBuilder] ${elem.type} send not yet implemented`);
|
||||
break;
|
||||
|
||||
130
packages/core/src/bridge/event-bus.ts
Normal file
130
packages/core/src/bridge/event-bus.ts
Normal file
@@ -0,0 +1,130 @@
|
||||
// Typed, per-kind pub/sub for bridge-level events.
|
||||
//
|
||||
// Replaces the single-callback firehose where every consumer received every
|
||||
// event variant and had to switch on `event.kind`. Now each downstream
|
||||
// concern (OneBot dispatch, member cache refresh, etc.) registers exactly
|
||||
// the kinds it cares about, much closer to NapCat's per-listener pattern.
|
||||
//
|
||||
// `emit` is fire-and-forget: subscribers can be sync or async; async
|
||||
// rejections are surfaced via `Promise.allSettled` and reported through the
|
||||
// optional `onError` hook so one buggy handler never starves the others.
|
||||
|
||||
import type { QQEventVariant } from './events';
|
||||
import { createLogger } from '../utils/logger';
|
||||
|
||||
type EventKind = QQEventVariant['kind'];
|
||||
type EventOf<K extends EventKind> = Extract<QQEventVariant, { kind: K }>;
|
||||
|
||||
export type EventHandler<K extends EventKind> = (event: EventOf<K>) => void | Promise<void>;
|
||||
export type AnyEventHandler = (event: QQEventVariant) => void | Promise<void>;
|
||||
|
||||
export interface EventBusOptions {
|
||||
/** Logger label for handler failures. Defaults to `Bridge.Events`. */
|
||||
loggerName?: string;
|
||||
/** Override the default error reporter (e.g. for tests). */
|
||||
onError?: (kind: EventKind | '*', err: unknown) => void;
|
||||
}
|
||||
|
||||
const DEFAULT_LOGGER = createLogger('Bridge.Events');
|
||||
|
||||
export class BridgeEventBus {
|
||||
// Per-kind subscribers are stored as `Set<unknown>` so the container
|
||||
// doesn't carry a contravariant function type that fights TS variance
|
||||
// rules. The runtime invariant is straightforward: handlers stored under
|
||||
// key `K` only ever see `EventOf<K>` events, which is what the single
|
||||
// narrowing cast at the dispatch site below relies on.
|
||||
private readonly handlers = new Map<EventKind, Set<unknown>>();
|
||||
private readonly anyHandlers = new Set<AnyEventHandler>();
|
||||
private readonly onError: (kind: EventKind | '*', err: unknown) => void;
|
||||
|
||||
constructor(opts: EventBusOptions = {}) {
|
||||
if (opts.onError) {
|
||||
this.onError = opts.onError;
|
||||
} else {
|
||||
const log = opts.loggerName ? createLogger(opts.loggerName) : DEFAULT_LOGGER;
|
||||
this.onError = (kind, err) => {
|
||||
log.error(
|
||||
'event handler error [%s]: %s',
|
||||
kind,
|
||||
err instanceof Error ? (err.stack ?? err.message) : String(err),
|
||||
);
|
||||
};
|
||||
}
|
||||
}
|
||||
|
||||
/** Subscribe to one kind. Returns an unsubscribe function. */
|
||||
on<K extends EventKind>(kind: K, handler: EventHandler<K>): () => void {
|
||||
let set = this.handlers.get(kind);
|
||||
if (!set) {
|
||||
set = new Set();
|
||||
this.handlers.set(kind, set);
|
||||
}
|
||||
set.add(handler);
|
||||
return () => {
|
||||
this.handlers.get(kind)?.delete(handler);
|
||||
};
|
||||
}
|
||||
|
||||
/** Subscribe to every kind (low-volume callers like loggers). */
|
||||
onAny(handler: AnyEventHandler): () => void {
|
||||
this.anyHandlers.add(handler);
|
||||
return () => {
|
||||
this.anyHandlers.delete(handler);
|
||||
};
|
||||
}
|
||||
|
||||
off<K extends EventKind>(kind: K, handler: EventHandler<K>): void {
|
||||
this.handlers.get(kind)?.delete(handler);
|
||||
}
|
||||
|
||||
has(kind: EventKind): boolean {
|
||||
return (this.handlers.get(kind)?.size ?? 0) + this.anyHandlers.size > 0;
|
||||
}
|
||||
|
||||
/** Drop every subscriber. Mostly useful for tests. */
|
||||
clear(): void {
|
||||
this.handlers.clear();
|
||||
this.anyHandlers.clear();
|
||||
}
|
||||
|
||||
/**
|
||||
* Dispatch an event in parallel to every subscriber for its kind plus every
|
||||
* onAny handler. Rejections are isolated per-handler — one bad subscriber
|
||||
* never blocks the others, and the returned promise resolves once every
|
||||
* subscriber settles.
|
||||
*/
|
||||
async emit<K extends EventKind>(event: EventOf<K>): Promise<void> {
|
||||
const kindHandlers = this.handlers.get(event.kind);
|
||||
if ((!kindHandlers || kindHandlers.size === 0) && this.anyHandlers.size === 0) {
|
||||
return;
|
||||
}
|
||||
const tasks: Promise<unknown>[] = [];
|
||||
if (kindHandlers) {
|
||||
for (const handler of kindHandlers) {
|
||||
// Single narrowing cast — the only place we re-assert that handlers
|
||||
// stored under `event.kind` accept `EventOf<event.kind>` events.
|
||||
const typed = handler as EventHandler<K>;
|
||||
tasks.push(invoke(this.onError, event.kind, () => typed(event)));
|
||||
}
|
||||
}
|
||||
for (const handler of this.anyHandlers) {
|
||||
tasks.push(invoke(this.onError, '*', () => handler(event)));
|
||||
}
|
||||
await Promise.allSettled(tasks);
|
||||
}
|
||||
}
|
||||
|
||||
async function invoke(
|
||||
onError: (kind: EventKind | '*', err: unknown) => void,
|
||||
kind: EventKind | '*',
|
||||
fn: () => unknown,
|
||||
): Promise<void> {
|
||||
try {
|
||||
const ret = fn();
|
||||
if (ret && typeof (ret as Promise<unknown>).then === 'function') {
|
||||
await ret;
|
||||
}
|
||||
} catch (err) {
|
||||
onError(kind, err);
|
||||
}
|
||||
}
|
||||
161
packages/core/src/bridge/highway/ffmpeg-addon.ts
Normal file
161
packages/core/src/bridge/highway/ffmpeg-addon.ts
Normal file
@@ -0,0 +1,161 @@
|
||||
// FFmpeg native addon wrapper — port of NapCat's FFmpegAddonAdapter.
|
||||
// No fallback: throws if the addon isn't available on this platform/arch.
|
||||
//
|
||||
// The addon is shipped under `native/ffmpeg/ffmpegAddon.<platform>.<arch>.node`
|
||||
// to match the layout used by the upstream NapCat build so the binaries
|
||||
// can be dropped in as-is.
|
||||
|
||||
import fs from 'fs';
|
||||
import os from 'os';
|
||||
import path from 'path';
|
||||
import crypto from 'crypto';
|
||||
import { fileURLToPath } from 'url';
|
||||
|
||||
const __dirname = path.dirname(fileURLToPath(import.meta.url));
|
||||
|
||||
export interface FFmpegVideoInfo {
|
||||
width: number;
|
||||
height: number;
|
||||
duration: number;
|
||||
format: string;
|
||||
videoCodec: string;
|
||||
image: Buffer;
|
||||
}
|
||||
|
||||
interface FFmpegNativeAddon {
|
||||
convertFile(inputFile: string, outputFile: string, format: string): Promise<{ success: boolean }>;
|
||||
getVideoInfo(filePath: string, format?: 'bmp' | 'bmp24'): Promise<FFmpegVideoInfo>;
|
||||
getDuration(filePath: string): Promise<number>;
|
||||
convertToNTSilkTct(inputPath: string, outputPath: string): Promise<void>;
|
||||
decodeAudioToPCM(filePath: string, pcmPath: string, sampleRate?: number): Promise<{ result: boolean; sampleRate: number }>;
|
||||
decodeAudioToFmt(filePath: string, pcmPath: string, format: string): Promise<{ channels: number; sampleRate: number; format: string }>;
|
||||
}
|
||||
|
||||
let cachedAddon: FFmpegNativeAddon | null = null;
|
||||
let cachedLoadError: string | null = null;
|
||||
|
||||
function addonFileName(): string {
|
||||
return `ffmpegAddon.${process.platform}.${process.arch}.node`;
|
||||
}
|
||||
|
||||
function addonSearchDirs(): string[] {
|
||||
// Mirrors the hook injector's resolution strategy so the addon is found
|
||||
// regardless of whether we're running from:
|
||||
// 1. A released zip (dist/native/ffmpeg/<file>.node), where __dirname is
|
||||
// the dist root.
|
||||
// 2. The bundled build (repoRoot/dist/native/ffmpeg/<file>.node).
|
||||
// 3. `tsx` dev mode (packages/runtime/native/ffmpeg/<file>.node), where
|
||||
// __dirname is `packages/core/src/bridge/highway` — four levels deep
|
||||
// under `packages/`. Note: the hook injector lives at
|
||||
// `packages/core/src/hook` so it only needs 3 `..`; we need 4.
|
||||
return [
|
||||
path.resolve(__dirname, 'native', 'ffmpeg'),
|
||||
path.resolve(__dirname, '..', '..', '..', '..', 'runtime', 'native', 'ffmpeg'),
|
||||
path.resolve(process.cwd(), 'dist', 'native', 'ffmpeg'),
|
||||
path.resolve(process.cwd(), 'packages', 'runtime', 'native', 'ffmpeg'),
|
||||
];
|
||||
}
|
||||
|
||||
function resolveAddonPath(): string | null {
|
||||
const fileName = addonFileName();
|
||||
for (const dir of addonSearchDirs()) {
|
||||
const full = path.join(dir, fileName);
|
||||
if (fs.existsSync(full)) return full;
|
||||
}
|
||||
return null;
|
||||
}
|
||||
|
||||
/**
|
||||
* Load the ffmpegAddon once and return a cached instance.
|
||||
* Throws on first-use failure; subsequent calls replay the same error message
|
||||
* so callers don't silently fall back.
|
||||
*/
|
||||
export function getFFmpegAddon(): FFmpegNativeAddon {
|
||||
if (cachedAddon) return cachedAddon;
|
||||
if (cachedLoadError) throw new Error(cachedLoadError);
|
||||
|
||||
const addonPath = resolveAddonPath();
|
||||
if (!addonPath) {
|
||||
cachedLoadError = `ffmpegAddon not found for ${process.platform}-${process.arch} (looked for ${addonFileName()})`;
|
||||
throw new Error(cachedLoadError);
|
||||
}
|
||||
|
||||
try {
|
||||
const mod = { exports: {} as Record<string, unknown> };
|
||||
process.dlopen(mod, addonPath);
|
||||
cachedAddon = mod.exports as unknown as FFmpegNativeAddon;
|
||||
return cachedAddon;
|
||||
} catch (error) {
|
||||
cachedLoadError = `failed to load ffmpegAddon (${addonPath}): ${error instanceof Error ? error.message : String(error)}`;
|
||||
throw new Error(cachedLoadError);
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Check whether `filePath` is already an NT SILK container. The addon can
|
||||
* read any input directly so the only reason we peek at the header is to
|
||||
* skip the conversion (and the temp file) when the caller already fed us
|
||||
* a ready-to-upload silk file.
|
||||
*/
|
||||
export function isSilkFile(filePath: string): boolean {
|
||||
try {
|
||||
const fd = fs.openSync(filePath, 'r');
|
||||
try {
|
||||
const buf = Buffer.alloc(10);
|
||||
fs.readSync(fd, buf, 0, 10, 0);
|
||||
const header = buf.toString();
|
||||
return header.includes('#!SILK') || header.includes('\x02#!SILK');
|
||||
} finally {
|
||||
fs.closeSync(fd);
|
||||
}
|
||||
} catch {
|
||||
return false;
|
||||
}
|
||||
}
|
||||
|
||||
export interface EncodeSilkResult {
|
||||
/** Absolute path to the silk file ready for highway upload. */
|
||||
path: string;
|
||||
/** Voice duration in whole seconds (>= 1). */
|
||||
duration: number;
|
||||
/** `true` if we wrote a new silk file and the caller should unlink it. */
|
||||
converted: boolean;
|
||||
}
|
||||
|
||||
/**
|
||||
* Convert `inputFile` to NT SILK when necessary and return the output path
|
||||
* + duration. The caller is responsible for unlinking the returned path
|
||||
* when `converted === true`.
|
||||
*/
|
||||
export async function encodeSilk(inputFile: string, tempDir: string): Promise<EncodeSilkResult> {
|
||||
const addon = getFFmpegAddon();
|
||||
|
||||
// Already silk — trust the file, just measure duration via the addon.
|
||||
if (isSilkFile(inputFile)) {
|
||||
let duration = 1;
|
||||
try {
|
||||
duration = Math.max(1, Math.round(await addon.getDuration(inputFile)));
|
||||
} catch {
|
||||
// getDuration on a silk file occasionally fails on certain encodings;
|
||||
// the upload path only needs a rough, non-zero value, so fall back
|
||||
// to the size-based heuristic used by NapCat's audio.ts.
|
||||
const stat = fs.statSync(inputFile);
|
||||
duration = Math.max(1, Math.floor(stat.size / 1024 / 3));
|
||||
}
|
||||
return { path: inputFile, duration, converted: false };
|
||||
}
|
||||
|
||||
fs.mkdirSync(tempDir, { recursive: true });
|
||||
const outPath = path.join(tempDir, crypto.randomUUID());
|
||||
await addon.convertToNTSilkTct(inputFile, outPath);
|
||||
if (!fs.existsSync(outPath)) {
|
||||
throw new Error('convertToNTSilkTct produced no output file');
|
||||
}
|
||||
const duration = Math.max(1, Math.round(await addon.getDuration(inputFile)));
|
||||
return { path: outPath, duration, converted: true };
|
||||
}
|
||||
|
||||
/** Default location for temporary silk files. */
|
||||
export function defaultPttTempDir(): string {
|
||||
return path.join(os.tmpdir(), 'snowluma-ptt');
|
||||
}
|
||||
274
packages/core/src/bridge/highway/ptt-upload.ts
Normal file
274
packages/core/src/bridge/highway/ptt-upload.ts
Normal file
@@ -0,0 +1,274 @@
|
||||
// Voice (PTT) upload pipeline:
|
||||
// 1. resolve / fetch the source audio bytes,
|
||||
// 2. convert to NT SILK via the ffmpegAddon (skip if already silk),
|
||||
// 3. NTV2 OIDB upload request — 0x126E (group) / 0x126D (private),
|
||||
// 4. highway HTTP upload — commandId 1008 (group) / 1007 (private),
|
||||
// 5. return the encoded `MsgInfo` bytes ready for the commonElem.
|
||||
//
|
||||
// Port of NapCat's `UploadGroupPtt` / `UploadPrivatePtt` transformer + the
|
||||
// `uploadGroupPtt` / `uploadC2CPtt` paths in `PacketHighwayContext`.
|
||||
|
||||
import fs from 'fs';
|
||||
import path from 'path';
|
||||
import crypto from 'crypto';
|
||||
|
||||
import type { Bridge } from '../bridge';
|
||||
import type { MessageElement } from '../events';
|
||||
import { protoEncode, protoDecode } from '../../protobuf/decode';
|
||||
import { makeOidbBaseSchema } from '../proto/oidb';
|
||||
import {
|
||||
NTV2UploadRichMediaReqSchema,
|
||||
NTV2UploadRichMediaRespSchema,
|
||||
EncodableMediaMsgInfoSchema,
|
||||
} from '../proto/highway';
|
||||
import { loadBinarySource, computeHashes } from './utils';
|
||||
import {
|
||||
fetchHighwaySession,
|
||||
uploadHighwayHttp,
|
||||
buildHighwayExtend,
|
||||
} from './highway-client';
|
||||
import { encodeSilk, defaultPttTempDir } from './ffmpeg-addon';
|
||||
import { createLogger } from '../../utils/logger';
|
||||
|
||||
const log = createLogger('Ptt');
|
||||
|
||||
export const PRIVATE_PTT_CMD_ID = 1007;
|
||||
export const GROUP_PTT_CMD_ID = 1008;
|
||||
|
||||
interface PttPayload {
|
||||
/** Silk bytes that get uploaded to highway. */
|
||||
bytes: Uint8Array;
|
||||
md5: Uint8Array;
|
||||
sha1: Uint8Array;
|
||||
md5Hex: string;
|
||||
sha1Hex: string;
|
||||
fileName: string;
|
||||
/** Whole seconds, >= 1. */
|
||||
duration: number;
|
||||
/** Cleanup hooks invoked once the OIDB request + highway upload finish. */
|
||||
cleanups: Array<() => void>;
|
||||
}
|
||||
|
||||
/**
|
||||
* Decide whether `source` looks like a local filesystem path. The shape
|
||||
* matches the heuristics used inside `loadBinarySource`: we only reuse the
|
||||
* caller-supplied path verbatim for things the addon can read directly.
|
||||
*/
|
||||
function asLocalFilePath(source: string): string | null {
|
||||
if (!source) return null;
|
||||
if (source.startsWith('base64://')) return null;
|
||||
if (source.startsWith('http://') || source.startsWith('https://')) return null;
|
||||
|
||||
let filePath = source;
|
||||
if (filePath.startsWith('file://')) filePath = filePath.slice(7);
|
||||
if (/^\/[a-zA-Z]:/.test(filePath)) filePath = filePath.slice(1);
|
||||
|
||||
return filePath;
|
||||
}
|
||||
|
||||
async function loadPtt(element: MessageElement, tempDir: string): Promise<PttPayload> {
|
||||
const source = element.url || element.fileId || '';
|
||||
if (!source) throw new Error('record source is empty');
|
||||
|
||||
const cleanups: Array<() => void> = [];
|
||||
// Run all queued cleanups; callable both on the success path (via the
|
||||
// returned `cleanups` array) and the failure path (try/catch below).
|
||||
const runCleanups = () => {
|
||||
while (cleanups.length > 0) {
|
||||
const fn = cleanups.pop();
|
||||
if (!fn) continue;
|
||||
try { fn(); } catch { /* best-effort */ }
|
||||
}
|
||||
};
|
||||
|
||||
fs.mkdirSync(tempDir, { recursive: true });
|
||||
|
||||
try {
|
||||
// Resolve the on-disk path the addon should read. Anything that isn't
|
||||
// already a local file (base64, HTTP) gets staged into the temp dir.
|
||||
let inputPath: string;
|
||||
const local = asLocalFilePath(source);
|
||||
if (local && fs.existsSync(local)) {
|
||||
inputPath = local;
|
||||
} else {
|
||||
const loaded = await loadBinarySource(source, 'record');
|
||||
inputPath = path.join(tempDir, `snowluma-ptt-in-${crypto.randomUUID()}`);
|
||||
fs.writeFileSync(inputPath, Buffer.from(loaded.bytes));
|
||||
cleanups.push(() => { try { fs.unlinkSync(inputPath); } catch { /* ignore */ } });
|
||||
}
|
||||
|
||||
const silk = await encodeSilk(inputPath, tempDir);
|
||||
if (silk.converted) {
|
||||
cleanups.push(() => { try { fs.unlinkSync(silk.path); } catch { /* ignore */ } });
|
||||
log.debug('converted record to silk: %s -> %s (duration=%ds)', inputPath, silk.path, silk.duration);
|
||||
}
|
||||
|
||||
const silkBytes = new Uint8Array(fs.readFileSync(silk.path));
|
||||
if (silkBytes.length === 0) throw new Error('silk file is empty after conversion');
|
||||
|
||||
const hashes = computeHashes(silkBytes);
|
||||
return {
|
||||
bytes: silkBytes,
|
||||
md5: hashes.md5,
|
||||
sha1: hashes.sha1,
|
||||
md5Hex: hashes.md5Hex,
|
||||
sha1Hex: hashes.sha1Hex,
|
||||
fileName: `${hashes.md5Hex}.amr`,
|
||||
duration: silk.duration,
|
||||
cleanups: [...cleanups],
|
||||
};
|
||||
} catch (err) {
|
||||
runCleanups();
|
||||
throw err;
|
||||
}
|
||||
}
|
||||
|
||||
function makeClientRandomId(): bigint {
|
||||
// Same trick NapCat uses: 8 random bytes, masked into the positive int64
|
||||
// range so it survives proto signed-int64 encoding without surprises.
|
||||
const buf = crypto.randomBytes(8);
|
||||
return buf.readBigUInt64BE() & 0x7FFFFFFFFFFFFFFFn;
|
||||
}
|
||||
|
||||
async function startPttUpload(
|
||||
bridge: Bridge,
|
||||
isGroup: boolean,
|
||||
targetIdOrUid: string | number,
|
||||
ptt: PttPayload,
|
||||
): Promise<any> {
|
||||
const body: any = {
|
||||
reqHead: {
|
||||
// NapCat uses requestId=1 for group / 4 for c2c. Mirror it.
|
||||
common: { requestId: isGroup ? 1 : 4, command: 100 },
|
||||
scene: {
|
||||
requestType: 2,
|
||||
businessType: 3,
|
||||
sceneType: isGroup ? 2 : 1,
|
||||
...(isGroup
|
||||
? { group: { groupUin: Number(targetIdOrUid) } }
|
||||
: { c2c: { accountType: 2, targetUid: String(targetIdOrUid) } }),
|
||||
},
|
||||
client: { agentType: 2 },
|
||||
},
|
||||
upload: {
|
||||
uploadInfo: [{
|
||||
fileInfo: {
|
||||
fileSize: ptt.bytes.length,
|
||||
fileHash: ptt.md5Hex,
|
||||
fileSha1: ptt.sha1Hex,
|
||||
fileName: ptt.fileName,
|
||||
// type=3 voice, voiceFormat=1 (silk).
|
||||
type: { type: 3, picFormat: 0, videoFormat: 0, voiceFormat: 1 },
|
||||
width: 0,
|
||||
height: 0,
|
||||
time: ptt.duration,
|
||||
original: 0,
|
||||
},
|
||||
subFileType: 0,
|
||||
}],
|
||||
tryFastUploadCompleted: true,
|
||||
srvSendMsg: false,
|
||||
clientRandomId: makeClientRandomId(),
|
||||
compatQmsgSceneType: isGroup ? 2 : 1,
|
||||
extBizInfo: {
|
||||
// NapCat fills in a placeholder textSummary so the legacy compat
|
||||
// QMsg path still has something to render. Mirror it.
|
||||
pic: { textSummary: 'Nya~' },
|
||||
video: { bytesPbReserve: new Uint8Array(0) },
|
||||
ptt: {
|
||||
bytesReserve: new Uint8Array([0x08, 0x00, 0x38, 0x00]),
|
||||
bytesPbReserve: new Uint8Array(0),
|
||||
// `bytesGeneralFlags` differs between group / c2c voice. Lifted
|
||||
// verbatim from NapCat (UploadGroupPtt.ts / UploadPrivatePtt.ts).
|
||||
bytesGeneralFlags: isGroup
|
||||
? new Uint8Array([0x9a, 0x01, 0x07, 0xaa, 0x03, 0x04, 0x08, 0x08, 0x12, 0x00])
|
||||
: new Uint8Array([0x9a, 0x01, 0x0b, 0xaa, 0x03, 0x08, 0x08, 0x04, 0x12, 0x04, 0x00, 0x00, 0x00, 0x00]),
|
||||
},
|
||||
},
|
||||
clientSeq: 0,
|
||||
noNeedCompatMsg: false,
|
||||
},
|
||||
};
|
||||
|
||||
const oidbCmd = isGroup ? 0x126E : 0x126D;
|
||||
const serviceCmd = isGroup ? 'OidbSvcTrpcTcp.0x126e_100' : 'OidbSvcTrpcTcp.0x126d_100';
|
||||
|
||||
const baseSchema = makeOidbBaseSchema(NTV2UploadRichMediaReqSchema);
|
||||
const request = protoEncode({
|
||||
command: oidbCmd, subCommand: 100, errorCode: 0, body, errorMsg: '', reserved: 1,
|
||||
}, baseSchema);
|
||||
|
||||
const result = await bridge.sendRawPacket(serviceCmd, request);
|
||||
if (!result.success || !result.gotResponse || !result.responseData) {
|
||||
throw new Error(result.errorMessage || 'ptt upload request failed');
|
||||
}
|
||||
|
||||
const respBaseSchema = makeOidbBaseSchema(NTV2UploadRichMediaRespSchema);
|
||||
const resp: any = protoDecode(result.responseData, respBaseSchema);
|
||||
if (!resp) throw new Error('failed to decode ptt upload response');
|
||||
if (resp.errorCode && resp.errorCode !== 0) {
|
||||
throw new Error(`OIDB error ${resp.errorCode}: ${resp.errorMsg ?? ''}`);
|
||||
}
|
||||
|
||||
const uploadBody = resp.body;
|
||||
if (!uploadBody) throw new Error('ptt upload response body missing');
|
||||
if (uploadBody.respHead?.retCode && uploadBody.respHead.retCode !== 0) {
|
||||
throw new Error(uploadBody.respHead.message ?? 'ptt upload failed');
|
||||
}
|
||||
return uploadBody.upload;
|
||||
}
|
||||
|
||||
function finalizePttMsgInfo(upload: any): Uint8Array {
|
||||
if (!upload?.msgInfo) throw new Error('ptt upload response missing msgInfo');
|
||||
|
||||
const msgInfoBody = (upload.msgInfo.msgInfoBody ?? []).map((b: any) => ({
|
||||
index: b.index, picture: b.picture, fileExist: b.fileExist, hashSum: b.hashSum,
|
||||
}));
|
||||
|
||||
const extBizInfo: any = {};
|
||||
if (upload.msgInfo.extBizInfo?.pic) extBizInfo.pic = upload.msgInfo.extBizInfo.pic;
|
||||
if (upload.msgInfo.extBizInfo?.video) extBizInfo.video = upload.msgInfo.extBizInfo.video;
|
||||
if (upload.msgInfo.extBizInfo?.ptt) extBizInfo.ptt = upload.msgInfo.extBizInfo.ptt;
|
||||
if (upload.msgInfo.extBizInfo?.busiType !== undefined) {
|
||||
extBizInfo.busiType = upload.msgInfo.extBizInfo.busiType;
|
||||
}
|
||||
|
||||
return protoEncode({ msgInfoBody, extBizInfo }, EncodableMediaMsgInfoSchema);
|
||||
}
|
||||
|
||||
/**
|
||||
* Upload a voice clip and return the encoded `MsgInfo` bytes that go inside
|
||||
* a `commonElem { serviceType: 48, businessType: 22 }`.
|
||||
*/
|
||||
export async function uploadPttMsgInfo(
|
||||
bridge: Bridge,
|
||||
isGroup: boolean,
|
||||
targetIdOrUid: string | number,
|
||||
element: MessageElement,
|
||||
): Promise<Uint8Array> {
|
||||
const tempDir = defaultPttTempDir();
|
||||
const ptt = await loadPtt(element, tempDir);
|
||||
try {
|
||||
const upload = await startPttUpload(bridge, isGroup, targetIdOrUid, ptt);
|
||||
|
||||
// Highway upload only happens when the server didn't fast-path the file
|
||||
// (uKey present == "we want the bytes"). Otherwise we just embed the
|
||||
// returned MsgInfo and trust the dedupe.
|
||||
const uKey = upload?.uKey ?? '';
|
||||
if (uKey && upload?.msgInfo) {
|
||||
log.debug('highway upload: bytes=%d md5=%s scene=%s', ptt.bytes.length, ptt.md5Hex, isGroup ? 'group' : 'c2c');
|
||||
const session = await fetchHighwaySession(bridge);
|
||||
const extend = buildHighwayExtend(uKey, upload.msgInfo, upload.ipv4s ?? [], ptt.sha1);
|
||||
const commandId = isGroup ? GROUP_PTT_CMD_ID : PRIVATE_PTT_CMD_ID;
|
||||
await uploadHighwayHttp(bridge, session, commandId, ptt.bytes, ptt.md5, extend);
|
||||
} else {
|
||||
log.debug('ptt fast-uploaded (server already has md5=%s)', ptt.md5Hex);
|
||||
}
|
||||
|
||||
return finalizePttMsgInfo(upload);
|
||||
} finally {
|
||||
for (const fn of ptt.cleanups) {
|
||||
try { fn(); } catch { /* best-effort cleanup */ }
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -4,7 +4,6 @@
|
||||
|
||||
import type { NtqqHandler } from '../protocol/ntqq-handler';
|
||||
import type { PacketInfo } from '../protocol/types';
|
||||
import type { QQEventVariant } from './events';
|
||||
import { Bridge } from './bridge';
|
||||
import { QQInfo } from './qq-info';
|
||||
import type { PacketSender } from '../protocol/packet-sender';
|
||||
@@ -12,7 +11,6 @@ import { createLogger } from '../utils/logger';
|
||||
|
||||
export type SessionStartedCallback = (uin: string, qqInfo: QQInfo, bridge: Bridge) => void;
|
||||
export type SessionClosedCallback = (uin: string) => void;
|
||||
export type BridgeEventCallback = (uin: string, event: QQEventVariant) => void;
|
||||
|
||||
interface QQSession {
|
||||
qqInfo: QQInfo;
|
||||
@@ -28,11 +26,9 @@ export class BridgeManager {
|
||||
|
||||
private onSessionStarted_: SessionStartedCallback | null = null;
|
||||
private onSessionClosed_: SessionClosedCallback | null = null;
|
||||
private onBridgeEvent_: BridgeEventCallback | null = null;
|
||||
|
||||
setSessionStartedCallback(cb: SessionStartedCallback): void { this.onSessionStarted_ = cb; }
|
||||
setSessionClosedCallback(cb: SessionClosedCallback): void { this.onSessionClosed_ = cb; }
|
||||
setEventCallback(cb: BridgeEventCallback): void { this.onBridgeEvent_ = cb; }
|
||||
|
||||
bind(ntqq: NtqqHandler): void {
|
||||
ntqq.registerCmdAll((pkt: PacketInfo) => this.onPacket(pkt));
|
||||
@@ -115,11 +111,9 @@ export class BridgeManager {
|
||||
session = { qqInfo, bridge };
|
||||
this.sessions_.set(uin, session);
|
||||
|
||||
// Wire event callback
|
||||
bridge.setEventCallback((event) => {
|
||||
if (this.onBridgeEvent_) this.onBridgeEvent_(uin, event);
|
||||
});
|
||||
|
||||
// Each downstream consumer (e.g. OneBotInstance) subscribes to
|
||||
// `bridge.events` directly via the per-kind bus — there is no longer a
|
||||
// generic firehose to wire here.
|
||||
return { session, created: true };
|
||||
}
|
||||
|
||||
|
||||
@@ -165,13 +165,12 @@ export class HookManager {
|
||||
const livePipes = await QqHookClient.listLivePipes();
|
||||
if (livePipes.has(pid)) {
|
||||
state.injected = true;
|
||||
state.method = 'reconnect';
|
||||
state.method = state.method || 'reconnect';
|
||||
log.info('PID=%d already has SnowLuma pipe; will reconnect via watcher', pid);
|
||||
} else {
|
||||
state.injectResult = injectHookProcess(pid);
|
||||
state.injected = true;
|
||||
state.method = state.injectResult.method;
|
||||
log.info('SnowLuma loaded into PID=%d via %s', pid, state.method);
|
||||
}
|
||||
}
|
||||
state.status = state.connected
|
||||
|
||||
@@ -25,7 +25,6 @@ async function main() {
|
||||
process.env.SNOWLUMA_DEV_WEBUI === '1'
|
||||
) {
|
||||
try {
|
||||
log.info('WebUI is enabled, starting...');
|
||||
const { initWebUI } = await import('./webui/server');
|
||||
await initWebUI(runtimeConfig.webuiPort || 5099, oneBotManager, hookManager);
|
||||
} catch (err) {
|
||||
|
||||
@@ -392,22 +392,20 @@ export function register(h: ApiHandler, ctx: ApiActionContext): void {
|
||||
// --- Media ---
|
||||
|
||||
h.registerAction('get_image', async (params) => {
|
||||
const file = asString(params.file);
|
||||
const file = asString(params.file) || asString(params.file_id);
|
||||
if (!file) return failedResponse(RETCODE.BAD_REQUEST, 'file is required');
|
||||
const imageInfo = findMediaInStore('image', file, ctx);
|
||||
if (imageInfo) {
|
||||
return okResponse(imageInfo as unknown as import('../types').JsonValue);
|
||||
}
|
||||
if (!ctx.getImageInfo) return failedResponse(RETCODE.ACTION_FAILED, 'not implemented');
|
||||
const info = await ctx.getImageInfo(file);
|
||||
if (info) return okResponse(info);
|
||||
return failedResponse(RETCODE.ACTION_FAILED, 'image not found in cache');
|
||||
});
|
||||
|
||||
h.registerAction('get_record', async (params) => {
|
||||
const file = asString(params.file);
|
||||
const file = asString(params.file) || asString(params.file_id);
|
||||
if (!file) return failedResponse(RETCODE.BAD_REQUEST, 'file is required');
|
||||
const recordInfo = findMediaInStore('record', file, ctx);
|
||||
if (recordInfo) {
|
||||
return okResponse(recordInfo as unknown as import('../types').JsonValue);
|
||||
}
|
||||
if (!ctx.getRecordInfo) return failedResponse(RETCODE.ACTION_FAILED, 'not implemented');
|
||||
const info = await ctx.getRecordInfo(file);
|
||||
if (info) return okResponse(info);
|
||||
return failedResponse(RETCODE.ACTION_FAILED, 'record not found in cache');
|
||||
});
|
||||
|
||||
@@ -463,7 +461,7 @@ export function register(h: ApiHandler, ctx: ApiActionContext): void {
|
||||
const context = params.context as import('../types').JsonObject | undefined;
|
||||
const operation = params.operation as Record<string, unknown> | undefined;
|
||||
if (!context || !operation) return failedResponse(RETCODE.BAD_REQUEST, 'context and operation are required');
|
||||
const { executeQuickOperation } = await import('../http-post-transport');
|
||||
const { executeQuickOperation } = await import('../network/quick-operation');
|
||||
await executeQuickOperation(context, operation, h);
|
||||
return okResponse();
|
||||
});
|
||||
@@ -736,23 +734,6 @@ export function register(h: ApiHandler, ctx: ApiActionContext): void {
|
||||
});
|
||||
}
|
||||
|
||||
/**
|
||||
* Search through cached message segments to find a media element (image/record)
|
||||
* that matches the given file identifier.
|
||||
*/
|
||||
function findMediaInStore(
|
||||
mediaType: 'image' | 'record',
|
||||
file: string,
|
||||
ctx: ApiActionContext,
|
||||
): Record<string, unknown> | null {
|
||||
// The file param can match a file id, a URL, or a filename stored in segments.
|
||||
// We don't have a reverse index, so this is best-effort from stored events.
|
||||
// Most callers will pass the `file` field from a received message segment.
|
||||
// Just return the info if we can look it up from any recent cached message.
|
||||
// This is a known limitation — full implementation would require a media cache.
|
||||
return null;
|
||||
}
|
||||
|
||||
/**
|
||||
* Parse download_file headers parameter into a Record.
|
||||
*/
|
||||
|
||||
@@ -105,6 +105,9 @@ export interface ApiActionContext {
|
||||
getCookiesStr?: (domain: string) => Promise<string>;
|
||||
getCsrfToken?: () => Promise<number>;
|
||||
getCredentials?: (domain: string) => Promise<{ cookies: string; token: number; csrf_token: number }>;
|
||||
// Media lookup (populated from previously dispatched message segments)
|
||||
getImageInfo?: (file: string) => Promise<JsonObject | null>;
|
||||
getRecordInfo?: (file: string) => Promise<JsonObject | null>;
|
||||
}
|
||||
|
||||
type ActionHandler = (params: JsonObject) => Promise<import('./types').ApiResponse>;
|
||||
|
||||
@@ -5,11 +5,24 @@ import { GROUP_MESSAGE_EVENT, PRIVATE_MESSAGE_EVENT } from './message-id';
|
||||
export type ImageUrlResolver = (element: MessageElement, isGroup: boolean) => string;
|
||||
export type MediaUrlResolver = (element: MessageElement, isGroup: boolean, sessionId: number) => Promise<string>;
|
||||
export type MessageIdResolver = (isGroup: boolean, sessionId: number, sequence: number, eventName: string) => number;
|
||||
/**
|
||||
* Side-channel callback invoked every time an image/record segment is
|
||||
* produced, so that callers can keep a lookup index (e.g. for `get_image` /
|
||||
* `get_record`) without having to re-scan the persisted message store.
|
||||
*/
|
||||
export type MediaSegmentSink = (
|
||||
mediaType: 'image' | 'record',
|
||||
element: MessageElement,
|
||||
data: JsonObject,
|
||||
isGroup: boolean,
|
||||
sessionId: number,
|
||||
) => void;
|
||||
|
||||
export class EventConverter {
|
||||
private imageUrlResolver_: ImageUrlResolver | null = null;
|
||||
private mediaUrlResolver_: MediaUrlResolver | null = null;
|
||||
private messageIdResolver_: MessageIdResolver | null = null;
|
||||
private mediaSegmentSink_: MediaSegmentSink | null = null;
|
||||
|
||||
setImageUrlResolver(resolver: ImageUrlResolver): void {
|
||||
this.imageUrlResolver_ = resolver;
|
||||
@@ -23,6 +36,10 @@ export class EventConverter {
|
||||
this.messageIdResolver_ = resolver;
|
||||
}
|
||||
|
||||
setMediaSegmentSink(sink: MediaSegmentSink): void {
|
||||
this.mediaSegmentSink_ = sink;
|
||||
}
|
||||
|
||||
async convert(instanceUin: string, event: QQEventVariant): Promise<JsonObject | null> {
|
||||
const selfId = parseSelfId(instanceUin);
|
||||
|
||||
@@ -32,7 +49,7 @@ export class EventConverter {
|
||||
const isSelf = event.senderUin === selfId;
|
||||
const postType = isSelf ? 'message_sent' : 'message';
|
||||
const messageId = this.resolveMessageId(false, event.senderUin, event.msgSeq, PRIVATE_MESSAGE_EVENT);
|
||||
const segments = await elementsToJson(event.elements, false, event.senderUin, this.imageUrlResolver_, this.mediaUrlResolver_, this.messageIdResolver_);
|
||||
const segments = await elementsToJson(event.elements, false, event.senderUin, this.imageUrlResolver_, this.mediaUrlResolver_, this.messageIdResolver_, this.mediaSegmentSink_);
|
||||
return {
|
||||
time: event.time,
|
||||
self_id: selfId,
|
||||
@@ -59,7 +76,7 @@ export class EventConverter {
|
||||
const isSelf = event.senderUin === selfId;
|
||||
const postType = isSelf ? 'message_sent' : 'message';
|
||||
const messageId = this.resolveMessageId(true, event.groupId, event.msgSeq, GROUP_MESSAGE_EVENT);
|
||||
const segments = await elementsToJson(event.elements, true, event.groupId, this.imageUrlResolver_, this.mediaUrlResolver_, this.messageIdResolver_);
|
||||
const segments = await elementsToJson(event.elements, true, event.groupId, this.imageUrlResolver_, this.mediaUrlResolver_, this.messageIdResolver_, this.mediaSegmentSink_);
|
||||
return {
|
||||
time: event.time,
|
||||
self_id: selfId,
|
||||
@@ -90,7 +107,7 @@ export class EventConverter {
|
||||
const isSelf = event.senderUin === selfId;
|
||||
const postType = isSelf ? 'message_sent' : 'message';
|
||||
const messageId = this.resolveMessageId(false, event.senderUin, event.msgSeq, PRIVATE_MESSAGE_EVENT);
|
||||
const segments = await elementsToJson(event.elements, false, event.senderUin, this.imageUrlResolver_, this.mediaUrlResolver_, this.messageIdResolver_);
|
||||
const segments = await elementsToJson(event.elements, false, event.senderUin, this.imageUrlResolver_, this.mediaUrlResolver_, this.messageIdResolver_, this.mediaSegmentSink_);
|
||||
return {
|
||||
time: event.time,
|
||||
self_id: selfId,
|
||||
@@ -320,10 +337,11 @@ async function elementsToJson(
|
||||
resolver?: ImageUrlResolver | null,
|
||||
mediaResolver?: MediaUrlResolver | null,
|
||||
messageIdResolver?: MessageIdResolver | null,
|
||||
mediaSink?: MediaSegmentSink | null,
|
||||
): Promise<JsonArray> {
|
||||
const result: JsonArray = [];
|
||||
for (const element of elements) {
|
||||
result.push(await elementToSegment(element, isGroup, sessionId, resolver, mediaResolver, messageIdResolver));
|
||||
result.push(await elementToSegment(element, isGroup, sessionId, resolver, mediaResolver, messageIdResolver, mediaSink));
|
||||
}
|
||||
return result;
|
||||
}
|
||||
@@ -335,8 +353,9 @@ export async function elementsToOneBotSegments(
|
||||
resolver?: ImageUrlResolver | null,
|
||||
mediaResolver?: MediaUrlResolver | null,
|
||||
messageIdResolver?: MessageIdResolver | null,
|
||||
mediaSink?: MediaSegmentSink | null,
|
||||
): Promise<JsonArray> {
|
||||
return elementsToJson(elements, isGroup, sessionId, resolver, mediaResolver, messageIdResolver);
|
||||
return elementsToJson(elements, isGroup, sessionId, resolver, mediaResolver, messageIdResolver, mediaSink);
|
||||
}
|
||||
|
||||
async function elementToSegment(
|
||||
@@ -346,6 +365,7 @@ async function elementToSegment(
|
||||
resolver?: ImageUrlResolver | null,
|
||||
mediaResolver?: MediaUrlResolver | null,
|
||||
messageIdResolver?: MessageIdResolver | null,
|
||||
mediaSink?: MediaSegmentSink | null,
|
||||
): Promise<JsonObject> {
|
||||
if (element.type === 'text') {
|
||||
return { type: 'text', data: { text: element.text ?? '' } };
|
||||
@@ -357,13 +377,12 @@ async function elementToSegment(
|
||||
|
||||
if (element.type === 'image') {
|
||||
const url = resolver ? resolver(element, isGroup) : (element.imageUrl ?? '');
|
||||
return {
|
||||
type: 'image',
|
||||
data: {
|
||||
url,
|
||||
file: element.fileId ?? '',
|
||||
},
|
||||
const data: JsonObject = {
|
||||
url,
|
||||
file: element.fileId ?? '',
|
||||
};
|
||||
if (mediaSink) mediaSink('image', element, data, isGroup, sessionId);
|
||||
return { type: 'image', data };
|
||||
}
|
||||
|
||||
if (element.type === 'at') {
|
||||
@@ -380,13 +399,12 @@ async function elementToSegment(
|
||||
|
||||
if (element.type === 'record') {
|
||||
const url = mediaResolver ? await mediaResolver(element, isGroup, sessionId) : (element.url ?? '');
|
||||
return {
|
||||
type: 'record',
|
||||
data: {
|
||||
file: element.fileName ?? element.fileId ?? '',
|
||||
url,
|
||||
},
|
||||
const data: JsonObject = {
|
||||
file: element.fileName ?? element.fileId ?? '',
|
||||
url,
|
||||
};
|
||||
if (mediaSink) mediaSink('record', element, data, isGroup, sessionId);
|
||||
return { type: 'record', data };
|
||||
}
|
||||
|
||||
if (element.type === 'video') {
|
||||
|
||||
113
packages/core/src/onebot/event-pipeline.ts
Normal file
113
packages/core/src/onebot/event-pipeline.ts
Normal file
@@ -0,0 +1,113 @@
|
||||
// Per-kind bridge → OneBot event handlers.
|
||||
//
|
||||
// Replaces the legacy single-firehose `OneBotInstance.onBridgeEvent` switch.
|
||||
// Every bridge event kind gets a small async handler bound to a shared
|
||||
// `OneBotInstanceContext`; subscribers register on `ctx.bridge.events` so
|
||||
// multiple unrelated downstream concerns (meta caching, OB11 conversion,
|
||||
// dispatch) compose cleanly without one giant switch statement.
|
||||
|
||||
import type { OneBotInstanceContext } from './instance-context';
|
||||
import { GROUP_MESSAGE_EVENT, PRIVATE_MESSAGE_EVENT, hashMessageIdInt32 } from './message-id';
|
||||
import type { QQEventVariant } from '../bridge/events';
|
||||
|
||||
/**
|
||||
* Subscribe every `OneBotInstanceContext`-aware handler onto the bridge
|
||||
* event bus. Returns a disposer that removes every subscription registered
|
||||
* here in one shot — useful for tests and for tearing down a session.
|
||||
*/
|
||||
export function registerEventPipeline(ctx: OneBotInstanceContext): () => void {
|
||||
const disposers: Array<() => void> = [];
|
||||
|
||||
// Every kind that maps onto an OB11 message event also seeds the
|
||||
// message-meta cache; we do that synchronously before async conversion so
|
||||
// reply / quote lookups for that message id work even if the converter
|
||||
// takes a beat to finish (e.g. while resolving image URLs).
|
||||
disposers.push(
|
||||
ctx.bridge.events.on('group_message', async (event) => {
|
||||
cacheGroupMessageMeta(ctx, event);
|
||||
await convertAndDispatch(ctx, event);
|
||||
}),
|
||||
);
|
||||
disposers.push(
|
||||
ctx.bridge.events.on('friend_message', async (event) => {
|
||||
cachePrivateMessageMeta(ctx, event.senderUin, event.msgSeq, event.time, event.msgId);
|
||||
await convertAndDispatch(ctx, event);
|
||||
}),
|
||||
);
|
||||
disposers.push(
|
||||
ctx.bridge.events.on('temp_message', async (event) => {
|
||||
cachePrivateMessageMeta(ctx, event.senderUin, event.msgSeq, event.time, 0);
|
||||
await convertAndDispatch(ctx, event);
|
||||
}),
|
||||
);
|
||||
|
||||
// Notice / request / non-message events: no meta caching needed, just
|
||||
// convert and dispatch.
|
||||
for (const kind of NOTICE_KINDS) {
|
||||
disposers.push(
|
||||
ctx.bridge.events.on(kind, async (event) => {
|
||||
await convertAndDispatch(ctx, event);
|
||||
}),
|
||||
);
|
||||
}
|
||||
|
||||
return () => {
|
||||
for (const dispose of disposers) {
|
||||
try { dispose(); } catch { /* ignore */ }
|
||||
}
|
||||
};
|
||||
}
|
||||
|
||||
const NOTICE_KINDS = [
|
||||
'group_member_join',
|
||||
'group_member_leave',
|
||||
'group_mute',
|
||||
'group_admin',
|
||||
'friend_recall',
|
||||
'group_recall',
|
||||
'friend_request',
|
||||
'group_invite',
|
||||
'friend_poke',
|
||||
'group_poke',
|
||||
'group_essence',
|
||||
'group_file_upload',
|
||||
'friend_add',
|
||||
] as const satisfies readonly QQEventVariant['kind'][];
|
||||
|
||||
async function convertAndDispatch(ctx: OneBotInstanceContext, event: QQEventVariant): Promise<void> {
|
||||
const converted = await ctx.eventConverter.convert(ctx.uin, event);
|
||||
if (!converted) return;
|
||||
ctx.dispatchEvent(converted);
|
||||
}
|
||||
|
||||
function cacheGroupMessageMeta(ctx: OneBotInstanceContext, event: Extract<QQEventVariant, { kind: 'group_message' }>): void {
|
||||
const messageId = hashMessageIdInt32(event.msgSeq, event.groupId, GROUP_MESSAGE_EVENT);
|
||||
ctx.cacheMessageMeta(messageId, {
|
||||
isGroup: true,
|
||||
targetId: event.groupId,
|
||||
sequence: event.msgSeq,
|
||||
eventName: GROUP_MESSAGE_EVENT,
|
||||
clientSequence: 0,
|
||||
random: event.msgId,
|
||||
timestamp: event.time,
|
||||
});
|
||||
}
|
||||
|
||||
function cachePrivateMessageMeta(
|
||||
ctx: OneBotInstanceContext,
|
||||
senderUin: number,
|
||||
msgSeq: number,
|
||||
timestamp: number,
|
||||
random: number,
|
||||
): void {
|
||||
const messageId = hashMessageIdInt32(msgSeq, senderUin, PRIVATE_MESSAGE_EVENT);
|
||||
ctx.cacheMessageMeta(messageId, {
|
||||
isGroup: false,
|
||||
targetId: senderUin,
|
||||
sequence: msgSeq,
|
||||
eventName: PRIVATE_MESSAGE_EVENT,
|
||||
clientSequence: 0,
|
||||
random,
|
||||
timestamp,
|
||||
});
|
||||
}
|
||||
@@ -1,230 +0,0 @@
|
||||
import type { HttpClientNetwork, JsonObject, OneBotConfig } from './types';
|
||||
import { createLogger } from '../utils/logger';
|
||||
import {
|
||||
buildDispatchPayload,
|
||||
pickDispatchJson,
|
||||
resolveReportOptions,
|
||||
type DispatchPayload,
|
||||
type EventReportOptions,
|
||||
} from './event-filter';
|
||||
|
||||
export interface HttpPostTransportContext {
|
||||
uin: string;
|
||||
api: import('./api-handler').ApiHandler;
|
||||
}
|
||||
|
||||
const log = createLogger('OneBot.POST');
|
||||
const DEFAULT_TIMEOUT_MS = 5000;
|
||||
|
||||
interface ResolvedClient {
|
||||
network: HttpClientNetwork;
|
||||
options: EventReportOptions;
|
||||
}
|
||||
|
||||
export class HttpPostTransport {
|
||||
private readonly context: HttpPostTransportContext;
|
||||
private clients = new Map<string, ResolvedClient>();
|
||||
private stopped = false;
|
||||
|
||||
constructor(config: OneBotConfig, context: HttpPostTransportContext) {
|
||||
this.clients = resolveClients(config);
|
||||
this.context = context;
|
||||
}
|
||||
|
||||
start(): void {
|
||||
this.stopped = false;
|
||||
if (this.clients.size > 0) {
|
||||
log.info('configured %d HTTP POST adapter(s): %s', this.clients.size, [...this.clients.keys()].join(', '));
|
||||
}
|
||||
}
|
||||
|
||||
reloadConfig(config: OneBotConfig): void {
|
||||
this.clients = resolveClients(config);
|
||||
log.info('reloaded %d HTTP POST adapter(s)', this.clients.size);
|
||||
}
|
||||
|
||||
stop(): void {
|
||||
this.stopped = true;
|
||||
}
|
||||
|
||||
/**
|
||||
* Forward one canonical event to every active HTTP push client.
|
||||
*
|
||||
* The instance pre-builds the {@link DispatchPayload} so this method only
|
||||
* picks the right pre-serialized variant per client (zero extra
|
||||
* `JSON.stringify` calls). The raw `event` is still kept around because the
|
||||
* quick-operation handler reads structured fields from it.
|
||||
*/
|
||||
publishEvent(event: JsonObject, payload?: DispatchPayload): void {
|
||||
if (this.stopped || this.clients.size === 0) return;
|
||||
|
||||
const dispatch = payload ?? buildDispatchPayload(event);
|
||||
for (const client of this.clients.values()) {
|
||||
const json = pickDispatchJson(dispatch, client.options);
|
||||
if (json === null) continue;
|
||||
void this.postEvent(client.network, json, event);
|
||||
}
|
||||
}
|
||||
|
||||
private async postEvent(network: HttpClientNetwork, payload: string, event: JsonObject): Promise<void> {
|
||||
if (this.stopped) return;
|
||||
|
||||
const headers: Record<string, string> = {
|
||||
'Content-Type': 'application/json',
|
||||
'User-Agent': 'OneBot',
|
||||
'X-Self-ID': this.context.uin,
|
||||
};
|
||||
|
||||
if (network.accessToken) {
|
||||
headers['X-Signature'] = await computeHmacSha1(network.accessToken, payload);
|
||||
}
|
||||
|
||||
const timeoutMs = network.timeoutMs ?? DEFAULT_TIMEOUT_MS;
|
||||
|
||||
try {
|
||||
const response = await fetch(network.url, {
|
||||
method: 'POST',
|
||||
headers,
|
||||
body: payload,
|
||||
signal: AbortSignal.timeout(timeoutMs),
|
||||
});
|
||||
|
||||
// OneBot v11: if the response has a JSON body, it's a quick operation
|
||||
if (response.ok) {
|
||||
const contentType = response.headers.get('content-type') ?? '';
|
||||
if (contentType.includes('application/json')) {
|
||||
const body = await response.text();
|
||||
if (body.trim()) {
|
||||
await this.handleQuickOperation(event, body);
|
||||
}
|
||||
}
|
||||
} else {
|
||||
log.warn('[%s] POST %s returned %d', network.name, network.url, response.status);
|
||||
}
|
||||
} catch (error) {
|
||||
if (!this.stopped) {
|
||||
log.warn('[%s] POST %s failed: %s', network.name, network.url, error instanceof Error ? error.message : String(error));
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
private async handleQuickOperation(event: JsonObject, responseBody: string): Promise<void> {
|
||||
try {
|
||||
const operation = JSON.parse(responseBody) as Record<string, unknown>;
|
||||
if (!operation || typeof operation !== 'object') return;
|
||||
|
||||
await executeQuickOperation(event, operation, this.context.api);
|
||||
} catch (error) {
|
||||
log.warn('quick operation failed: %s', error instanceof Error ? error.message : String(error));
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
function resolveClients(config: OneBotConfig): Map<string, ResolvedClient> {
|
||||
const out = new Map<string, ResolvedClient>();
|
||||
for (const network of config.networks.httpClients) {
|
||||
if (network.enabled === false) continue;
|
||||
if (!network.url) continue;
|
||||
out.set(network.name, {
|
||||
network,
|
||||
options: resolveReportOptions(network),
|
||||
});
|
||||
}
|
||||
return out;
|
||||
}
|
||||
|
||||
async function computeHmacSha1(secret: string, payload: string): Promise<string> {
|
||||
const { createHmac } = await import('crypto');
|
||||
return 'sha1=' + createHmac('sha1', secret).update(payload).digest('hex');
|
||||
}
|
||||
|
||||
/**
|
||||
* Execute a quick operation based on the event type and the response body.
|
||||
* This implements the .handle_quick_operation hidden API behavior.
|
||||
* See: https://github.com/botuniverse/onebot-11/blob/master/api/hidden.md
|
||||
*/
|
||||
export async function executeQuickOperation(
|
||||
event: JsonObject,
|
||||
operation: Record<string, unknown>,
|
||||
api: import('./api-handler').ApiHandler,
|
||||
): Promise<void> {
|
||||
const postType = event.post_type as string;
|
||||
|
||||
if (postType === 'message') {
|
||||
// Quick reply
|
||||
if (operation.reply !== undefined && operation.reply !== null && operation.reply !== '') {
|
||||
const messageType = event.message_type as string;
|
||||
const autoEscape = !!operation.auto_escape;
|
||||
|
||||
if (messageType === 'group') {
|
||||
const params: JsonObject = {
|
||||
group_id: event.group_id as number,
|
||||
message: operation.reply as import('./types').JsonValue,
|
||||
auto_escape: autoEscape,
|
||||
};
|
||||
// at_sender defaults to true for group messages
|
||||
if (operation.at_sender !== false && event.user_id) {
|
||||
// Prepend an @ segment
|
||||
const atSegment = { type: 'at', data: { qq: String(event.user_id) } };
|
||||
if (typeof operation.reply === 'string') {
|
||||
params.message = [atSegment, { type: 'text', data: { text: operation.reply as string } }] as import('./types').JsonValue;
|
||||
params.auto_escape = false;
|
||||
} else if (Array.isArray(operation.reply)) {
|
||||
params.message = [atSegment, ...(operation.reply as unknown[])] as import('./types').JsonValue;
|
||||
}
|
||||
}
|
||||
await api.handle('send_group_msg', params);
|
||||
} else if (messageType === 'private') {
|
||||
await api.handle('send_private_msg', {
|
||||
user_id: event.user_id as number,
|
||||
message: operation.reply as import('./types').JsonValue,
|
||||
auto_escape: autoEscape,
|
||||
});
|
||||
}
|
||||
}
|
||||
|
||||
// Quick delete
|
||||
if (operation.delete) {
|
||||
await api.handle('delete_msg', { message_id: event.message_id as number });
|
||||
}
|
||||
|
||||
// Quick ban (group only)
|
||||
if (operation.ban && event.message_type === 'group') {
|
||||
const duration = typeof operation.ban_duration === 'number' ? operation.ban_duration : 1800;
|
||||
await api.handle('set_group_ban', {
|
||||
group_id: event.group_id as number,
|
||||
user_id: event.user_id as number,
|
||||
duration: duration as import('./types').JsonValue,
|
||||
});
|
||||
}
|
||||
|
||||
// Quick kick (group only)
|
||||
if (operation.kick && event.message_type === 'group') {
|
||||
await api.handle('set_group_kick', {
|
||||
group_id: event.group_id as number,
|
||||
user_id: event.user_id as number,
|
||||
reject_add_request: !!operation.reject_add_request as unknown as import('./types').JsonValue,
|
||||
});
|
||||
}
|
||||
}
|
||||
|
||||
if (postType === 'request') {
|
||||
if (operation.approve !== undefined) {
|
||||
const requestType = event.request_type as string;
|
||||
if (requestType === 'friend') {
|
||||
await api.handle('set_friend_add_request', {
|
||||
flag: event.flag as string,
|
||||
approve: operation.approve as import('./types').JsonValue,
|
||||
remark: (operation.remark ?? '') as import('./types').JsonValue,
|
||||
});
|
||||
} else if (requestType === 'group') {
|
||||
await api.handle('set_group_add_request', {
|
||||
flag: event.flag as string,
|
||||
sub_type: event.sub_type as string,
|
||||
approve: operation.approve as import('./types').JsonValue,
|
||||
reason: (operation.reason ?? '') as import('./types').JsonValue,
|
||||
});
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -1,232 +0,0 @@
|
||||
import {
|
||||
createServer,
|
||||
type IncomingMessage,
|
||||
type Server,
|
||||
type ServerResponse,
|
||||
} from 'http';
|
||||
import type { ApiHandler } from './api-handler';
|
||||
import type { HttpServerNetwork, OneBotConfig } from './types';
|
||||
import { createLogger } from '../utils/logger';
|
||||
|
||||
export interface HttpTransportContext {
|
||||
api: ApiHandler;
|
||||
}
|
||||
|
||||
const log = createLogger('OneBot.HTTP');
|
||||
|
||||
interface RunningServer {
|
||||
server: Server;
|
||||
signature: string;
|
||||
network: HttpServerNetwork;
|
||||
}
|
||||
|
||||
export class HttpTransport {
|
||||
private readonly context: HttpTransportContext;
|
||||
private readonly servers = new Map<string, RunningServer>();
|
||||
private networks: HttpServerNetwork[] = [];
|
||||
|
||||
constructor(config: OneBotConfig, context: HttpTransportContext) {
|
||||
this.networks = activeNetworks(config);
|
||||
this.context = context;
|
||||
}
|
||||
|
||||
start(): void {
|
||||
for (const network of this.networks) this.startEndpoint(network);
|
||||
}
|
||||
|
||||
reloadConfig(config: OneBotConfig): void {
|
||||
const nextNetworks = activeNetworks(config);
|
||||
const nextByName = new Map(nextNetworks.map((n) => [n.name, n] as const));
|
||||
|
||||
// Stop adapters that no longer exist or whose binding/auth changed.
|
||||
for (const [name, running] of [...this.servers]) {
|
||||
const next = nextByName.get(name);
|
||||
if (!next || httpServerSignature(next) !== running.signature) {
|
||||
running.server.close();
|
||||
this.servers.delete(name);
|
||||
log.info('stopped [%s]', name);
|
||||
}
|
||||
}
|
||||
|
||||
// (Re)start adapters that aren't running yet.
|
||||
for (const network of nextNetworks) {
|
||||
if (!this.servers.has(network.name)) {
|
||||
this.startEndpoint(network);
|
||||
}
|
||||
}
|
||||
|
||||
this.networks = nextNetworks;
|
||||
}
|
||||
|
||||
stop(): void {
|
||||
for (const { server } of this.servers.values()) {
|
||||
server.close();
|
||||
}
|
||||
this.servers.clear();
|
||||
}
|
||||
|
||||
private startEndpoint(network: HttpServerNetwork): void {
|
||||
const expectedPath = normalizePath(network.path ?? '/');
|
||||
const endpointToken = network.accessToken ?? '';
|
||||
const server = createServer((req, res) => {
|
||||
void this.handleRequest(expectedPath, endpointToken, req, res);
|
||||
});
|
||||
|
||||
server.on('listening', () => {
|
||||
log.success('[%s] listening %s:%d%s', network.name, network.host ?? '0.0.0.0', network.port, expectedPath);
|
||||
});
|
||||
|
||||
server.on('error', (error) => {
|
||||
log.warn('[%s] server error: %s', network.name, error instanceof Error ? error.message : String(error));
|
||||
});
|
||||
|
||||
server.listen(network.port, network.host ?? '0.0.0.0');
|
||||
this.servers.set(network.name, { server, signature: httpServerSignature(network), network });
|
||||
}
|
||||
|
||||
private async handleRequest(expectedPath: string, accessToken: string, req: IncomingMessage, res: ServerResponse): Promise<void> {
|
||||
const parsedUrl = new URL(req.url ?? '/', 'http://127.0.0.1');
|
||||
const incomingPath = parsedUrl.pathname;
|
||||
|
||||
// Determine the expected prefix (e.g., "/" or "/api/")
|
||||
const ep = expectedPath.endsWith('/') ? expectedPath : expectedPath + '/';
|
||||
let action = '';
|
||||
|
||||
if (incomingPath === expectedPath || incomingPath === expectedPath + '/') {
|
||||
action = ''; // No action in URL (legacy body mode)
|
||||
} else if (incomingPath.startsWith(ep)) {
|
||||
action = incomingPath.substring(ep.length); // Extract action from URL
|
||||
} else {
|
||||
writeJson(res, 404, { status: 'failed', retcode: 1404, data: null, wording: 'not found' });
|
||||
return;
|
||||
}
|
||||
|
||||
if (!isAuthorized(req, accessToken)) {
|
||||
writeJson(res, 401, { status: 'failed', retcode: 1401, data: null, wording: 'unauthorized' });
|
||||
return;
|
||||
}
|
||||
|
||||
if (req.method === 'GET' && !action) {
|
||||
writeJson(res, 200, { status: 'ok', retcode: 0, data: { online: true } });
|
||||
return;
|
||||
}
|
||||
|
||||
try {
|
||||
let params: Record<string, unknown> = {};
|
||||
let echo: unknown;
|
||||
|
||||
if (req.method === 'GET') {
|
||||
parsedUrl.searchParams.forEach((value, key) => {
|
||||
try {
|
||||
params[key] = JSON.parse(value);
|
||||
} catch {
|
||||
params[key] = value;
|
||||
}
|
||||
});
|
||||
} else if (req.method === 'POST') {
|
||||
const bodyContent = await readRequestBody(req);
|
||||
if (bodyContent.trim()) {
|
||||
try {
|
||||
const parsedBody = JSON.parse(bodyContent);
|
||||
if (typeof parsedBody === 'object' && parsedBody !== null && !Array.isArray(parsedBody)) {
|
||||
// Legacy format: { action: "...", params: {...} } vs standard raw params
|
||||
if (parsedBody.action && !action) {
|
||||
action = String(parsedBody.action);
|
||||
}
|
||||
if (parsedBody.params && typeof parsedBody.params === 'object' && !Array.isArray(parsedBody.params)) {
|
||||
params = parsedBody.params as Record<string, unknown>;
|
||||
} else {
|
||||
params = parsedBody as Record<string, unknown>;
|
||||
}
|
||||
echo = parsedBody.echo;
|
||||
}
|
||||
} catch {
|
||||
writeJson(res, 400, { status: 'failed', retcode: 1400, data: null, wording: 'bad request: invalid json' });
|
||||
return;
|
||||
}
|
||||
}
|
||||
} else {
|
||||
writeJson(res, 405, { status: 'failed', retcode: 1400, data: null, wording: 'method not allowed' });
|
||||
return;
|
||||
}
|
||||
|
||||
if (!action) {
|
||||
writeJson(res, 400, { status: 'failed', retcode: 1400, data: null, wording: 'bad request: missing action' });
|
||||
return;
|
||||
}
|
||||
|
||||
// Handle the API call
|
||||
const response = await this.context.api.handle(action, params as import('./types').JsonObject);
|
||||
|
||||
if (echo !== undefined) {
|
||||
response.echo = echo as import('./types').JsonValue;
|
||||
}
|
||||
|
||||
writeJson(res, 200, response);
|
||||
} catch (error) {
|
||||
const wording = error instanceof Error ? error.message : 'internal error';
|
||||
writeJson(res, 500, { status: 'failed', retcode: 1200, data: null, wording });
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
function normalizePath(pathValue: string): string {
|
||||
const path = pathValue.trim() || '/';
|
||||
if (path === '/') return '/';
|
||||
return path.endsWith('/') ? path.slice(0, -1) : path;
|
||||
}
|
||||
|
||||
function httpServerSignature(network: HttpServerNetwork): string {
|
||||
return `${network.host ?? '0.0.0.0'}:${network.port}${normalizePath(network.path ?? '/')}#${network.accessToken ?? ''}`;
|
||||
}
|
||||
|
||||
function activeNetworks(config: OneBotConfig): HttpServerNetwork[] {
|
||||
return config.networks.httpServers.filter((n) => n.enabled !== false);
|
||||
}
|
||||
|
||||
function isAuthorized(request: IncomingMessage, token: string): boolean {
|
||||
if (!token) return true;
|
||||
// 1. Header auth
|
||||
const rawAuth = request.headers.authorization;
|
||||
const auth = Array.isArray(rawAuth) ? rawAuth[0] : rawAuth ?? '';
|
||||
if (auth === `Bearer ${token}`) return true;
|
||||
|
||||
// 2. Query string auth
|
||||
try {
|
||||
const url = new URL(request.url ?? '/', 'http://127.0.0.1');
|
||||
if (url.searchParams.get('access_token') === token) {
|
||||
return true;
|
||||
}
|
||||
} catch {}
|
||||
|
||||
return false;
|
||||
}
|
||||
|
||||
function readRequestBody(req: IncomingMessage, maxBytes = 2 * 1024 * 1024): Promise<string> {
|
||||
return new Promise((resolve, reject) => {
|
||||
const chunks: Buffer[] = [];
|
||||
let total = 0;
|
||||
|
||||
req.on('data', (chunk: Buffer) => {
|
||||
total += chunk.length;
|
||||
if (total > maxBytes) {
|
||||
reject(new Error('request body too large'));
|
||||
req.destroy();
|
||||
return;
|
||||
}
|
||||
chunks.push(chunk);
|
||||
});
|
||||
|
||||
req.on('end', () => {
|
||||
resolve(Buffer.concat(chunks).toString('utf8'));
|
||||
});
|
||||
|
||||
req.on('error', reject);
|
||||
});
|
||||
}
|
||||
|
||||
function writeJson(res: ServerResponse, statusCode: number, data: unknown): void {
|
||||
res.statusCode = statusCode;
|
||||
res.setHeader('Content-Type', 'application/json; charset=utf-8');
|
||||
res.end(JSON.stringify(data));
|
||||
}
|
||||
@@ -2,27 +2,56 @@ import type { Bridge } from '../bridge/bridge';
|
||||
import type { ForwardNodePayload, MessageElement } from '../bridge/events';
|
||||
import type { QQInfo } from '../bridge/qq-info';
|
||||
import type { ApiActionContext, MessageSendResult } from './api-handler';
|
||||
import type { EventConverter } from './event-converter';
|
||||
import { elementsToOneBotSegments } from './event-converter';
|
||||
import { MessageStore } from './message-store';
|
||||
import { parseMessage } from './message-parser';
|
||||
import { GROUP_MESSAGE_EVENT, PRIVATE_MESSAGE_EVENT, hashMessageIdInt32 } from './message-id';
|
||||
import type { JsonObject, JsonValue, MessageMeta } from './types';
|
||||
import type { MediaStore } from './media-store';
|
||||
import type { JsonObject, JsonValue, MessageMeta, OneBotConfig } from './types';
|
||||
import { createLogger } from '../utils/logger';
|
||||
import {WebHonorType} from "@/bridge/web/group-honor";
|
||||
|
||||
const log = createLogger('OneBot');
|
||||
|
||||
export interface InstanceRef {
|
||||
/**
|
||||
* Single shared context bag that flows through every OneBot instance-internal
|
||||
* subsystem: API builder and the per-kind event pipeline.
|
||||
*
|
||||
* Only fields that are actually read through this bag live here — the api
|
||||
* handler and network manager are owned by `OneBotInstance` directly because
|
||||
* nothing reads them via ctx, and including them here would force a
|
||||
* chicken-and-egg `late-bound` field dance during construction.
|
||||
*
|
||||
* `dispatchEvent` is the indirection used by the event pipeline to hand a
|
||||
* converted OneBot event back to the instance for caching + adapter fan-out;
|
||||
* it lets the pipeline stay decoupled from the network manager.
|
||||
*/
|
||||
export interface OneBotInstanceContext {
|
||||
/** Self UIN as string (matches what's on disk and on the wire). */
|
||||
uin: string;
|
||||
/** Self UIN parsed once, used in event payloads. */
|
||||
selfId: number;
|
||||
|
||||
qqInfo: QQInfo;
|
||||
bridge: Bridge;
|
||||
|
||||
messageStore: MessageStore;
|
||||
mediaStore: MediaStore;
|
||||
|
||||
eventConverter: EventConverter;
|
||||
|
||||
config: OneBotConfig;
|
||||
musicSignUrl?: string;
|
||||
|
||||
/** Persist meta about a message id; safe to call any number of times. */
|
||||
cacheMessageMeta(messageId: number, meta: MessageMeta): void;
|
||||
/** Hand a fully-converted OneBot event to the network manager + caches. */
|
||||
dispatchEvent(event: JsonObject): void;
|
||||
}
|
||||
|
||||
export function buildApiContext(ref: InstanceRef): ApiActionContext {
|
||||
const { bridge, qqInfo, messageStore } = ref;
|
||||
export function buildApiContext(ref: OneBotInstanceContext): ApiActionContext {
|
||||
const { bridge, qqInfo, messageStore, mediaStore } = ref;
|
||||
|
||||
return {
|
||||
getLoginInfo: () => getLoginInfo(ref),
|
||||
@@ -30,7 +59,7 @@ export function buildApiContext(ref: InstanceRef): ApiActionContext {
|
||||
getMessage: (messageId) => messageStore.findEvent(messageId),
|
||||
getMessageMeta: (messageId) => messageStore.findMeta(messageId),
|
||||
canSendImage: () => true,
|
||||
canSendRecord: () => false,
|
||||
canSendRecord: () => true,
|
||||
sendPrivateMessage: (userId, message, autoEscape) => handleSendPrivate(ref, userId, message, autoEscape),
|
||||
sendGroupMessage: (groupId, message, autoEscape) => handleSendGroup(ref, groupId, message, autoEscape),
|
||||
deleteMessage: (messageId, meta) => handleDeleteMessage(bridge, meta),
|
||||
@@ -135,12 +164,64 @@ export function buildApiContext(ref: InstanceRef): ApiActionContext {
|
||||
getCookiesStr: (domain: string) => bridge.getCookiesStr(domain),
|
||||
getCsrfToken: () => bridge.getCsrfToken(),
|
||||
getCredentials: (domain: string) => bridge.getCredentials(domain),
|
||||
// Media lookup
|
||||
getImageInfo: (file) => handleGetImageInfo(mediaStore, file),
|
||||
getRecordInfo: (file) => handleGetRecordInfo(bridge, mediaStore, file),
|
||||
};
|
||||
}
|
||||
|
||||
// --- Media lookup ---
|
||||
|
||||
async function handleGetImageInfo(
|
||||
mediaStore: MediaStore,
|
||||
file: string,
|
||||
): Promise<JsonObject | null> {
|
||||
const cached = mediaStore.findImage(file);
|
||||
if (!cached) return null;
|
||||
const url = cached.url || cached.imageUrl || '';
|
||||
return {
|
||||
file: url || cached.file,
|
||||
url,
|
||||
file_size: String(cached.fileSize ?? 0),
|
||||
file_name: cached.fileName || cached.file,
|
||||
};
|
||||
}
|
||||
|
||||
async function handleGetRecordInfo(
|
||||
bridge: Bridge,
|
||||
mediaStore: MediaStore,
|
||||
file: string,
|
||||
): Promise<JsonObject | null> {
|
||||
const cached = mediaStore.findRecord(file);
|
||||
if (!cached) return null;
|
||||
|
||||
// Re-resolve via OIDB if the cached URL is missing or empty.
|
||||
// Mirrors NapCat's getPttUrl path: GetGroupPttUrl / GetPttUrl by fileUuid.
|
||||
let url = cached.url;
|
||||
if (!url && cached.mediaNode) {
|
||||
try {
|
||||
url = cached.isGroup
|
||||
? await bridge.fetchGroupPttUrlByNode(cached.sessionId, cached.mediaNode)
|
||||
: await bridge.fetchPrivatePttUrlByNode(cached.mediaNode);
|
||||
if (url) {
|
||||
mediaStore.updateRecordUrl(file, url);
|
||||
}
|
||||
} catch (err) {
|
||||
log.warn('get_record url refetch failed: %s', err instanceof Error ? err.message : String(err));
|
||||
}
|
||||
}
|
||||
|
||||
return {
|
||||
file: url || cached.file,
|
||||
url: url || '',
|
||||
file_size: String(cached.fileSize ?? 0),
|
||||
file_name: cached.fileName || cached.file,
|
||||
};
|
||||
}
|
||||
|
||||
// --- Login info ---
|
||||
|
||||
function getLoginInfo(ref: InstanceRef): { userId: number; nickname: string } {
|
||||
function getLoginInfo(ref: OneBotInstanceContext): { userId: number; nickname: string } {
|
||||
const userId = parseInt(ref.uin, 10) || 0;
|
||||
const nickname = ref.qqInfo.nickname || ref.uin;
|
||||
return { userId, nickname };
|
||||
@@ -496,7 +577,7 @@ function logSentMessage(isGroup: boolean, targetId: number, elements: MessageEle
|
||||
// --- Send message ---
|
||||
|
||||
async function handleSendPrivate(
|
||||
ref: InstanceRef,
|
||||
ref: OneBotInstanceContext,
|
||||
userId: number,
|
||||
message: JsonValue,
|
||||
autoEscape: boolean,
|
||||
@@ -542,7 +623,7 @@ async function handleSendPrivate(
|
||||
}
|
||||
|
||||
async function handleSendGroup(
|
||||
ref: InstanceRef,
|
||||
ref: OneBotInstanceContext,
|
||||
groupId: number,
|
||||
message: JsonValue,
|
||||
autoEscape: boolean,
|
||||
@@ -588,7 +669,7 @@ async function handleSendGroup(
|
||||
}
|
||||
|
||||
async function handleSendGroupForward(
|
||||
ref: InstanceRef,
|
||||
ref: OneBotInstanceContext,
|
||||
groupId: number,
|
||||
messages: JsonValue,
|
||||
): Promise<{ messageId: number; forwardId: string }> {
|
||||
@@ -611,7 +692,7 @@ async function handleSendGroupForward(
|
||||
}
|
||||
|
||||
async function handleSendPrivateForward(
|
||||
ref: InstanceRef,
|
||||
ref: OneBotInstanceContext,
|
||||
userId: number,
|
||||
messages: JsonValue,
|
||||
): Promise<{ messageId: number; forwardId: string }> {
|
||||
@@ -634,7 +715,7 @@ async function handleSendPrivateForward(
|
||||
}
|
||||
|
||||
async function handleUploadForward(
|
||||
ref: InstanceRef,
|
||||
ref: OneBotInstanceContext,
|
||||
messages: JsonValue,
|
||||
): Promise<{ forwardId: string }> {
|
||||
const nodes = await parseForwardNodes(ref, messages);
|
||||
@@ -643,7 +724,7 @@ async function handleUploadForward(
|
||||
}
|
||||
|
||||
async function handleGetForward(
|
||||
ref: InstanceRef,
|
||||
ref: OneBotInstanceContext,
|
||||
resId: string,
|
||||
): Promise<JsonObject[]> {
|
||||
const nodes = await ref.bridge.fetchForwardNodes(resId);
|
||||
@@ -663,7 +744,7 @@ async function handleGetForward(
|
||||
return results;
|
||||
}
|
||||
|
||||
async function parseForwardNodes(ref: InstanceRef, messages: JsonValue): Promise<ForwardNodePayload[]> {
|
||||
async function parseForwardNodes(ref: OneBotInstanceContext, messages: JsonValue): Promise<ForwardNodePayload[]> {
|
||||
if (!Array.isArray(messages)) {
|
||||
throw new Error('forward messages must be an array');
|
||||
}
|
||||
|
||||
@@ -1,18 +1,23 @@
|
||||
import path from 'path';
|
||||
import type { QQEventVariant } from '../bridge/events';
|
||||
import type { Bridge } from '../bridge/bridge';
|
||||
import type { QQInfo } from '../bridge/qq-info';
|
||||
import { ApiHandler } from './api-handler';
|
||||
import { EventConverter } from './event-converter';
|
||||
import { MessageStore } from './message-store';
|
||||
import { MediaStore } from './media-store';
|
||||
import { RKeyCache } from './instance-rkey';
|
||||
import { buildApiContext } from './instance-context';
|
||||
import { buildApiContext, type OneBotInstanceContext } from './instance-context';
|
||||
import { registerEventPipeline } from './event-pipeline';
|
||||
import { GROUP_MESSAGE_EVENT, PRIVATE_MESSAGE_EVENT, hashMessageIdInt32 } from './message-id';
|
||||
import type { JsonObject, MessageMeta, OneBotConfig } from './types';
|
||||
import { HttpTransport } from './http-transport';
|
||||
import { HttpPostTransport } from './http-post-transport';
|
||||
import { WsTransport } from './ws-transport';
|
||||
import { buildDispatchPayload } from './event-filter';
|
||||
import type { JsonObject, MessageMeta, OneBotConfig, NetworkBase } from './types';
|
||||
import {
|
||||
OneBotNetworkManager,
|
||||
WsServerAdapter,
|
||||
WsClientAdapter,
|
||||
HttpServerAdapter,
|
||||
HttpPostAdapter,
|
||||
type NetworkAdapterContext,
|
||||
} from './network';
|
||||
import { createLogger } from '../utils/logger';
|
||||
|
||||
const log = createLogger('Event');
|
||||
@@ -25,10 +30,11 @@ export class OneBotInstance {
|
||||
private readonly apiHandler: ApiHandler;
|
||||
private readonly eventConverter: EventConverter;
|
||||
private readonly messageStore: MessageStore;
|
||||
private readonly httpTransport: HttpTransport;
|
||||
private readonly httpPostTransport: HttpPostTransport;
|
||||
private readonly wsTransport: WsTransport;
|
||||
private readonly mediaStore: MediaStore;
|
||||
private readonly networkManager: OneBotNetworkManager;
|
||||
private readonly rkeyCache: RKeyCache;
|
||||
private readonly ctx: OneBotInstanceContext;
|
||||
private disposeEventPipeline: (() => void) | null = null;
|
||||
|
||||
private readonly pids = new Set<number>();
|
||||
private online = true;
|
||||
@@ -42,6 +48,7 @@ export class OneBotInstance {
|
||||
|
||||
this.eventConverter = new EventConverter();
|
||||
this.rkeyCache = new RKeyCache();
|
||||
this.mediaStore = new MediaStore(path.join('data', this.uin, 'media.db'));
|
||||
this.eventConverter.setImageUrlResolver((element, isGroup) =>
|
||||
this.rkeyCache.resolveImageUrl(this.bridge, element, isGroup));
|
||||
this.eventConverter.setMediaUrlResolver(async (element, isGroup, sessionId) => {
|
||||
@@ -70,69 +77,83 @@ export class OneBotInstance {
|
||||
// Then apply RKey if needed
|
||||
return this.rkeyCache.resolveMediaUrl(this.bridge, element, isGroup);
|
||||
});
|
||||
this.eventConverter.setMediaSegmentSink((mediaType, element, data, isGroup, sessionId) => {
|
||||
const url = typeof data.url === 'string' ? data.url : '';
|
||||
const file = typeof data.file === 'string' ? data.file : '';
|
||||
if (mediaType === 'image') {
|
||||
this.mediaStore.rememberImage({
|
||||
file: file || element.fileId || '',
|
||||
url,
|
||||
fileSize: element.fileSize ?? 0,
|
||||
fileName: element.fileId ?? '',
|
||||
subType: element.subType ?? 0,
|
||||
summary: element.summary ?? '',
|
||||
imageUrl: element.imageUrl ?? '',
|
||||
isGroup,
|
||||
sessionId,
|
||||
});
|
||||
return;
|
||||
}
|
||||
this.mediaStore.rememberRecord({
|
||||
file: file || element.fileName || element.fileId || '',
|
||||
fileId: element.fileId ?? '',
|
||||
url,
|
||||
fileSize: element.fileSize ?? 0,
|
||||
fileName: element.fileName ?? '',
|
||||
duration: element.duration ?? 0,
|
||||
fileHash: element.fileHash ?? '',
|
||||
mediaNode: element.mediaNode,
|
||||
isGroup,
|
||||
sessionId,
|
||||
});
|
||||
});
|
||||
this.eventConverter.setMessageIdResolver((isGroup, sessionId, sequence, eventName) =>
|
||||
hashMessageIdInt32(sequence, sessionId, eventName || (isGroup ? GROUP_MESSAGE_EVENT : PRIVATE_MESSAGE_EVENT)));
|
||||
this.messageStore = new MessageStore(path.join('data', this.uin, 'messages.json'));
|
||||
|
||||
const context = buildApiContext({
|
||||
// Shared instance context. Only carries fields that are actually read
|
||||
// through it — api handler and network manager stay as direct fields on
|
||||
// the instance because nothing reads them via ctx.
|
||||
const ctx: OneBotInstanceContext = {
|
||||
uin: this.uin,
|
||||
selfId: parseInt(this.uin, 10) || 0,
|
||||
qqInfo: this.qqInfo,
|
||||
bridge: this.bridge,
|
||||
messageStore: this.messageStore,
|
||||
mediaStore: this.mediaStore,
|
||||
eventConverter: this.eventConverter,
|
||||
config,
|
||||
musicSignUrl: config.musicSignUrl,
|
||||
cacheMessageMeta: (messageId, meta) => this.cacheMessageMeta(messageId, meta),
|
||||
});
|
||||
this.apiHandler = new ApiHandler(context);
|
||||
dispatchEvent: (event) => this.dispatchEvent(event),
|
||||
};
|
||||
this.ctx = ctx;
|
||||
|
||||
this.httpTransport = new HttpTransport(config, {
|
||||
api: this.apiHandler,
|
||||
});
|
||||
this.apiHandler = new ApiHandler(buildApiContext(ctx));
|
||||
this.networkManager = new OneBotNetworkManager();
|
||||
this.installAdaptersFromConfig(config);
|
||||
void this.networkManager.openAll();
|
||||
|
||||
this.httpPostTransport = new HttpPostTransport(config, {
|
||||
uin: this.uin,
|
||||
api: this.apiHandler,
|
||||
});
|
||||
|
||||
this.wsTransport = new WsTransport(config, {
|
||||
uin: this.uin,
|
||||
api: this.apiHandler,
|
||||
buildLifecycleEvent: (subType) => this.makeLifecycleEvent(subType),
|
||||
buildHeartbeatEvent: () => this.makeHeartbeatEvent(),
|
||||
});
|
||||
|
||||
this.httpTransport.start();
|
||||
this.httpPostTransport.start();
|
||||
this.wsTransport.start();
|
||||
this.startHeartbeat();
|
||||
this.rkeyCache.warmUp(this.bridge, this.uin);
|
||||
|
||||
// Per-kind subscription on the typed event bus. Each bridge event kind
|
||||
// gets its own focused handler in `event-pipeline`; the firehose is gone.
|
||||
this.disposeEventPipeline = registerEventPipeline(ctx);
|
||||
}
|
||||
|
||||
reloadConfig(config: OneBotConfig): void {
|
||||
this.httpTransport.reloadConfig(config);
|
||||
this.httpPostTransport.reloadConfig(config);
|
||||
this.wsTransport.reloadConfig(config);
|
||||
void this.applyConfigDiff(config);
|
||||
}
|
||||
|
||||
dispose(): void {
|
||||
this.online = false;
|
||||
this.stopHeartbeat();
|
||||
this.httpTransport.stop();
|
||||
this.httpPostTransport.stop();
|
||||
this.wsTransport.stop();
|
||||
this.disposeEventPipeline?.();
|
||||
this.disposeEventPipeline = null;
|
||||
void this.networkManager.closeAll();
|
||||
this.messageStore.close();
|
||||
}
|
||||
|
||||
onBridgeEvent(event: QQEventVariant): void {
|
||||
this.cacheMessageMetaFromBridgeEvent(event);
|
||||
|
||||
void this.dispatchBridgeEventAsync(event);
|
||||
}
|
||||
|
||||
private async dispatchBridgeEventAsync(event: QQEventVariant): Promise<void> {
|
||||
const converted = await this.eventConverter.convert(this.uin, event);
|
||||
if (!converted) return;
|
||||
|
||||
this.dispatchEvent(converted);
|
||||
this.mediaStore.close();
|
||||
}
|
||||
|
||||
addPid(pid: number): void {
|
||||
@@ -158,11 +179,87 @@ export class OneBotInstance {
|
||||
private dispatchEvent(event: JsonObject): void {
|
||||
this.cacheMessageEvent(event);
|
||||
this.logReceivedMessage(event);
|
||||
// Produce one canonical event, serialize the two format variants once,
|
||||
// then let each adapter pick its slot at zero allocation cost.
|
||||
const payload = buildDispatchPayload(event);
|
||||
this.wsTransport.publishEvent(event, payload);
|
||||
this.httpPostTransport.publishEvent(event, payload);
|
||||
// NetworkManager builds the dispatch payload once and fans out to every
|
||||
// active adapter in parallel via Promise.allSettled.
|
||||
void this.networkManager.emitEvent(event);
|
||||
}
|
||||
|
||||
private buildNetworkContext(): NetworkAdapterContext {
|
||||
return {
|
||||
uin: this.uin,
|
||||
api: this.apiHandler,
|
||||
buildLifecycleEvent: (subType) => this.makeLifecycleEvent(subType),
|
||||
buildHeartbeatEvent: () => this.makeHeartbeatEvent(),
|
||||
};
|
||||
}
|
||||
|
||||
private installAdaptersFromConfig(config: OneBotConfig): void {
|
||||
const ctx = this.buildNetworkContext();
|
||||
for (const net of config.networks.httpServers) {
|
||||
if (net.enabled === false) continue;
|
||||
this.networkManager.register(new HttpServerAdapter(net.name, net, ctx));
|
||||
}
|
||||
for (const net of config.networks.httpClients) {
|
||||
if (net.enabled === false || !net.url) continue;
|
||||
this.networkManager.register(new HttpPostAdapter(net.name, net, ctx));
|
||||
}
|
||||
for (const net of config.networks.wsServers) {
|
||||
if (net.enabled === false) continue;
|
||||
this.networkManager.register(new WsServerAdapter(net.name, net, ctx));
|
||||
}
|
||||
for (const net of config.networks.wsClients) {
|
||||
if (net.enabled === false || !net.url) continue;
|
||||
this.networkManager.register(new WsClientAdapter(net.name, net, ctx));
|
||||
}
|
||||
}
|
||||
|
||||
private async applyConfigDiff(next: OneBotConfig): Promise<void> {
|
||||
const ctx = this.buildNetworkContext();
|
||||
const desired = new Map<string, NetworkBase>();
|
||||
const factories = new Map<string, () => void>();
|
||||
|
||||
for (const net of next.networks.httpServers) {
|
||||
desired.set(net.name, net);
|
||||
factories.set(net.name, () => this.networkManager.register(new HttpServerAdapter(net.name, net, ctx)));
|
||||
}
|
||||
for (const net of next.networks.httpClients) {
|
||||
desired.set(net.name, net);
|
||||
factories.set(net.name, () => this.networkManager.register(new HttpPostAdapter(net.name, net, ctx)));
|
||||
}
|
||||
for (const net of next.networks.wsServers) {
|
||||
desired.set(net.name, net);
|
||||
factories.set(net.name, () => this.networkManager.register(new WsServerAdapter(net.name, net, ctx)));
|
||||
}
|
||||
for (const net of next.networks.wsClients) {
|
||||
desired.set(net.name, net);
|
||||
factories.set(net.name, () => this.networkManager.register(new WsClientAdapter(net.name, net, ctx)));
|
||||
}
|
||||
|
||||
// Close adapters whose entry has been removed entirely.
|
||||
for (const adapter of this.networkManager.list()) {
|
||||
if (!desired.has(adapter.name)) {
|
||||
await this.networkManager.closeOne(adapter.name);
|
||||
}
|
||||
}
|
||||
|
||||
// Reload existing adapters in place; spin up new ones the manager hasn't
|
||||
// seen before.
|
||||
for (const [name, net] of desired) {
|
||||
const existing = this.networkManager.get(name);
|
||||
if (existing) {
|
||||
try {
|
||||
await existing.reload(net as never);
|
||||
} catch (err) {
|
||||
log.warn('reload [%s] failed: %s', name, err instanceof Error ? err.message : String(err));
|
||||
}
|
||||
} else if (net.enabled !== false) {
|
||||
const factory = factories.get(name);
|
||||
if (factory) {
|
||||
factory();
|
||||
await this.networkManager.get(name)?.open();
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
private logReceivedMessage(event: JsonObject): void {
|
||||
@@ -239,49 +336,6 @@ export class OneBotInstance {
|
||||
this.messageStore.storeEvent(messageId, isGroup, sessionId, sequence, eventName, event);
|
||||
}
|
||||
|
||||
private cacheMessageMetaFromBridgeEvent(event: QQEventVariant): void {
|
||||
if (event.kind === 'group_message') {
|
||||
const messageId = hashMessageIdInt32(event.msgSeq, event.groupId, GROUP_MESSAGE_EVENT);
|
||||
this.cacheMessageMeta(messageId, {
|
||||
isGroup: true,
|
||||
targetId: event.groupId,
|
||||
sequence: event.msgSeq,
|
||||
eventName: GROUP_MESSAGE_EVENT,
|
||||
clientSequence: 0,
|
||||
random: event.msgId,
|
||||
timestamp: event.time,
|
||||
});
|
||||
return;
|
||||
}
|
||||
|
||||
if (event.kind === 'friend_message') {
|
||||
const messageId = hashMessageIdInt32(event.msgSeq, event.senderUin, PRIVATE_MESSAGE_EVENT);
|
||||
this.cacheMessageMeta(messageId, {
|
||||
isGroup: false,
|
||||
targetId: event.senderUin,
|
||||
sequence: event.msgSeq,
|
||||
eventName: PRIVATE_MESSAGE_EVENT,
|
||||
clientSequence: 0,
|
||||
random: event.msgId,
|
||||
timestamp: event.time,
|
||||
});
|
||||
return;
|
||||
}
|
||||
|
||||
if (event.kind === 'temp_message') {
|
||||
const messageId = hashMessageIdInt32(event.msgSeq, event.senderUin, PRIVATE_MESSAGE_EVENT);
|
||||
this.cacheMessageMeta(messageId, {
|
||||
isGroup: false,
|
||||
targetId: event.senderUin,
|
||||
sequence: event.msgSeq,
|
||||
eventName: PRIVATE_MESSAGE_EVENT,
|
||||
clientSequence: 0,
|
||||
random: 0,
|
||||
timestamp: event.time,
|
||||
});
|
||||
}
|
||||
}
|
||||
|
||||
private cacheMessageMeta(messageId: number, meta: MessageMeta): void {
|
||||
if (!Number.isInteger(messageId) || messageId === 0) return;
|
||||
this.messageStore.storeMeta(messageId, meta);
|
||||
|
||||
@@ -1,4 +1,3 @@
|
||||
import type { QQEventVariant } from '../bridge/events';
|
||||
import type { Bridge } from '../bridge/bridge';
|
||||
import type { QQInfo } from '../bridge/qq-info';
|
||||
import type { BridgeManager } from '../bridge/manager';
|
||||
@@ -21,9 +20,8 @@ export class OneBotManager {
|
||||
this.onSessionClosed(uin);
|
||||
});
|
||||
|
||||
bridgeManager.setEventCallback((uin, event) => {
|
||||
this.onBridgeEvent(uin, event);
|
||||
});
|
||||
// Per-kind subscriptions to `bridge.events` happen inside
|
||||
// `OneBotInstance` itself; no global firehose to wire here.
|
||||
}
|
||||
|
||||
getInstance(uin: string): OneBotInstance | null {
|
||||
@@ -80,12 +78,6 @@ export class OneBotManager {
|
||||
log.info('session closed: UIN=%s', uin);
|
||||
}
|
||||
|
||||
private onBridgeEvent(uin: string, event: QQEventVariant): void {
|
||||
const instance = this.instances.get(uin);
|
||||
if (!instance) return;
|
||||
|
||||
instance.onBridgeEvent(event);
|
||||
}
|
||||
}
|
||||
|
||||
async function warmUpBridgeState(uin: string, qqInfo: QQInfo, bridge: Bridge): Promise<void> {
|
||||
|
||||
267
packages/core/src/onebot/media-store.ts
Normal file
267
packages/core/src/onebot/media-store.ts
Normal file
@@ -0,0 +1,267 @@
|
||||
// Persistent media metadata store.
|
||||
//
|
||||
// The `get_image` / `get_record` actions need to map a `data.file` (or related
|
||||
// identifier) we previously emitted in a message segment back to the URL,
|
||||
// size, name, and any OIDB media-node info needed to re-resolve a stale URL.
|
||||
//
|
||||
// Earlier this lived in an in-memory `MediaCache`, which meant the lookup
|
||||
// table was lost on every restart. This implementation persists everything
|
||||
// alongside the message store so OneBot consumers can always resolve the
|
||||
// media that produced any segment ever stored, even after the bot restarts.
|
||||
//
|
||||
// Schema overview (single SQLite file per UIN, e.g. `data/<uin>/media.db`):
|
||||
// media_entries(type, primary_key, data JSON, last_seen) -- one row per logical media item
|
||||
// media_keys(type, key, primary_key) -- secondary index for every alias
|
||||
//
|
||||
// `rememberImage` / `rememberRecord` upsert exactly one entry row plus one
|
||||
// alias row per identifier (file / fileName / fileId / url). The alias rows
|
||||
// always point to the canonical entry so URL refreshes propagate to every
|
||||
// alias automatically.
|
||||
|
||||
import fs from 'fs';
|
||||
import path from 'path';
|
||||
import { DatabaseSync, type StatementSync } from 'node:sqlite';
|
||||
|
||||
import type { MessageElement } from '../bridge/events';
|
||||
|
||||
export interface CachedImage {
|
||||
/** Primary `data.file` value as exposed in the OneBot segment. */
|
||||
file: string;
|
||||
/** Last known resolved URL (may be empty if resolution failed). */
|
||||
url: string;
|
||||
fileSize: number;
|
||||
fileName: string;
|
||||
subType: number;
|
||||
summary: string;
|
||||
/** Conversation the media originated from. */
|
||||
isGroup: boolean;
|
||||
sessionId: number;
|
||||
/** Original imageUrl from the MessageElement, used for RKey re-appending. */
|
||||
imageUrl: string;
|
||||
}
|
||||
|
||||
export interface CachedRecord {
|
||||
/** Primary `data.file` value as exposed in the OneBot segment. */
|
||||
file: string;
|
||||
/** Raw fileId from the MessageElement (typically the fileUuid). */
|
||||
fileId: string;
|
||||
/** Last known resolved URL (may be empty if resolution failed). */
|
||||
url: string;
|
||||
fileSize: number;
|
||||
fileName: string;
|
||||
duration: number;
|
||||
fileHash: string;
|
||||
/** OIDB media node used to re-fetch the URL via getPtt*UrlByNode. */
|
||||
mediaNode?: MessageElement['mediaNode'];
|
||||
/** Conversation the media originated from (group vs private path). */
|
||||
isGroup: boolean;
|
||||
sessionId: number;
|
||||
}
|
||||
|
||||
const TYPE_IMAGE = 'image';
|
||||
const TYPE_RECORD = 'record';
|
||||
const DEFAULT_KEEP_ENTRIES = 4096;
|
||||
|
||||
export class MediaStore {
|
||||
private readonly db: DatabaseSync;
|
||||
private readonly maxEntriesPerType: number;
|
||||
|
||||
// Prepared statements (pay the parsing cost once at startup).
|
||||
private readonly upsertEntry: StatementSync;
|
||||
private readonly upsertKey: StatementSync;
|
||||
private readonly findEntryByKey: StatementSync;
|
||||
private readonly findEntryByPrimary: StatementSync;
|
||||
private readonly evictByType: StatementSync;
|
||||
private readonly purgeOrphanKeys: StatementSync;
|
||||
private readonly countByType: StatementSync;
|
||||
|
||||
constructor(dbPath: string, maxEntriesPerType = DEFAULT_KEEP_ENTRIES) {
|
||||
this.maxEntriesPerType = Math.max(64, maxEntriesPerType);
|
||||
|
||||
const dir = path.dirname(dbPath);
|
||||
fs.mkdirSync(dir, { recursive: true });
|
||||
|
||||
this.db = new DatabaseSync(dbPath);
|
||||
this.db.exec('PRAGMA journal_mode = WAL');
|
||||
this.db.exec('PRAGMA synchronous = NORMAL');
|
||||
this.initSchema();
|
||||
|
||||
this.upsertEntry = this.db.prepare(
|
||||
`INSERT INTO media_entries (type, primary_key, data, last_seen)
|
||||
VALUES (?, ?, ?, ?)
|
||||
ON CONFLICT(type, primary_key) DO UPDATE SET
|
||||
data = excluded.data,
|
||||
last_seen = excluded.last_seen`,
|
||||
);
|
||||
this.upsertKey = this.db.prepare(
|
||||
`INSERT INTO media_keys (type, key, primary_key)
|
||||
VALUES (?, ?, ?)
|
||||
ON CONFLICT(type, key) DO UPDATE SET primary_key = excluded.primary_key`,
|
||||
);
|
||||
this.findEntryByKey = this.db.prepare(
|
||||
`SELECT e.data FROM media_entries e
|
||||
JOIN media_keys k ON k.type = e.type AND k.primary_key = e.primary_key
|
||||
WHERE k.type = ? AND k.key = ?
|
||||
LIMIT 1`,
|
||||
);
|
||||
this.findEntryByPrimary = this.db.prepare(
|
||||
`SELECT data FROM media_entries WHERE type = ? AND primary_key = ?`,
|
||||
);
|
||||
this.evictByType = this.db.prepare(
|
||||
// `rowid DESC` makes the tiebreaker match insertion order (newest first)
|
||||
// so reproducible inserts within the same `last_seen` second still get
|
||||
// the most recent rows retained, regardless of how the lexicographic
|
||||
// sort would have ordered the synthetic primary_key.
|
||||
`DELETE FROM media_entries WHERE type = ? AND rowid IN (
|
||||
SELECT rowid FROM media_entries
|
||||
WHERE type = ?
|
||||
ORDER BY last_seen DESC, rowid DESC
|
||||
LIMIT -1 OFFSET ?
|
||||
)`,
|
||||
);
|
||||
this.purgeOrphanKeys = this.db.prepare(
|
||||
`DELETE FROM media_keys WHERE type = ? AND primary_key NOT IN (
|
||||
SELECT primary_key FROM media_entries WHERE type = ?
|
||||
)`,
|
||||
);
|
||||
this.countByType = this.db.prepare(
|
||||
`SELECT COUNT(*) AS n FROM media_entries WHERE type = ?`,
|
||||
);
|
||||
}
|
||||
|
||||
close(): void {
|
||||
this.db.close();
|
||||
}
|
||||
|
||||
rememberImage(info: CachedImage): void {
|
||||
const primaryKey = pickPrimary([info.file, info.fileName]);
|
||||
if (!primaryKey) return;
|
||||
this.upsertWithAliases(TYPE_IMAGE, primaryKey, info, [info.file, info.fileName, info.url]);
|
||||
}
|
||||
|
||||
rememberRecord(info: CachedRecord): void {
|
||||
const primaryKey = pickPrimary([info.file, info.fileName, info.fileId]);
|
||||
if (!primaryKey) return;
|
||||
this.upsertWithAliases(TYPE_RECORD, primaryKey, info, [info.file, info.fileName, info.fileId, info.url]);
|
||||
}
|
||||
|
||||
findImage(key: string): CachedImage | null {
|
||||
return this.findByAnyKey<CachedImage>(TYPE_IMAGE, key);
|
||||
}
|
||||
|
||||
findRecord(key: string): CachedRecord | null {
|
||||
return this.findByAnyKey<CachedRecord>(TYPE_RECORD, key);
|
||||
}
|
||||
|
||||
updateImageUrl(key: string, url: string): void {
|
||||
if (!url) return;
|
||||
const cached = this.findImage(key);
|
||||
if (!cached || cached.url === url) return;
|
||||
this.rememberImage({ ...cached, url });
|
||||
}
|
||||
|
||||
updateRecordUrl(key: string, url: string): void {
|
||||
if (!url) return;
|
||||
const cached = this.findRecord(key);
|
||||
if (!cached || cached.url === url) return;
|
||||
this.rememberRecord({ ...cached, url });
|
||||
}
|
||||
|
||||
/** Snapshot count of distinct entries per type; mostly used by tests. */
|
||||
size(): { images: number; records: number } {
|
||||
const img = this.countByType.get(TYPE_IMAGE) as { n: number } | undefined;
|
||||
const rec = this.countByType.get(TYPE_RECORD) as { n: number } | undefined;
|
||||
return { images: img?.n ?? 0, records: rec?.n ?? 0 };
|
||||
}
|
||||
|
||||
// --- internals ---
|
||||
|
||||
private initSchema(): void {
|
||||
this.db.exec(`
|
||||
CREATE TABLE IF NOT EXISTS media_entries (
|
||||
type TEXT NOT NULL,
|
||||
primary_key TEXT NOT NULL,
|
||||
data TEXT NOT NULL,
|
||||
last_seen INTEGER NOT NULL,
|
||||
PRIMARY KEY (type, primary_key)
|
||||
);
|
||||
CREATE INDEX IF NOT EXISTS idx_media_entries_lastseen
|
||||
ON media_entries(type, last_seen DESC);
|
||||
CREATE TABLE IF NOT EXISTS media_keys (
|
||||
type TEXT NOT NULL,
|
||||
key TEXT NOT NULL,
|
||||
primary_key TEXT NOT NULL,
|
||||
PRIMARY KEY (type, key)
|
||||
);
|
||||
CREATE INDEX IF NOT EXISTS idx_media_keys_primary
|
||||
ON media_keys(type, primary_key);
|
||||
`);
|
||||
}
|
||||
|
||||
private upsertWithAliases<T>(
|
||||
type: string,
|
||||
primaryKey: string,
|
||||
info: T,
|
||||
aliases: (string | undefined)[],
|
||||
): void {
|
||||
const data = JSON.stringify(info);
|
||||
const lastSeen = Math.floor(Date.now() / 1000);
|
||||
|
||||
// Run the writes in a transaction so concurrent readers always see a
|
||||
// consistent (entry, keys) pair.
|
||||
this.db.exec('BEGIN');
|
||||
try {
|
||||
this.upsertEntry.run(type, primaryKey, data, lastSeen);
|
||||
const seen = new Set<string>();
|
||||
for (const raw of aliases) {
|
||||
if (!raw) continue;
|
||||
if (seen.has(raw)) continue;
|
||||
seen.add(raw);
|
||||
this.upsertKey.run(type, raw, primaryKey);
|
||||
}
|
||||
this.db.exec('COMMIT');
|
||||
} catch (err) {
|
||||
try { this.db.exec('ROLLBACK'); } catch { /* ignore */ }
|
||||
throw err;
|
||||
}
|
||||
|
||||
// Eager eviction. The DELETE is a no-op when row count <= cap so
|
||||
// there is no measurable cost while we are below the limit.
|
||||
this.evictOldEntries(type);
|
||||
}
|
||||
|
||||
private findByAnyKey<T>(type: string, key: string): T | null {
|
||||
if (!key) return null;
|
||||
const row = this.findEntryByKey.get(type, key) as { data: string } | undefined;
|
||||
if (row?.data) return safeParse<T>(row.data);
|
||||
// Fall back to looking up by primary_key directly so callers that pass
|
||||
// the canonical identifier still hit (e.g. when the alias index is yet
|
||||
// to be built for that key in this session).
|
||||
const fallback = this.findEntryByPrimary.get(type, key) as { data: string } | undefined;
|
||||
return fallback?.data ? safeParse<T>(fallback.data) : null;
|
||||
}
|
||||
|
||||
private evictOldEntries(type: string): void {
|
||||
try {
|
||||
this.evictByType.run(type, type, this.maxEntriesPerType);
|
||||
this.purgeOrphanKeys.run(type, type);
|
||||
} catch {
|
||||
// Best-effort eviction; don't propagate.
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
function pickPrimary(candidates: (string | undefined)[]): string {
|
||||
for (const c of candidates) {
|
||||
if (c && c.length > 0) return c;
|
||||
}
|
||||
return '';
|
||||
}
|
||||
|
||||
function safeParse<T>(json: string): T | null {
|
||||
try {
|
||||
return JSON.parse(json) as T;
|
||||
} catch {
|
||||
return null;
|
||||
}
|
||||
}
|
||||
@@ -150,9 +150,11 @@ async function segmentToElement(type: string, data: Record<string, unknown>, opt
|
||||
};
|
||||
}
|
||||
case 'record': {
|
||||
const source = String(data.file ?? data.url ?? data.path ?? '');
|
||||
if (!source) return null;
|
||||
return {
|
||||
type: 'record',
|
||||
url: String(data.file ?? data.url ?? ''),
|
||||
url: source,
|
||||
};
|
||||
}
|
||||
case 'video': {
|
||||
|
||||
65
packages/core/src/onebot/network/adapter.ts
Normal file
65
packages/core/src/onebot/network/adapter.ts
Normal file
@@ -0,0 +1,65 @@
|
||||
// Base abstractions for OneBot network adapters.
|
||||
//
|
||||
// Modeled on NapCat's `IOB11NetworkAdapter` so each entry under
|
||||
// `config.networks.{httpServers,httpClients,wsServers,wsClients}` becomes
|
||||
// exactly one adapter instance, identified by `name`. The previous design
|
||||
// rolled multiple servers/clients into a single transport class; the
|
||||
// per-entry split makes hot-reload, lifecycle, and event isolation much
|
||||
// simpler to reason about.
|
||||
|
||||
import type { ApiHandler } from '../api-handler';
|
||||
import type { JsonObject, NetworkBase } from '../types';
|
||||
import type { DispatchPayload } from '../event-filter';
|
||||
|
||||
export interface NetworkAdapterContext {
|
||||
/** Self UIN as string — written into outbound headers. */
|
||||
uin: string;
|
||||
/** Shared API dispatcher used by request/response style adapters. */
|
||||
api: ApiHandler;
|
||||
/** Build a lifecycle event payload (connect/enable/disable). */
|
||||
buildLifecycleEvent(subType: 'connect' | 'enable' | 'disable'): JsonObject;
|
||||
/** Build a heartbeat event payload. */
|
||||
buildHeartbeatEvent(): JsonObject;
|
||||
}
|
||||
|
||||
export enum NetworkReloadType {
|
||||
/** Configuration unchanged or only soft fields updated. */
|
||||
Normal = 0,
|
||||
/** Underlying socket/listener restarted in place. */
|
||||
Reopened = 1,
|
||||
/** Was running, now closed. */
|
||||
Closed = 2,
|
||||
/** Was idle, now opened. */
|
||||
Opened = 3,
|
||||
}
|
||||
|
||||
export abstract class IOneBotNetworkAdapter<C extends NetworkBase> {
|
||||
readonly name: string;
|
||||
protected config: C;
|
||||
protected readonly ctx: NetworkAdapterContext;
|
||||
protected isEnabled = false;
|
||||
|
||||
constructor(name: string, config: C, ctx: NetworkAdapterContext) {
|
||||
this.name = name;
|
||||
// Defensive copy so reload diffs never mutate the caller's object.
|
||||
this.config = structuredClone(config);
|
||||
this.ctx = ctx;
|
||||
}
|
||||
|
||||
/** Whether the adapter is currently accepting/relaying events. */
|
||||
get isActive(): boolean { return this.isEnabled; }
|
||||
|
||||
/** Snapshot of the active config (read-only). */
|
||||
get currentConfig(): Readonly<C> { return this.config; }
|
||||
|
||||
abstract open(): void | Promise<void>;
|
||||
abstract close(): void | Promise<void>;
|
||||
abstract reload(config: C): NetworkReloadType | Promise<NetworkReloadType>;
|
||||
|
||||
/**
|
||||
* Receive one fully-shaped OneBot event for forwarding. Adapters that
|
||||
* don't push events (e.g. HTTP request-response servers) override with a
|
||||
* no-op.
|
||||
*/
|
||||
abstract onEvent(event: JsonObject, payload: DispatchPayload): void | Promise<void>;
|
||||
}
|
||||
136
packages/core/src/onebot/network/http-post-adapter.ts
Normal file
136
packages/core/src/onebot/network/http-post-adapter.ts
Normal file
@@ -0,0 +1,136 @@
|
||||
// Outbound HTTP webhook adapter — one instance per `httpClients[]` entry.
|
||||
//
|
||||
// Forwards every event to the configured URL via HTTP POST and interprets
|
||||
// any JSON response body as a OneBot v11 quick-operation.
|
||||
|
||||
import type { HttpClientNetwork, JsonObject } from '../types';
|
||||
import {
|
||||
pickDispatchJson,
|
||||
resolveReportOptions,
|
||||
type DispatchPayload,
|
||||
type EventReportOptions,
|
||||
} from '../event-filter';
|
||||
import { createLogger } from '../../utils/logger';
|
||||
import { IOneBotNetworkAdapter, NetworkReloadType, type NetworkAdapterContext } from './adapter';
|
||||
import { executeQuickOperation } from './quick-operation';
|
||||
|
||||
const log = createLogger('OneBot.POST');
|
||||
const DEFAULT_TIMEOUT_MS = 5000;
|
||||
|
||||
export class HttpPostAdapter extends IOneBotNetworkAdapter<HttpClientNetwork> {
|
||||
private options: EventReportOptions;
|
||||
private signature_: string;
|
||||
|
||||
constructor(name: string, config: HttpClientNetwork, ctx: NetworkAdapterContext) {
|
||||
super(name, config, ctx);
|
||||
this.options = resolveReportOptions(config);
|
||||
this.signature_ = bindingSignature(config);
|
||||
}
|
||||
|
||||
override get isActive(): boolean {
|
||||
return this.isEnabled;
|
||||
}
|
||||
|
||||
open(): void {
|
||||
if (this.config.enabled === false) return;
|
||||
if (!this.config.url) return;
|
||||
this.isEnabled = true;
|
||||
}
|
||||
|
||||
close(): void {
|
||||
this.isEnabled = false;
|
||||
}
|
||||
|
||||
async reload(next: HttpClientNetwork): Promise<NetworkReloadType> {
|
||||
const wasEnabled = this.isEnabled;
|
||||
const willEnable = next.enabled !== false && !!next.url;
|
||||
|
||||
this.config = structuredClone(next);
|
||||
this.options = resolveReportOptions(next);
|
||||
const newSig = bindingSignature(next);
|
||||
const sigChanged = newSig !== this.signature_;
|
||||
this.signature_ = newSig;
|
||||
|
||||
if (sigChanged && wasEnabled) {
|
||||
this.close();
|
||||
if (willEnable) {
|
||||
this.open();
|
||||
return NetworkReloadType.Reopened;
|
||||
}
|
||||
return NetworkReloadType.Closed;
|
||||
}
|
||||
if (!wasEnabled && willEnable) {
|
||||
this.open();
|
||||
return NetworkReloadType.Opened;
|
||||
}
|
||||
if (wasEnabled && !willEnable) {
|
||||
this.close();
|
||||
return NetworkReloadType.Closed;
|
||||
}
|
||||
return NetworkReloadType.Normal;
|
||||
}
|
||||
|
||||
onEvent(event: JsonObject, payload: DispatchPayload): void {
|
||||
if (!this.isEnabled) return;
|
||||
const json = pickDispatchJson(payload, this.options);
|
||||
if (json === null) return;
|
||||
void this.postEvent(json, event);
|
||||
}
|
||||
|
||||
private async postEvent(payload: string, event: JsonObject): Promise<void> {
|
||||
if (!this.isEnabled) return;
|
||||
|
||||
const headers: Record<string, string> = {
|
||||
'Content-Type': 'application/json',
|
||||
'User-Agent': 'OneBot',
|
||||
'X-Self-ID': this.ctx.uin,
|
||||
};
|
||||
if (this.config.accessToken) {
|
||||
headers['X-Signature'] = await computeHmacSha1(this.config.accessToken, payload);
|
||||
}
|
||||
|
||||
const timeoutMs = this.config.timeoutMs ?? DEFAULT_TIMEOUT_MS;
|
||||
try {
|
||||
const response = await fetch(this.config.url, {
|
||||
method: 'POST',
|
||||
headers,
|
||||
body: payload,
|
||||
signal: AbortSignal.timeout(timeoutMs),
|
||||
});
|
||||
if (response.ok) {
|
||||
const contentType = response.headers.get('content-type') ?? '';
|
||||
if (contentType.includes('application/json')) {
|
||||
const body = await response.text();
|
||||
if (body.trim()) {
|
||||
await this.handleQuickOperation(event, body);
|
||||
}
|
||||
}
|
||||
} else {
|
||||
log.warn('[%s] POST %s returned %d', this.name, this.config.url, response.status);
|
||||
}
|
||||
} catch (error) {
|
||||
if (this.isEnabled) {
|
||||
log.warn('[%s] POST %s failed: %s', this.name, this.config.url, error instanceof Error ? error.message : String(error));
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
private async handleQuickOperation(event: JsonObject, responseBody: string): Promise<void> {
|
||||
try {
|
||||
const operation = JSON.parse(responseBody) as Record<string, unknown>;
|
||||
if (!operation || typeof operation !== 'object') return;
|
||||
await executeQuickOperation(event, operation, this.ctx.api);
|
||||
} catch (error) {
|
||||
log.warn('[%s] quick operation failed: %s', this.name, error instanceof Error ? error.message : String(error));
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
function bindingSignature(net: HttpClientNetwork): string {
|
||||
return `${net.url}#${net.accessToken ?? ''}#${net.timeoutMs ?? DEFAULT_TIMEOUT_MS}`;
|
||||
}
|
||||
|
||||
async function computeHmacSha1(secret: string, payload: string): Promise<string> {
|
||||
const { createHmac } = await import('crypto');
|
||||
return 'sha1=' + createHmac('sha1', secret).update(payload).digest('hex');
|
||||
}
|
||||
203
packages/core/src/onebot/network/http-server-adapter.ts
Normal file
203
packages/core/src/onebot/network/http-server-adapter.ts
Normal file
@@ -0,0 +1,203 @@
|
||||
// Inbound HTTP API server — one instance per `httpServers[]` entry.
|
||||
//
|
||||
// Pure request/response: incoming POST/GET maps to `ApiHandler.handle`,
|
||||
// the response body is JSON-serialized back. `onEvent` is a deliberate
|
||||
// no-op since this transport never pushes events.
|
||||
|
||||
import {
|
||||
createServer,
|
||||
type IncomingMessage,
|
||||
type Server,
|
||||
type ServerResponse,
|
||||
} from 'http';
|
||||
import type { HttpServerNetwork, JsonObject, JsonValue } from '../types';
|
||||
import type { DispatchPayload } from '../event-filter';
|
||||
import { createLogger } from '../../utils/logger';
|
||||
import { IOneBotNetworkAdapter, NetworkReloadType, type NetworkAdapterContext } from './adapter';
|
||||
import { isAuthorized, normalizePath } from './utils';
|
||||
|
||||
const log = createLogger('OneBot.HTTP');
|
||||
|
||||
export class HttpServerAdapter extends IOneBotNetworkAdapter<HttpServerNetwork> {
|
||||
private server: Server | null = null;
|
||||
|
||||
override get isActive(): boolean {
|
||||
// HTTP server never receives events — `isActive` purely tracks the
|
||||
// bound listener so the network manager can skip dispatch cleanly.
|
||||
return this.isEnabled;
|
||||
}
|
||||
|
||||
open(): void {
|
||||
if (this.isEnabled) return;
|
||||
if (this.config.enabled === false) return;
|
||||
this.startServer();
|
||||
this.isEnabled = true;
|
||||
}
|
||||
|
||||
close(): void {
|
||||
if (!this.isEnabled && !this.server) return;
|
||||
this.isEnabled = false;
|
||||
this.server?.close();
|
||||
this.server = null;
|
||||
}
|
||||
|
||||
async reload(next: HttpServerNetwork): Promise<NetworkReloadType> {
|
||||
const prevSig = bindingSignature(this.config);
|
||||
const wasEnabled = this.isEnabled;
|
||||
const willEnable = next.enabled !== false;
|
||||
|
||||
this.config = structuredClone(next);
|
||||
|
||||
const sigChanged = prevSig !== bindingSignature(next);
|
||||
if (sigChanged && wasEnabled) {
|
||||
this.close();
|
||||
if (willEnable) {
|
||||
this.open();
|
||||
return NetworkReloadType.Reopened;
|
||||
}
|
||||
return NetworkReloadType.Closed;
|
||||
}
|
||||
if (!wasEnabled && willEnable) {
|
||||
this.open();
|
||||
return NetworkReloadType.Opened;
|
||||
}
|
||||
if (wasEnabled && !willEnable) {
|
||||
this.close();
|
||||
return NetworkReloadType.Closed;
|
||||
}
|
||||
return NetworkReloadType.Normal;
|
||||
}
|
||||
|
||||
// HTTP server only acts on inbound requests; it doesn't push events.
|
||||
onEvent(_event: JsonObject, _payload: DispatchPayload): void { /* no-op */ }
|
||||
|
||||
private startServer(): void {
|
||||
const expectedPath = normalizePath(this.config.path ?? '/');
|
||||
const accessToken = this.config.accessToken ?? '';
|
||||
|
||||
const server = createServer((req, res) => {
|
||||
void this.handleRequest(expectedPath, accessToken, req, res);
|
||||
});
|
||||
this.server = server;
|
||||
|
||||
server.on('listening', () => {
|
||||
log.success(
|
||||
'[%s] listening %s:%d%s',
|
||||
this.name,
|
||||
this.config.host ?? '0.0.0.0',
|
||||
this.config.port,
|
||||
expectedPath,
|
||||
);
|
||||
});
|
||||
server.on('error', (err) => {
|
||||
log.warn('[%s] server error: %s', this.name, err instanceof Error ? err.message : String(err));
|
||||
});
|
||||
|
||||
server.listen(this.config.port, this.config.host ?? '0.0.0.0');
|
||||
}
|
||||
|
||||
private async handleRequest(expectedPath: string, accessToken: string, req: IncomingMessage, res: ServerResponse): Promise<void> {
|
||||
const parsedUrl = new URL(req.url ?? '/', 'http://127.0.0.1');
|
||||
const incomingPath = parsedUrl.pathname;
|
||||
|
||||
const ep = expectedPath.endsWith('/') ? expectedPath : expectedPath + '/';
|
||||
let action = '';
|
||||
if (incomingPath === expectedPath || incomingPath === expectedPath + '/') {
|
||||
action = '';
|
||||
} else if (incomingPath.startsWith(ep)) {
|
||||
action = incomingPath.substring(ep.length);
|
||||
} else {
|
||||
writeJson(res, 404, { status: 'failed', retcode: 1404, data: null, wording: 'not found' });
|
||||
return;
|
||||
}
|
||||
|
||||
if (!isAuthorized(req, accessToken)) {
|
||||
writeJson(res, 401, { status: 'failed', retcode: 1401, data: null, wording: 'unauthorized' });
|
||||
return;
|
||||
}
|
||||
|
||||
if (req.method === 'GET' && !action) {
|
||||
writeJson(res, 200, { status: 'ok', retcode: 0, data: { online: true } });
|
||||
return;
|
||||
}
|
||||
|
||||
try {
|
||||
let params: Record<string, unknown> = {};
|
||||
let echo: unknown;
|
||||
|
||||
if (req.method === 'GET') {
|
||||
parsedUrl.searchParams.forEach((value, key) => {
|
||||
try {
|
||||
params[key] = JSON.parse(value);
|
||||
} catch {
|
||||
params[key] = value;
|
||||
}
|
||||
});
|
||||
} else if (req.method === 'POST') {
|
||||
const bodyContent = await readRequestBody(req);
|
||||
if (bodyContent.trim()) {
|
||||
try {
|
||||
const parsedBody = JSON.parse(bodyContent);
|
||||
if (typeof parsedBody === 'object' && parsedBody !== null && !Array.isArray(parsedBody)) {
|
||||
if (parsedBody.action && !action) action = String(parsedBody.action);
|
||||
if (parsedBody.params && typeof parsedBody.params === 'object' && !Array.isArray(parsedBody.params)) {
|
||||
params = parsedBody.params as Record<string, unknown>;
|
||||
} else {
|
||||
params = parsedBody as Record<string, unknown>;
|
||||
}
|
||||
echo = parsedBody.echo;
|
||||
}
|
||||
} catch {
|
||||
writeJson(res, 400, { status: 'failed', retcode: 1400, data: null, wording: 'bad request: invalid json' });
|
||||
return;
|
||||
}
|
||||
}
|
||||
} else {
|
||||
writeJson(res, 405, { status: 'failed', retcode: 1400, data: null, wording: 'method not allowed' });
|
||||
return;
|
||||
}
|
||||
|
||||
if (!action) {
|
||||
writeJson(res, 400, { status: 'failed', retcode: 1400, data: null, wording: 'bad request: missing action' });
|
||||
return;
|
||||
}
|
||||
|
||||
const response = await this.ctx.api.handle(action, params as JsonObject);
|
||||
if (echo !== undefined) {
|
||||
response.echo = echo as JsonValue;
|
||||
}
|
||||
writeJson(res, 200, response);
|
||||
} catch (error) {
|
||||
const wording = error instanceof Error ? error.message : 'internal error';
|
||||
writeJson(res, 500, { status: 'failed', retcode: 1200, data: null, wording });
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
function bindingSignature(net: HttpServerNetwork): string {
|
||||
return `${net.host ?? '0.0.0.0'}:${net.port}${normalizePath(net.path ?? '/')}#${net.accessToken ?? ''}`;
|
||||
}
|
||||
|
||||
function readRequestBody(req: IncomingMessage, maxBytes = 2 * 1024 * 1024): Promise<string> {
|
||||
return new Promise((resolve, reject) => {
|
||||
const chunks: Buffer[] = [];
|
||||
let total = 0;
|
||||
req.on('data', (chunk: Buffer) => {
|
||||
total += chunk.length;
|
||||
if (total > maxBytes) {
|
||||
reject(new Error('request body too large'));
|
||||
req.destroy();
|
||||
return;
|
||||
}
|
||||
chunks.push(chunk);
|
||||
});
|
||||
req.on('end', () => resolve(Buffer.concat(chunks).toString('utf8')));
|
||||
req.on('error', reject);
|
||||
});
|
||||
}
|
||||
|
||||
function writeJson(res: ServerResponse, statusCode: number, data: unknown): void {
|
||||
res.statusCode = statusCode;
|
||||
res.setHeader('Content-Type', 'application/json; charset=utf-8');
|
||||
res.end(JSON.stringify(data));
|
||||
}
|
||||
9
packages/core/src/onebot/network/index.ts
Normal file
9
packages/core/src/onebot/network/index.ts
Normal file
@@ -0,0 +1,9 @@
|
||||
// Public surface for the OneBot network package.
|
||||
|
||||
export { IOneBotNetworkAdapter, NetworkReloadType, type NetworkAdapterContext } from './adapter';
|
||||
export { OneBotNetworkManager } from './network-manager';
|
||||
export { WsServerAdapter } from './ws-server-adapter';
|
||||
export { WsClientAdapter } from './ws-client-adapter';
|
||||
export { HttpServerAdapter } from './http-server-adapter';
|
||||
export { HttpPostAdapter } from './http-post-adapter';
|
||||
export { executeQuickOperation } from './quick-operation';
|
||||
105
packages/core/src/onebot/network/network-manager.ts
Normal file
105
packages/core/src/onebot/network/network-manager.ts
Normal file
@@ -0,0 +1,105 @@
|
||||
// OneBot network manager.
|
||||
//
|
||||
// Mirrors NapCat's `OB11NetworkManager`: holds a `Map<name, adapter>`, fans
|
||||
// events out to every active adapter in parallel, and provides primitives
|
||||
// the OneBot instance uses to register, hot-reload, and tear adapters down.
|
||||
|
||||
import type { JsonObject, NetworkBase } from '../types';
|
||||
import { buildDispatchPayload } from '../event-filter';
|
||||
import { IOneBotNetworkAdapter } from './adapter';
|
||||
import { createLogger } from '../../utils/logger';
|
||||
|
||||
const log = createLogger('OneBot.Network');
|
||||
|
||||
type AnyAdapter = IOneBotNetworkAdapter<NetworkBase>;
|
||||
|
||||
export class OneBotNetworkManager {
|
||||
private readonly adapters = new Map<string, AnyAdapter>();
|
||||
|
||||
register<C extends NetworkBase>(adapter: IOneBotNetworkAdapter<C>): void {
|
||||
const existing = this.adapters.get(adapter.name);
|
||||
if (existing) {
|
||||
// Replacing an adapter under the same name — close the previous one
|
||||
// before storing the new instance to keep ports/sockets clean.
|
||||
log.info('replacing adapter [%s]', adapter.name);
|
||||
void Promise.resolve(existing.close()).catch(() => { /* best-effort */ });
|
||||
}
|
||||
this.adapters.set(adapter.name, adapter as AnyAdapter);
|
||||
}
|
||||
|
||||
has(name: string): boolean { return this.adapters.has(name); }
|
||||
|
||||
get(name: string): AnyAdapter | null {
|
||||
return this.adapters.get(name) ?? null;
|
||||
}
|
||||
|
||||
list(): AnyAdapter[] { return [...this.adapters.values()]; }
|
||||
|
||||
hasActiveAdapters(): boolean {
|
||||
for (const a of this.adapters.values()) if (a.isActive) return true;
|
||||
return false;
|
||||
}
|
||||
|
||||
async openAll(): Promise<void> {
|
||||
const tasks = this.list().map(async (a) => {
|
||||
try {
|
||||
await a.open();
|
||||
} catch (err) {
|
||||
log.error('adapter [%s] open failed: %s', a.name, errMessage(err));
|
||||
}
|
||||
});
|
||||
await Promise.all(tasks);
|
||||
}
|
||||
|
||||
async closeAll(): Promise<void> {
|
||||
const tasks = this.list().map(async (a) => {
|
||||
try {
|
||||
await a.close();
|
||||
} catch (err) {
|
||||
log.warn('adapter [%s] close failed: %s', a.name, errMessage(err));
|
||||
}
|
||||
});
|
||||
await Promise.all(tasks);
|
||||
this.adapters.clear();
|
||||
}
|
||||
|
||||
async closeOne(name: string): Promise<void> {
|
||||
const adapter = this.adapters.get(name);
|
||||
if (!adapter) return;
|
||||
this.adapters.delete(name);
|
||||
try {
|
||||
await adapter.close();
|
||||
} catch (err) {
|
||||
log.warn('adapter [%s] close failed: %s', adapter.name, errMessage(err));
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Dispatch one canonical OneBot event to every active adapter in parallel.
|
||||
* The dispatch payload is built once so each adapter pays only the cost
|
||||
* of picking the right pre-serialized variant.
|
||||
*
|
||||
* Errors thrown inside an adapter are isolated — one bad adapter never
|
||||
* blocks the others.
|
||||
*/
|
||||
async emitEvent(event: JsonObject): Promise<void> {
|
||||
if (!this.hasActiveAdapters()) return;
|
||||
const payload = buildDispatchPayload(event);
|
||||
const tasks: Promise<unknown>[] = [];
|
||||
for (const adapter of this.adapters.values()) {
|
||||
if (!adapter.isActive) continue;
|
||||
tasks.push(
|
||||
Promise.resolve()
|
||||
.then(() => adapter.onEvent(event, payload))
|
||||
.catch((err) => {
|
||||
log.warn('adapter [%s] onEvent error: %s', adapter.name, errMessage(err));
|
||||
}),
|
||||
);
|
||||
}
|
||||
await Promise.allSettled(tasks);
|
||||
}
|
||||
}
|
||||
|
||||
function errMessage(err: unknown): string {
|
||||
return err instanceof Error ? err.message : String(err);
|
||||
}
|
||||
89
packages/core/src/onebot/network/quick-operation.ts
Normal file
89
packages/core/src/onebot/network/quick-operation.ts
Normal file
@@ -0,0 +1,89 @@
|
||||
// OneBot v11 hidden API: `.handle_quick_operation`.
|
||||
//
|
||||
// When an HTTP POST event report receives a JSON body in response, that body
|
||||
// is interpreted as a "quick operation" — short-cuts to common follow-up
|
||||
// API calls (reply, recall, ban, kick, approve/reject). Spec:
|
||||
// https://github.com/botuniverse/onebot-11/blob/master/api/hidden.md
|
||||
|
||||
import type { ApiHandler } from '../api-handler';
|
||||
import type { JsonObject, JsonValue } from '../types';
|
||||
|
||||
export async function executeQuickOperation(
|
||||
event: JsonObject,
|
||||
operation: Record<string, unknown>,
|
||||
api: ApiHandler,
|
||||
): Promise<void> {
|
||||
const postType = event.post_type as string;
|
||||
|
||||
if (postType === 'message') {
|
||||
if (operation.reply !== undefined && operation.reply !== null && operation.reply !== '') {
|
||||
const messageType = event.message_type as string;
|
||||
const autoEscape = !!operation.auto_escape;
|
||||
|
||||
if (messageType === 'group') {
|
||||
const params: JsonObject = {
|
||||
group_id: event.group_id as number,
|
||||
message: operation.reply as JsonValue,
|
||||
auto_escape: autoEscape,
|
||||
};
|
||||
if (operation.at_sender !== false && event.user_id) {
|
||||
const atSegment = { type: 'at', data: { qq: String(event.user_id) } };
|
||||
if (typeof operation.reply === 'string') {
|
||||
params.message = [atSegment, { type: 'text', data: { text: operation.reply as string } }] as JsonValue;
|
||||
params.auto_escape = false;
|
||||
} else if (Array.isArray(operation.reply)) {
|
||||
params.message = [atSegment, ...(operation.reply as unknown[])] as JsonValue;
|
||||
}
|
||||
}
|
||||
await api.handle('send_group_msg', params);
|
||||
} else if (messageType === 'private') {
|
||||
await api.handle('send_private_msg', {
|
||||
user_id: event.user_id as number,
|
||||
message: operation.reply as JsonValue,
|
||||
auto_escape: autoEscape,
|
||||
});
|
||||
}
|
||||
}
|
||||
|
||||
if (operation.delete) {
|
||||
await api.handle('delete_msg', { message_id: event.message_id as number });
|
||||
}
|
||||
|
||||
if (operation.ban && event.message_type === 'group') {
|
||||
const duration = typeof operation.ban_duration === 'number' ? operation.ban_duration : 1800;
|
||||
await api.handle('set_group_ban', {
|
||||
group_id: event.group_id as number,
|
||||
user_id: event.user_id as number,
|
||||
duration: duration as JsonValue,
|
||||
});
|
||||
}
|
||||
|
||||
if (operation.kick && event.message_type === 'group') {
|
||||
await api.handle('set_group_kick', {
|
||||
group_id: event.group_id as number,
|
||||
user_id: event.user_id as number,
|
||||
reject_add_request: !!operation.reject_add_request,
|
||||
});
|
||||
}
|
||||
}
|
||||
|
||||
if (postType === 'request') {
|
||||
if (operation.approve !== undefined) {
|
||||
const requestType = event.request_type as string;
|
||||
if (requestType === 'friend') {
|
||||
await api.handle('set_friend_add_request', {
|
||||
flag: event.flag as string,
|
||||
approve: operation.approve as JsonValue,
|
||||
remark: (operation.remark ?? '') as JsonValue,
|
||||
});
|
||||
} else if (requestType === 'group') {
|
||||
await api.handle('set_group_add_request', {
|
||||
flag: event.flag as string,
|
||||
sub_type: event.sub_type as string,
|
||||
approve: operation.approve as JsonValue,
|
||||
reason: (operation.reason ?? '') as JsonValue,
|
||||
});
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
59
packages/core/src/onebot/network/utils.ts
Normal file
59
packages/core/src/onebot/network/utils.ts
Normal file
@@ -0,0 +1,59 @@
|
||||
// Helpers shared between OneBot network adapters.
|
||||
|
||||
import type { IncomingMessage } from 'http';
|
||||
import type { WebSocket } from '@snowluma/websocket';
|
||||
|
||||
/** Validate a request's bearer token / `?access_token=` query against the configured token. */
|
||||
export function isAuthorized(request: IncomingMessage, token: string): boolean {
|
||||
if (!token) return true;
|
||||
const rawAuth = request.headers.authorization;
|
||||
const auth = Array.isArray(rawAuth) ? rawAuth[0] : rawAuth ?? '';
|
||||
if (auth === `Bearer ${token}`) return true;
|
||||
try {
|
||||
const url = new URL(request.url ?? '/', 'http://127.0.0.1');
|
||||
if (url.searchParams.get('access_token') === token) return true;
|
||||
} catch { /* ignore malformed URLs */ }
|
||||
return false;
|
||||
}
|
||||
|
||||
/** Convert anything ws can hand us into a UTF-8 string. */
|
||||
export function rawDataToString(raw: Buffer | string | ArrayBuffer | ArrayBufferView | Buffer[]): string {
|
||||
if (typeof raw === 'string') return raw;
|
||||
if (Buffer.isBuffer(raw)) return raw.toString('utf8');
|
||||
if (Array.isArray(raw)) return Buffer.concat(raw).toString('utf8');
|
||||
if (raw instanceof ArrayBuffer) return Buffer.from(new Uint8Array(raw)).toString('utf8');
|
||||
if (ArrayBuffer.isView(raw)) {
|
||||
return Buffer.from(raw.buffer, raw.byteOffset, raw.byteLength).toString('utf8');
|
||||
}
|
||||
return '';
|
||||
}
|
||||
|
||||
/** Best-effort send: drops payload if the socket isn't OPEN, reports send errors. */
|
||||
export function safeSend(socket: WebSocket, payload: string, onError?: (err: Error) => void): void {
|
||||
if (socket.readyState !== 1 /* WebSocket.OPEN */) return;
|
||||
socket.send(payload, (error?: Error | null) => {
|
||||
if (error && onError) onError(error);
|
||||
});
|
||||
}
|
||||
|
||||
/** Best-effort close, treats already-closed sockets as a no-op. */
|
||||
export function safeClose(socket: WebSocket, code = 1000, reason = 'normal'): void {
|
||||
if (socket.readyState === 3 /* CLOSED */ || socket.readyState === 2 /* CLOSING */) return;
|
||||
socket.close(code, reason);
|
||||
}
|
||||
|
||||
/** Normalize an HTTP/WS path to a comparable form (strip trailing slash, default to "/"). */
|
||||
export function normalizePath(pathValue: string | undefined): string {
|
||||
const path = (pathValue ?? '/').trim() || '/';
|
||||
if (path === '/') return '/';
|
||||
return path.endsWith('/') ? path.slice(0, -1) : path;
|
||||
}
|
||||
|
||||
/** Parse the `pathname` from a (potentially relative) WebSocket request URL. */
|
||||
export function parseRequestPath(urlValue: string): string {
|
||||
try {
|
||||
return new URL(urlValue, 'ws://127.0.0.1').pathname;
|
||||
} catch {
|
||||
return '/';
|
||||
}
|
||||
}
|
||||
177
packages/core/src/onebot/network/ws-client-adapter.ts
Normal file
177
packages/core/src/onebot/network/ws-client-adapter.ts
Normal file
@@ -0,0 +1,177 @@
|
||||
// Reverse (client) WebSocket adapter — one instance per `wsClients[]` entry.
|
||||
//
|
||||
// Connects out to a remote OneBot endpoint, manages reconnects, forwards
|
||||
// pushed events on `onEvent`, and dispatches incoming API messages to the
|
||||
// shared ApiHandler.
|
||||
|
||||
import { WebSocket } from '@snowluma/websocket';
|
||||
import type { WsClientNetwork, WsRole, JsonObject } from '../types';
|
||||
import {
|
||||
pickDispatchJson,
|
||||
resolveReportOptions,
|
||||
shapeEventForAdapter,
|
||||
type DispatchPayload,
|
||||
type EventReportOptions,
|
||||
} from '../event-filter';
|
||||
import { createLogger } from '../../utils/logger';
|
||||
import { IOneBotNetworkAdapter, NetworkReloadType, type NetworkAdapterContext } from './adapter';
|
||||
import { rawDataToString, safeClose, safeSend } from './utils';
|
||||
|
||||
const log = createLogger('OneBot.WS-Client');
|
||||
const DEFAULT_RECONNECT_INTERVAL_MS = 5000;
|
||||
|
||||
export class WsClientAdapter extends IOneBotNetworkAdapter<WsClientNetwork> {
|
||||
private socket: WebSocket | null = null;
|
||||
private reconnectTimer: NodeJS.Timeout | null = null;
|
||||
private options: EventReportOptions;
|
||||
private role: WsRole;
|
||||
private explicitlyClosed = false;
|
||||
|
||||
constructor(name: string, config: WsClientNetwork, ctx: NetworkAdapterContext) {
|
||||
super(name, config, ctx);
|
||||
this.options = resolveReportOptions(config);
|
||||
this.role = config.role ?? 'Universal';
|
||||
}
|
||||
|
||||
override get isActive(): boolean {
|
||||
return this.isEnabled;
|
||||
}
|
||||
|
||||
open(): void {
|
||||
if (this.isEnabled) return;
|
||||
if (this.config.enabled === false) return;
|
||||
if (!this.config.url) return;
|
||||
this.explicitlyClosed = false;
|
||||
this.isEnabled = true;
|
||||
this.connect();
|
||||
}
|
||||
|
||||
close(): void {
|
||||
this.explicitlyClosed = true;
|
||||
this.isEnabled = false;
|
||||
this.cancelReconnect();
|
||||
if (this.socket) {
|
||||
safeClose(this.socket);
|
||||
this.socket = null;
|
||||
}
|
||||
}
|
||||
|
||||
async reload(next: WsClientNetwork): Promise<NetworkReloadType> {
|
||||
const prevSig = bindingSignature(this.config);
|
||||
const wasEnabled = this.isEnabled;
|
||||
const willEnable = next.enabled !== false && !!next.url;
|
||||
|
||||
this.config = structuredClone(next);
|
||||
this.options = resolveReportOptions(next);
|
||||
this.role = next.role ?? 'Universal';
|
||||
|
||||
const sigChanged = prevSig !== bindingSignature(next);
|
||||
if (sigChanged && wasEnabled) {
|
||||
this.close();
|
||||
if (willEnable) {
|
||||
this.open();
|
||||
return NetworkReloadType.Reopened;
|
||||
}
|
||||
return NetworkReloadType.Closed;
|
||||
}
|
||||
if (!wasEnabled && willEnable) {
|
||||
this.open();
|
||||
return NetworkReloadType.Opened;
|
||||
}
|
||||
if (wasEnabled && !willEnable) {
|
||||
this.close();
|
||||
return NetworkReloadType.Closed;
|
||||
}
|
||||
return NetworkReloadType.Normal;
|
||||
}
|
||||
|
||||
onEvent(_event: JsonObject, payload: DispatchPayload): void {
|
||||
if (!this.isEnabled || !this.socket) return;
|
||||
if (this.role !== 'Event' && this.role !== 'Universal') return;
|
||||
const json = pickDispatchJson(payload, this.options);
|
||||
if (json === null) return;
|
||||
safeSend(this.socket, json);
|
||||
}
|
||||
|
||||
private connect(): void {
|
||||
if (this.explicitlyClosed) return;
|
||||
if (!this.config.url) return;
|
||||
if (this.socket) return;
|
||||
|
||||
const headers: Record<string, string> = {
|
||||
'User-Agent': 'OneBot/11',
|
||||
'X-Self-ID': this.ctx.uin,
|
||||
'X-Client-Role': this.role,
|
||||
};
|
||||
if (this.config.accessToken) {
|
||||
headers.Authorization = `Bearer ${this.config.accessToken}`;
|
||||
}
|
||||
|
||||
const socket = new WebSocket(this.config.url, { headers });
|
||||
this.socket = socket;
|
||||
|
||||
socket.on('open', () => {
|
||||
log.info('[%s] connected %s', this.name, this.config.url);
|
||||
this.sendBootstrapMetaEvents(socket);
|
||||
});
|
||||
|
||||
socket.on('message', (raw: Buffer) => {
|
||||
void this.handleApiMessage(socket, raw);
|
||||
});
|
||||
|
||||
socket.on('close', () => {
|
||||
this.socket = null;
|
||||
if (this.explicitlyClosed || !this.isEnabled) return;
|
||||
this.scheduleReconnect();
|
||||
});
|
||||
|
||||
socket.on('error', (err: Error) => {
|
||||
log.warn('[%s] error %s: %s', this.name, this.config.url, err instanceof Error ? err.message : String(err));
|
||||
});
|
||||
}
|
||||
|
||||
private scheduleReconnect(): void {
|
||||
if (this.reconnectTimer) return;
|
||||
if (this.explicitlyClosed) return;
|
||||
const interval = Math.max(1000, this.config.reconnectIntervalMs ?? DEFAULT_RECONNECT_INTERVAL_MS);
|
||||
const timer = setTimeout(() => {
|
||||
this.reconnectTimer = null;
|
||||
if (this.explicitlyClosed || !this.isEnabled) return;
|
||||
this.connect();
|
||||
}, interval);
|
||||
timer.unref?.();
|
||||
this.reconnectTimer = timer;
|
||||
}
|
||||
|
||||
private cancelReconnect(): void {
|
||||
if (!this.reconnectTimer) return;
|
||||
clearTimeout(this.reconnectTimer);
|
||||
this.reconnectTimer = null;
|
||||
}
|
||||
|
||||
private async handleApiMessage(socket: WebSocket, raw: Buffer | string): Promise<void> {
|
||||
if (this.role !== 'Api' && this.role !== 'Universal') return;
|
||||
const text = rawDataToString(raw);
|
||||
if (!text) return;
|
||||
const response = await this.ctx.api.processRequest(text);
|
||||
safeSend(socket, response);
|
||||
}
|
||||
|
||||
private sendBootstrapMetaEvents(socket: WebSocket): void {
|
||||
if (this.role !== 'Event' && this.role !== 'Universal') return;
|
||||
const events = [
|
||||
this.ctx.buildLifecycleEvent('connect'),
|
||||
this.ctx.buildLifecycleEvent('enable'),
|
||||
this.ctx.buildHeartbeatEvent(),
|
||||
];
|
||||
for (const event of events) {
|
||||
const shaped = shapeEventForAdapter(event, this.options);
|
||||
if (!shaped) continue;
|
||||
safeSend(socket, JSON.stringify(shaped));
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
function bindingSignature(net: WsClientNetwork): string {
|
||||
return `${net.url}#${net.role ?? 'Universal'}#${Math.max(1000, net.reconnectIntervalMs ?? DEFAULT_RECONNECT_INTERVAL_MS)}#${net.accessToken ?? ''}`;
|
||||
}
|
||||
187
packages/core/src/onebot/network/ws-server-adapter.ts
Normal file
187
packages/core/src/onebot/network/ws-server-adapter.ts
Normal file
@@ -0,0 +1,187 @@
|
||||
// Forward (server) WebSocket adapter — one instance per `wsServers[]` entry.
|
||||
//
|
||||
// Each adapter owns its own `WebSocketServer`, accepts inbound forward
|
||||
// connections (api / event / universal roles), and pushes events to all live
|
||||
// event-receiving sockets when `onEvent` fires.
|
||||
|
||||
import { WebSocket, WebSocketServer } from '@snowluma/websocket';
|
||||
import type { IncomingMessage } from 'http';
|
||||
import type { WsRole, WsServerNetwork, JsonObject } from '../types';
|
||||
import {
|
||||
pickDispatchJson,
|
||||
resolveReportOptions,
|
||||
shapeEventForAdapter,
|
||||
type DispatchPayload,
|
||||
type EventReportOptions,
|
||||
} from '../event-filter';
|
||||
import { createLogger } from '../../utils/logger';
|
||||
import { IOneBotNetworkAdapter, NetworkReloadType, type NetworkAdapterContext } from './adapter';
|
||||
import { isAuthorized, parseRequestPath, rawDataToString, safeClose, safeSend, normalizePath } from './utils';
|
||||
|
||||
const log = createLogger('OneBot.WS-Server');
|
||||
|
||||
interface ForwardConn {
|
||||
socket: WebSocket;
|
||||
role: WsRole;
|
||||
options: EventReportOptions;
|
||||
}
|
||||
|
||||
export class WsServerAdapter extends IOneBotNetworkAdapter<WsServerNetwork> {
|
||||
private wss: WebSocketServer | null = null;
|
||||
private connections = new Map<WebSocket, ForwardConn>();
|
||||
private options: EventReportOptions;
|
||||
|
||||
constructor(name: string, config: WsServerNetwork, ctx: NetworkAdapterContext) {
|
||||
super(name, config, ctx);
|
||||
this.options = resolveReportOptions(config);
|
||||
}
|
||||
|
||||
override get isActive(): boolean {
|
||||
return this.isEnabled;
|
||||
}
|
||||
|
||||
open(): void {
|
||||
if (this.isEnabled) return;
|
||||
if (this.config.enabled === false) return;
|
||||
this.startServer();
|
||||
this.isEnabled = true;
|
||||
}
|
||||
|
||||
close(): void {
|
||||
if (!this.isEnabled && this.connections.size === 0 && !this.wss) return;
|
||||
// Final lifecycle broadcast before tearing down so attached event clients
|
||||
// see the disable transition.
|
||||
const lifecycle = this.ctx.buildLifecycleEvent('disable');
|
||||
for (const conn of this.connections.values()) {
|
||||
if (conn.role === 'Api') continue;
|
||||
const shaped = shapeEventForAdapter(lifecycle, conn.options);
|
||||
if (!shaped) continue;
|
||||
safeSend(conn.socket, JSON.stringify(shaped));
|
||||
}
|
||||
|
||||
this.isEnabled = false;
|
||||
for (const ws of [...this.connections.keys()]) safeClose(ws);
|
||||
this.connections.clear();
|
||||
this.wss?.close();
|
||||
this.wss = null;
|
||||
}
|
||||
|
||||
async reload(next: WsServerNetwork): Promise<NetworkReloadType> {
|
||||
const prevSig = bindingSignature(this.config);
|
||||
const wasEnabled = this.isEnabled;
|
||||
const willEnable = next.enabled !== false;
|
||||
|
||||
this.config = structuredClone(next);
|
||||
this.options = resolveReportOptions(next);
|
||||
for (const conn of this.connections.values()) conn.options = this.options;
|
||||
|
||||
const sigChanged = prevSig !== bindingSignature(next);
|
||||
if (sigChanged && wasEnabled) {
|
||||
this.close();
|
||||
if (willEnable) {
|
||||
this.open();
|
||||
return NetworkReloadType.Reopened;
|
||||
}
|
||||
return NetworkReloadType.Closed;
|
||||
}
|
||||
if (!wasEnabled && willEnable) {
|
||||
this.open();
|
||||
return NetworkReloadType.Opened;
|
||||
}
|
||||
if (wasEnabled && !willEnable) {
|
||||
this.close();
|
||||
return NetworkReloadType.Closed;
|
||||
}
|
||||
return NetworkReloadType.Normal;
|
||||
}
|
||||
|
||||
onEvent(_event: JsonObject, payload: DispatchPayload): void {
|
||||
if (!this.isEnabled || this.connections.size === 0) return;
|
||||
for (const conn of this.connections.values()) {
|
||||
if (conn.role !== 'Event' && conn.role !== 'Universal') continue;
|
||||
const json = pickDispatchJson(payload, conn.options);
|
||||
if (json === null) continue;
|
||||
safeSend(conn.socket, json);
|
||||
}
|
||||
}
|
||||
|
||||
private startServer(): void {
|
||||
const wss = new WebSocketServer({
|
||||
host: this.config.host ?? '0.0.0.0',
|
||||
port: this.config.port,
|
||||
path: this.config.path ?? '/',
|
||||
});
|
||||
this.wss = wss;
|
||||
|
||||
wss.on('listening', () => {
|
||||
log.success(
|
||||
'[%s] listening %s:%d%s',
|
||||
this.name,
|
||||
this.config.host ?? '0.0.0.0',
|
||||
this.config.port,
|
||||
this.config.path ?? '/',
|
||||
);
|
||||
});
|
||||
|
||||
wss.on('error', (err: Error) => {
|
||||
log.warn('[%s] server error: %s', this.name, err instanceof Error ? err.message : String(err));
|
||||
});
|
||||
|
||||
wss.on('connection', (socket: WebSocket, request: IncomingMessage) => this.onConnection(socket, request));
|
||||
}
|
||||
|
||||
private onConnection(socket: WebSocket, request: IncomingMessage): void {
|
||||
if (!isAuthorized(request, this.config.accessToken ?? '')) {
|
||||
safeClose(socket, 1008, 'invalid access token');
|
||||
return;
|
||||
}
|
||||
|
||||
const role = this.config.role ?? classifyForwardRole(request);
|
||||
const conn: ForwardConn = { socket, role, options: this.options };
|
||||
this.connections.set(socket, conn);
|
||||
|
||||
socket.on('message', (raw: Buffer) => {
|
||||
void this.handleApiMessage(socket, role, raw);
|
||||
});
|
||||
socket.on('close', () => this.connections.delete(socket));
|
||||
socket.on('error', (err: Error) => {
|
||||
log.warn('[%s] socket error: %s', this.name, err instanceof Error ? err.message : String(err));
|
||||
});
|
||||
|
||||
if (role === 'Event' || role === 'Universal') {
|
||||
this.sendBootstrapMetaEvents(socket);
|
||||
}
|
||||
}
|
||||
|
||||
private async handleApiMessage(socket: WebSocket, role: WsRole, raw: Buffer | string): Promise<void> {
|
||||
if (role !== 'Api' && role !== 'Universal') return;
|
||||
const text = rawDataToString(raw);
|
||||
if (!text) return;
|
||||
const response = await this.ctx.api.processRequest(text);
|
||||
safeSend(socket, response);
|
||||
}
|
||||
|
||||
private sendBootstrapMetaEvents(socket: WebSocket): void {
|
||||
const events = [
|
||||
this.ctx.buildLifecycleEvent('connect'),
|
||||
this.ctx.buildLifecycleEvent('enable'),
|
||||
this.ctx.buildHeartbeatEvent(),
|
||||
];
|
||||
for (const event of events) {
|
||||
const shaped = shapeEventForAdapter(event, this.options);
|
||||
if (!shaped) continue;
|
||||
safeSend(socket, JSON.stringify(shaped));
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
function classifyForwardRole(request: IncomingMessage): WsRole {
|
||||
const path = parseRequestPath(request.url ?? '/');
|
||||
if (path.endsWith('/api')) return 'Api';
|
||||
if (path.endsWith('/event')) return 'Event';
|
||||
return 'Universal';
|
||||
}
|
||||
|
||||
function bindingSignature(net: WsServerNetwork): string {
|
||||
return `${net.host ?? '0.0.0.0'}:${net.port}${normalizePath(net.path)}#${net.role ?? 'auto'}#${net.accessToken ?? ''}`;
|
||||
}
|
||||
@@ -33,7 +33,7 @@ export type NetworkKind = 'httpServers' | 'httpClients' | 'wsServers' | 'wsClien
|
||||
* The `name` is a free-form identifier scoped to the adapter's array; it is
|
||||
* used for hot-reload bookkeeping and as a label in logs / WebUI.
|
||||
*/
|
||||
interface NetworkBase {
|
||||
export interface NetworkBase {
|
||||
name: string;
|
||||
/** When `false`, the adapter is configured but inactive. Defaults to `true`. */
|
||||
enabled?: boolean;
|
||||
|
||||
@@ -1,424 +0,0 @@
|
||||
import { WebSocket, WebSocketServer } from '@snowluma/websocket';
|
||||
import type { IncomingMessage } from 'http';
|
||||
import type { ApiHandler } from './api-handler';
|
||||
import type { JsonObject, OneBotConfig, WsClientNetwork, WsRole, WsServerNetwork } from './types';
|
||||
import { createLogger } from '../utils/logger';
|
||||
import {
|
||||
buildDispatchPayload,
|
||||
pickDispatchJson,
|
||||
resolveReportOptions,
|
||||
shapeEventForAdapter,
|
||||
type DispatchPayload,
|
||||
type EventReportOptions,
|
||||
} from './event-filter';
|
||||
|
||||
interface ForwardConnection {
|
||||
socket: WebSocket;
|
||||
role: WsRole;
|
||||
options: EventReportOptions;
|
||||
serverName: string;
|
||||
}
|
||||
|
||||
interface ReverseConnection {
|
||||
socket: WebSocket;
|
||||
role: WsRole;
|
||||
options: EventReportOptions;
|
||||
endpointUrl: string;
|
||||
reconnectIntervalMs: number;
|
||||
name: string;
|
||||
}
|
||||
|
||||
interface RunningWsServer {
|
||||
wss: WebSocketServer;
|
||||
signature: string;
|
||||
network: WsServerNetwork;
|
||||
options: EventReportOptions;
|
||||
}
|
||||
|
||||
interface RunningWsClient {
|
||||
network: WsClientNetwork;
|
||||
signature: string;
|
||||
options: EventReportOptions;
|
||||
}
|
||||
|
||||
export interface WsTransportContext {
|
||||
uin: string;
|
||||
api: ApiHandler;
|
||||
buildLifecycleEvent: (subType: 'connect' | 'enable' | 'disable') => JsonObject;
|
||||
buildHeartbeatEvent: () => JsonObject;
|
||||
}
|
||||
|
||||
const log = createLogger('OneBot.WS');
|
||||
|
||||
export class WsTransport {
|
||||
private readonly context: WsTransportContext;
|
||||
|
||||
private readonly servers = new Map<string, RunningWsServer>();
|
||||
private readonly clientStates = new Map<string, RunningWsClient>();
|
||||
private readonly forwardConnections = new Map<WebSocket, ForwardConnection>();
|
||||
private readonly reverseConnections = new Map<string, ReverseConnection>();
|
||||
private readonly reconnectTimers = new Map<string, NodeJS.Timeout>();
|
||||
private serverNetworks: WsServerNetwork[] = [];
|
||||
private clientNetworks: WsClientNetwork[] = [];
|
||||
private stopped = false;
|
||||
|
||||
constructor(config: OneBotConfig, context: WsTransportContext) {
|
||||
this.serverNetworks = activeServers(config);
|
||||
this.clientNetworks = activeClients(config);
|
||||
this.context = context;
|
||||
for (const network of this.clientNetworks) {
|
||||
this.clientStates.set(network.name, {
|
||||
network,
|
||||
signature: wsClientSignature(network),
|
||||
options: resolveReportOptions(network),
|
||||
});
|
||||
}
|
||||
}
|
||||
|
||||
start(): void {
|
||||
this.stopped = false;
|
||||
for (const network of this.serverNetworks) this.startServerEndpoint(network);
|
||||
for (const network of this.clientNetworks) this.startClientEndpoint(network.name);
|
||||
}
|
||||
|
||||
reloadConfig(config: OneBotConfig): void {
|
||||
const nextServers = activeServers(config);
|
||||
const nextClients = activeClients(config);
|
||||
const nextServerByName = new Map(nextServers.map((n) => [n.name, n] as const));
|
||||
const nextClientByName = new Map(nextClients.map((n) => [n.name, n] as const));
|
||||
|
||||
// --- WS Servers ---
|
||||
for (const [name, running] of [...this.servers]) {
|
||||
const next = nextServerByName.get(name);
|
||||
if (!next || wsServerSignature(next) !== running.signature) {
|
||||
running.wss.close();
|
||||
this.servers.delete(name);
|
||||
// Drop forward connections that belonged to the closed adapter.
|
||||
for (const [socket, conn] of [...this.forwardConnections]) {
|
||||
if (conn.serverName === name) {
|
||||
safeClose(socket);
|
||||
this.forwardConnections.delete(socket);
|
||||
}
|
||||
}
|
||||
log.info('stopped forward server [%s]', name);
|
||||
} else {
|
||||
// Same binding — refresh options so reload picks up format changes.
|
||||
running.network = next;
|
||||
running.options = resolveReportOptions(next);
|
||||
for (const conn of this.forwardConnections.values()) {
|
||||
if (conn.serverName === name) conn.options = running.options;
|
||||
}
|
||||
}
|
||||
}
|
||||
for (const network of nextServers) {
|
||||
if (!this.servers.has(network.name)) this.startServerEndpoint(network);
|
||||
}
|
||||
|
||||
// --- WS Clients (reverse) ---
|
||||
for (const [name, state] of [...this.clientStates]) {
|
||||
const next = nextClientByName.get(name);
|
||||
const sig = next ? wsClientSignature(next) : null;
|
||||
if (!next || sig !== state.signature) {
|
||||
const conn = this.reverseConnections.get(name);
|
||||
if (conn) {
|
||||
safeClose(conn.socket);
|
||||
this.reverseConnections.delete(name);
|
||||
}
|
||||
const timer = this.reconnectTimers.get(name);
|
||||
if (timer) {
|
||||
clearTimeout(timer);
|
||||
this.reconnectTimers.delete(name);
|
||||
}
|
||||
this.clientStates.delete(name);
|
||||
log.info('stopped reverse client [%s]', name);
|
||||
} else {
|
||||
state.network = next;
|
||||
state.options = resolveReportOptions(next);
|
||||
const conn = this.reverseConnections.get(name);
|
||||
if (conn) conn.options = state.options;
|
||||
}
|
||||
}
|
||||
for (const network of nextClients) {
|
||||
if (!this.clientStates.has(network.name)) {
|
||||
this.clientStates.set(network.name, {
|
||||
network,
|
||||
signature: wsClientSignature(network),
|
||||
options: resolveReportOptions(network),
|
||||
});
|
||||
if (!this.stopped) this.startClientEndpoint(network.name);
|
||||
}
|
||||
}
|
||||
|
||||
this.serverNetworks = nextServers;
|
||||
this.clientNetworks = nextClients;
|
||||
}
|
||||
|
||||
stop(): void {
|
||||
// Final lifecycle broadcast before we mark ourselves stopped.
|
||||
this.publishEvent(this.context.buildLifecycleEvent('disable'));
|
||||
this.stopped = true;
|
||||
|
||||
for (const timer of this.reconnectTimers.values()) {
|
||||
clearTimeout(timer);
|
||||
}
|
||||
this.reconnectTimers.clear();
|
||||
|
||||
for (const socket of this.forwardConnections.keys()) {
|
||||
safeClose(socket);
|
||||
}
|
||||
this.forwardConnections.clear();
|
||||
|
||||
for (const conn of this.reverseConnections.values()) {
|
||||
safeClose(conn.socket);
|
||||
}
|
||||
this.reverseConnections.clear();
|
||||
|
||||
for (const { wss } of this.servers.values()) {
|
||||
wss.close();
|
||||
}
|
||||
this.servers.clear();
|
||||
this.clientStates.clear();
|
||||
}
|
||||
|
||||
/**
|
||||
* Fan out one canonical event to every event-receiving WS connection.
|
||||
*
|
||||
* The instance pre-builds the {@link DispatchPayload} (two JSON variants at
|
||||
* most) so each connection is served with a single O(1) pick + send rather
|
||||
* than re-shaping or re-serializing the event itself. The raw `event` is
|
||||
* accepted so ad-hoc callers (e.g. `stop()`) can dispatch without allocating
|
||||
* a payload at the call site.
|
||||
*/
|
||||
publishEvent(event: JsonObject, payload?: DispatchPayload): void {
|
||||
const dispatch = payload ?? buildDispatchPayload(event);
|
||||
|
||||
for (const conn of this.forwardConnections.values()) {
|
||||
if (conn.role !== 'Event' && conn.role !== 'Universal') continue;
|
||||
const json = pickDispatchJson(dispatch, conn.options);
|
||||
if (json === null) continue;
|
||||
safeSend(conn.socket, json);
|
||||
}
|
||||
|
||||
for (const conn of this.reverseConnections.values()) {
|
||||
if (conn.role !== 'Event' && conn.role !== 'Universal') continue;
|
||||
const json = pickDispatchJson(dispatch, conn.options);
|
||||
if (json === null) continue;
|
||||
safeSend(conn.socket, json);
|
||||
}
|
||||
}
|
||||
|
||||
private startServerEndpoint(network: WsServerNetwork): void {
|
||||
const wss = new WebSocketServer({
|
||||
host: network.host ?? '0.0.0.0',
|
||||
port: network.port,
|
||||
path: network.path ?? '/',
|
||||
});
|
||||
|
||||
const running: RunningWsServer = {
|
||||
wss,
|
||||
signature: wsServerSignature(network),
|
||||
network,
|
||||
options: resolveReportOptions(network),
|
||||
};
|
||||
this.servers.set(network.name, running);
|
||||
|
||||
wss.on('listening', () => {
|
||||
log.success('[%s] listening %s:%d%s', network.name, network.host ?? '0.0.0.0', network.port, network.path ?? '/');
|
||||
});
|
||||
|
||||
wss.on('connection', (socket, request) => {
|
||||
if (!isAuthorized(request, running.network.accessToken ?? '')) {
|
||||
safeClose(socket, 1008, 'invalid access token');
|
||||
return;
|
||||
}
|
||||
|
||||
const role = running.network.role ?? classifyForwardRole(request);
|
||||
const conn: ForwardConnection = {
|
||||
socket,
|
||||
role,
|
||||
options: running.options,
|
||||
serverName: running.network.name,
|
||||
};
|
||||
this.forwardConnections.set(socket, conn);
|
||||
|
||||
socket.on('message', (raw: Buffer) => {
|
||||
void this.handleApiMessage(socket, role, raw);
|
||||
});
|
||||
|
||||
socket.on('close', () => {
|
||||
this.forwardConnections.delete(socket);
|
||||
});
|
||||
|
||||
socket.on('error', (error: Error) => {
|
||||
log.warn('[%s] forward socket error: %s', running.network.name, error instanceof Error ? error.message : String(error));
|
||||
});
|
||||
|
||||
this.sendBootstrapMetaEvents(socket, role, conn.options);
|
||||
});
|
||||
|
||||
wss.on('error', (error: Error) => {
|
||||
log.warn('[%s] server error: %s', network.name, error instanceof Error ? error.message : String(error));
|
||||
});
|
||||
}
|
||||
|
||||
private startClientEndpoint(name: string): void {
|
||||
const state = this.clientStates.get(name);
|
||||
if (!state || this.stopped) return;
|
||||
if (this.reverseConnections.has(name) || this.reconnectTimers.has(name)) return;
|
||||
|
||||
const network = state.network;
|
||||
const role = network.role ?? 'Universal';
|
||||
const headers: Record<string, string> = {
|
||||
'User-Agent': 'OneBot/11',
|
||||
'X-Self-ID': this.context.uin,
|
||||
'X-Client-Role': role,
|
||||
};
|
||||
if (network.accessToken) headers.Authorization = `Bearer ${network.accessToken}`;
|
||||
|
||||
const socket = new WebSocket(network.url, { headers });
|
||||
const conn: ReverseConnection = {
|
||||
socket,
|
||||
role,
|
||||
options: state.options,
|
||||
endpointUrl: network.url,
|
||||
reconnectIntervalMs: Math.max(1000, network.reconnectIntervalMs ?? 5000),
|
||||
name,
|
||||
};
|
||||
this.reverseConnections.set(name, conn);
|
||||
|
||||
socket.on('open', () => {
|
||||
log.info('[%s] reverse connected %s', name, network.url);
|
||||
this.sendBootstrapMetaEvents(socket, role, state.options);
|
||||
});
|
||||
|
||||
socket.on('message', (raw: Buffer) => {
|
||||
void this.handleApiMessage(socket, role, raw);
|
||||
});
|
||||
|
||||
socket.on('close', () => {
|
||||
this.reverseConnections.delete(name);
|
||||
if (this.stopped) return;
|
||||
if (!this.clientStates.has(name)) return;
|
||||
if (this.reconnectTimers.has(name)) return;
|
||||
|
||||
const timer = setTimeout(() => {
|
||||
this.reconnectTimers.delete(name);
|
||||
if (this.stopped || !this.clientStates.has(name)) return;
|
||||
this.startClientEndpoint(name);
|
||||
}, conn.reconnectIntervalMs);
|
||||
timer.unref?.();
|
||||
this.reconnectTimers.set(name, timer);
|
||||
});
|
||||
|
||||
socket.on('error', (error: Error) => {
|
||||
log.warn('[%s] reverse error %s: %s', name, network.url, error instanceof Error ? error.message : String(error));
|
||||
});
|
||||
}
|
||||
|
||||
private async handleApiMessage(socket: WebSocket, role: WsRole, raw: Buffer | string): Promise<void> {
|
||||
if (role !== 'Api' && role !== 'Universal') return;
|
||||
|
||||
const text = rawDataToString(raw);
|
||||
if (!text) return;
|
||||
|
||||
const response = await this.context.api.processRequest(text);
|
||||
safeSend(socket, response);
|
||||
}
|
||||
|
||||
private sendBootstrapMetaEvents(socket: WebSocket, role: WsRole, options: EventReportOptions): void {
|
||||
if (role !== 'Event' && role !== 'Universal') return;
|
||||
|
||||
const events = [
|
||||
this.context.buildLifecycleEvent('connect'),
|
||||
this.context.buildLifecycleEvent('enable'),
|
||||
this.context.buildHeartbeatEvent(),
|
||||
];
|
||||
for (const event of events) {
|
||||
const shaped = shapeEventForAdapter(event, options);
|
||||
if (!shaped) continue;
|
||||
safeSend(socket, JSON.stringify(shaped));
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
function classifyForwardRole(request: IncomingMessage): WsRole {
|
||||
const path = parseRequestPath(request.url ?? '/');
|
||||
if (path.endsWith('/api')) return 'Api';
|
||||
if (path.endsWith('/event')) return 'Event';
|
||||
return 'Universal';
|
||||
}
|
||||
|
||||
function parseRequestPath(urlValue: string): string {
|
||||
try {
|
||||
return new URL(urlValue, 'ws://127.0.0.1').pathname;
|
||||
} catch {
|
||||
return '/';
|
||||
}
|
||||
}
|
||||
|
||||
function normalizeWsPath(pathValue: string | undefined): string {
|
||||
const path = (pathValue ?? '/').trim() || '/';
|
||||
if (path === '/') return '/';
|
||||
return path.endsWith('/') ? path.slice(0, -1) : path;
|
||||
}
|
||||
|
||||
function activeServers(config: OneBotConfig): WsServerNetwork[] {
|
||||
return config.networks.wsServers.filter((n) => n.enabled !== false);
|
||||
}
|
||||
|
||||
function activeClients(config: OneBotConfig): WsClientNetwork[] {
|
||||
return config.networks.wsClients.filter((n) => n.enabled !== false && !!n.url);
|
||||
}
|
||||
|
||||
function wsServerSignature(network: WsServerNetwork): string {
|
||||
return `${network.host ?? '0.0.0.0'}:${network.port}${normalizeWsPath(network.path)}#${network.role ?? 'auto'}#${network.accessToken ?? ''}`;
|
||||
}
|
||||
|
||||
function wsClientSignature(network: WsClientNetwork): string {
|
||||
const role = network.role ?? 'Universal';
|
||||
const reconnectIntervalMs = Math.max(1000, network.reconnectIntervalMs ?? 5000);
|
||||
return `${network.url}#${role}#${reconnectIntervalMs}#${network.accessToken ?? ''}`;
|
||||
}
|
||||
|
||||
function isAuthorized(request: IncomingMessage, token: string): boolean {
|
||||
if (!token) return true;
|
||||
// 1. Header auth
|
||||
const rawAuth = request.headers.authorization;
|
||||
const auth = Array.isArray(rawAuth) ? rawAuth[0] : rawAuth ?? '';
|
||||
if (auth === `Bearer ${token}`) return true;
|
||||
|
||||
// 2. Query string auth
|
||||
try {
|
||||
const url = new URL(request.url ?? '/', 'ws://127.0.0.1');
|
||||
if (url.searchParams.get('access_token') === token) {
|
||||
return true;
|
||||
}
|
||||
} catch { }
|
||||
|
||||
return false;
|
||||
}
|
||||
|
||||
function rawDataToString(raw: Buffer | string | ArrayBuffer | ArrayBufferView | Buffer[]): string {
|
||||
if (typeof raw === 'string') return raw;
|
||||
if (Buffer.isBuffer(raw)) return raw.toString('utf8');
|
||||
if (Array.isArray(raw)) return Buffer.concat(raw).toString('utf8');
|
||||
if (raw instanceof ArrayBuffer) return Buffer.from(new Uint8Array(raw)).toString('utf8');
|
||||
if (ArrayBuffer.isView(raw)) {
|
||||
return Buffer.from(raw.buffer, raw.byteOffset, raw.byteLength).toString('utf8');
|
||||
}
|
||||
return '';
|
||||
}
|
||||
|
||||
function safeSend(socket: WebSocket, payload: string): void {
|
||||
if (socket.readyState !== WebSocket.OPEN) return;
|
||||
socket.send(payload, (error?: Error | null) => {
|
||||
if (error) {
|
||||
log.warn('send error: %s', error instanceof Error ? error.message : String(error));
|
||||
}
|
||||
});
|
||||
}
|
||||
|
||||
function safeClose(socket: WebSocket, code = 1000, reason = 'normal'): void {
|
||||
if (socket.readyState === WebSocket.CLOSED || socket.readyState === WebSocket.CLOSING) return;
|
||||
socket.close(code, reason);
|
||||
}
|
||||
@@ -78,21 +78,13 @@ export async function initWebUI(
|
||||
const auth = WebuiAuth.load();
|
||||
const initialPassword = auth.takeInitialPassword();
|
||||
if (auth.isDevMode()) {
|
||||
log.warn('=========================================');
|
||||
log.warn('WebUI 已进入开发模式 (SNOWLUMA_DEV_MODE=1)');
|
||||
log.warn('固定密码: %s', WebuiAuth.devPassword);
|
||||
log.warn('config/webui.json 不会被读写,强制改密流程已跳过');
|
||||
log.warn('请勿在生产环境启用此模式');
|
||||
log.warn('=========================================');
|
||||
log.warn('dev mode enabled: password=%s', WebuiAuth.devPassword);
|
||||
log.warn('dev mode skips config/webui.json and password rotation');
|
||||
} else if (initialPassword) {
|
||||
log.info('=========================================');
|
||||
log.info('WebUI 安全认证(首次启动,已生成临时密码)');
|
||||
log.info('默认用户: admin');
|
||||
log.info('临时密码: %s', initialPassword);
|
||||
log.info('请使用该密码登录后立即设置强密码(≥10 位、含大小写、特殊符号、不含空格)');
|
||||
log.info('=========================================');
|
||||
log.info('initial credentials: user=admin password=%s', initialPassword);
|
||||
log.info('password change required after first login');
|
||||
} else if (auth.mustChangePassword()) {
|
||||
log.warn('WebUI 仍未完成强制改密,登录后须立即修改密码。');
|
||||
log.warn('password change is still required');
|
||||
}
|
||||
|
||||
const app = new Hono();
|
||||
@@ -216,7 +208,7 @@ export async function initWebUI(
|
||||
sessionTokens.delete(tok);
|
||||
}
|
||||
}
|
||||
log.info('WebUI 密码已更新(强制改密流程完成)');
|
||||
log.info('password updated');
|
||||
return c.json({ success: true });
|
||||
});
|
||||
|
||||
@@ -458,12 +450,12 @@ export async function initWebUI(
|
||||
|
||||
const finalPort = await findAvailablePort(desiredPort);
|
||||
if (finalPort !== desiredPort) {
|
||||
log.warn('端口 %d 已被占用,已自动改用 %d', desiredPort, finalPort);
|
||||
log.warn('port %d is in use, using %d instead', desiredPort, finalPort);
|
||||
}
|
||||
|
||||
await new Promise<void>((resolve) => {
|
||||
serve({ fetch: app.fetch, port: finalPort }, (info) => {
|
||||
log.info(`WebUI 服务监听 http://localhost:${info.port}`);
|
||||
log.info(`listening http://localhost:${info.port}`);
|
||||
resolve();
|
||||
});
|
||||
});
|
||||
|
||||
135
packages/core/tests/bridge-event-bus.test.ts
Normal file
135
packages/core/tests/bridge-event-bus.test.ts
Normal file
@@ -0,0 +1,135 @@
|
||||
import { describe, expect, it, vi } from 'vitest';
|
||||
import { BridgeEventBus } from '../src/bridge/event-bus';
|
||||
import type { FriendMessage, GroupMessage } from '../src/bridge/events';
|
||||
|
||||
function makeFriendMessage(): FriendMessage {
|
||||
return {
|
||||
kind: 'friend_message',
|
||||
time: 1700000000,
|
||||
selfUin: 10001,
|
||||
senderUin: 22222,
|
||||
senderNick: 'peer',
|
||||
msgSeq: 1,
|
||||
msgId: 1,
|
||||
elements: [{ type: 'text', text: 'hi' }],
|
||||
};
|
||||
}
|
||||
|
||||
function makeGroupMessage(): GroupMessage {
|
||||
return {
|
||||
kind: 'group_message',
|
||||
time: 1700000000,
|
||||
selfUin: 10001,
|
||||
groupId: 99999,
|
||||
senderUin: 22222,
|
||||
senderNick: 'peer',
|
||||
senderCard: '',
|
||||
senderRole: 'member',
|
||||
msgSeq: 2,
|
||||
msgId: 2,
|
||||
elements: [{ type: 'text', text: 'hi' }],
|
||||
};
|
||||
}
|
||||
|
||||
describe('BridgeEventBus', () => {
|
||||
it('routes events only to subscribers of the matching kind', async () => {
|
||||
const bus = new BridgeEventBus();
|
||||
const friend = vi.fn();
|
||||
const group = vi.fn();
|
||||
bus.on('friend_message', friend);
|
||||
bus.on('group_message', group);
|
||||
|
||||
await bus.emit(makeFriendMessage());
|
||||
await bus.emit(makeGroupMessage());
|
||||
|
||||
expect(friend).toHaveBeenCalledTimes(1);
|
||||
expect(group).toHaveBeenCalledTimes(1);
|
||||
});
|
||||
|
||||
it('runs every subscriber in parallel for one kind', async () => {
|
||||
const bus = new BridgeEventBus();
|
||||
const order: string[] = [];
|
||||
bus.on('friend_message', async () => {
|
||||
await new Promise((r) => setTimeout(r, 20));
|
||||
order.push('slow');
|
||||
});
|
||||
bus.on('friend_message', () => {
|
||||
order.push('fast');
|
||||
});
|
||||
|
||||
await bus.emit(makeFriendMessage());
|
||||
// The synchronous handler must finish before the async one — proves we
|
||||
// don't serialize handlers across the kind.
|
||||
expect(order).toEqual(['fast', 'slow']);
|
||||
});
|
||||
|
||||
it('isolates handler errors and reports them via onError', async () => {
|
||||
const seen: Array<{ kind: string; err: unknown }> = [];
|
||||
const bus = new BridgeEventBus({ onError: (kind, err) => seen.push({ kind, err }) });
|
||||
const ok = vi.fn();
|
||||
bus.on('friend_message', () => {
|
||||
throw new Error('boom');
|
||||
});
|
||||
bus.on('friend_message', ok);
|
||||
|
||||
await bus.emit(makeFriendMessage());
|
||||
|
||||
expect(ok).toHaveBeenCalledTimes(1);
|
||||
expect(seen).toHaveLength(1);
|
||||
expect(seen[0].kind).toBe('friend_message');
|
||||
expect((seen[0].err as Error).message).toBe('boom');
|
||||
});
|
||||
|
||||
it('supports unsubscribe via the returned disposer', async () => {
|
||||
const bus = new BridgeEventBus();
|
||||
const handler = vi.fn();
|
||||
const off = bus.on('friend_message', handler);
|
||||
|
||||
await bus.emit(makeFriendMessage());
|
||||
expect(handler).toHaveBeenCalledTimes(1);
|
||||
|
||||
off();
|
||||
await bus.emit(makeFriendMessage());
|
||||
expect(handler).toHaveBeenCalledTimes(1);
|
||||
});
|
||||
|
||||
it('supports onAny and isolates its errors separately', async () => {
|
||||
const seen: Array<{ kind: string; err: unknown }> = [];
|
||||
const bus = new BridgeEventBus({ onError: (kind, err) => seen.push({ kind, err }) });
|
||||
const tap = vi.fn();
|
||||
bus.onAny(tap);
|
||||
bus.onAny(() => { throw new Error('any-fail'); });
|
||||
|
||||
await bus.emit(makeFriendMessage());
|
||||
await bus.emit(makeGroupMessage());
|
||||
|
||||
expect(tap).toHaveBeenCalledTimes(2);
|
||||
expect(seen).toHaveLength(2);
|
||||
expect(seen.every((s) => s.kind === '*')).toBe(true);
|
||||
});
|
||||
|
||||
it('reports has() based on per-kind + onAny subscriptions', () => {
|
||||
const bus = new BridgeEventBus();
|
||||
expect(bus.has('friend_message')).toBe(false);
|
||||
|
||||
const off = bus.on('friend_message', () => {});
|
||||
expect(bus.has('friend_message')).toBe(true);
|
||||
off();
|
||||
expect(bus.has('friend_message')).toBe(false);
|
||||
|
||||
bus.onAny(() => {});
|
||||
expect(bus.has('friend_message')).toBe(true);
|
||||
});
|
||||
|
||||
it('clear() drops every subscriber', async () => {
|
||||
const bus = new BridgeEventBus();
|
||||
const handler = vi.fn();
|
||||
bus.on('friend_message', handler);
|
||||
bus.onAny(handler);
|
||||
|
||||
bus.clear();
|
||||
await bus.emit(makeFriendMessage());
|
||||
|
||||
expect(handler).not.toHaveBeenCalled();
|
||||
});
|
||||
});
|
||||
193
packages/core/tests/event-pipeline.test.ts
Normal file
193
packages/core/tests/event-pipeline.test.ts
Normal file
@@ -0,0 +1,193 @@
|
||||
import { describe, expect, it, vi } from 'vitest';
|
||||
import { BridgeEventBus } from '../src/bridge/event-bus';
|
||||
import { EventConverter } from '../src/onebot/event-converter';
|
||||
import { registerEventPipeline } from '../src/onebot/event-pipeline';
|
||||
import type { OneBotInstanceContext } from '../src/onebot/instance-context';
|
||||
import type {
|
||||
FriendMessage,
|
||||
GroupMessage,
|
||||
GroupMemberJoin,
|
||||
TempMessage,
|
||||
QQEventVariant,
|
||||
} from '../src/bridge/events';
|
||||
import type { JsonObject, MessageMeta } from '../src/onebot/types';
|
||||
|
||||
const SELF_UIN = '10001';
|
||||
const SELF_ID = 10001;
|
||||
const PEER_UIN = 22222;
|
||||
const GROUP_ID = 99999;
|
||||
|
||||
interface FakeBridge {
|
||||
events: BridgeEventBus;
|
||||
}
|
||||
|
||||
function makeFriendMessage(): FriendMessage {
|
||||
return {
|
||||
kind: 'friend_message',
|
||||
time: 1700000000,
|
||||
selfUin: SELF_ID,
|
||||
senderUin: PEER_UIN,
|
||||
senderNick: 'peer',
|
||||
msgSeq: 11,
|
||||
msgId: 555,
|
||||
elements: [{ type: 'text', text: 'hi' }],
|
||||
};
|
||||
}
|
||||
|
||||
function makeGroupMessage(): GroupMessage {
|
||||
return {
|
||||
kind: 'group_message',
|
||||
time: 1700000000,
|
||||
selfUin: SELF_ID,
|
||||
groupId: GROUP_ID,
|
||||
senderUin: PEER_UIN,
|
||||
senderNick: 'peer',
|
||||
senderCard: '',
|
||||
senderRole: 'member',
|
||||
msgSeq: 22,
|
||||
msgId: 777,
|
||||
elements: [{ type: 'text', text: 'group' }],
|
||||
};
|
||||
}
|
||||
|
||||
function makeTempMessage(): TempMessage {
|
||||
return {
|
||||
kind: 'temp_message',
|
||||
time: 1700000000,
|
||||
selfUin: SELF_ID,
|
||||
senderUin: PEER_UIN,
|
||||
groupId: GROUP_ID,
|
||||
senderNick: 'peer',
|
||||
msgSeq: 33,
|
||||
elements: [{ type: 'text', text: 'temp' }],
|
||||
};
|
||||
}
|
||||
|
||||
function makeMemberJoin(): GroupMemberJoin {
|
||||
return {
|
||||
kind: 'group_member_join',
|
||||
time: 1700000000,
|
||||
selfUin: SELF_ID,
|
||||
groupId: GROUP_ID,
|
||||
userUin: PEER_UIN,
|
||||
operatorUin: PEER_UIN,
|
||||
};
|
||||
}
|
||||
|
||||
function makeContext(extra: Partial<OneBotInstanceContext> = {}): {
|
||||
ctx: OneBotInstanceContext;
|
||||
bus: BridgeEventBus;
|
||||
metaCalls: Array<{ id: number; meta: MessageMeta }>;
|
||||
dispatchCalls: JsonObject[];
|
||||
} {
|
||||
const bus = new BridgeEventBus();
|
||||
const fakeBridge: FakeBridge = { events: bus };
|
||||
const eventConverter = new EventConverter();
|
||||
const metaCalls: Array<{ id: number; meta: MessageMeta }> = [];
|
||||
const dispatchCalls: JsonObject[] = [];
|
||||
|
||||
const ctx: OneBotInstanceContext = {
|
||||
uin: SELF_UIN,
|
||||
selfId: SELF_ID,
|
||||
qqInfo: {} as never,
|
||||
bridge: fakeBridge as never,
|
||||
messageStore: {} as never,
|
||||
mediaStore: {} as never,
|
||||
eventConverter,
|
||||
config: { networks: { httpServers: [], httpClients: [], wsServers: [], wsClients: [] } } as never,
|
||||
cacheMessageMeta: (id, meta) => { metaCalls.push({ id, meta }); },
|
||||
dispatchEvent: (event) => { dispatchCalls.push(event); },
|
||||
...extra,
|
||||
};
|
||||
|
||||
return { ctx, bus, metaCalls, dispatchCalls };
|
||||
}
|
||||
|
||||
describe('registerEventPipeline', () => {
|
||||
it('caches meta and dispatches a converted event for friend_message', async () => {
|
||||
const { ctx, bus, metaCalls, dispatchCalls } = makeContext();
|
||||
registerEventPipeline(ctx);
|
||||
|
||||
await bus.emit(makeFriendMessage());
|
||||
|
||||
expect(metaCalls).toHaveLength(1);
|
||||
expect(metaCalls[0].meta.isGroup).toBe(false);
|
||||
expect(metaCalls[0].meta.targetId).toBe(PEER_UIN);
|
||||
expect(metaCalls[0].meta.sequence).toBe(11);
|
||||
expect(metaCalls[0].meta.random).toBe(555);
|
||||
|
||||
expect(dispatchCalls).toHaveLength(1);
|
||||
expect(dispatchCalls[0].post_type).toBe('message');
|
||||
expect(dispatchCalls[0].message_type).toBe('private');
|
||||
});
|
||||
|
||||
it('caches meta and dispatches for group_message', async () => {
|
||||
const { ctx, bus, metaCalls, dispatchCalls } = makeContext();
|
||||
registerEventPipeline(ctx);
|
||||
|
||||
await bus.emit(makeGroupMessage());
|
||||
|
||||
expect(metaCalls[0].meta.isGroup).toBe(true);
|
||||
expect(metaCalls[0].meta.targetId).toBe(GROUP_ID);
|
||||
expect(dispatchCalls[0].message_type).toBe('group');
|
||||
});
|
||||
|
||||
it('caches meta with random=0 for temp_message and dispatches as private+sub_type=group', async () => {
|
||||
const { ctx, bus, metaCalls, dispatchCalls } = makeContext();
|
||||
registerEventPipeline(ctx);
|
||||
|
||||
await bus.emit(makeTempMessage());
|
||||
|
||||
expect(metaCalls[0].meta.isGroup).toBe(false);
|
||||
expect(metaCalls[0].meta.random).toBe(0);
|
||||
expect(dispatchCalls[0].message_type).toBe('private');
|
||||
expect(dispatchCalls[0].sub_type).toBe('group');
|
||||
});
|
||||
|
||||
it('dispatches notice events without seeding meta', async () => {
|
||||
const { ctx, bus, metaCalls, dispatchCalls } = makeContext();
|
||||
registerEventPipeline(ctx);
|
||||
|
||||
await bus.emit(makeMemberJoin());
|
||||
|
||||
expect(metaCalls).toHaveLength(0);
|
||||
expect(dispatchCalls).toHaveLength(1);
|
||||
expect(dispatchCalls[0].notice_type).toBe('group_increase');
|
||||
});
|
||||
|
||||
it('returns a disposer that fully unsubscribes', async () => {
|
||||
const { ctx, bus, metaCalls, dispatchCalls } = makeContext();
|
||||
const dispose = registerEventPipeline(ctx);
|
||||
|
||||
await bus.emit(makeFriendMessage());
|
||||
expect(dispatchCalls).toHaveLength(1);
|
||||
|
||||
dispose();
|
||||
await bus.emit(makeFriendMessage());
|
||||
// No new calls after dispose.
|
||||
expect(dispatchCalls).toHaveLength(1);
|
||||
expect(metaCalls).toHaveLength(1);
|
||||
});
|
||||
|
||||
it('dispatches a separate event for every kind in parallel', async () => {
|
||||
const { ctx, bus, dispatchCalls } = makeContext();
|
||||
registerEventPipeline(ctx);
|
||||
|
||||
const events: QQEventVariant[] = [makeFriendMessage(), makeGroupMessage(), makeMemberJoin(), makeTempMessage()];
|
||||
await Promise.all(events.map((e) => bus.emit(e)));
|
||||
|
||||
expect(dispatchCalls).toHaveLength(events.length);
|
||||
});
|
||||
|
||||
it('skips dispatch for kinds without a converter mapping (no crash)', async () => {
|
||||
// Stub `convert` on a real EventConverter instance so the type stays
|
||||
// honest -- no structural casts.
|
||||
const stubbed = new EventConverter();
|
||||
stubbed.convert = vi.fn().mockResolvedValue(null);
|
||||
const { ctx, bus, dispatchCalls } = makeContext({ eventConverter: stubbed });
|
||||
registerEventPipeline(ctx);
|
||||
|
||||
await bus.emit(makeFriendMessage());
|
||||
expect(dispatchCalls).toHaveLength(0);
|
||||
});
|
||||
});
|
||||
306
packages/core/tests/media-store.test.ts
Normal file
306
packages/core/tests/media-store.test.ts
Normal file
@@ -0,0 +1,306 @@
|
||||
import { afterEach, beforeEach, describe, expect, it } from 'vitest';
|
||||
import fs from 'fs';
|
||||
import path from 'path';
|
||||
import { MediaStore } from '../src/onebot/media-store';
|
||||
import { EventConverter } from '../src/onebot/event-converter';
|
||||
import type { GroupMessage, FriendMessage, MessageElement } from '../src/bridge/events';
|
||||
|
||||
const SELF_UIN = '10001';
|
||||
const SELF_ID = 10001;
|
||||
const PEER_UIN = 22222;
|
||||
const GROUP_ID = 99999;
|
||||
|
||||
function imageElement(overrides: Partial<MessageElement> = {}): MessageElement {
|
||||
return {
|
||||
type: 'image',
|
||||
fileId: 'abc.png',
|
||||
fileSize: 4242,
|
||||
imageUrl: 'https://example.com/abc.png',
|
||||
...overrides,
|
||||
};
|
||||
}
|
||||
|
||||
function recordElement(overrides: Partial<MessageElement> = {}): MessageElement {
|
||||
return {
|
||||
type: 'record',
|
||||
fileId: 'uuid-base64-fake',
|
||||
fileName: 'silk_test.amr',
|
||||
fileSize: 1024,
|
||||
duration: 3,
|
||||
fileHash: 'deadbeef',
|
||||
mediaNode: { fileUuid: 'uuid-base64-fake', storeId: 1 },
|
||||
...overrides,
|
||||
};
|
||||
}
|
||||
|
||||
function makeGroupMessage(elements: MessageElement[]): GroupMessage {
|
||||
return {
|
||||
kind: 'group_message',
|
||||
time: 1700000000,
|
||||
selfUin: SELF_ID,
|
||||
groupId: GROUP_ID,
|
||||
senderUin: PEER_UIN,
|
||||
senderNick: 'peer',
|
||||
senderCard: '',
|
||||
senderRole: 'member',
|
||||
msgSeq: 1,
|
||||
msgId: 1,
|
||||
elements,
|
||||
};
|
||||
}
|
||||
|
||||
function makeFriendMessage(elements: MessageElement[]): FriendMessage {
|
||||
return {
|
||||
kind: 'friend_message',
|
||||
time: 1700000000,
|
||||
selfUin: SELF_ID,
|
||||
senderUin: PEER_UIN,
|
||||
senderNick: 'peer',
|
||||
msgSeq: 1,
|
||||
msgId: 1,
|
||||
elements,
|
||||
};
|
||||
}
|
||||
|
||||
function tempDbPath(label: string): string {
|
||||
return path.join('data', 'test', `media-${label}-${process.pid}-${Date.now()}-${Math.random().toString(36).slice(2)}.db`);
|
||||
}
|
||||
|
||||
describe('MediaStore basic semantics', () => {
|
||||
const dbs: string[] = [];
|
||||
|
||||
beforeEach(() => {
|
||||
dbs.length = 0;
|
||||
});
|
||||
|
||||
afterEach(() => {
|
||||
for (const dbPath of dbs) {
|
||||
for (const ext of ['', '-wal', '-shm']) {
|
||||
try { fs.unlinkSync(dbPath + ext); } catch { /* ignore */ }
|
||||
}
|
||||
}
|
||||
});
|
||||
|
||||
function open(label: string, max?: number): MediaStore {
|
||||
const dbPath = tempDbPath(label);
|
||||
dbs.push(dbPath);
|
||||
return max !== undefined ? new MediaStore(dbPath, max) : new MediaStore(dbPath);
|
||||
}
|
||||
|
||||
it('indexes images by file, fileName, and url', () => {
|
||||
const store = open('img-keys');
|
||||
store.rememberImage({
|
||||
file: 'abc.png',
|
||||
url: 'https://example.com/abc.png',
|
||||
fileSize: 4242,
|
||||
fileName: 'abc.png',
|
||||
subType: 0,
|
||||
summary: '',
|
||||
imageUrl: 'https://example.com/abc.png',
|
||||
isGroup: true,
|
||||
sessionId: GROUP_ID,
|
||||
});
|
||||
|
||||
expect(store.findImage('abc.png')?.fileSize).toBe(4242);
|
||||
expect(store.findImage('https://example.com/abc.png')?.url).toBe('https://example.com/abc.png');
|
||||
expect(store.findImage('missing.png')).toBeNull();
|
||||
expect(store.findImage('')).toBeNull();
|
||||
store.close();
|
||||
});
|
||||
|
||||
it('indexes records by file, fileName, fileId, and url', () => {
|
||||
const store = open('rec-keys');
|
||||
store.rememberRecord({
|
||||
file: 'silk_test.amr',
|
||||
fileId: 'uuid-base64-fake',
|
||||
url: 'https://example.com/voice.amr',
|
||||
fileSize: 1024,
|
||||
fileName: 'silk_test.amr',
|
||||
duration: 3,
|
||||
fileHash: 'deadbeef',
|
||||
mediaNode: { fileUuid: 'uuid-base64-fake' },
|
||||
isGroup: false,
|
||||
sessionId: PEER_UIN,
|
||||
});
|
||||
|
||||
expect(store.findRecord('silk_test.amr')?.duration).toBe(3);
|
||||
expect(store.findRecord('uuid-base64-fake')?.fileId).toBe('uuid-base64-fake');
|
||||
expect(store.findRecord('https://example.com/voice.amr')?.url).toBe('https://example.com/voice.amr');
|
||||
expect(store.findRecord('nope')).toBeNull();
|
||||
store.close();
|
||||
});
|
||||
|
||||
it('updates URLs in place across all alias keys', () => {
|
||||
const store = open('url-update');
|
||||
store.rememberRecord({
|
||||
file: 'silk_test.amr',
|
||||
fileId: 'uuid-base64-fake',
|
||||
url: '',
|
||||
fileSize: 1024,
|
||||
fileName: 'silk_test.amr',
|
||||
duration: 3,
|
||||
fileHash: '',
|
||||
mediaNode: { fileUuid: 'uuid-base64-fake' },
|
||||
isGroup: false,
|
||||
sessionId: PEER_UIN,
|
||||
});
|
||||
store.updateRecordUrl('silk_test.amr', 'https://refreshed.example.com/voice.amr');
|
||||
|
||||
expect(store.findRecord('silk_test.amr')?.url).toBe('https://refreshed.example.com/voice.amr');
|
||||
expect(store.findRecord('uuid-base64-fake')?.url).toBe('https://refreshed.example.com/voice.amr');
|
||||
store.close();
|
||||
});
|
||||
|
||||
it('survives close+reopen against the same db path', () => {
|
||||
const dbPath = tempDbPath('persist');
|
||||
dbs.push(dbPath);
|
||||
|
||||
{
|
||||
const store = new MediaStore(dbPath);
|
||||
store.rememberImage({
|
||||
file: 'abc.png',
|
||||
url: 'https://example.com/abc.png',
|
||||
fileSize: 99,
|
||||
fileName: 'abc.png',
|
||||
subType: 0,
|
||||
summary: '',
|
||||
imageUrl: 'https://example.com/abc.png',
|
||||
isGroup: true,
|
||||
sessionId: GROUP_ID,
|
||||
});
|
||||
store.close();
|
||||
}
|
||||
|
||||
{
|
||||
const store = new MediaStore(dbPath);
|
||||
const found = store.findImage('abc.png');
|
||||
expect(found).not.toBeNull();
|
||||
expect(found!.fileSize).toBe(99);
|
||||
// Alias index must also persist.
|
||||
expect(store.findImage('https://example.com/abc.png')?.fileSize).toBe(99);
|
||||
store.close();
|
||||
}
|
||||
});
|
||||
|
||||
it('evicts old entries beyond the configured cap', () => {
|
||||
// EVICT_EVERY_N_REMEMBERS = 64 inside the store; we exercise the eviction
|
||||
// path by writing well past the cap so it triggers at least once.
|
||||
const cap = 80;
|
||||
const store = open('evict', cap);
|
||||
for (let i = 0; i < 200; i++) {
|
||||
store.rememberImage({
|
||||
file: `file-${i}.png`,
|
||||
url: `https://example.com/${i}.png`,
|
||||
fileSize: i,
|
||||
fileName: `file-${i}.png`,
|
||||
subType: 0,
|
||||
summary: '',
|
||||
imageUrl: '',
|
||||
isGroup: true,
|
||||
sessionId: GROUP_ID,
|
||||
});
|
||||
}
|
||||
const { images } = store.size();
|
||||
expect(images).toBeLessThanOrEqual(cap);
|
||||
// Most recent entries should still be present.
|
||||
expect(store.findImage('file-199.png')?.fileSize).toBe(199);
|
||||
store.close();
|
||||
});
|
||||
});
|
||||
|
||||
describe('EventConverter media segment sink → MediaStore wiring', () => {
|
||||
const dbs: string[] = [];
|
||||
|
||||
afterEach(() => {
|
||||
for (const dbPath of dbs) {
|
||||
for (const ext of ['', '-wal', '-shm']) {
|
||||
try { fs.unlinkSync(dbPath + ext); } catch { /* ignore */ }
|
||||
}
|
||||
}
|
||||
dbs.length = 0;
|
||||
});
|
||||
|
||||
it('emits sink invocations for image segments with the right context', async () => {
|
||||
const conv = new EventConverter();
|
||||
const sinkCalls: Array<{ type: string; isGroup: boolean; sessionId: number; file: string }> = [];
|
||||
conv.setMediaSegmentSink((type, _element, data, isGroup, sessionId) => {
|
||||
sinkCalls.push({ type, isGroup, sessionId, file: String(data.file ?? '') });
|
||||
});
|
||||
|
||||
await conv.convert(SELF_UIN, makeGroupMessage([imageElement()]));
|
||||
await conv.convert(SELF_UIN, makeFriendMessage([recordElement()]));
|
||||
|
||||
expect(sinkCalls).toEqual([
|
||||
{ type: 'image', isGroup: true, sessionId: GROUP_ID, file: 'abc.png' },
|
||||
{ type: 'record', isGroup: false, sessionId: PEER_UIN, file: 'silk_test.amr' },
|
||||
]);
|
||||
});
|
||||
|
||||
it('lets the sink populate a MediaStore that get_image-style lookups can use', async () => {
|
||||
const dbPath = tempDbPath('sink');
|
||||
dbs.push(dbPath);
|
||||
|
||||
const store = new MediaStore(dbPath);
|
||||
const conv = new EventConverter();
|
||||
conv.setImageUrlResolver((element) => element.imageUrl ?? '');
|
||||
conv.setMediaUrlResolver(async (element) => element.url ?? '');
|
||||
conv.setMediaSegmentSink((type, element, data, isGroup, sessionId) => {
|
||||
const url = typeof data.url === 'string' ? data.url : '';
|
||||
const file = typeof data.file === 'string' ? data.file : '';
|
||||
if (type === 'image') {
|
||||
store.rememberImage({
|
||||
file: file || element.fileId || '',
|
||||
url,
|
||||
fileSize: element.fileSize ?? 0,
|
||||
fileName: element.fileId ?? '',
|
||||
subType: element.subType ?? 0,
|
||||
summary: element.summary ?? '',
|
||||
imageUrl: element.imageUrl ?? '',
|
||||
isGroup,
|
||||
sessionId,
|
||||
});
|
||||
} else {
|
||||
store.rememberRecord({
|
||||
file: file || element.fileName || element.fileId || '',
|
||||
fileId: element.fileId ?? '',
|
||||
url,
|
||||
fileSize: element.fileSize ?? 0,
|
||||
fileName: element.fileName ?? '',
|
||||
duration: element.duration ?? 0,
|
||||
fileHash: element.fileHash ?? '',
|
||||
mediaNode: element.mediaNode,
|
||||
isGroup,
|
||||
sessionId,
|
||||
});
|
||||
}
|
||||
});
|
||||
|
||||
await conv.convert(SELF_UIN, makeGroupMessage([imageElement()]));
|
||||
await conv.convert(SELF_UIN, makeFriendMessage([recordElement()]));
|
||||
|
||||
const img = store.findImage('abc.png');
|
||||
expect(img).not.toBeNull();
|
||||
expect(img!.url).toBe('https://example.com/abc.png');
|
||||
expect(img!.fileSize).toBe(4242);
|
||||
expect(img!.isGroup).toBe(true);
|
||||
expect(img!.sessionId).toBe(GROUP_ID);
|
||||
|
||||
const rec = store.findRecord('silk_test.amr');
|
||||
expect(rec).not.toBeNull();
|
||||
expect(rec!.fileId).toBe('uuid-base64-fake');
|
||||
expect(rec!.duration).toBe(3);
|
||||
expect(rec!.isGroup).toBe(false);
|
||||
expect(rec!.sessionId).toBe(PEER_UIN);
|
||||
// Alias lookup by fileUuid still works.
|
||||
expect(store.findRecord('uuid-base64-fake')?.fileName).toBe('silk_test.amr');
|
||||
store.close();
|
||||
});
|
||||
|
||||
it('does not invoke the sink when no media segments are present', async () => {
|
||||
const conv = new EventConverter();
|
||||
let calls = 0;
|
||||
conv.setMediaSegmentSink(() => { calls++; });
|
||||
await conv.convert(SELF_UIN, makeGroupMessage([{ type: 'text', text: 'hello' }]));
|
||||
expect(calls).toBe(0);
|
||||
});
|
||||
});
|
||||
@@ -87,6 +87,30 @@ describe('parseMessage', () => {
|
||||
expect(result[0].url).toBe('https://example.com/img.png');
|
||||
});
|
||||
|
||||
it('parses record segment from data.file', async () => {
|
||||
const result = await parseMessage(
|
||||
[{ type: 'record', data: { file: 'file:///tmp/voice.amr' } }] as any,
|
||||
false,
|
||||
);
|
||||
expect(result).toEqual([{ type: 'record', url: 'file:///tmp/voice.amr' }]);
|
||||
});
|
||||
|
||||
it('parses record segment from data.path (NapCat parity)', async () => {
|
||||
const result = await parseMessage(
|
||||
[{ type: 'record', data: { path: 'C:\\voices\\hi.silk' } }] as any,
|
||||
false,
|
||||
);
|
||||
expect(result).toEqual([{ type: 'record', url: 'C:\\voices\\hi.silk' }]);
|
||||
});
|
||||
|
||||
it('drops record segment with empty source', async () => {
|
||||
const result = await parseMessage(
|
||||
[{ type: 'record', data: {} }] as any,
|
||||
false,
|
||||
);
|
||||
expect(result).toEqual([]);
|
||||
});
|
||||
|
||||
it('parses at segment', async () => {
|
||||
const result = await parseMessage(
|
||||
[{ type: 'at', data: { qq: 12345 } }] as any,
|
||||
@@ -144,6 +168,24 @@ describe('parseMessage', () => {
|
||||
expect(protoElems[0].text?.str).toBe('@User ');
|
||||
});
|
||||
|
||||
it('skips record send when SendContext is absent (graceful no-bridge path)', async () => {
|
||||
// Without a SendContext, buildSendElems can't run highway upload —
|
||||
// it should warn and drop the element instead of throwing into the
|
||||
// ffmpegAddon (which would explode for callers that don't actually
|
||||
// need to send).
|
||||
const elements = await parseMessage(
|
||||
[
|
||||
{ type: 'text', data: { text: 'hi ' } },
|
||||
{ type: 'record', data: { file: '/tmp/x.silk' } },
|
||||
] as any,
|
||||
false,
|
||||
);
|
||||
const protoElems = await buildSendElems(elements);
|
||||
// Only the leading text should make it through.
|
||||
expect(protoElems).toHaveLength(1);
|
||||
expect(protoElems[0].text?.str).toBe('hi ');
|
||||
});
|
||||
|
||||
it('parses multiple segments', async () => {
|
||||
const result = await parseMessage(
|
||||
[
|
||||
|
||||
180
packages/core/tests/network-manager.test.ts
Normal file
180
packages/core/tests/network-manager.test.ts
Normal file
@@ -0,0 +1,180 @@
|
||||
import { describe, expect, it } from 'vitest';
|
||||
import { IOneBotNetworkAdapter, NetworkReloadType, OneBotNetworkManager } from '../src/onebot/network';
|
||||
import type { NetworkAdapterContext } from '../src/onebot/network';
|
||||
import type { JsonObject, NetworkBase } from '../src/onebot/types';
|
||||
import type { DispatchPayload } from '../src/onebot/event-filter';
|
||||
|
||||
interface FakeNetworkConfig extends NetworkBase {
|
||||
// Allows tests to influence behavior via config:
|
||||
failOnEvent?: boolean;
|
||||
}
|
||||
|
||||
class FakeAdapter extends IOneBotNetworkAdapter<FakeNetworkConfig> {
|
||||
events: JsonObject[] = [];
|
||||
opens = 0;
|
||||
closes = 0;
|
||||
reloads = 0;
|
||||
// Last dispatch payload object identity, to assert it was reused per emit.
|
||||
lastPayloads: DispatchPayload[] = [];
|
||||
|
||||
open(): void {
|
||||
this.opens++;
|
||||
if (this.config.enabled !== false) this.isEnabled = true;
|
||||
}
|
||||
close(): void {
|
||||
this.closes++;
|
||||
this.isEnabled = false;
|
||||
}
|
||||
reload(next: FakeNetworkConfig): NetworkReloadType {
|
||||
this.reloads++;
|
||||
this.config = structuredClone(next);
|
||||
if (next.enabled === false && this.isEnabled) {
|
||||
this.close();
|
||||
return NetworkReloadType.Closed;
|
||||
}
|
||||
if (next.enabled !== false && !this.isEnabled) {
|
||||
this.open();
|
||||
return NetworkReloadType.Opened;
|
||||
}
|
||||
return NetworkReloadType.Normal;
|
||||
}
|
||||
onEvent(event: JsonObject, payload: DispatchPayload): void {
|
||||
this.events.push(event);
|
||||
this.lastPayloads.push(payload);
|
||||
if (this.config.failOnEvent) throw new Error('boom');
|
||||
}
|
||||
}
|
||||
|
||||
const NULL_CTX: NetworkAdapterContext = {
|
||||
uin: '10001',
|
||||
api: { handle: async () => ({ status: 'failed', retcode: 0, data: null }), processRequest: async () => '' } as never,
|
||||
buildLifecycleEvent: () => ({}),
|
||||
buildHeartbeatEvent: () => ({}),
|
||||
};
|
||||
|
||||
function makeAdapter(name: string, partial: Partial<FakeNetworkConfig> = {}): FakeAdapter {
|
||||
const config: FakeNetworkConfig = {
|
||||
name,
|
||||
enabled: true,
|
||||
messageFormat: 'array',
|
||||
reportSelfMessage: false,
|
||||
...partial,
|
||||
};
|
||||
return new FakeAdapter(name, config, NULL_CTX);
|
||||
}
|
||||
|
||||
const SAMPLE_EVENT: JsonObject = {
|
||||
time: 1,
|
||||
self_id: 10001,
|
||||
post_type: 'message',
|
||||
message_type: 'private',
|
||||
sub_type: 'friend',
|
||||
message_id: 1,
|
||||
user_id: 22222,
|
||||
message: [{ type: 'text', data: { text: 'hi' } }],
|
||||
raw_message: 'hi',
|
||||
font: 0,
|
||||
sender: { user_id: 22222, nickname: 'peer', sex: 'unknown', age: 0 },
|
||||
};
|
||||
|
||||
describe('OneBotNetworkManager', () => {
|
||||
it('opens and emits to every active adapter in parallel', async () => {
|
||||
const mgr = new OneBotNetworkManager();
|
||||
const a = makeAdapter('a');
|
||||
const b = makeAdapter('b');
|
||||
mgr.register(a);
|
||||
mgr.register(b);
|
||||
await mgr.openAll();
|
||||
|
||||
expect(a.opens).toBe(1);
|
||||
expect(b.opens).toBe(1);
|
||||
|
||||
await mgr.emitEvent(SAMPLE_EVENT);
|
||||
expect(a.events).toEqual([SAMPLE_EVENT]);
|
||||
expect(b.events).toEqual([SAMPLE_EVENT]);
|
||||
// Both adapters should receive the same payload reference (built once).
|
||||
expect(a.lastPayloads[0]).toBe(b.lastPayloads[0]);
|
||||
});
|
||||
|
||||
it('skips inactive adapters during emit', async () => {
|
||||
const mgr = new OneBotNetworkManager();
|
||||
const active = makeAdapter('active');
|
||||
const idle = makeAdapter('idle', { enabled: false });
|
||||
mgr.register(active);
|
||||
mgr.register(idle);
|
||||
await mgr.openAll();
|
||||
|
||||
await mgr.emitEvent(SAMPLE_EVENT);
|
||||
expect(active.events).toHaveLength(1);
|
||||
expect(idle.events).toHaveLength(0);
|
||||
});
|
||||
|
||||
it('isolates adapter errors so one bad adapter does not block others', async () => {
|
||||
const mgr = new OneBotNetworkManager();
|
||||
const ok = makeAdapter('ok');
|
||||
const bad = makeAdapter('bad', { failOnEvent: true });
|
||||
mgr.register(ok);
|
||||
mgr.register(bad);
|
||||
await mgr.openAll();
|
||||
|
||||
await mgr.emitEvent(SAMPLE_EVENT);
|
||||
// The good adapter still saw the event.
|
||||
expect(ok.events).toHaveLength(1);
|
||||
// The bad adapter logged the throw but didn't crash the manager.
|
||||
expect(bad.events).toHaveLength(1);
|
||||
});
|
||||
|
||||
it('replaces an existing adapter under the same name and closes the old one', async () => {
|
||||
const mgr = new OneBotNetworkManager();
|
||||
const first = makeAdapter('dup');
|
||||
mgr.register(first);
|
||||
await mgr.openAll();
|
||||
|
||||
const second = makeAdapter('dup');
|
||||
mgr.register(second);
|
||||
|
||||
expect(mgr.get('dup')).toBe(second);
|
||||
expect(first.closes).toBe(1);
|
||||
});
|
||||
|
||||
it('closeOne shuts down a single adapter and removes it', async () => {
|
||||
const mgr = new OneBotNetworkManager();
|
||||
const a = makeAdapter('a');
|
||||
const b = makeAdapter('b');
|
||||
mgr.register(a);
|
||||
mgr.register(b);
|
||||
await mgr.openAll();
|
||||
|
||||
await mgr.closeOne('a');
|
||||
expect(mgr.has('a')).toBe(false);
|
||||
expect(a.closes).toBe(1);
|
||||
expect(b.closes).toBe(0);
|
||||
expect(mgr.hasActiveAdapters()).toBe(true);
|
||||
});
|
||||
|
||||
it('closeAll clears every adapter', async () => {
|
||||
const mgr = new OneBotNetworkManager();
|
||||
const a = makeAdapter('a');
|
||||
const b = makeAdapter('b');
|
||||
mgr.register(a);
|
||||
mgr.register(b);
|
||||
await mgr.openAll();
|
||||
|
||||
await mgr.closeAll();
|
||||
expect(mgr.list()).toHaveLength(0);
|
||||
expect(a.closes).toBe(1);
|
||||
expect(b.closes).toBe(1);
|
||||
});
|
||||
|
||||
it('hasActiveAdapters reflects current state', async () => {
|
||||
const mgr = new OneBotNetworkManager();
|
||||
expect(mgr.hasActiveAdapters()).toBe(false);
|
||||
const a = makeAdapter('a');
|
||||
mgr.register(a);
|
||||
expect(mgr.hasActiveAdapters()).toBe(false);
|
||||
await mgr.openAll();
|
||||
expect(mgr.hasActiveAdapters()).toBe(true);
|
||||
await mgr.closeAll();
|
||||
expect(mgr.hasActiveAdapters()).toBe(false);
|
||||
});
|
||||
});
|
||||
@@ -26,7 +26,7 @@ const nativeSrc = toPosix(nativeDir);
|
||||
// Target selection: `SNOWLUMA_TARGET=<platform>-<arch>` overrides the host
|
||||
// detection, enabling cross-target packaging on CI.
|
||||
const targetTriple = process.env.SNOWLUMA_TARGET ?? `${process.platform}-${process.arch}`;
|
||||
const targetPlatform = targetTriple.split('-')[0];
|
||||
const [targetPlatform, targetArch] = targetTriple.split('-');
|
||||
|
||||
// Runtime scaffolding files copied into dist/. The NTQQ hook is Windows-only,
|
||||
// so its launcher/shell script differ per target.
|
||||
@@ -47,12 +47,22 @@ const nativeFiles = [
|
||||
: []),
|
||||
];
|
||||
|
||||
// FFmpeg native addon ported from NapCat. Uses NapCat's
|
||||
// `<platform>.<arch>` naming so the prebuilt binaries can be vendored
|
||||
// as-is without renaming. Lives under `native/ffmpeg/` to keep it
|
||||
// separate from the SnowLuma flat-naming addons above.
|
||||
const ffmpegAddonFile = `ffmpegAddon.${targetPlatform}.${targetArch}.node`;
|
||||
const ffmpegSrcDir = path.resolve(nativeDir, 'ffmpeg');
|
||||
|
||||
// Fail fast if any expected native binary is missing from packages/runtime/native/.
|
||||
// vite-plugin-cp only emits a warning on missing source files; we want a hard
|
||||
// error so CI can't accidentally ship an incomplete archive.
|
||||
const missingNatives = nativeFiles.filter(
|
||||
(f) => !fs.existsSync(path.join(nativeDir, f)),
|
||||
);
|
||||
if (!fs.existsSync(path.join(ffmpegSrcDir, ffmpegAddonFile))) {
|
||||
missingNatives.push(`ffmpeg/${ffmpegAddonFile}`);
|
||||
}
|
||||
if (missingNatives.length > 0) {
|
||||
throw new Error(
|
||||
`Missing native binaries for target ${targetTriple}:\n` +
|
||||
@@ -73,6 +83,11 @@ const BaseConfigPlugin: PluginOption[] = [
|
||||
dest: path.join(distDir, 'native'),
|
||||
flatten: true,
|
||||
})),
|
||||
{
|
||||
src: `${toPosix(ffmpegSrcDir)}/${ffmpegAddonFile}`,
|
||||
dest: path.join(distDir, 'native', 'ffmpeg'),
|
||||
flatten: true,
|
||||
},
|
||||
]
|
||||
})
|
||||
];
|
||||
|
||||
BIN
packages/runtime/native/ffmpeg/ffmpegAddon.darwin.arm64.node
Normal file
BIN
packages/runtime/native/ffmpeg/ffmpegAddon.darwin.arm64.node
Normal file
Binary file not shown.
BIN
packages/runtime/native/ffmpeg/ffmpegAddon.linux.arm64.node
Normal file
BIN
packages/runtime/native/ffmpeg/ffmpegAddon.linux.arm64.node
Normal file
Binary file not shown.
BIN
packages/runtime/native/ffmpeg/ffmpegAddon.linux.x64.node
Normal file
BIN
packages/runtime/native/ffmpeg/ffmpegAddon.linux.x64.node
Normal file
Binary file not shown.
BIN
packages/runtime/native/ffmpeg/ffmpegAddon.win32.x64.node
Normal file
BIN
packages/runtime/native/ffmpeg/ffmpegAddon.win32.x64.node
Normal file
Binary file not shown.
Reference in New Issue
Block a user