fix(hub/wecom): use parseAccessToken for bind validation

The naive prefix-strip accepted any text starting with `${cliApiToken}:`
and stored the suffix as the namespace, so `TOKEN:foo:bar` was
confirmed as namespace `foo:bar` — but parseAccessToken (used by the
CLI and /api/auth) splits on the LAST colon and would parse the same
input as baseToken=`TOKEN:foo`, namespace=`bar`, then reject it
because the base token doesn't match. Net effect: a persisted WeCom
binding for a namespace no client could ever authenticate into.

Replace the manual parse with parseAccessToken + constantTimeEquals
on the base token. Now WeCom accepts exactly what the rest of HAPI
accepts: bare TOKEN binds to `default`, TOKEN:<ns> binds to <ns>,
TOKEN:foo:bar is rejected.

Author: wzxjohn

hub/src/wecom/bot.test.ts

@@ -257,6 +257,28 @@ describe('WecomBot binding', () => {
         const body = client.sendMessage.mock.calls[0][1] as Extract<SendMsgBody, { msgtype: 'markdown' }>
         expect(body.markdown.content).toContain('Already bound to namespace **nsA**')
     })
+
+    it('rejects "<token>:<a>:<b>" because parseAccessToken splits on the LAST colon', async () => {
+        // Old behaviour persisted namespace `foo:bar`, which no CLI/web client
+        // could ever authenticate into (parseAccessToken would parse the same
+        // string as baseToken=`TOKEN:foo`, namespace=`bar`).
+        const { client, addUser } = makeBot([])
+        client.emit('message.text', textFrame('u-new', 'TOKEN:foo:bar'))
+        await tick()
+        expect(addUser).not.toHaveBeenCalled()
+        expect(client.sendMessage.mock.calls).toHaveLength(0)
+    })
+
+    it('binds to the default namespace when only the bare token is sent', async () => {
+        // parseAccessToken returns { baseToken, namespace: 'default' } when the
+        // input has no colon — match that behaviour rather than silently dropping.
+        const { client, addUser } = makeBot([])
+        client.emit('message.text', textFrame('u-new', 'TOKEN'))
+        await tick()
+        expect(addUser).toHaveBeenCalledWith('wecom', 'u-new', 'default')
+        const body = client.sendMessage.mock.calls[0][1] as Extract<SendMsgBody, { msgtype: 'markdown' }>
+        expect(body.markdown.content).toContain('namespace **default**')
+    })
 })
 
 function clickFrame(eventKey: string, userid: string, reqId: string): WsFrame {

hub/src/wecom/bot.ts

@@ -15,6 +15,8 @@ import {
     buildSessionCompletionCard,
     buildTaskCard
 } from './sessionView'
+import { parseAccessToken } from '../utils/accessToken'
+import { constantTimeEquals } from '../utils/crypto'
 
 /** 30 s cooldown before we try to reconnect after a server-initiated kick. */
 const SERVER_KICK_RECONNECT_DELAY_MS = 30_000
@@ -168,19 +170,22 @@ export class WecomBot implements NotificationChannel {
 
     private onTextMessage(frame: WsFrame): void {
         const body = frame.body as { text?: { content?: string }; from?: { userid?: string } } | undefined
-        const content = body?.text?.content?.trim()
+        const content = body?.text?.content
         const userid = body?.from?.userid
         if (!content || !userid) return
 
-        const prefix = `${this.cliApiToken}:`
-        if (!content.startsWith(prefix)) return
-        const namespace = content.slice(prefix.length).trim()
-        if (!namespace) return
+        // Use parseAccessToken (the same parser /api/auth and the CLI use) so we
+        // can't persist a binding that no client could authenticate into. The
+        // naive prefix-strip would accept `TOKEN:foo:bar` as namespace `foo:bar`
+        // even though parseAccessToken splits on the LAST colon and would reject
+        // that token (baseToken becomes `TOKEN:foo`, which is not our token).
+        const parsed = parseAccessToken(content)
+        if (!parsed || !constantTimeEquals(parsed.baseToken, this.cliApiToken)) return
+        const namespace = parsed.namespace
 
-        // Accept any non-empty namespace, matching parseAccessToken() and the
-        // /api/auth flow. Escape markdown metacharacters when interpolating
-        // into the confirmation reply so a namespace with `*` / `_` / `` ` ``
-        // can't break the rendered card.
+        // Escape markdown metacharacters when interpolating into the
+        // confirmation reply so a namespace with `*` / `_` / `` ` `` can't
+        // break the rendered card.
         const safeNamespace = escapeMarkdown(namespace)
         const safeUserid = escapeMarkdown(userid)