cortico-world-wechat-claw 0.1.2 → 0.1.4
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- package/CHANGELOG.md +26 -0
- package/README.md +34 -0
- package/describe.json +1 -1
- package/package.json +1 -1
- package/src/ENV_PROMPT.md +19 -0
- package/src/config.ts +74 -0
- package/src/protocol/inbound.ts +16 -6
- package/src/protocol/mime.ts +73 -1
- package/src/segment.ts +185 -0
- package/src/world.ts +124 -7
package/CHANGELOG.md
CHANGED
|
@@ -1,5 +1,31 @@
|
|
|
1
1
|
# Changelog
|
|
2
2
|
|
|
3
|
+
## 0.1.4
|
|
4
|
+
|
|
5
|
+
新增语义分段发送。
|
|
6
|
+
|
|
7
|
+
- **按语义把一次回复拆成多条微信消息**,一条一条发,像人一句一句说话。
|
|
8
|
+
- **拆分只算一次**:有换行就只按换行拆;没有换行才按句号;再没有才按 `!?…~`。
|
|
9
|
+
换行与句号同时出现时不会拆两次,也不会多出空段。
|
|
10
|
+
- **删谁不删谁**:换行、`。`、`.` 删掉(微信里带句号显得生硬);`!?!?…~~` 只拆不删,语气留着。
|
|
11
|
+
ASCII `.` 只在后面跟空白或位于结尾时才当句号,`3.14`、`docs.nonebot.dev`、`report.md` 不会被切坏。
|
|
12
|
+
- **间隔可配**:固定间隔或随机区间,单位秒。默认固定 2 秒。
|
|
13
|
+
- **两道上限**:单次最多 12 段(超出并进最后一段)、累计等待最多 30 秒(到点就不再等,
|
|
14
|
+
但剩下的**照常发完**,不会因为等不起就漏发)。
|
|
15
|
+
- 每段之间会亮一次「正在输入」,让人看着像还在打字。
|
|
16
|
+
- 环境提示词里说明分段规则,让模型知道换行会变成独立消息、句号会被删掉。
|
|
17
|
+
|
|
18
|
+
默认开启。不想要就在配置页关掉「分段发送」,行为回到 0.1.3。
|
|
19
|
+
|
|
20
|
+
## 0.1.3
|
|
21
|
+
|
|
22
|
+
- **正文里的图片尺寸改成真图尺寸。** 之前用的是 `image_item.thumb_width` / `thumb_height`,
|
|
23
|
+
那是微信给的缩略图尺寸(实测普遍 210 像素宽),而同一张图的文件实际是 868×1920、1440×1699。
|
|
24
|
+
模型看到 `[图片 210x465]` 会按「这是一张小图」处理,于是把图判成糊的。现在从落盘文件本身读
|
|
25
|
+
(JPEG 的 SOF、PNG 的 IHDR、GIF/BMP/WebP 各自的文件头),读不出就不写尺寸,不猜。
|
|
26
|
+
- **上报版本号只认 `package.json`。** 早先 `world.ts` 里另抄了一份常量,停在 `0.1.0`,
|
|
27
|
+
于是 `base_info.channel_version` 连续两个版本都在报旧号。现在直接读 `package.json`。
|
|
28
|
+
|
|
3
29
|
## 0.1.2
|
|
4
30
|
|
|
5
31
|
安全修复:收件人钉死在绑定本人。
|
package/README.md
CHANGED
|
@@ -78,9 +78,39 @@ corepack pnpm add "<这个包所在的绝对路径>"
|
|
|
78
78
|
| `videoFrames` | `4` | 每条视频抽几帧,0 表示不抽 |
|
|
79
79
|
| `videoFrameMaxEdge` | `640` | 每帧最长边像素 |
|
|
80
80
|
| `ffmpegProxyUrl` | 空 | 下载 ffmpeg 用的代理;留空直连(不继承只给模型用的那条代理) |
|
|
81
|
+
| `segmentEnabled` | `true` | 分段发送:一次回复拆成多条微信消息 |
|
|
82
|
+
| `segmentDelayMode` | `fixed` | `fixed` 固定间隔;`random` 在 `segmentDelayMinSec`~`segmentDelayMaxSec` 之间随机 |
|
|
83
|
+
| `segmentDelayFixedSec` | `2` | 固定间隔,秒 |
|
|
84
|
+
| `segmentDelayMinSec` | `1` | 随机间隔下限,秒 |
|
|
85
|
+
| `segmentDelayMaxSec` | `4` | 随机间隔上限,秒 |
|
|
86
|
+
| `segmentMaxParts` | `12` | 单次最多拆几段,超出并进最后一段 |
|
|
87
|
+
| `segmentMaxTotalSec` | `30` | 累计等待上限,到点不再等但剩下的照常发完 |
|
|
81
88
|
|
|
82
89
|
`bot_token`、同步游标和 `context_token` 都在 `<dataDir>/wechat-claw/`,不进配置、不进日志、不进事件 `meta.raw`。
|
|
83
90
|
|
|
91
|
+
## 分段发送
|
|
92
|
+
|
|
93
|
+
微信里一次吐一大段不像人说话。打开分段发送后,一次回复会拆成几条,一条一条发,条与条之间停顿。
|
|
94
|
+
|
|
95
|
+
**拆分只算一次**,不会拆两次:
|
|
96
|
+
|
|
97
|
+
| 文本里有 | 按什么拆 | 分隔符 |
|
|
98
|
+
|---|---|---|
|
|
99
|
+
| 换行 `\n` | 只按换行 | 删掉 |
|
|
100
|
+
| 没有换行,有句号 `。..` | 只按句号 | 删掉 |
|
|
101
|
+
| 都没有,有 `!?!?…~~` | 只按这些 | **保留** |
|
|
102
|
+
| 都没有 | 整条发 | —— |
|
|
103
|
+
|
|
104
|
+
换行和句号同时出现时(「三层:\n第一。\n第二。」),按换行拆完就结束,句号留在段内,**不会再多拆一次**。
|
|
105
|
+
|
|
106
|
+
**为什么删句号**:微信里带句号显得生硬,像在写公文,真人不这么打字。`!?…~` 留着,因为那是语气。
|
|
107
|
+
|
|
108
|
+
**ASCII `.` 有额外保护**:只在后面跟空白或位于结尾时才当句号。所以 `3.14`、`docs.nonebot.dev`、`report.2026.11.md` 不会被切坏。
|
|
109
|
+
|
|
110
|
+
**两道上限**:单次最多 `segmentMaxParts` 段,多的并进最后一段;累计等待超过 `segmentMaxTotalSec` 就不再多等,但**剩下的照常发完**(不会因为等不起而漏发)。
|
|
111
|
+
|
|
112
|
+
不想要就在配置页关掉「分段发送」。
|
|
113
|
+
|
|
84
114
|
## 视频抽帧
|
|
85
115
|
|
|
86
116
|
视频抽帧要 ffmpeg,但扩展不把它打进包里,**也绝不悄悄下载**。
|
|
@@ -133,6 +163,10 @@ POST 密文到微信 CDN → 从响应头 `x-encrypted-param` 取下载参数
|
|
|
133
163
|
落到 `<dataDir>/wechat-claw/inbox/{images,files,videos,voices}/` → 路径写进事件正文 →
|
|
134
164
|
模型接受该 MIME 时字节作为附件随事件到达。
|
|
135
165
|
|
|
166
|
+
正文里的图片尺寸读自落盘文件本身(JPEG 的 SOF 段、PNG 的 IHDR 等)。微信消息里的
|
|
167
|
+
`thumb_width` / `thumb_height` 是缩略图尺寸,普遍只有 210 像素宽,和真图差一个数量级,
|
|
168
|
+
所以不用它。
|
|
169
|
+
|
|
136
170
|
## 限制
|
|
137
171
|
|
|
138
172
|
- 只支持 1v1 私聊;没有群聊、好友列表、朋友圈、转账或红包。
|
package/describe.json
CHANGED
|
@@ -154,7 +154,7 @@
|
|
|
154
154
|
"key": "worlds.wechat-claw.envPrompt",
|
|
155
155
|
"title": "微信 ClawBot · 环境提示词",
|
|
156
156
|
"role": "envPrompt",
|
|
157
|
-
"content": "微信 ClawBot 是一条一对一私聊通道,接在微信里,只能回复刚发消息的那个人。\n\n## 手边的状态\n\n{{wechat.state | (微信还没接上。)}}\n{{wechat.account | (还没有绑定的微信号。)}}\n{{wechat.lastMessageAt | (还没有收到过微信消息。)}}\n{{wechat.lastError | (最近没有连接错误。)}}\n\n## 什么时候用\n\n微信里来人说话时,会收到一条 `wechat-claw.message`,正文以 `[微信 时间 发送者]` 开头,媒体路径就写在里面。要回话就用 `wechat_send`;图片用 `wechat_send_image`,其他文件用 `wechat_send_file`,两者都接本机绝对路径。\n\n- 对方发来图片时,图片会作为附件一起到达,路径也写在正文里。看不到附件时,按路径自行读取。\n- 对方发来文件时,路径写在正文里,需要内容就按路径读。\n- 对方发来视频时,视频落盘、路径写在正文里;抽帧可用时按时间顺序附几张画面,正文会写明抽了几帧。正文说「视频帧未抽取」就是真的没看过,不要描述画面内容。\n- 对方发来语音时,正文里带服务端的转写文本;语音本身是 SILK 编码,一般不必再处理。没有转写文本时,你只知道时长,不知道说了什么。\n\n## 约束\n\n这条通道只能回复最近发消息的人,不能主动找人,也不能发到别处。`wechat_send` 的回执会写明发给了谁。\n\n一条文本最多 4000 字,超出的部分会自动接着发成下一条,不必自己切。断行位置优先落在段落和句号上。\n\n对方的 `context_token` 会过期。回复被拒并提示没有可用 token 时,等对方再说一句再回,不要反复重试。\n\n这里发出的一切都会真的进到对方的微信里。不确定要不要发的时候,先问清楚。\n"
|
|
157
|
+
"content": "微信 ClawBot 是一条一对一私聊通道,接在微信里,只能回复刚发消息的那个人。\n\n## 手边的状态\n\n{{wechat.state | (微信还没接上。)}}\n{{wechat.account | (还没有绑定的微信号。)}}\n{{wechat.lastMessageAt | (还没有收到过微信消息。)}}\n{{wechat.lastError | (最近没有连接错误。)}}\n\n## 什么时候用\n\n微信里来人说话时,会收到一条 `wechat-claw.message`,正文以 `[微信 时间 发送者]` 开头,媒体路径就写在里面。要回话就用 `wechat_send`;图片用 `wechat_send_image`,其他文件用 `wechat_send_file`,两者都接本机绝对路径。\n\n- 对方发来图片时,图片会作为附件一起到达,路径也写在正文里。看不到附件时,按路径自行读取。\n- 对方发来文件时,路径写在正文里,需要内容就按路径读。\n- 对方发来视频时,视频落盘、路径写在正文里;抽帧可用时按时间顺序附几张画面,正文会写明抽了几帧。正文说「视频帧未抽取」就是真的没看过,不要描述画面内容。\n- 对方发来语音时,正文里带服务端的转写文本;语音本身是 SILK 编码,一般不必再处理。没有转写文本时,你只知道时长,不知道说了什么。\n\n## 约束\n\n这条通道只能回复最近发消息的人,不能主动找人,也不能发到别处。`wechat_send` 的回执会写明发给了谁。\n\n一条文本最多 4000 字,超出的部分会自动接着发成下一条,不必自己切。断行位置优先落在段落和句号上。\n\n## 分段发送\n\n这一段决定你说话的样子,值得花心思。\n\n打开分段发送时,你写的东西会被拆成好几条微信消息,一条一条发出去,条与条之间会停顿,让对方看着像你还在打字。\n\n拆的顺序按一次算,不会拆两次:\n\n- 你写了换行,就只按换行拆;换行会消失,段内不再按标点拆。\n- 没写换行但有句号,就只按句号拆,句号会消失。\n- 都没写,但有 `!?…~`,就按它们拆;它们留着,因为你靠它们表达语气。\n- 都没有,就整条发出去。\n\n所以换行是你的节奏工具:**想让对方连看几行、想顿一下再说下一句,就写换行**。反过来,一句话里硬写换行会被拆成好几个气泡,看着像结巴。\n\n中文句号会被删掉,因为在微信里带句号显得生硬、像在写公文。这就是聊天里很少见句号的原因。别为了排版写句号。\n\n分段与间隔都是对方在配置页设的,你看不到也不必猜;照平时的习惯说话就行。\n\n对方的 `context_token` 会过期。回复被拒并提示没有可用 token 时,等对方再说一句再回,不要反复重试。\n\n这里发出的一切都会真的进到对方的微信里。不确定要不要发的时候,先问清楚。\n"
|
|
158
158
|
}
|
|
159
159
|
]
|
|
160
160
|
}
|
package/package.json
CHANGED
package/src/ENV_PROMPT.md
CHANGED
|
@@ -22,6 +22,25 @@
|
|
|
22
22
|
|
|
23
23
|
一条文本最多 4000 字,超出的部分会自动接着发成下一条,不必自己切。断行位置优先落在段落和句号上。
|
|
24
24
|
|
|
25
|
+
## 分段发送
|
|
26
|
+
|
|
27
|
+
这一段决定你说话的样子,值得花心思。
|
|
28
|
+
|
|
29
|
+
打开分段发送时,你写的东西会被拆成好几条微信消息,一条一条发出去,条与条之间会停顿,让对方看着像你还在打字。
|
|
30
|
+
|
|
31
|
+
拆的顺序按一次算,不会拆两次:
|
|
32
|
+
|
|
33
|
+
- 你写了换行,就只按换行拆;换行会消失,段内不再按标点拆。
|
|
34
|
+
- 没写换行但有句号,就只按句号拆,句号会消失。
|
|
35
|
+
- 都没写,但有 `!?…~`,就按它们拆;它们留着,因为你靠它们表达语气。
|
|
36
|
+
- 都没有,就整条发出去。
|
|
37
|
+
|
|
38
|
+
所以换行是你的节奏工具:**想让对方连看几行、想顿一下再说下一句,就写换行**。反过来,一句话里硬写换行会被拆成好几个气泡,看着像结巴。
|
|
39
|
+
|
|
40
|
+
中文句号会被删掉,因为在微信里带句号显得生硬、像在写公文。这就是聊天里很少见句号的原因。别为了排版写句号。
|
|
41
|
+
|
|
42
|
+
分段与间隔都是对方在配置页设的,你看不到也不必猜;照平时的习惯说话就行。
|
|
43
|
+
|
|
25
44
|
对方的 `context_token` 会过期。回复被拒并提示没有可用 token 时,等对方再说一句再回,不要反复重试。
|
|
26
45
|
|
|
27
46
|
这里发出的一切都会真的进到对方的微信里。不确定要不要发的时候,先问清楚。
|
package/src/config.ts
CHANGED
|
@@ -35,6 +35,25 @@ export interface WechatClawConfigSection {
|
|
|
35
35
|
videoFrameMaxEdge: number;
|
|
36
36
|
/** 下载 ffmpeg 用的代理;留空表示直连(不继承只给模型用的那条代理)。 */
|
|
37
37
|
ffmpegProxyUrl: string;
|
|
38
|
+
/**
|
|
39
|
+
* 按语义分段发送。打开后一次回复会拆成多条微信消息,像人一句一句说。
|
|
40
|
+
*
|
|
41
|
+
* 有换行就只按换行拆;没有换行才按句号;再没有才按 `!?…~`。
|
|
42
|
+
* 中文句号删掉(社交软件里带句号显得生硬),情绪标点保留。
|
|
43
|
+
*/
|
|
44
|
+
segmentEnabled: boolean;
|
|
45
|
+
/** 段间等待口径:固定间隔,或在区间内随机。 */
|
|
46
|
+
segmentDelayMode: 'fixed' | 'random';
|
|
47
|
+
/** 固定间隔,秒。 */
|
|
48
|
+
segmentDelayFixedSec: number;
|
|
49
|
+
/** 随机间隔下限,秒。 */
|
|
50
|
+
segmentDelayMinSec: number;
|
|
51
|
+
/** 随机间隔上限,秒。 */
|
|
52
|
+
segmentDelayMaxSec: number;
|
|
53
|
+
/** 单次回复最多拆几条;超出就把剩下的合并进最后一条。 */
|
|
54
|
+
segmentMaxParts: number;
|
|
55
|
+
/** 一次发送累计等待上限,秒;到点就把剩下的一起发完。 */
|
|
56
|
+
segmentMaxTotalSec: number;
|
|
38
57
|
}
|
|
39
58
|
|
|
40
59
|
export const WECHAT_CLAW_DEFAULTS: WechatClawConfigSection = {
|
|
@@ -51,6 +70,13 @@ export const WECHAT_CLAW_DEFAULTS: WechatClawConfigSection = {
|
|
|
51
70
|
videoFrames: 4,
|
|
52
71
|
videoFrameMaxEdge: 640,
|
|
53
72
|
ffmpegProxyUrl: '',
|
|
73
|
+
segmentEnabled: true,
|
|
74
|
+
segmentDelayMode: 'fixed',
|
|
75
|
+
segmentDelayFixedSec: 2,
|
|
76
|
+
segmentDelayMinSec: 1,
|
|
77
|
+
segmentDelayMaxSec: 4,
|
|
78
|
+
segmentMaxParts: 12,
|
|
79
|
+
segmentMaxTotalSec: 30,
|
|
54
80
|
};
|
|
55
81
|
|
|
56
82
|
export const WECHAT_CLAW_CONFIG_GROUP: ConfigGroup = {
|
|
@@ -144,6 +170,54 @@ export const WECHAT_CLAW_CONFIG_GROUP: ConfigGroup = {
|
|
|
144
170
|
description: '抽出的帧会缩到这个尺寸再交给模型。越小越省 token,也越看不清细节。',
|
|
145
171
|
'x-hot': true,
|
|
146
172
|
},
|
|
173
|
+
'worlds.wechat-claw.segmentEnabled': {
|
|
174
|
+
type: 'boolean',
|
|
175
|
+
title: '分段发送',
|
|
176
|
+
description:
|
|
177
|
+
'打开后一次回复拆成多条微信消息,像人一句一句说。'
|
|
178
|
+
+ '有换行就只按换行拆;没有换行才按句号;再没有才按!?…~。'
|
|
179
|
+
+ '中文句号会删掉(社交软件里带句号显得生硬),!?…~ 保留语气。修改后需重启。',
|
|
180
|
+
'x-hot': false,
|
|
181
|
+
},
|
|
182
|
+
'worlds.wechat-claw.segmentDelayMode': {
|
|
183
|
+
type: 'string',
|
|
184
|
+
title: '间隔方式',
|
|
185
|
+
description: '固定间隔,或在区间内随机取值。只在「分段发送」打开时有效。',
|
|
186
|
+
enum: ['fixed', 'random'],
|
|
187
|
+
'x-hot': true,
|
|
188
|
+
},
|
|
189
|
+
'worlds.wechat-claw.segmentDelayFixedSec': {
|
|
190
|
+
type: 'number',
|
|
191
|
+
title: '固定间隔(秒)',
|
|
192
|
+
description: '每一段发完后等这么久。0 表示连着发完。',
|
|
193
|
+
'x-hot': true,
|
|
194
|
+
},
|
|
195
|
+
'worlds.wechat-claw.segmentDelayMinSec': {
|
|
196
|
+
type: 'number',
|
|
197
|
+
title: '随机下限(秒)',
|
|
198
|
+
description: '随机间隔的下界。和上限写反了会自动换过来。',
|
|
199
|
+
'x-hot': true,
|
|
200
|
+
},
|
|
201
|
+
'worlds.wechat-claw.segmentDelayMaxSec': {
|
|
202
|
+
type: 'number',
|
|
203
|
+
title: '随机上限(秒)',
|
|
204
|
+
description: '随机间隔的上界。',
|
|
205
|
+
'x-hot': true,
|
|
206
|
+
},
|
|
207
|
+
'worlds.wechat-claw.segmentMaxParts': {
|
|
208
|
+
type: 'number',
|
|
209
|
+
title: '最多拆几段',
|
|
210
|
+
description:
|
|
211
|
+
'单次回复的上限。超出时把多出来的内容并进最后一段,避免模型输出几十行把这次发送拖很久。',
|
|
212
|
+
'x-hot': true,
|
|
213
|
+
},
|
|
214
|
+
'worlds.wechat-claw.segmentMaxTotalSec': {
|
|
215
|
+
type: 'number',
|
|
216
|
+
title: '总等待上限(秒)',
|
|
217
|
+
description:
|
|
218
|
+
'一次发送里所有间隔加起来的上限。到点就把剩下的一起发完,回执会写明有截断。',
|
|
219
|
+
'x-hot': true,
|
|
220
|
+
},
|
|
147
221
|
},
|
|
148
222
|
},
|
|
149
223
|
};
|
package/src/protocol/inbound.ts
CHANGED
|
@@ -8,7 +8,7 @@
|
|
|
8
8
|
import { mkdir, writeFile } from 'node:fs/promises';
|
|
9
9
|
import { join } from 'node:path';
|
|
10
10
|
|
|
11
|
-
import { extensionForInbound, mimeFromFilename, sniffImageMime } from './mime.ts';
|
|
11
|
+
import { extensionForInbound, imageSize, mimeFromFilename, sniffImageMime } from './mime.ts';
|
|
12
12
|
import type { MediaTransfer } from './media.ts';
|
|
13
13
|
import { MessageItemType, type MessageItem, type WeixinMessage } from './types.ts';
|
|
14
14
|
|
|
@@ -20,6 +20,9 @@ export interface InboundMedia {
|
|
|
20
20
|
label: string;
|
|
21
21
|
kind: 'image' | 'file' | 'video' | 'voice';
|
|
22
22
|
bytes: number;
|
|
23
|
+
/** 图片的真实像素尺寸;读不出文件头时缺省。 */
|
|
24
|
+
width?: number;
|
|
25
|
+
height?: number;
|
|
23
26
|
}
|
|
24
27
|
|
|
25
28
|
/** 一条入站消息渲染后的结果。 */
|
|
@@ -200,9 +203,9 @@ export async function renderInbound(
|
|
|
200
203
|
lines.push(missText(fetched, '图片', opts.maxBytes));
|
|
201
204
|
continue;
|
|
202
205
|
}
|
|
203
|
-
|
|
204
|
-
|
|
205
|
-
|
|
206
|
+
// 尺寸取落盘文件本身。`image_item.thumb_width` 是缩略图尺寸(微信普遍给 210 宽),
|
|
207
|
+
// 拿它当图片尺寸会让上下文里的数字比真图小一个数量级。
|
|
208
|
+
const dims = fetched.width && fetched.height ? ` ${fetched.width}x${fetched.height}` : '';
|
|
206
209
|
lines.push(`[图片${dims},${sizeText(fetched.bytes)},已存为 ${fetched.path}]`);
|
|
207
210
|
media.push({ ...fetched, kind: 'image', label: `[图片${dims}]` });
|
|
208
211
|
continue;
|
|
@@ -255,7 +258,7 @@ export async function renderInbound(
|
|
|
255
258
|
|
|
256
259
|
/** 媒体取回的结果:成功给路径,失败给一句能区分原因的话。 */
|
|
257
260
|
type FetchOutcome =
|
|
258
|
-
| { ok: true; path: string; mime: string; bytes: number }
|
|
261
|
+
| { ok: true; path: string; mime: string; bytes: number; width?: number; height?: number }
|
|
259
262
|
| { ok: false; reason: 'too-large' | 'no-ref' | 'failed' };
|
|
260
263
|
|
|
261
264
|
/** 取一个媒体项的字节并按类型落盘。 */
|
|
@@ -285,7 +288,14 @@ async function fetchItem(
|
|
|
285
288
|
dir: join(opts.mediaDir, 'images'),
|
|
286
289
|
prefix: 'wx-image',
|
|
287
290
|
});
|
|
288
|
-
|
|
291
|
+
const size = imageSize(bytes);
|
|
292
|
+
return {
|
|
293
|
+
ok: true,
|
|
294
|
+
path,
|
|
295
|
+
mime,
|
|
296
|
+
bytes: bytes.length,
|
|
297
|
+
...(size ? { width: size.width, height: size.height } : {}),
|
|
298
|
+
};
|
|
289
299
|
}
|
|
290
300
|
if (kind === 'file') {
|
|
291
301
|
const file = item.file_item;
|
package/src/protocol/mime.ts
CHANGED
|
@@ -1,5 +1,5 @@
|
|
|
1
1
|
/**
|
|
2
|
-
* 按扩展名判 MIME
|
|
2
|
+
* 按扩展名判 MIME、反向取扩展名,以及读图片文件头的像素尺寸。
|
|
3
3
|
*
|
|
4
4
|
* 微信按 MIME 决定一条媒体走图片、视频还是文件通道(见 `sendMedia`),
|
|
5
5
|
* 所以这张表决定「发出去是一张图还是一个附件」。
|
|
@@ -90,3 +90,75 @@ export function extensionForInbound(mime: string, bytes: Uint8Array): string {
|
|
|
90
90
|
if (mime && mime !== OCTET_STREAM) return extensionFromMime(mime);
|
|
91
91
|
return extensionFromMime(sniffImageMime(bytes) || OCTET_STREAM);
|
|
92
92
|
}
|
|
93
|
+
|
|
94
|
+
/** 读图片文件头里的像素尺寸;格式认不出或数据不够时返回 null。 */
|
|
95
|
+
export function imageSize(bytes: Uint8Array): { width: number; height: number } | null {
|
|
96
|
+
const b = bytes;
|
|
97
|
+
const be16 = (i: number): number => (b[i]! << 8) | b[i + 1]!;
|
|
98
|
+
const be32 = (i: number): number => ((b[i]! << 24) | (b[i + 1]! << 16) | (b[i + 2]! << 8) | b[i + 3]!) >>> 0;
|
|
99
|
+
const le16 = (i: number): number => b[i]! | (b[i + 1]! << 8);
|
|
100
|
+
const le32 = (i: number): number => (b[i]! | (b[i + 1]! << 8) | (b[i + 2]! << 16) | (b[i + 3]! << 24)) >>> 0;
|
|
101
|
+
|
|
102
|
+
if (b.length >= 24 && b[0] === 0x89 && b[1] === 0x50 && b[2] === 0x4e && b[3] === 0x47) {
|
|
103
|
+
return { width: be32(16), height: be32(20) };
|
|
104
|
+
}
|
|
105
|
+
if (b.length >= 10 && b[0] === 0x47 && b[1] === 0x49 && b[2] === 0x46) {
|
|
106
|
+
return { width: le16(6), height: le16(8) };
|
|
107
|
+
}
|
|
108
|
+
if (b.length >= 30 && b[0] === 0x52 && b[1] === 0x49 && b[2] === 0x46 && b[3] === 0x46
|
|
109
|
+
&& b[8] === 0x57 && b[9] === 0x45 && b[10] === 0x42 && b[11] === 0x50) {
|
|
110
|
+
return webpSize(b, le16, le32);
|
|
111
|
+
}
|
|
112
|
+
if (b.length >= 26 && b[0] === 0x42 && b[1] === 0x4d) {
|
|
113
|
+
return { width: le32(18), height: Math.abs(le32(22) | 0) };
|
|
114
|
+
}
|
|
115
|
+
if (b.length >= 4 && b[0] === 0xff && b[1] === 0xd8) return jpegSize(b);
|
|
116
|
+
return null;
|
|
117
|
+
}
|
|
118
|
+
|
|
119
|
+
/** JPEG 的尺寸在 SOF 段里;逐段走到 SOF 为止,跳过填充字节与独立的 RSTn。 */
|
|
120
|
+
function jpegSize(b: Uint8Array): { width: number; height: number } | null {
|
|
121
|
+
let i = 2;
|
|
122
|
+
while (i + 9 < b.length) {
|
|
123
|
+
if (b[i] !== 0xff) return null;
|
|
124
|
+
const marker = b[i + 1]!;
|
|
125
|
+
if (marker === 0xff) { i += 1; continue; }
|
|
126
|
+
if (marker === 0x01 || (marker >= 0xd0 && marker <= 0xd7)) { i += 2; continue; }
|
|
127
|
+
// 到了扫描数据或文件尾还没见到 SOF,说明这个文件没有可读的尺寸。
|
|
128
|
+
if (marker === 0xd9 || marker === 0xda) return null;
|
|
129
|
+
const length = (b[i + 2]! << 8) | b[i + 3]!;
|
|
130
|
+
if (length < 2) return null;
|
|
131
|
+
// SOF0–SOF15 里 C4(DHT)、C8(JPG)、CC(DAC) 不是帧头。
|
|
132
|
+
if (marker >= 0xc0 && marker <= 0xcf && marker !== 0xc4 && marker !== 0xc8 && marker !== 0xcc) {
|
|
133
|
+
return { height: (b[i + 5]! << 8) | b[i + 6]!, width: (b[i + 7]! << 8) | b[i + 8]! };
|
|
134
|
+
}
|
|
135
|
+
i += 2 + length;
|
|
136
|
+
}
|
|
137
|
+
return null;
|
|
138
|
+
}
|
|
139
|
+
|
|
140
|
+
/** WebP 三种子格式各有一套宽高编码。 */
|
|
141
|
+
function webpSize(
|
|
142
|
+
b: Uint8Array,
|
|
143
|
+
le16: (i: number) => number,
|
|
144
|
+
le32: (i: number) => number,
|
|
145
|
+
): { width: number; height: number } | null {
|
|
146
|
+
const chunk = String.fromCharCode(b[12]!, b[13]!, b[14]!, b[15]!);
|
|
147
|
+
if (chunk === 'VP8X') {
|
|
148
|
+
return {
|
|
149
|
+
width: 1 + (b[24]! | (b[25]! << 8) | (b[26]! << 16)),
|
|
150
|
+
height: 1 + (b[27]! | (b[28]! << 8) | (b[29]! << 16)),
|
|
151
|
+
};
|
|
152
|
+
}
|
|
153
|
+
if (chunk === 'VP8 ') {
|
|
154
|
+
// 关键帧起始码 9D 01 2A 之后是 14 位宽、14 位高。
|
|
155
|
+
if (b[23] !== 0x9d || b[24] !== 0x01 || b[25] !== 0x2a) return null;
|
|
156
|
+
return { width: le16(26) & 0x3fff, height: le16(28) & 0x3fff };
|
|
157
|
+
}
|
|
158
|
+
if (chunk === 'VP8L') {
|
|
159
|
+
if (b[20] !== 0x2f) return null;
|
|
160
|
+
const bits = le32(21);
|
|
161
|
+
return { width: (bits & 0x3fff) + 1, height: ((bits >>> 14) & 0x3fff) + 1 };
|
|
162
|
+
}
|
|
163
|
+
return null;
|
|
164
|
+
}
|
package/src/segment.ts
ADDED
|
@@ -0,0 +1,185 @@
|
|
|
1
|
+
/**
|
|
2
|
+
* 语义分段:把桌宠一次回复切成多条微信消息。
|
|
3
|
+
*
|
|
4
|
+
* 微信里一句一条才像人在说话。这里按「语义」拆,长度上限交给 `splitText`。
|
|
5
|
+
*
|
|
6
|
+
* ## 四种情况,只按一种分隔符拆
|
|
7
|
+
*
|
|
8
|
+
* ```
|
|
9
|
+
* ① 含 \n → 只按 \n 拆
|
|
10
|
+
* ② 无 \n,但有 。/./. → 只按句号拆
|
|
11
|
+
* ③ 无 \n 无句号,但有 !?…~ → 只按这些拆
|
|
12
|
+
* ④ 都没有 → 不分段
|
|
13
|
+
* ```
|
|
14
|
+
*
|
|
15
|
+
* **段内不再二次拆。** 一处文本里同时有换行和句号时(例如「三层:\n…第一。\n…」),
|
|
16
|
+
* 按换行拆完就结束;若再按句号拆一次,会多出空段、节奏也乱。
|
|
17
|
+
*
|
|
18
|
+
* ## 删谁不删谁
|
|
19
|
+
*
|
|
20
|
+
* - `\n`、`。`(U+3002)、`.`(U+FF0E) 删掉:中文社交软件里句号显得生硬,换行是版式。
|
|
21
|
+
* - `.`(U+002E) **只在后面跟空白或位于结尾时**才算句号,删掉。否则 `3.14`、
|
|
22
|
+
* `docs.nonebot.dev`、`report.2026.11.md` 会被切坏。
|
|
23
|
+
* - `!?!?…~~` 只拆不删:它们带情绪,删了语气就变平。
|
|
24
|
+
*
|
|
25
|
+
* ## 哪条规则同时命中
|
|
26
|
+
*
|
|
27
|
+
* 优先级从上往下:只要出现 `\n` 就用换行;只要有中文句号就用句号;
|
|
28
|
+
* 只剩情绪标点才用它。混排时不会两个都用,这正是「只按一次算」的含义。
|
|
29
|
+
*/
|
|
30
|
+
|
|
31
|
+
/** 中文句号与全角句点:无条件当分隔符,且删掉。 */
|
|
32
|
+
const HARD_STOPS = new Set(['。', '.']);
|
|
33
|
+
|
|
34
|
+
/** 情绪标点:只拆不删。 */
|
|
35
|
+
const SOFT_STOPS = new Set(['!', '?', '!', '?', '…', '~', '~']);
|
|
36
|
+
|
|
37
|
+
/** 空白字符(用来判断 ASCII 句点后面是不是断句)。 */
|
|
38
|
+
const isSpace = (ch: string | undefined): boolean => ch === undefined || /\s/.test(ch);
|
|
39
|
+
|
|
40
|
+
/**
|
|
41
|
+
* 判断位置 `i` 的 ASCII 句点算不算句号。
|
|
42
|
+
*
|
|
43
|
+
* 只有「后面是空白或已到结尾」才算。这样 `3.14`、`a.txt`、`example.com` 不会被拆。
|
|
44
|
+
*/
|
|
45
|
+
function isAsciiStop(text: string, i: number): boolean {
|
|
46
|
+
return isSpace(text[i + 1]);
|
|
47
|
+
}
|
|
48
|
+
|
|
49
|
+
/** 一个切点:分隔符起点、终点,以及切完要不要把它留在前一段里。 */
|
|
50
|
+
interface CutPoint {
|
|
51
|
+
/** 分隔符起点。 */
|
|
52
|
+
start: number;
|
|
53
|
+
/** 分隔符终点(不含)。 */
|
|
54
|
+
end: number;
|
|
55
|
+
/**
|
|
56
|
+
* 切完之后,分隔符本身留在前一段末尾(`keep`),还是删掉。
|
|
57
|
+
*
|
|
58
|
+
* `。`/换行删掉;`!?…~` 保留语气,留在前段里。
|
|
59
|
+
*/
|
|
60
|
+
keep: boolean;
|
|
61
|
+
}
|
|
62
|
+
|
|
63
|
+
/** 找出所有切点,按位置升序。 */
|
|
64
|
+
function findCuts(text: string, kind: 'newline' | 'stop' | 'soft'): CutPoint[] {
|
|
65
|
+
const cuts: CutPoint[] = [];
|
|
66
|
+
for (let i = 0; i < text.length; i += 1) {
|
|
67
|
+
const ch = text[i]!;
|
|
68
|
+
if (kind === 'newline') {
|
|
69
|
+
// 换行是版式,不留在正文里。
|
|
70
|
+
if (ch === '\n') cuts.push({ start: i, end: i + 1, keep: false });
|
|
71
|
+
continue;
|
|
72
|
+
}
|
|
73
|
+
if (kind === 'stop') {
|
|
74
|
+
// 句号删掉:社交软件里带着它显得生硬。
|
|
75
|
+
if (HARD_STOPS.has(ch)) {
|
|
76
|
+
cuts.push({ start: i, end: i + 1, keep: false });
|
|
77
|
+
continue;
|
|
78
|
+
}
|
|
79
|
+
if (ch === '.' && isAsciiStop(text, i)) cuts.push({ start: i, end: i + 1, keep: false });
|
|
80
|
+
continue;
|
|
81
|
+
}
|
|
82
|
+
// kind === 'soft':只拆不删,标点留在前一段。
|
|
83
|
+
if (SOFT_STOPS.has(ch)) {
|
|
84
|
+
// 成对的「!?」算一处,别拆两个空段。
|
|
85
|
+
const next = text[i + 1];
|
|
86
|
+
if (next && SOFT_STOPS.has(next) && ch + next === '!?') {
|
|
87
|
+
cuts.push({ start: i, end: i + 2, keep: true });
|
|
88
|
+
i += 1;
|
|
89
|
+
continue;
|
|
90
|
+
}
|
|
91
|
+
cuts.push({ start: i, end: i + 1, keep: true });
|
|
92
|
+
}
|
|
93
|
+
}
|
|
94
|
+
return cuts;
|
|
95
|
+
}
|
|
96
|
+
|
|
97
|
+
/** 有没有可用的分隔符,以及该用哪一种。 */
|
|
98
|
+
function pickKind(text: string): 'newline' | 'stop' | 'soft' | null {
|
|
99
|
+
if (text.includes('\n')) return 'newline';
|
|
100
|
+
if (findCuts(text, 'stop').length > 0) return 'stop';
|
|
101
|
+
if (findCuts(text, 'soft').length > 0) return 'soft';
|
|
102
|
+
return null;
|
|
103
|
+
}
|
|
104
|
+
|
|
105
|
+
/**
|
|
106
|
+
* 按语义把 `text` 拆成若干段。
|
|
107
|
+
*
|
|
108
|
+
* 返回值已去掉分隔符、去掉首尾空白、丢弃空段。不含分隔符时返回单元素数组,
|
|
109
|
+
* 调用方不必区分「拆了」和「没拆」。
|
|
110
|
+
*
|
|
111
|
+
* 这里**只管语义**,不管单条长度上限:结果里某段仍超过微信的 4000 字时,
|
|
112
|
+
* 由调用方交给 `splitText` 再切。
|
|
113
|
+
*/
|
|
114
|
+
export function splitSegments(text: string): string[] {
|
|
115
|
+
const source = String(text ?? '');
|
|
116
|
+
const kind = pickKind(source);
|
|
117
|
+
if (!kind) {
|
|
118
|
+
const only = source.trim();
|
|
119
|
+
return only ? [only] : [];
|
|
120
|
+
}
|
|
121
|
+
|
|
122
|
+
const cuts = findCuts(source, kind);
|
|
123
|
+
const parts: string[] = [];
|
|
124
|
+
let cursor = 0;
|
|
125
|
+
|
|
126
|
+
for (const cut of cuts) {
|
|
127
|
+
// `keep` 为真时把分隔符留在前一段末尾(`!?…~` 的语气不能丢)。
|
|
128
|
+
const piece = source.slice(cursor, cut.keep ? cut.end : cut.start).trim();
|
|
129
|
+
if (piece) parts.push(piece);
|
|
130
|
+
cursor = cut.end;
|
|
131
|
+
}
|
|
132
|
+
const tail = source.slice(cursor).trim();
|
|
133
|
+
if (tail) parts.push(tail);
|
|
134
|
+
|
|
135
|
+
return parts;
|
|
136
|
+
}
|
|
137
|
+
|
|
138
|
+
/** 分段延时的两种口径。 */
|
|
139
|
+
export type SegmentDelay = { mode: 'fixed'; seconds: number } | { mode: 'random'; min: number; max: number };
|
|
140
|
+
|
|
141
|
+
/**
|
|
142
|
+
* 从配置段里取出延时口径。
|
|
143
|
+
*
|
|
144
|
+
* 数值容错:负数归零、`NaN` 归零;随机区间写反了由 `segmentDelayMs` 换回来。
|
|
145
|
+
*/
|
|
146
|
+
export function segmentDelayOf(cfg: {
|
|
147
|
+
segmentDelayMode?: string;
|
|
148
|
+
segmentDelayFixedSec?: number;
|
|
149
|
+
segmentDelayMinSec?: number;
|
|
150
|
+
segmentDelayMaxSec?: number;
|
|
151
|
+
}): SegmentDelay {
|
|
152
|
+
if (cfg.segmentDelayMode === 'random') {
|
|
153
|
+
return {
|
|
154
|
+
mode: 'random',
|
|
155
|
+
min: numOr0(cfg.segmentDelayMinSec),
|
|
156
|
+
max: numOr0(cfg.segmentDelayMaxSec),
|
|
157
|
+
};
|
|
158
|
+
}
|
|
159
|
+
return { mode: 'fixed', seconds: numOr0(cfg.segmentDelayFixedSec) };
|
|
160
|
+
}
|
|
161
|
+
|
|
162
|
+
const numOr0 = (value: unknown): number => {
|
|
163
|
+
const n = Number(value);
|
|
164
|
+
return Number.isFinite(n) && n > 0 ? n : 0;
|
|
165
|
+
};
|
|
166
|
+
|
|
167
|
+
/**
|
|
168
|
+
* 算第 `index` 段发完之后该等多久(毫秒)。
|
|
169
|
+
*
|
|
170
|
+
* `index` 从 0 开始;最后一段之后不需要等待,调用方自己判断。
|
|
171
|
+
* 这里只做**纯计算**,不 sleep,方便测试与调用方控制总时长。
|
|
172
|
+
*
|
|
173
|
+
* 随机口径用 `random` 注入,默认 `Math.random`。
|
|
174
|
+
*/
|
|
175
|
+
export function segmentDelayMs(delay: SegmentDelay, index: number, random: () => number = Math.random): number {
|
|
176
|
+
void index;
|
|
177
|
+
if (delay.mode === 'fixed') {
|
|
178
|
+
return Math.max(0, Math.round(delay.seconds * 1000));
|
|
179
|
+
}
|
|
180
|
+
const lo = Math.min(delay.min, delay.max);
|
|
181
|
+
const hi = Math.max(delay.min, delay.max);
|
|
182
|
+
const span = Math.max(0, hi - lo);
|
|
183
|
+
const pick = lo + span * Math.min(Math.max(random(), 0), 1);
|
|
184
|
+
return Math.max(0, Math.round(pick * 1000));
|
|
185
|
+
}
|
package/src/world.ts
CHANGED
|
@@ -14,6 +14,8 @@ import { fileURLToPath } from 'node:url';
|
|
|
14
14
|
|
|
15
15
|
import QRCode from 'qrcode';
|
|
16
16
|
|
|
17
|
+
import pkg from '../package.json' with { type: 'json' };
|
|
18
|
+
|
|
17
19
|
import type {
|
|
18
20
|
BlobInput,
|
|
19
21
|
Logger,
|
|
@@ -36,6 +38,7 @@ import { UploadMediaType, TypingStatus, type WeixinMessage } from './protocol/ty
|
|
|
36
38
|
import { ILinkDriver } from './driver.ts';
|
|
37
39
|
import { CredentialStore, type AuthRecord } from './store.ts';
|
|
38
40
|
import { pickChannel, splitText } from './text.ts';
|
|
41
|
+
import { segmentDelayMs, segmentDelayOf, splitSegments } from './segment.ts';
|
|
39
42
|
import { ensureFfmpeg, installFfmpeg, installedSize, removeFfmpeg, type FfmpegResolution, type InstallProgress } from './media/ffmpeg.ts';
|
|
40
43
|
import { extractFrames } from './media/frames.ts';
|
|
41
44
|
import {
|
|
@@ -49,7 +52,8 @@ export const EVENT_MESSAGE = 'wechat-claw.message';
|
|
|
49
52
|
export const EVENT_LINK = 'wechat-claw.link';
|
|
50
53
|
|
|
51
54
|
const ENV_PROMPT_FILE = fileURLToPath(new URL('./ENV_PROMPT.md', import.meta.url));
|
|
52
|
-
|
|
55
|
+
/** 版本号只认 package.json;这里再抄一份会漂。 */
|
|
56
|
+
const PACKAGE_VERSION: string = pkg.version;
|
|
53
57
|
/** 发消息时上报的观测标识,形状是 UA 的 `Name/Version`。 */
|
|
54
58
|
const BOT_AGENT = `Cortico/6 (Coopanion; cortico-world-wechat-claw/${PACKAGE_VERSION})`;
|
|
55
59
|
|
|
@@ -197,6 +201,10 @@ export class WechatClawWorld implements World {
|
|
|
197
201
|
#lastError = '';
|
|
198
202
|
#lastMessageAt = '';
|
|
199
203
|
#contextCount = 0;
|
|
204
|
+
/** 段间等待的唤醒钩子;stop() 用它打断睡眠。 */
|
|
205
|
+
#sleepWake: (() => void) | null = null;
|
|
206
|
+
/** 随机源;测试可替换成定值。 */
|
|
207
|
+
#random: () => number = Math.random;
|
|
200
208
|
#networkProblem = '';
|
|
201
209
|
#ffmpeg: FfmpegResolution | null = null;
|
|
202
210
|
/** ffmpeg 安装进度;null 表示没在装。 */
|
|
@@ -289,6 +297,13 @@ export class WechatClawWorld implements World {
|
|
|
289
297
|
return token;
|
|
290
298
|
}
|
|
291
299
|
|
|
300
|
+
/**
|
|
301
|
+
* 发一条文本。
|
|
302
|
+
*
|
|
303
|
+
* 分两层:先按语义拆(换行 / 句号 / 情绪标点),再对仍超长的段交给 `splitText` 硬切。
|
|
304
|
+
* 逐条真发,条间按配置等待;累计等待到上限就把剩下的连着发完,并在回执里说明。
|
|
305
|
+
* 全部发完才返回——回执报「已发送」时不骗人。
|
|
306
|
+
*/
|
|
292
307
|
async #toolSendText(args: Record<string, unknown>): Promise<string> {
|
|
293
308
|
const text = String(args.text ?? '').trim();
|
|
294
309
|
if (!text) throw new Error('text 不能为空。');
|
|
@@ -296,15 +311,115 @@ export class WechatClawWorld implements World {
|
|
|
296
311
|
const contextToken = await this.#requireContextToken(to);
|
|
297
312
|
const api = this.#requireApi();
|
|
298
313
|
|
|
299
|
-
const chunks =
|
|
300
|
-
|
|
301
|
-
|
|
314
|
+
const { chunks, merged, waits } = this.#planChunks(text);
|
|
315
|
+
|
|
316
|
+
let sleptMs = 0;
|
|
317
|
+
const maxTotalMs = Math.max(0, Number(this.#cfg.segmentMaxTotalSec) || 0) * 1000;
|
|
318
|
+
let budgetCut = false;
|
|
319
|
+
|
|
320
|
+
for (let i = 0; i < chunks.length; i += 1) {
|
|
321
|
+
await api.sendMessage(textMessage({ to, text: chunks[i]!, contextToken }));
|
|
322
|
+
|
|
323
|
+
const isLast = i === chunks.length - 1;
|
|
324
|
+
if (isLast) break;
|
|
325
|
+
|
|
326
|
+
const waitMs = waits[i] ?? 0;
|
|
327
|
+
if (waitMs <= 0) continue;
|
|
328
|
+
|
|
329
|
+
// 预算不够就**不再等**,但剩下的段必须照常发完——不能因为等不起就不发了。
|
|
330
|
+
if (maxTotalMs > 0 && sleptMs + waitMs > maxTotalMs) {
|
|
331
|
+
budgetCut = true;
|
|
332
|
+
continue;
|
|
333
|
+
}
|
|
334
|
+
|
|
335
|
+
// 下一段之前先亮「正在输入」,让人看着像还在打,而不是卡住。
|
|
336
|
+
void this.#signalTyping(to, contextToken);
|
|
337
|
+
await this.#sleepMs(waitMs);
|
|
338
|
+
sleptMs += waitMs;
|
|
339
|
+
}
|
|
340
|
+
|
|
341
|
+
this.#host?.log?.info?.('微信已发送文本', {
|
|
342
|
+
to: shortId(to),
|
|
343
|
+
chars: text.length,
|
|
344
|
+
parts: chunks.length,
|
|
345
|
+
merged,
|
|
346
|
+
sleptMs,
|
|
347
|
+
budgetCut,
|
|
348
|
+
});
|
|
349
|
+
|
|
350
|
+
const bits: string[] = [];
|
|
351
|
+
if (chunks.length > 1) bits.push(`分 ${chunks.length} 条`);
|
|
352
|
+
if (merged) bits.push(`内容过多,已合并到 ${chunks.length} 条`);
|
|
353
|
+
if (budgetCut) bits.push('等待到上限,其余连着发完');
|
|
354
|
+
if (sleptMs > 0) bits.push(`共等待 ${(sleptMs / 1000).toFixed(1)} 秒`);
|
|
355
|
+
const suffix = bits.length ? `,${bits.join(',')}` : '';
|
|
356
|
+
return `已发送到微信(${shortId(to)})${suffix},共 ${text.length} 字。`;
|
|
357
|
+
}
|
|
358
|
+
|
|
359
|
+
/**
|
|
360
|
+
* 把一次回复规划成要发的内容。
|
|
361
|
+
*
|
|
362
|
+
* - 语义分段(`splitSegments`)
|
|
363
|
+
* - 每段仍超 4000 字时交给 `splitText` 再切,保证发得出去
|
|
364
|
+
* - 总段数超过 `segmentMaxParts` 时,把多出来的并进最后一段
|
|
365
|
+
* - 给出每段之后该等多久(毫秒)
|
|
366
|
+
*
|
|
367
|
+
* 分段关闭时退化成原来的行为:只按长度切、不等。
|
|
368
|
+
*/
|
|
369
|
+
#planChunks(text: string): { chunks: string[]; waits: number[]; merged: boolean } {
|
|
370
|
+
const enabled = this.#cfg.segmentEnabled !== false;
|
|
371
|
+
|
|
372
|
+
// 语义段 → 长度段。
|
|
373
|
+
const seedParts = enabled ? splitSegments(text) : [text];
|
|
374
|
+
let chunks: string[] = [];
|
|
375
|
+
for (const part of seedParts.length ? seedParts : [text]) {
|
|
376
|
+
for (const piece of splitText(part, MAX_TEXT_CHARS)) {
|
|
377
|
+
if (piece) chunks.push(piece);
|
|
378
|
+
}
|
|
302
379
|
}
|
|
303
|
-
|
|
304
|
-
|
|
305
|
-
|
|
380
|
+
if (!chunks.length) chunks = [text];
|
|
381
|
+
|
|
382
|
+
// 段数上限:多的并进最后一段。
|
|
383
|
+
const maxParts = Math.floor(Number(this.#cfg.segmentMaxParts) || 0);
|
|
384
|
+
let merged = false;
|
|
385
|
+
if (enabled && maxParts > 0 && chunks.length > maxParts) {
|
|
386
|
+
const keep = chunks.slice(0, maxParts - 1);
|
|
387
|
+
const rest = chunks.slice(maxParts - 1).join('');
|
|
388
|
+
chunks = [...keep, rest];
|
|
389
|
+
merged = true;
|
|
390
|
+
}
|
|
391
|
+
|
|
392
|
+
// 每段之后的等待;关闭分段时全 0。
|
|
393
|
+
const waits: number[] = [];
|
|
394
|
+
if (enabled) {
|
|
395
|
+
const delay = segmentDelayOf(this.#cfg);
|
|
396
|
+
for (let i = 0; i < chunks.length - 1; i += 1) {
|
|
397
|
+
waits.push(segmentDelayMs(delay, i, this.#random));
|
|
398
|
+
}
|
|
399
|
+
} else {
|
|
400
|
+
for (let i = 0; i < chunks.length - 1; i += 1) waits.push(0);
|
|
401
|
+
}
|
|
402
|
+
|
|
403
|
+
return { chunks, waits, merged };
|
|
306
404
|
}
|
|
307
405
|
|
|
406
|
+
/** 等一会儿;`stop()` 时会被唤醒,避免关机干等半分钟。 */
|
|
407
|
+
#sleepMs(ms: number): Promise<void> {
|
|
408
|
+
if (ms <= 0) return Promise.resolve();
|
|
409
|
+
return new Promise((resolve) => {
|
|
410
|
+
const timer = setTimeout(() => {
|
|
411
|
+
this.#sleepWake = null;
|
|
412
|
+
resolve();
|
|
413
|
+
}, ms);
|
|
414
|
+
this.#sleepWake = () => {
|
|
415
|
+
clearTimeout(timer);
|
|
416
|
+
this.#sleepWake = null;
|
|
417
|
+
resolve();
|
|
418
|
+
};
|
|
419
|
+
});
|
|
420
|
+
}
|
|
421
|
+
|
|
422
|
+
|
|
308
423
|
/**
|
|
309
424
|
* 图片与文件共用一条上传路径,只有 media_type 和消息项不同。
|
|
310
425
|
*
|
|
@@ -1311,6 +1426,8 @@ export class WechatClawWorld implements World {
|
|
|
1311
1426
|
|
|
1312
1427
|
async stop(): Promise<void> {
|
|
1313
1428
|
this.#started = false;
|
|
1429
|
+
// 打断段间等待,否则关机要干等到间隔结束。
|
|
1430
|
+
this.#sleepWake?.();
|
|
1314
1431
|
const login = this.#login;
|
|
1315
1432
|
if (login?.active) login.active = false;
|
|
1316
1433
|
this.#loginAbort?.abort();
|