9afb8b7b68
Lark and Feishu are the same product deployed on two isolated clouds (open.larksuite.com and open.feishu.cn). WeKnora touches both from two places — the IM bot and the Wiki data-source connector — and this brings Lark to parity across both. Neither API surface differs, so rather than duplicate either implementation, each is parametrized by a Region and registered twice. IM (internal/im/feishu): Every API call routes through a.api(), which prefixes the region's host, and the WebSocket client passes larkws.WithDomain — the SDK defaults to open.feishu.cn, so Lark long connections would otherwise fail to authenticate. Data source (internal/datasource/connector/feishu): Lark was half-supported: the client honoured a base_url override and a LarkBaseURL constant existed, but the connector registered only as "feishu" and the UI never exposed base_url, so Lark wikis could not be configured at all. Lark is now its own connector type. base_url is kept as an explicit override so data sources that pointed a "feishu" connector at open.larksuite.com keep working. Bugs found and fixed along the way: - Wiki resource links were hardcoded to https://feishu.cn/wiki/{token} in four places, so a Lark wiki linked into the wrong cloud entirely. - Bot identity is now platform-prefixed (feishu:cli_x vs lark:cli_x). BotIdentity carries a unique index, so without this a Lark channel would be rejected as a duplicate of an unrelated Feishu bot sharing an app_id. - The card image cache is now keyed by app_id. image_keys are issued per app on one cloud; a Feishu key handed to a Lark app fails the card update with code=200570. - The datasource doc claimed Lark "adapts automatically" — it could not, since the UI had no way to reach base_url. Permissions are where the clouds genuinely diverge. Identical APIs do not mean identical permission catalogues: aily:file:read, aily:file:write and corehr:file:download exist on Feishu but not on Lark, so pasting Feishu's scope JSON into Lark fails to import. That JSON is also over-broad (it covers products WeKnora never calls) and simultaneously incomplete (it omits the drive:*/docx:* scopes the connector needs). Lark therefore gets its own list, derived from the 17 endpoints the code actually calls and checked identifier-by-identifier against Lark's own API reference, plus a full Feishu→Lark mapping table marking each scope verified, unverified, or absent. Both features use tenant_access_token only — no user_access_ token exists anywhere in the repo — so the user dimension stays empty. Known limitation: Region.ThinkingText makes Lark's initial card placeholder English, but once streaming starts the think-block headers come from the shared MarkdownThinkStyle and are Chinese on every platform (Lark, Slack, Telegram, Mattermost alike). Fixing that means threading a locale through FormatIMDisplayContent, which has no platform context — a cross-platform change, not a Lark one. Documented as such. The channel-creation 400 message is now derived from validIMPlatforms so the list cannot drift as platforms are added. Tests: region invariants and per-region URL construction on both sides, the Feishu/Lark bot-identity split, platform-to-channel mapping, base_url override precedence, an end-to-end SendReply against a fake Open Platform (token fetch, reply, thread-unsupported fallback, hard-error surfacing), and a ListResources drive asserting wiki links never leak the other cloud's host. Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
65 lines
2.2 KiB
Go
65 lines
2.2 KiB
Go
package feishu
|
|
|
|
import (
|
|
"context"
|
|
"fmt"
|
|
|
|
"github.com/Tencent/WeKnora/internal/im"
|
|
"github.com/Tencent/WeKnora/internal/logger"
|
|
)
|
|
|
|
// NewFactory returns an im.AdapterFactory for channels on the given region's
|
|
// cloud — RegionFeishu for 飞书, RegionLark for Lark. Both use the same
|
|
// credentials and modes; only the API host and tenant differ.
|
|
//
|
|
// The HTTP adapter is always created (needed for SendReply in both modes);
|
|
// "websocket" mode additionally runs a long-connection event stream.
|
|
func NewFactory(region Region) im.AdapterFactory {
|
|
return func(factoryCtx context.Context, channel *im.IMChannel, msgHandler func(context.Context, *im.IncomingMessage) error) (im.Adapter, context.CancelFunc, error) {
|
|
creds, err := im.ParseCredentials(channel.Credentials)
|
|
if err != nil {
|
|
return nil, nil, fmt.Errorf("parse %s credentials: %w", region.Platform, err)
|
|
}
|
|
|
|
appID := im.GetString(creds, "app_id")
|
|
appSecret := im.GetString(creds, "app_secret")
|
|
verificationToken := im.GetString(creds, "verification_token")
|
|
encryptKey := im.GetString(creds, "encrypt_key")
|
|
|
|
// Always create the HTTP adapter (needed for SendReply in both modes)
|
|
adapter := NewAdapter(region, appID, appSecret, verificationToken, encryptKey)
|
|
|
|
mode := im.ResolveMode(channel, "websocket")
|
|
|
|
switch mode {
|
|
case "webhook":
|
|
return adapter, nil, nil
|
|
|
|
case "websocket":
|
|
client := NewLongConnClient(region, appID, appSecret, msgHandler)
|
|
|
|
wsCtx, wsCancel := context.WithCancel(context.Background())
|
|
go func() {
|
|
if err := client.Start(wsCtx); err != nil && wsCtx.Err() == nil {
|
|
logger.Errorf(context.Background(), "[IM] %s long connection stopped for channel %s: %v",
|
|
region.Label, channel.ID, err)
|
|
}
|
|
}()
|
|
|
|
// stop tears down the connection for real. wsCancel alone is a
|
|
// no-op: the Feishu SDK's Start blocks on select{} and never
|
|
// observes ctx, so we must call Close() to actually close the
|
|
// socket and disable auto-reconnect. wsCancel is kept as a
|
|
// belt-and-braces fallback for the start goroutine.
|
|
stop := func() {
|
|
client.Close()
|
|
wsCancel()
|
|
}
|
|
return adapter, stop, nil
|
|
|
|
default:
|
|
return nil, nil, fmt.Errorf("unknown %s mode: %s", region.Platform, mode)
|
|
}
|
|
}
|
|
}
|