{
const defaultWebChannelConfig = getDefaultWebChannelConfig(t)
if (!configJson.trim()) {
@@ -276,6 +307,7 @@ function buildForm(item: AdminChannel | null, t: Translate): EditForm {
const isWechatMP = item.channelType === "wechat_mp"
const isTelegram = item.channelType === "telegram"
const isZaloOA = item.channelType === "zalo_oa"
+ const isDiscord = item.channelType === "discord"
const webConfig = parseWebChannelConfig(item.configJson, t)
const wechatConfig = isWechatMP
? parseWechatMPChannelConfig(item.configJson, t)
@@ -286,6 +318,9 @@ function buildForm(item: AdminChannel | null, t: Translate): EditForm {
const zaloConfig = isZaloOA
? parseZaloOAChannelConfig(item.configJson)
: null
+ const discordConfig = isDiscord
+ ? parseDiscordChannelConfig(item.configJson)
+ : null
return {
channelType:
item.channelType === "wxwork_kf"
@@ -294,20 +329,29 @@ function buildForm(item: AdminChannel | null, t: Translate): EditForm {
? "telegram"
: item.channelType === "zalo_oa"
? "zalo_oa"
- : item.channelType === "wechat_mp"
- ? "wechat_mp"
- : "web",
+ : item.channelType === "discord"
+ ? "discord"
+ : item.channelType === "wechat_mp"
+ ? "wechat_mp"
+ : "web",
aiAgentId: item.aiAgentId > 0 ? String(item.aiAgentId) : "",
aiAgentRolloutPercent: item.aiAgentRolloutPercent || 100,
name: item.name,
openKfId: parseOpenKfId(item.configJson),
botToken: telegramConfig?.botToken ?? "",
botUsername: telegramConfig?.botUsername ?? "",
- webhookSecret: telegramConfig?.webhookSecret ?? zaloConfig?.webhookSecret ?? "",
+ webhookSecret:
+ telegramConfig?.webhookSecret ??
+ zaloConfig?.webhookSecret ??
+ discordConfig?.webhookSecret ??
+ "",
zaloAppId: zaloConfig?.appId ?? "",
zaloOaId: zaloConfig?.oaId ?? "",
zaloAccessToken: zaloConfig?.accessToken ?? "",
zaloSecretKey: zaloConfig?.secretKey ?? "",
+ discordGuildId: discordConfig?.guildId ?? "",
+ discordGuildName: discordConfig?.guildName ?? "",
+ discordBotToken: discordConfig?.botToken ?? "",
widgetTitle: wechatConfig?.title ?? webConfig.title,
widgetSubtitle: wechatConfig?.subtitle ?? webConfig.subtitle,
widgetThemeColor: wechatConfig?.themeColor ?? webConfig.themeColor,
@@ -347,14 +391,21 @@ function buildPayload(form: EditForm, status: number, t: Translate): CreateAdmin
secretKey: form.zaloSecretKey.trim(),
webhookSecret: form.webhookSecret.trim(),
})
- : channelType === "wechat_mp"
- ? JSON.stringify(webLikeConfig)
- : JSON.stringify({
- ...webLikeConfig,
- position: form.widgetPosition || defaultWebChannelConfig.position,
- width: form.widgetWidth.trim() || defaultWebChannelConfig.width,
- userTokenSecret: form.userTokenSecret.trim(),
+ : channelType === "discord"
+ ? JSON.stringify({
+ guildId: form.discordGuildId.trim(),
+ guildName: form.discordGuildName.trim(),
+ botToken: form.discordBotToken.trim(),
+ webhookSecret: form.webhookSecret.trim(),
})
+ : channelType === "wechat_mp"
+ ? JSON.stringify(webLikeConfig)
+ : JSON.stringify({
+ ...webLikeConfig,
+ position: form.widgetPosition || defaultWebChannelConfig.position,
+ width: form.widgetWidth.trim() || defaultWebChannelConfig.width,
+ userTokenSecret: form.userTokenSecret.trim(),
+ })
return {
channelType,
aiAgentId: Number(form.aiAgentId),
@@ -543,6 +594,7 @@ function ChannelFormBody({
const channelTypeOptions = [
{ value: "web", label: t("channel.typeWeb") },
{ value: "telegram", label: t("channel.typeTelegram") },
+ { value: "discord", label: t("channel.typeDiscord") },
{ value: "wechat_mp", label: t("channel.typeWechatMp") },
{ value: "wxwork_kf", label: t("channel.typeWxworkKf") },
] as const
@@ -765,6 +817,57 @@ function ChannelFormBody({
) : null}
+ {channelType === "discord" ? (
+
+
+
+ {t("channel.discordGuildId")}
+
+
+
+
+
+ {t("channel.discordGuildName")}
+
+
+
+
+
+
+ {t("channel.discordBotToken")}
+
+
+
+
+
+
{t("channel.discordSetupTitle")}
+
{t("channel.discordSetupDescription")}
+
+ {t("channel.inboundWebhookUrl")}: /api/third/discord/webhook
+
+
+
diff --git a/web/app/(dashboard)/dashboard/channels/page.tsx b/web/app/(dashboard)/dashboard/channels/page.tsx
index aa8c06f7..4ecbc8de 100644
--- a/web/app/(dashboard)/dashboard/channels/page.tsx
+++ b/web/app/(dashboard)/dashboard/channels/page.tsx
@@ -2,6 +2,7 @@
import {
Building2Icon,
+ Gamepad2Icon,
MessagesSquareIcon,
MessageSquareMoreIcon,
SendIcon,
@@ -39,6 +40,9 @@ function getChannelTypeLabel(channelType: string, t: (key: string) => string) {
if (channelType === "zalo_oa") {
return t("channel.typeZaloOa")
}
+ if (channelType === "discord") {
+ return t("channel.typeDiscord")
+ }
return t("channel.typeWeb")
}
@@ -62,6 +66,9 @@ function ChannelIcon({ channelType }: { channelType: string }) {
if (channelType === "telegram" || channelType === "zalo_oa") {
return
Date: Wed, 16 Sep 2026 00:24:25 +0800
Subject: [PATCH 8/9] =?UTF-8?q?=E5=A2=9E=E5=8A=A0=E6=B6=88=E6=81=AF?=
=?UTF-8?q?=E5=A4=84=E7=90=86=E5=8D=A0=E4=BD=8D=EF=BC=8C=E6=8F=90=E5=8D=87?=
=?UTF-8?q?=E7=94=A8=E6=88=B7=E4=BD=93=E9=AA=8C=EF=BC=9B=E5=A2=9E=E5=8A=A0?=
=?UTF-8?q?=E7=B3=BB=E7=BB=9F=E6=97=A5=E5=BF=97=E5=8A=9F=E8=83=BD=EF=BC=8C?=
=?UTF-8?q?=E5=85=81=E8=AE=B8=E7=95=8C=E9=9D=A2=E7=9B=B4=E6=8E=A5=E6=9F=A5?=
=?UTF-8?q?=E7=9C=8B=E6=9C=80=E8=BF=91=E4=B8=80=E4=B8=AA=E6=9C=88info?=
=?UTF-8?q?=E4=BB=A5=E4=B8=8A=E7=BA=A7=E5=88=AB=E6=97=A5=E5=BF=97=EF=BC=9B?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit
---
AGENTS.md | 546 +++++++++---------
Dockerfile | 2 +
README_ZH.md | 10 +-
cmd/import_jsh_knowledge/main.go | 314 ++++++++++
cmd/server/main.go | 13 +
docker-compose.qdrant.yml | 30 +
internal/ai/runtime/reply_commit_service.go | 35 +-
internal/ai/runtime/reply_service_test.go | 18 +-
internal/ai/runtime/reply_trigger_service.go | 32 +-
internal/ai/runtime/reply_types.go | 8 +-
internal/bootstrap/init.go | 10 +-
internal/bootstrap/routes.go | 7 +
internal/bootstrap/server.go | 25 +
internal/bootstrap/server_route_test.go | 108 ++++
internal/builders/conversation_builder.go | 4 +
internal/builders/system_log_builder.go | 33 ++
.../handlers/dashboard/channel_handler.go | 20 +
.../dashboard/knowledge_document_handler.go | 18 +
.../handlers/dashboard/system_log_handler.go | 56 ++
internal/migration/000002_init_auth_data.go | 2 +
.../000010_backfill_employee_user_type.go | 32 +
internal/models/channel.go | 31 +
internal/models/models.go | 4 +
internal/models/system_log.go | 18 +
internal/pkg/constants/auth.go | 6 +
internal/pkg/dto/dto.go | 15 +
internal/pkg/dto/request/channel_request.go | 7 +
internal/pkg/dto/request/knowledge_request.go | 4 +
internal/pkg/dto/response/channel_response.go | 6 +
.../pkg/dto/response/conversation_response.go | 2 +
.../pkg/dto/response/system_log_response.go | 15 +
.../wxwork_kf_message_read_test_response.go | 32 +
internal/pkg/enums/external_identity.go | 26 +-
internal/pkg/enums/im.go | 1 +
internal/pkg/i18nx/locales/en-US.yml | 1 +
internal/pkg/i18nx/locales/zh-CN.yml | 1 +
internal/pkg/logx/db_sink.go | 225 ++++++++
internal/pkg/logx/logger.go | 31 +-
.../repositories/system_log_repository.go | 47 ++
.../services/ai_reply_placeholder_service.go | 205 +++++++
.../channel_message_outbox_service.go | 15 +-
.../channel_message_outbox_service_test.go | 201 +++++++
internal/services/channel_service.go | 6 +
internal/services/cronx/cron.go | 17 +-
.../services/knowledge_document_service.go | 25 +
internal/services/system_log_service.go | 32 +
internal/services/ws_realtime_types.go | 13 +
internal/services/ws_service.go | 26 +
.../wxwork_kf_message_read_test_service.go | 332 +++++++++++
.../dashboard/channels/_components/edit.tsx | 71 +++
.../channels/_components/read-test-button.tsx | 303 ++++++++++
.../(dashboard)/dashboard/channels/page.tsx | 39 +-
.../_components/conversation-info-panel.tsx | 21 +
.../_components/conversation-list.tsx | 26 +-
.../knowledge/_components/document-list.tsx | 73 ++-
.../dashboard/system-logs/page.tsx | 219 +++++++
web/components/support-chat/chat-shell.tsx | 27 +-
web/hooks/use-agent-conversation-realtime.ts | 3 +-
web/lib/api/admin.ts | 70 +++
web/lib/api/agent.ts | 2 +
web/lib/channel-i18n.ts | 48 ++
web/lib/navigation.tsx | 7 +
web/lib/sdk/agent-desk-sdk.ts | 527 ++++++++++++++++-
web/lib/stores/support-chat.ts | 4 +-
web/messages/en-US.json | 99 ++++
web/messages/zh-CN.json | 99 ++++
web/pnpm-workspace.yaml | 5 +
web/public/sdk/agent-desk-sdk.min.js | 2 +-
68 files changed, 3914 insertions(+), 398 deletions(-)
create mode 100644 cmd/import_jsh_knowledge/main.go
create mode 100644 docker-compose.qdrant.yml
create mode 100644 internal/builders/system_log_builder.go
create mode 100644 internal/handlers/dashboard/system_log_handler.go
create mode 100644 internal/migration/000010_backfill_employee_user_type.go
create mode 100644 internal/models/channel.go
create mode 100644 internal/models/system_log.go
create mode 100644 internal/pkg/dto/response/system_log_response.go
create mode 100644 internal/pkg/dto/response/wxwork_kf_message_read_test_response.go
create mode 100644 internal/pkg/logx/db_sink.go
create mode 100644 internal/repositories/system_log_repository.go
create mode 100644 internal/services/ai_reply_placeholder_service.go
create mode 100644 internal/services/channel_message_outbox_service_test.go
create mode 100644 internal/services/system_log_service.go
create mode 100644 internal/services/wxwork_kf_message_read_test_service.go
create mode 100644 web/app/(dashboard)/dashboard/channels/_components/read-test-button.tsx
create mode 100644 web/app/(dashboard)/dashboard/system-logs/page.tsx
create mode 100644 web/lib/channel-i18n.ts
diff --git a/AGENTS.md b/AGENTS.md
index 2c9e318c..6c436d37 100644
--- a/AGENTS.md
+++ b/AGENTS.md
@@ -1,275 +1,275 @@
# AGENTS.md
-This file defines the mandatory working agreement for AI agents in this repository. It is intentionally based on the current codebase rather than historical conventions.
-
-## 1. Scope and Priorities
-
-- These rules apply to the repository root and every subdirectory.
-- Explicit user instructions take precedence over this file. Mention any deliberate deviation in the final summary.
-- Inspect the relevant implementation before editing. Reuse current helpers, component APIs, generated-code workflows, and neighboring patterns instead of relying on memory.
-- Keep changes narrowly scoped. Preserve unrelated and user-owned worktree changes, including staged changes.
-- A review, investigation, or diagnosis request is read-only unless the user also asks for implementation.
-
-## 2. Current Architecture
-
-The repository contains three application areas:
-
-- Go server: `cmd/server` and `internal/*`
-- Next.js application: `web/*`
-- Embedded workflow editor: `flowgram-editor/*`, built into `web/public/flowgram-editor`
-
-The main stack is:
-
-- Go 1.26, Gin, GORM, `github.com/mlogclub/simple`
-- SQLite and MySQL
-- Next.js 16 App Router, React 19, TypeScript, Tailwind CSS, shadcn/Base UI
-- `pnpm` for both frontend projects
-- Optional LanceDB builds through CGO; Qdrant is also supported by the application
-
-Important entry points:
-
-- Server assembly and middleware: `internal/bootstrap/server.go`
-- Explicit API routes: `internal/bootstrap/routes.go`
-- Model registration: `internal/models/models.go`
-- Schema/data migration startup: `internal/bootstrap/migration.go`
-- CRUD generator: `cmd/generator/generator.go`
-- Frontend enum generator: `cmd/enums/generator.go`
-- Frontend API client: `web/lib/api/client.ts`
-- Frontend i18n: `web/i18n/*` and `web/messages/*`
-- Dashboard shared components: `web/components/dashboard/*`
-- Project commands: `Taskfile.yml`
-
-## 3. General Change Rules
-
-- Read the actual type, function, or component signature before using it.
-- Prefer the highest-level existing abstraction that fits the requirement. Do not duplicate query state, pagination, auth refresh, localization, or dashboard CRUD behavior.
-- Do not edit generated artifacts by hand. Change their source and run the corresponding generator/build command.
-- Do not add a second implementation style when the repository already has a shared path for the same concern.
-- Use `log/slog` for new Go logging and structured key-value fields for relevant context.
-- New Go code uses `any`, not `interface{}`. Existing generated or legacy code does not need unrelated cleanup.
-- Secrets, tokens, credentials, and private customer data must never be committed or printed in logs/tests.
-
-## 4. Go Backend
-
-### 4.1 Layer Ownership
-
-The normal dependency and data flow is:
-
-`models -> repositories -> services -> handlers -> builders/response DTOs`
-
-- `internal/models`: entity fields, GORM mappings, associations, and schema metadata only.
-- `internal/repositories`: GORM/SQL access, conditions, ordering, pagination, locks, and persistence details.
-- `internal/services`: business validation, state changes, authorization-independent domain rules, aggregation, transactions, and event orchestration.
-- `internal/handlers/{api,dashboard,third}`: HTTP parameter parsing, authentication/permission checks, service calls, and response writing.
-- `internal/builders`: pure model/aggregate-to-response mapping. Builders must not query the database.
-- `internal/pkg/dto/request` and `internal/pkg/dto/response`: external request/response contracts.
-
-Mandatory boundaries:
-
-- Handlers must not call repositories or issue GORM queries directly.
-- Models and repositories must not contain HTTP, permission, or cross-resource workflow logic.
-- GORM models must not be returned directly from an API. Map them to response DTOs/builders.
-- A service may return models internally, but public response shape remains owned by builders/DTOs.
-- Put reusable SQL in repositories. A genuinely one-off aggregate query may stay near its domain service only when extraction would make ownership less clear.
-
-### 4.2 Database and Transactions
-
-- Repository methods that participate in transactions accept `db *gorm.DB`; call them with `sqls.DB()` outside a transaction and `ctx.Tx` inside one.
-- Services own transaction boundaries through `sqls.WithTransaction`.
-- Use a transaction for atomic multi-write workflows and consistency-sensitive read-modify-write operations.
-- Do not add a transaction around a single independent SQL write.
-- Every database operation inside a transaction must use the same `ctx.Tx`; never escape to `sqls.DB()` mid-transaction.
-- Use `sqls.Cnd`/`sqls.NewCnd()` and repository methods for ordinary filtering and pagination.
-- Preserve SQLite and MySQL compatibility. Avoid dialect-specific SQL unless both dialects are explicitly implemented and tested.
-- Use portable column types and `int64` primary/foreign identifiers. Keep time handling compatible with MySQL `parseTime=True`.
-
-### 4.3 Models, Generation, and Migrations
-
-- Register persistent models in `internal/models/models.go` so startup `AutoMigrate(models.Models...)` includes them.
-- New tables, columns, indexes, and compatible constraints are normally applied by GORM `AutoMigrate` in `internal/bootstrap/migration.go`.
-- Use `internal/migration/*` only for versioned, idempotent data migration/backfill/repair work. Its version must increase monotonically.
-- When a model uses the standard generated repository/service surface, register it in `cmd/generator/generator.go` and run `task generator`.
-- Treat generator output as mechanical infrastructure. Put business-specific methods in handwritten files and do not manually patch generated CRUD output.
-- Backend/frontend shared enums are defined in `internal/pkg/enums`, annotated using the existing enum pattern, and generated with `task enums` into `web/lib/generated/enums.ts`.
-- Never create a handwritten frontend duplicate of a generated backend enum.
-
-### 4.4 HTTP APIs
-
-- All routes are explicit in `internal/bootstrap/routes.go`; handler names do not create endpoints.
-- Public/product APIs live under `/api/*`, authenticated management APIs under `/api/dashboard/*`, callbacks under `/api/third/*`, and WebSockets under `/api/ws/*`.
-- Add a resource-specific `register...Routes` function or extend the existing one, then mount it from `addRouter` under the correct group.
-- Follow the existing resource contract: detail commonly uses `GET /:id`, list uses `/list`, writes use explicit POST actions such as `/create`, `/update`, `/delete`, and domain actions retain their established snake_case path names.
-- Do not introduce `/api/v1`, automatic routing assumptions, or unnecessary deeply nested resource paths.
-- Handler names mirror the registered method and path, for example `XxxGetBy`, `XxxAnyList`, and `XxxPostCreate`.
-- Parse JSON/form/query/path values with `internal/pkg/httpx/params` and `internal/pkg/httpx` helpers.
-- Dashboard permission checks use `services.AuthService.RequirePermission` or the established permission helper before domain work.
-- Write responses through `httpx.WriteJSON`; preserve the shared `JsonResult` contract.
-- Paginated responses use `web.PageResult` with `data.results` and `data.page`.
-- Convert not-found, validation, permission, and persistence failures into stable application errors. Never expose raw SQL errors to clients.
-
-### 4.5 Backend Internationalization
-
-- Any new or changed user-visible backend error must support every backend locale, currently `zh-CN` and `en-US`.
-- Add matching keys to both `internal/pkg/i18nx/locales/zh-CN.yml` and `internal/pkg/i18nx/locales/en-US.yml` in the same change.
-- Services should return localized application errors through the `errorsx.*I18n` helpers.
-- Handlers that need an immediate localized response use `httpx.JsonErrorMsg(ctx, key, args...)`; other request-context translation uses `i18nx.T`.
-- Do not hard-code Chinese or English error sentences in handlers/services when the text can reach a user.
-- Keep format arguments equivalent across locales and cover new reusable/error-format behavior with focused tests.
-
-## 5. Frontend
-
-### 5.1 Component and Data Boundaries
-
-- Application routes live under `web/app`; reusable business components live under `web/components`; route-private components live in the route's `_components` directory.
-- Reuse `web/components/ui/*` primitives. Do not edit these shadcn base components for a feature-specific requirement.
-- Use the current Base UI/shadcn component API as implemented in the repository; do not assume APIs such as Radix `asChild` exist.
-- Use `@/*` imports for code within `web`.
-- Client components must declare `"use client"` when they use state, effects, browser APIs, or client-only hooks.
-- Keep resource APIs in `web/lib/api/*` and route all normal requests through `web/lib/api/client.ts`.
-- Pages, business components, and stores must not implement their own `JsonResult` parsing, auth header handling, token refresh, or login-expiry cleanup.
-- Direct `fetch` is reserved for unsupported transports such as third-party calls, binary transfers, SSE, and WebSocket handshakes; explain the exception in code.
-- Prefer `OptionCombobox` for standard dropdowns rather than adding shadcn Select-based business controls.
-- Format displayed timestamps with `formatDateTime` from `web/lib/utils.ts` unless the product explicitly requires a different representation.
-
-### 5.2 Dashboard Pages
-
-Before building a dashboard page, inspect `web/components/dashboard/crud`, `web/components/dashboard/list`, and `web/components/dashboard-page.tsx`.
-
-Use this order of preference:
-
-1. `DashboardCrudPage` for standard create/read/update/delete resources.
-2. `DashboardListPage` for read-only or custom-content paginated resources.
-3. `useDashboardPagedList` when layout is bespoke but list query/filter/pagination lifecycle is standard.
-4. `DashboardPage`, `DashboardToolbar`, `DashboardTableShell`, and related low-level primitives only for interactions that cannot fit the higher-level components.
-
-Rules:
-
-- Do not copy a resource page to recreate standard filters, query/reset/refresh actions, pagination, loading/empty states, confirmations, row actions, or dialogs.
-- Configure `DashboardCrudPage` through its filters, columns, labels, service callbacks, row actions, sorting, and form/dialog extension points before adding page-local infrastructure.
-- Use its schema-driven `DashboardCrudFormDialog` when supported. A genuinely custom form may live in `_components` and should normally use `react-hook-form`, `zod`, and `Field`.
-- Configure `DashboardListPage` with columns or `renderContent`, and use `renderToolbarActions` for resource-specific actions.
-- Business API knowledge stays in the page/service module; generic dashboard components must not import a resource-specific API.
-- A change to `web/components/dashboard/*` must be generic, backward-compatible, and useful beyond one page. Otherwise keep it local to the feature.
-
-### 5.3 Frontend Internationalization
-
-- Every frontend feature and modification must work in all `SUPPORTED_LOCALES`, currently `zh-CN` and `en-US`.
-- Add every new key to both `web/messages/zh-CN.json` and `web/messages/en-US.json` in the same change, preserving matching structure.
-- React pages/components use `useI18n()`; locale-aware formatting/mapping may also use `useAppLocale()`.
-- Non-React code uses `translateCurrentMessage()` or `translateMessage()` from `web/i18n/messages.ts`.
-- Do not hard-code user-visible copy in JSX/TSX, toast messages, dialogs, confirmations, placeholders, validation, empty/loading/error states, tooltips, accessibility labels, or client-side fallback errors.
-- Product names, protocol literals, user content, and raw business data do not need translation unless the UI already provides a display-name mapping.
-- Dashboard labels supplied to shared CRUD/list components must come from translation keys.
-- Centralize localized display names for backend identifiers/enums in a reusable `web/lib/*-i18n.ts` helper instead of duplicating locale switches across pages.
-- Preserve the same placeholders in every locale and interpolate with `t(key, values)`; do not assemble sentences by concatenating translated fragments.
-- Locale configuration belongs to `AppI18nProvider` and `web/i18n/config.ts`; features must not introduce separate locale detection or state.
-
-### 5.4 Commercial-Grade UI and Interaction
-
-This is a commercial product, not a prototype or component demo. UI work is complete only when it is visually coherent, interaction-complete, responsive, localized, and credible with real production data.
-
-#### Visual Quality
-
-- Follow the existing design language, spacing scale, typography, radius, color tokens, and component variants. A new feature must look native to the product rather than like a pasted template.
-- In support platform UI, if rounded corners are needed, use `rounded-md` consistently.
-- Support platform components should not add `shadow`.
-- Establish a clear hierarchy: page title/primary action, filters or context, main content, and secondary information. Do not make every region a card or every action visually prominent.
-- Prefer restrained, purposeful styling. Avoid decorative gradients, oversized hero text, excessive shadows, glass effects, emoji icons, random accent colors, and ornamental copy unless the product context explicitly calls for them.
-- Use Lucide icons consistently. Choose icons by meaning, keep icon size and stroke weight aligned with neighboring controls, and never use icons as decoration without communicative value.
-- Keep spacing and alignment deliberate at every breakpoint. Labels, inputs, table columns, action groups, dialog footers, and empty states must align cleanly without ad hoc offsets.
-- Design for realistic content, not ideal sample text. Verify long names, multiline content, large counts, missing optional fields, and mixed Chinese/English values. Use wrapping, truncation, tooltips, or scroll containers intentionally.
-- Preserve information density appropriate to an operations dashboard. Do not waste large areas on decoration, but do not compress controls until scanning and clicking become difficult.
-
-#### Interaction Completeness
-
-- Every asynchronous action must have an immediate and unambiguous state: pending/loading, success, failure, and retry or recovery when appropriate.
-- Prevent duplicate submissions. Disable or lock the initiating control while a mutation is pending and show action-specific progress text or a spinner without causing layout shift.
-- Keep feedback close to the action. Use inline validation for field problems, contextual error states for failed content, and toast notifications for completed background or page-level actions.
-- Never silently discard user input. Warn before closing, navigating away, resetting, or switching context when there are meaningful unsaved changes.
-- Destructive, irreversible, security-sensitive, or broad-impact operations require confirmation that clearly names the object and consequence. Do not use a generic “Are you sure?” message.
-- Confirmation is not a substitute for good defaults: routine reversible actions should remain efficient and should not be interrupted by unnecessary modal prompts.
-- After create/update/delete operations, keep list state coherent: refresh affected data, preserve useful filters/page position when possible, close dialogs only on success, and prevent stale selections or detail panels.
-- Buttons and menu items must use precise verbs describing the result. Avoid vague labels such as “OK”, “Submit”, or “Process” when a specific action name is available.
-- Preserve keyboard behavior and focus flow: Enter submits only where expected, Escape closes dismissible overlays, focus moves into dialogs and returns to the trigger, and destructive actions are not the accidental default.
-- Interactive rows, icons, badges, and text links must look interactive only when they are interactive. Do not rely on hover-only discoverability for essential actions.
-
-#### Forms and Dialogs
-
-- Use the smallest suitable interaction container: inline editing for simple local changes, a dialog for focused tasks, and a full page/workbench for complex or multi-step workflows.
-- Dialogs need a clear title, concise context when necessary, stable body layout, and a consistent footer with secondary action before primary action. Long content must scroll inside the dialog without pushing actions off-screen.
-- Forms must have visible labels, appropriate controls, useful defaults, required/optional semantics, and examples or help text only where they reduce ambiguity.
-- Validate at the right time: do not show errors before the user has interacted, clear stale errors after correction, and map backend validation failures to the relevant field when possible.
-- Preserve entered values after failed submission. Do not reset or close a form until the server confirms success.
-- Dependent fields must clearly reflect disabled/loading/empty states. When one field invalidates another, update it predictably and explain the dependency when it is not obvious.
-- Configuration and high-impact forms should not expose a permanently editable surface when a deliberate edit mode improves safety. Saving sensitive configuration requires explicit user intent and appropriate confirmation.
-
-#### Lists, Tables, and Operational Screens
-
-- Use the shared Dashboard CRUD/list system and maintain consistent toolbar, filter, pagination, loading, empty, and action placement across resources.
-- Filters must distinguish draft values from applied query state. Query, reset, refresh, pagination, and URL/state behavior should be predictable and must not unexpectedly erase one another.
-- Tables must remain scannable: align comparable values, keep action columns stable, use badges sparingly for status, avoid dense multiline cells when a detail view is more appropriate, and provide horizontal overflow on narrow screens.
-- Empty states must distinguish “no data exists” from “no results match the current filters” and offer the most relevant next action when the user can resolve the state.
-- Loading states should preserve layout. Prefer skeletons for content whose shape is known and compact spinners for localized actions; avoid replacing an entire stable page with a centered spinner.
-- Error states must explain what failed in user terms and provide retry when retry is meaningful. Never leave a blank table or empty panel after a request failure.
-- Bulk actions must show selection count, affected scope, eligibility, and partial-failure results. Clear selection when it is no longer valid.
-
-#### Responsive and Accessibility Requirements
-
-- Every changed screen must work at desktop and narrow/mobile widths. Do not treat horizontal clipping, overlapping controls, wrapped action chaos, or off-screen dialog buttons as acceptable.
-- Responsive behavior must preserve task priority: primary actions remain reachable, secondary actions may move into menus, filters may stack or collapse, and tables may scroll without hiding row identity/actions.
-- Use semantic controls and accessible names. Icon-only buttons require localized accessible labels and tooltips where the meaning is not universally obvious.
-- Maintain visible focus states, logical tab order, sufficient target sizes, and adequate text/background contrast. Do not encode status or errors using color alone.
-- Respect reduced-motion preferences. Animations should explain state or continuity, remain subtle, and never delay work.
-
-#### Product Copy and Data Credibility
-
-- Copy must sound like a finished product: concise, specific, consistent, and action-oriented. Do not expose implementation jargon, placeholder prose, “TODO”, mock labels, debug wording, or developer instructions to users.
-- Do not ship fake statistics, sample records, disabled-looking placeholder buttons, decorative charts without meaning, or interactions that only log to the console.
-- Distinguish unavailable features from empty data. If a capability is not implemented, do not render a control that pretends it is functional.
-- User-visible names, statuses, permissions, dates, and errors must use the established formatting and i18n mappings rather than raw backend identifiers.
-
-#### UI Verification
-
-- For meaningful UI changes, inspect the finished screen in a real browser at representative desktop and narrow widths. Source review and typecheck alone are not sufficient visual validation.
-- Exercise the complete interaction, including initial load, populated state, empty/filtered state, validation failure, server failure when practical, pending/disabled behavior, success, cancel/close, and refresh.
-- Check both `zh-CN` and `en-US`; verify that translated copy does not overflow, truncate critical meaning, or break control alignment.
-- Before handoff, remove temporary data, debug UI, console output, test-only shortcuts, and visual artifacts introduced during verification.
-- When browser verification cannot be performed, state that limitation explicitly; do not describe the UI as visually verified.
-
-### 5.5 Generated and Embedded Frontend Assets
-
-- `web/lib/generated/enums.ts` is generated by `task enums`; do not edit it manually.
-- `web/public/sdk/agent-desk-sdk.min.js` is generated from the SDK source. When SDK source changes, run `cd web && pnpm build:sdk` and its focused SDK tests.
-- `web/public/flowgram-editor` is produced from `flowgram-editor`; edit the source project, not the generated public output.
-- When changing `flowgram-editor`, use its own `pnpm` scripts and ensure the embedding build still succeeds.
-- The Next.js application is statically exported/embedded into the Go binary. Avoid runtime-only Next.js features that conflict with the current export and embedding model.
-
-## 6. Testing and Validation
-
-Validation must match the changed surface. Do not claim checks that were not run.
-
-- Go formatting: run `gofmt` on every changed `.go` file.
-- Go behavior: add focused tests for changed business rules, transactions, security boundaries, parsing, and reusable helpers; run the narrow package tests first, then `go test ./...` when practical.
-- Frontend TypeScript: run `cd web && pnpm typecheck` for frontend changes.
-- Frontend lint: run `cd web && pnpm lint` for broader component/page changes or when lint-sensitive code changed.
-- Frontend logic: run relevant `node --test ...` files when changing utilities, i18n mappings, generated SDK behavior, or other modules with focused tests.
-- Workflow editor: run the relevant `flowgram-editor` lint/build commands for changes in that project.
-- Generation: after model CRUD or shared enum changes, run the corresponding `task generator` or `task enums` and review generated diffs.
-- Build: use `task build` when changes affect frontend embedding, build configuration, generated public assets, or release assembly.
-- Browser verification is expected for meaningful visual or interaction changes when a runnable environment is available; state explicitly when it was not performed.
-- Documentation-only changes require at least `git diff --check` and verification that every referenced path/command exists.
-
-## 7. Completion Checklist
-
-Before handing off a change, confirm the applicable items:
-
-- The implementation follows current layer/component ownership and does not create reverse dependencies.
-- Transactions cover exactly the operations that must be atomic, and all transactional DB calls use the same `ctx.Tx`.
-- API routes are explicitly registered and responses preserve `JsonResult`/`PageResult` contracts.
-- Models, migrations, queries, and tests remain compatible with SQLite and MySQL.
-- Backend and frontend user-visible text is complete in both Chinese and English.
-- Dashboard pages reuse the highest-level suitable component under `web/components/dashboard/*`.
-- UI changes meet the commercial-grade standard: complete states, precise feedback, safe mutations, responsive layout, accessible controls, credible copy/data, and no demo-only behavior.
-- Generated files were regenerated from their source and were not manually edited.
-- Relevant tests/typechecks/lint/build/browser checks were run, and any validation limitation is reported.
-- `git diff --check` passes and unrelated worktree changes remain untouched.
+本文件定义了本仓库中 AI 智能体必须遵守的工作约定。它刻意以当前代码库的实际情况为准，而非历史惯例。
+
+## 1. 适用范围与优先级
+
+- 本规则适用于仓库根目录及所有子目录。
+- 用户的明确指令优先于本文件。如有刻意偏离，须在最终总结中说明。
+- 修改前先查看相关实现。复用现有的辅助函数、组件 API、代码生成工作流和邻近代码的模式，不要依赖记忆行事。
+- 保持改动范围聚焦。保留与本次任务无关的、用户自有的工作区改动，包括已暂存的改动。
+- 审查、调研或诊断类请求默认为只读，除非用户同时要求实现。
+
+## 2. 当前架构
+
+仓库包含三个应用区域：
+
+- Go 服务端：`cmd/server` 和 `internal/*`
+- Next.js 应用：`web/*`
+- 内嵌的工作流编辑器：`flowgram-editor/*`，构建产物位于 `web/public/flowgram-editor`
+
+主要技术栈：
+
+- Go 1.26、Gin、GORM、`github.com/mlogclub/simple`
+- SQLite 和 MySQL
+- Next.js 16 App Router、React 19、TypeScript、Tailwind CSS、shadcn/Base UI
+- 两个前端项目均使用 `pnpm`
+- 可选通过 CGO 构建 LanceDB 支持；应用同时支持 Qdrant
+
+重要入口：
+
+- 服务装配与中间件：`internal/bootstrap/server.go`
+- 显式 API 路由：`internal/bootstrap/routes.go`
+- 模型注册：`internal/models/models.go`
+- 启动时结构/数据迁移：`internal/bootstrap/migration.go`
+- CRUD 生成器：`cmd/generator/generator.go`
+- 前端枚举生成器：`cmd/enums/generator.go`
+- 前端 API 客户端：`web/lib/api/client.ts`
+- 前端国际化：`web/i18n/*` 和 `web/messages/*`
+- 控制台共享组件：`web/components/dashboard/*`
+- 项目命令：`Taskfile.yml`
+
+## 3. 通用改动规则
+
+- 使用某个类型、函数或组件前，先阅读其真实签名。
+- 优先使用满足需求的最高层级现有抽象。不要重复实现查询状态、分页、鉴权刷新、本地化或控制台 CRUD 行为。
+- 不要手工编辑生成产物。应修改其源头并运行对应的生成器/构建命令。
+- 当仓库对同一关注点已有共享实现路径时，不要引入第二种实现风格。
+- 新的 Go 日志使用 `log/slog`，并以结构化键值字段记录相关上下文。
+- 新 Go 代码使用 `any`，不使用 `interface{}`。已有的生成代码或遗留代码无需做无关清理。
+- 密钥、令牌、凭据及客户隐私数据绝不能提交到仓库，也不能打印到日志/测试中。
+
+## 4. Go 后端
+
+### 4.1 分层职责
+
+正常的依赖与数据流方向为：
+
+`models -> repositories -> services -> handlers -> builders/响应 DTO`
+
+- `internal/models`：仅包含实体字段、GORM 映射、关联关系和 schema 元数据。
+- `internal/repositories`：GORM/SQL 访问、条件、排序、分页、锁及持久化细节。
+- `internal/services`：业务校验、状态变更、与授权无关的领域规则、聚合、事务及事件编排。
+- `internal/handlers/{api,dashboard,third}`：HTTP 参数解析、认证/权限检查、调用服务、写入响应。
+- `internal/builders`：纯粹的模型/聚合到响应的映射。Builder 不得查询数据库。
+- `internal/pkg/dto/request` 和 `internal/pkg/dto/response`：对外请求/响应契约。
+
+强制边界：
+
+- Handler 不得直接调用 repository 或发起 GORM 查询。
+- Model 和 repository 不得包含 HTTP、权限或跨资源工作流逻辑。
+- GORM model 不得直接从 API 返回。必须映射为响应 DTO/builder。
+- Service 内部可以返回 model，但对外响应结构仍由 builder/DTO 负责。
+- 可复用的 SQL 放在 repository 中。只有在抽取出来反而会使职责归属更不清晰时，真正一次性的聚合查询才可以留在其领域 service 附近。
+
+### 4.2 数据库与事务
+
+- 参与事务的 repository 方法接收 `db *gorm.DB`；事务外用 `sqls.DB()` 调用，事务内用 `ctx.Tx` 调用。
+- Service 通过 `sqls.WithTransaction` 拥有事务边界。
+- 原子性的多次写入工作流和对一致性敏感的读-改-写操作必须使用事务。
+- 不要为单个独立的 SQL 写操作添加事务。
+- 事务内的每个数据库操作都必须使用同一个 `ctx.Tx`；绝不能在事务中途逃逸到 `sqls.DB()`。
+- 普通的过滤和分页使用 `sqls.Cnd`/`sqls.NewCnd()` 及 repository 方法。
+- 保持 SQLite 和 MySQL 兼容。避免方言专属 SQL，除非两种方言都已显式实现并测试。
+- 使用可移植的列类型和 `int64` 主键/外键标识。时间处理需兼容 MySQL 的 `parseTime=True`。
+
+### 4.3 模型、代码生成与迁移
+
+- 持久化模型须注册到 `internal/models/models.go`，以便启动时的 `AutoMigrate(models.Models...)` 包含它们。
+- 新表、新列、索引及兼容性约束通常由 `internal/bootstrap/migration.go` 中的 GORM `AutoMigrate` 应用。
+- `internal/migration/*` 仅用于有版本的、幂等的数据迁移/回填/修复工作。其版本号必须单调递增。
+- 当模型使用标准的生成 repository/service 接口时，将其注册到 `cmd/generator/generator.go` 并运行 `task generator`。
+- 把生成器输出视为机械基础设施。业务专属方法放在手写文件中，不要手工修补生成的 CRUD 代码。
+- 后端/前端共享枚举定义在 `internal/pkg/enums`，按现有枚举模式添加注解，通过 `task enums` 生成到 `web/lib/generated/enums.ts`。
+- 绝不要在前端手写一份与已生成后端枚举重复的枚举。
+
+### 4.4 HTTP API
+
+- 所有路由都在 `internal/bootstrap/routes.go` 中显式声明；handler 名称不会自动创建端点。
+- 公开/产品 API 位于 `/api/*` 下，需要认证的管理 API 位于 `/api/dashboard/*` 下，回调位于 `/api/third/*` 下，WebSocket 位于 `/api/ws/*` 下。
+- 新增资源专属的 `register...Routes` 函数或扩展现有的函数，然后在 `addRouter` 中挂载到正确的分组。
+- 遵循现有资源约定：详情通常用 `GET /:id`，列表用 `/list`，写操作使用显式 POST 动作如 `/create`、`/update`、`/delete`，领域动作保留其既定的 snake_case 路径名。
+- 不要引入 `/api/v1`、自动路由假设或不必要的深层嵌套资源路径。
+- Handler 名称与注册的方法和路径对应，例如 `XxxGetBy`、`XxxAnyList`、`XxxPostCreate`。
+- 使用 `internal/pkg/httpx/params` 和 `internal/pkg/httpx` 辅助函数解析 JSON/表单/query/path 参数。
+- 控制台权限检查在领域工作之前使用 `services.AuthService.RequirePermission` 或既定的权限辅助函数。
+- 通过 `httpx.WriteJSON` 写入响应；保持共享的 `JsonResult` 契约。
+- 分页响应使用 `web.PageResult`，包含 `data.results` 和 `data.page`。
+- 将未找到、校验失败、权限不足和持久化失败转换为稳定的应用错误。绝不要把原始 SQL 错误暴露给客户端。
+
+### 4.5 后端国际化
+
+- 任何新增或变更的、用户可见的后端错误都必须支持全部后端语言，目前为 `zh-CN` 和 `en-US`。
+- 在同一次改动中，向 `internal/pkg/i18nx/locales/zh-CN.yml` 和 `internal/pkg/i18nx/locales/en-US.yml` 添加对应的键。
+- Service 应通过 `errorsx.*I18n` 辅助函数返回本地化的应用错误。
+- 需要立即返回本地化响应的 handler 使用 `httpx.JsonErrorMsg(ctx, key, args...)`；其他请求上下文内的翻译使用 `i18nx.T`。
+- 当中英文案可能触达用户时，不要在 handler/service 中硬编码中英文错误语句。
+- 各语言之间保持格式化参数一致，并为新的可复用/错误格式化行为补充聚焦测试。
+
+## 5. 前端
+
+### 5.1 组件与数据边界
+
+- 应用路由位于 `web/app`；可复用业务组件位于 `web/components`；路由私有组件位于该路由的 `_components` 目录。
+- 复用 `web/components/ui/*` 基础组件。不要为了某个功能的特定需求修改这些 shadcn 基础组件。
+- 使用仓库中实际实现的 Base UI/shadcn 组件 API；不要假设存在 Radix 的 `asChild` 等 API。
+- `web` 内的代码使用 `@/*` 导入。
+- 客户端组件在使用状态、effect、浏览器 API 或仅客户端可用的 hook 时，必须声明 `"use client"`。
+- 资源 API 放在 `web/lib/api/*`，所有常规请求都通过 `web/lib/api/client.ts` 发起。
+- 页面、业务组件和 store 不得自行实现 `JsonResult` 解析、鉴权头处理、令牌刷新或登录过期清理。
+- 直接使用 `fetch` 仅限于不支持的传输场景，例如第三方调用、二进制传输、SSE 和 WebSocket 握手；须在代码中说明例外原因。
+- 标准下拉选择优先使用 `OptionCombobox`，而不是新增基于 shadcn Select 的业务控件。
+- 展示的时间戳使用 `web/lib/utils.ts` 中的 `formatDateTime` 格式化，除非产品明确要求其他表现形式。
+
+### 5.2 控制台页面
+
+构建控制台页面之前，先查看 `web/components/dashboard/crud`、`web/components/dashboard/list` 和 `web/components/dashboard-page.tsx`。
+
+按以下优先级顺序选择：
+
+1. 标准增删改查资源使用 `DashboardCrudPage`。
+2. 只读或自定义内容的分页资源使用 `DashboardListPage`。
+3. 布局是定制的、但列表查询/筛选/分页生命周期是标准的，使用 `useDashboardPagedList`。
+4. 只有当高层级组件无法满足交互需求时，才使用 `DashboardPage`、`DashboardToolbar`、`DashboardTableShell` 及相关底层原语。
+
+规则：
+
+- 不要复制某个资源页面来重建标准筛选、查询/重置/刷新动作、分页、加载/空状态、确认框、行操作或对话框。
+- 在添加页面本地基础设施之前，先通过 `DashboardCrudPage` 的筛选器、列、标签、服务回调、行操作、排序以及表单/对话框扩展点进行配置。
+- 在支持的情况下使用其 schema 驱动的 `DashboardCrudFormDialog`。真正自定义的表单可以放在 `_components` 中，通常应使用 `react-hook-form`、`zod` 和 `Field`。
+- 通过列或 `renderContent` 配置 `DashboardListPage`，资源专属动作使用 `renderToolbarActions`。
+- 业务 API 知识留在页面/服务模块中；通用控制台组件不得导入资源专属 API。
+- 对 `web/components/dashboard/*` 的改动必须是通用的、向后兼容的、且对不止一个页面有用。否则应将其局限在功能模块内。
+
+### 5.3 前端国际化
+
+- 每一个前端功能和改动都必须在所有 `SUPPORTED_LOCALES`（目前为 `zh-CN` 和 `en-US`）下正常工作。
+- 每个新键都要在同一次改动中同时添加到 `web/messages/zh-CN.json` 和 `web/messages/en-US.json`，保持结构一致。
+- React 页面/组件使用 `useI18n()`；语言相关的格式化/映射也可以使用 `useAppLocale()`。
+- 非 React 代码使用 `web/i18n/messages.ts` 中的 `translateCurrentMessage()` 或 `translateMessage()`。
+- 不要在 JSX/TSX、toast 消息、对话框、确认框、占位符、校验提示、空/加载/错误状态、工具提示、无障碍标签或客户端兜底错误中硬编码用户可见文案。
+- 产品名称、协议字面量、用户内容和原始业务数据无需翻译，除非 UI 已提供显示名映射。
+- 提供给共享 CRUD/list 组件的控制台标签必须来自翻译键。
+- 将后端标识/枚举的本地化显示名集中到可复用的 `web/lib/*-i18n.ts` 辅助文件中，而不是在各页面重复编写语言分支。
+- 每种语言保留相同的占位符并用 `t(key, values)` 插值；不要通过拼接翻译片段来组装句子。
+- 语言配置归属于 `AppI18nProvider` 和 `web/i18n/config.ts`；各功能不得引入独立的语言检测或状态。
+
+### 5.4 商业级 UI 与交互
+
+这是一个商业产品，不是原型或组件演示。UI 工作只有在视觉统一、交互完整、响应式、已本地化、并能以真实生产数据可信呈现时才算完成。
+
+#### 视觉质量
+
+- 遵循现有设计语言、间距尺度、字体排版、圆角、色彩令牌和组件变体。新功能必须看起来像产品原生的一部分，而不是粘贴进来的模板。
+- 在控制台（support platform）UI 中，如需圆角，统一使用 `rounded-md`。
+- 控制台组件不应添加 `shadow`。
+- 建立清晰的层次：页面标题/主要操作、筛选或上下文、主要内容、次要信息。不要把每个区域都做成卡片，也不要让每个操作都在视觉上突出。
+- 优先采用克制、有目的性的样式。避免装饰性渐变、超大标题文字、过度阴影、玻璃拟态、emoji 图标、随意的强调色和装饰性文案，除非产品场景明确需要。
+- 一致地使用 Lucide 图标。按含义选择图标，保持图标尺寸和描边粗细与邻近控件一致，绝不使用没有传达意义的纯装饰性图标。
+- 在每个断点下保持间距和对齐的严谨。标签、输入框、表格列、操作组、对话框页脚和空状态必须整齐对齐，不得有临时拼凑的偏移。
+- 为真实内容而非理想示例文本而设计。验证长名称、多行内容、大数量、缺失可选字段以及中英文混排的情况。有意识地使用换行、截断、工具提示或滚动容器。
+- 保持适合运营控制台的信息密度。不要把大面积空间浪费在装饰上，但也不要把控件压缩到难以浏览和点击。
+
+#### 交互完整性
+
+- 每个异步操作都必须有即时且明确的状态：进行中/加载中、成功、失败，以及在适当时提供重试或恢复。
+- 防止重复提交。变更进行中时禁用或锁定触发控件，并显示针对该操作的进度文案或加载图标，且不引起布局跳动。
+- 反馈要贴近操作本身。字段问题使用内联校验，内容加载失败使用情境化错误状态，已完成的后台或页面级操作使用 toast 通知。
+- 绝不静默丢弃用户输入。当存在有意义的未保存改动时，在关闭、离开页面、重置或切换上下文之前发出警告。
+- 破坏性、不可逆、安全敏感或影响广泛的操作需要确认，确认文案须明确指出操作对象和后果。不要使用泛化的“你确定吗？”消息。
+- 确认不能替代良好的默认值：常规可逆操作应保持高效，不应被不必要的弹窗打断。
+- 创建/更新/删除操作后，保持列表状态一致：刷新受影响的数据，尽可能保留有用的筛选条件/页码位置，仅在成功时关闭对话框，防止出现过期的选中项或详情面板。
+- 按钮和菜单项必须使用准确描述结果的动词。当有具体的操作名可用时，避免“确定”“提交”“处理”这类模糊标签。
+- 保持键盘行为和焦点流转：Enter 仅在预期场景提交，Escape 关闭可 dismiss 的浮层，焦点进入对话框并在关闭后返回触发元素，破坏性操作不能是意外的默认项。
+- 可交互的行、图标、徽标和文字链接必须仅在确实可交互时才呈现可交互的外观。不要依赖仅悬停可见来发现关键操作。
+
+#### 表单与对话框
+
+- 使用最小且合适的交互容器：简单的局部改动用内联编辑，聚焦的任务用对话框，复杂或多步骤工作流用整页/工作台。
+- 对话框需要清晰的标题、必要时简洁的上下文说明、稳定的正文布局，以及一致的页脚（次要操作在前、主要操作在后）。长内容必须在对话框内部滚动，而不能把按钮挤出屏幕。
+- 表单必须有可见标签、合适的控件、有用的默认值、必填/选填语义，示例或帮助文本仅在能减少歧义时提供。
+- 在正确的时机校验：不要在用户交互前显示错误，修正后清除过期错误，并尽可能把后端校验失败映射到对应字段。
+- 提交失败后保留已输入的值。在服务器确认成功之前不要重置或关闭表单。
+- 依赖字段必须清晰反映禁用/加载/空状态。当一个字段使另一个字段失效时，应以可预测的方式更新后者，并在依赖关系不明显时加以说明。
+- 配置类和高影响表单不应在刻意的编辑模式能提升安全性时，仍暴露永久可编辑的界面。保存敏感配置需要明确的用户意图和恰当的确认。
+
+#### 列表、表格与运营界面
+
+- 使用共享的控制台 CRUD/list 体系，在各资源之间保持一致的工具栏、筛选、分页、加载、空状态和操作位置。
+- 筛选必须区分草稿值与已应用的查询状态。查询、重置、刷新、分页和 URL/状态行为应当可预测，不得意外地相互清除。
+- 表格必须保持可扫描性：对齐可比较的值，保持操作列稳定，状态徽标少用，当详情视图更合适时避免拥挤的多行单元格，并在窄屏上提供横向滚动。
+- 空状态必须区分“数据不存在”与“当前筛选无匹配结果”，并在用户可以自行解决时提供最相关的下一步操作。
+- 加载状态应保持布局。形状已知的内容优先使用骨架屏，局部操作使用紧凑的加载图标；避免用居中的加载图标替换整个稳定页面。
+- 错误状态必须用用户能理解的措辞说明失败原因，并在重试有意义时提供重试。请求失败后绝不要留下空白表格或空面板。
+- 批量操作必须显示选中数量、影响范围、适用条件及部分失败的结果。当选中项不再有效时清除选择。
+
+#### 响应式与无障碍要求
+
+- 每个改动的界面都必须在桌面宽度和窄屏/移动宽度下可用。不得把横向裁切、控件重叠、操作换行混乱或对话框按钮超出屏幕视为可接受。
+- 响应式行为必须保持任务优先级：主要操作始终可触达，次要操作可以收进菜单，筛选项可以堆叠或折叠，表格可以滚动但不得隐藏行标识/操作。
+- 使用语义化控件和无障碍名称。仅图标的按钮在含义并非普遍显而易见时，需要本地化的无障碍标签和工具提示。
+- 保持可见的焦点状态、合理的 Tab 顺序、足够的点击目标尺寸和充分的文字/背景对比度。不要仅用颜色表达状态或错误。
+- 尊重“减少动态效果”偏好。动画应有助于表达状态或连续性，保持克制，且绝不耽误操作。
+
+#### 产品文案与数据可信度
+
+- 文案必须像成品：简洁、具体、一致、以行动为导向。不要向用户暴露实现术语、占位符式文字、“TODO”、模拟标签、调试措辞或开发者说明。
+- 不要交付虚假统计、示例记录、看似禁用的占位按钮、无意义的装饰图表，或只会向控制台打印日志的交互。
+- 区分功能不可用与数据为空。如果某项能力尚未实现，不要渲染一个假装可用的控件。
+- 用户可见的名称、状态、权限、日期和错误必须使用既定的格式化和 i18n 映射，而不是原始的后端标识。
+
+#### UI 验证
+
+- 对于有意义的 UI 改动，在真实浏览器中以有代表性的桌面宽度和窄屏宽度检查完成后的界面。仅靠源码审查和类型检查不足以完成视觉验证。
+- 演练完整交互，包括初始加载、有数据状态、空/筛选状态、校验失败、在可行时模拟服务器失败、进行中/禁用行为、成功、取消/关闭以及刷新。
+- 同时检查 `zh-CN` 和 `en-US`；验证翻译文案不会溢出、截断关键含义或破坏控件对齐。
+- 交付前移除验证期间引入的临时数据、调试 UI、控制台输出、仅用于测试的快捷方式和视觉残留。
+- 当无法进行浏览器验证时，须明确说明这一限制；不要将 UI 描述为已经过视觉验证。
+
+### 5.5 生成的与内嵌的前端资产
+
+- `web/lib/generated/enums.ts` 由 `task enums` 生成；不要手工编辑。
+- `web/public/sdk/agent-desk-sdk.min.js` 由 SDK 源码生成。SDK 源码变更时，运行 `cd web && pnpm build:sdk` 及其聚焦的 SDK 测试。
+- `web/public/flowgram-editor` 由 `flowgram-editor` 产出；编辑源项目，而不是生成的 public 产物。
+- 修改 `flowgram-editor` 时，使用它自己的 `pnpm` 脚本，并确保内嵌构建仍然成功。
+- Next.js 应用以静态导出方式内嵌进 Go 二进制文件。避免与当前导出和内嵌模式冲突的、仅运行时可用的 Next.js 特性。
+
+## 6. 测试与验证
+
+验证必须与改动的范围相匹配。不要声称运行过并未执行的检查。
+
+- Go 格式化：对每个改动的 `.go` 文件运行 `gofmt`。
+- Go 行为：为改动的业务规则、事务、安全边界、参数解析和可复用辅助函数添加聚焦测试；先运行小范围的包测试，条件允许时再运行 `go test ./...`。
+- 前端 TypeScript：前端改动运行 `cd web && pnpm typecheck`。
+- 前端 lint：较广泛的组件/页面改动或改动了 lint 敏感代码时，运行 `cd web && pnpm lint`。
+- 前端逻辑：改动工具函数、i18n 映射、生成的 SDK 行为或其他有聚焦测试的模块时，运行相关的 `node --test ...` 文件。
+- 工作流编辑器：改动该项目时运行 `flowgram-editor` 相关的 lint/build 命令。
+- 代码生成：模型 CRUD 或共享枚举变更后，运行对应的 `task generator` 或 `task enums` 并审查生成的差异。
+- 构建：当改动影响前端内嵌、构建配置、生成的公共资产或发布装配时，使用 `task build`。
+- 当有可运行环境时，有意义的视觉或交互改动应进行浏览器验证；未执行时须明确说明。
+- 仅文档类改动至少需要 `git diff --check`，并验证每个引用的路径/命令确实存在。
+
+## 7. 完成检查清单
+
+交付改动之前，确认适用的各项：
+
+- 实现遵循当前的分层/组件职责划分，没有产生反向依赖。
+- 事务恰好覆盖必须原子的操作，且所有事务内数据库调用使用同一个 `ctx.Tx`。
+- API 路由已显式注册，响应保持 `JsonResult`/`PageResult` 契约。
+- 模型、迁移、查询和测试保持 SQLite 和 MySQL 兼容。
+- 后端和前端用户可见文本均中英文完整。
+- 控制台页面复用了 `web/components/dashboard/*` 下最高层级的合适组件。
+- UI 改动达到商业级标准：状态完整、反馈精准、变更安全、响应式布局、控件无障碍、文案/数据可信，无仅用于演示的行为。
+- 生成文件由源头重新生成，未被手工编辑。
+- 已运行相关的测试/类型检查/lint/构建/浏览器检查，并报告了任何验证限制。
+- `git diff --check` 通过，且无关的工作区改动保持原样未动。
diff --git a/Dockerfile b/Dockerfile
index 77572bcd..8d159647 100644
--- a/Dockerfile
+++ b/Dockerfile
@@ -25,6 +25,7 @@ RUN pnpm build:sdk && pnpm build
FROM golang:1.26-alpine AS server-builder
WORKDIR /src
+ENV GOPROXY=https://goproxy.cn,direct
RUN apk add --no-cache git
COPY go.mod go.sum ./
@@ -43,6 +44,7 @@ RUN --mount=type=cache,target=/go/pkg/mod \
FROM golang:1.26-trixie AS server-builder-lancedb
WORKDIR /src
+ENV GOPROXY=https://goproxy.cn,direct
ARG TARGETOS=linux
ARG TARGETARCH
diff --git a/README_ZH.md b/README_ZH.md
index 6a59a116..2ad527f7 100644
--- a/README_ZH.md
+++ b/README_ZH.md
@@ -257,15 +257,21 @@ flowchart LR
如果只需要构建应用镜像，可以自行准备 MySQL 和 Qdrant，并挂载配置文件：
```bash
-docker build -t mlogclub/agent-desk .
+docker build -t yekay/agent-desk:1.6.3.3 .
docker run --rm -p 8083:8083 \
-v $(pwd)/docker/agent-desk.yaml:/app/config/config.yaml:ro \
-v agent-desk-data:/app/data \
- mlogclub/agent-desk
+ yekay/agent-desk:1.6.3.3
```
Compose 使用 [docker/agent-desk.yaml](docker/agent-desk.yaml) 作为容器内配置，应用会通过 Docker 内部服务名访问 `mysql` 和 `qdrant`。
+导出镜像：
+
+```bash
+docker save -o agent-desk.tar yekay/agent-desk:1.6.3.3
+```
+
## 开源定位
`AgentDesk` 适合作为以下方向的开源基础项目：
diff --git a/cmd/import_jsh_knowledge/main.go b/cmd/import_jsh_knowledge/main.go
new file mode 100644
index 00000000..ac90f820
--- /dev/null
+++ b/cmd/import_jsh_knowledge/main.go
@@ -0,0 +1,314 @@
+// Package main 是一次性数据导入工具：将本地 jsh-knowledge 目录按层级
+// 导入 t_knowledge_directory / t_knowledge_document。
+//
+// 用法：
+//
+// go run ./cmd/import_jsh_knowledge -kb 3 -root ./jsh-knowledge
+//
+// 工具可重复执行（幂等）：已存在的同名目录会复用，同目录下同名文档会跳过。
+package main
+
+import (
+ "crypto/sha256"
+ "encoding/hex"
+ "flag"
+ "fmt"
+ "log"
+ "log/slog"
+ "os"
+ "path/filepath"
+ "regexp"
+ "sort"
+ "strconv"
+ "strings"
+ "time"
+
+ "agent-desk/internal/ai/rag"
+ "agent-desk/internal/models"
+ "agent-desk/internal/pkg/enums"
+
+ "gorm.io/driver/mysql"
+ "gorm.io/gorm"
+ "gorm.io/gorm/logger"
+ "gorm.io/gorm/schema"
+)
+
+// frontmatterRe 匹配文件开头的 YAML frontmatter（---\n ... \n---\n）。
+var frontmatterRe = regexp.MustCompile(`(?s)\A---\r?\n.*?\r?\n---\r?\n?`)
+
+// leadingNumberRe 提取目录名开头的数字前缀（如 "02-合作平台" -> 2）。
+var leadingNumberRe = regexp.MustCompile(`^\d+`)
+
+type options struct {
+ dsn string
+ root string
+ kbID int64
+ stripFrontmatter bool
+ dryRun bool
+}
+
+func main() {
+ opt := options{}
+ flag.StringVar(&opt.dsn, "dsn", "root:123456abcde@tcp(127.0.0.1:3306)/cs_ai_agent?charset=utf8mb4&parseTime=True&loc=Local", "MySQL DSN")
+ flag.StringVar(&opt.root, "root", "jsh-knowledge", "待导入的知识目录根路径")
+ flag.Int64Var(&opt.kbID, "kb", 3, "目标知识库 ID（t_knowledge_base.id）")
+ flag.BoolVar(&opt.stripFrontmatter, "strip-frontmatter", true, "是否剥离 Markdown 开头的 YAML frontmatter")
+ flag.BoolVar(&opt.dryRun, "dry-run", false, "只演练不写库")
+ flag.Parse()
+
+ if err := run(opt); err != nil {
+ slog.Error("import failed", "error", err)
+ os.Exit(1)
+ }
+}
+
+func run(opt options) error {
+ entries, err := scanRoot(opt.root)
+ if err != nil {
+ return err
+ }
+ if len(entries) == 0 {
+ return fmt.Errorf("目录 %s 下没有可导入的子目录", opt.root)
+ }
+
+ db, err := gorm.Open(mysql.Open(opt.dsn), &gorm.Config{
+ NamingStrategy: schema.NamingStrategy{TablePrefix: "t_", SingularTable: true},
+ Logger: logger.New(
+ log.New(os.Stdout, "\r\n", log.LstdFlags),
+ logger.Config{
+ SlowThreshold: time.Second,
+ LogLevel: logger.Warn,
+ IgnoreRecordNotFoundError: true,
+ },
+ ),
+ })
+ if err != nil {
+ return fmt.Errorf("连接数据库失败: %w", err)
+ }
+
+ // 校验目标知识库存在。
+ var kb models.KnowledgeBase
+ if err := db.Select("id", "name", "knowledge_type", "status").
+ First(&kb, opt.kbID).Error; err != nil {
+ return fmt.Errorf("知识库 id=%d 不存在或不可读: %w", opt.kbID, err)
+ }
+ slog.Info("目标知识库", "id", kb.ID, "name", kb.Name, "type", kb.KnowledgeType, "status", kb.Status)
+
+ var dirCreated, dirReused, docCreated, docSkipped int
+ now := time.Now()
+
+ for idx, entry := range entries {
+ sortNo := parseLeadingNumber(entry.name)
+ if sortNo == 0 {
+ sortNo = idx + 1
+ }
+
+ // 每个分类目录一个事务：目录行与其下文档要么全部落库要么整体回滚。
+ var dirID int64
+ var dirNew bool
+ var n importCounters
+ err := db.Transaction(func(tx *gorm.DB) error {
+ var terr error
+ dirID, dirNew, terr = findOrCreateDirectory(tx, opt, entry.name, sortNo, now)
+ if terr != nil {
+ return terr
+ }
+ n, terr = importDocuments(tx, opt, dirID, entry.files, now)
+ return terr
+ })
+ if err != nil {
+ return fmt.Errorf("目录 %s 处理失败: %w", entry.name, err)
+ }
+ if dirNew {
+ dirCreated++
+ } else {
+ dirReused++
+ }
+ docCreated += n.created
+ docSkipped += n.skipped
+ slog.Info("目录完成",
+ "name", entry.name, "dir_id", dirID, "new_dir", dirNew,
+ "new_docs", n.created, "skipped_docs", n.skipped)
+ }
+
+ slog.Info("导入完成",
+ "dry_run", opt.dryRun,
+ "directories_created", dirCreated,
+ "directories_reused", dirReused,
+ "documents_created", docCreated,
+ "documents_skipped", docSkipped)
+ return nil
+}
+
+type dirEntry struct {
+ name string
+ files []string
+}
+
+func scanRoot(root string) ([]dirEntry, error) {
+ top, err := os.ReadDir(root)
+ if err != nil {
+ return nil, fmt.Errorf("读取根目录失败: %w", err)
+ }
+ var out []dirEntry
+ for _, d := range top {
+ if !d.IsDir() {
+ continue
+ }
+ full := filepath.Join(root, d.Name())
+ files, err := collectMarkdownFiles(full)
+ if err != nil {
+ return nil, err
+ }
+ if len(files) == 0 {
+ slog.Warn("目录下没有 md 文件，已跳过", "dir", full)
+ continue
+ }
+ out = append(out, dirEntry{name: d.Name(), files: files})
+ }
+ sort.Slice(out, func(i, j int) bool { return out[i].name < out[j].name })
+ return out, nil
+}
+
+// collectMarkdownFiles 递归收集 .md 文件（当前数据只有一层，递归以兼容未来嵌套）。
+func collectMarkdownFiles(dir string) ([]string, error) {
+ var files []string
+
+ err := filepath.WalkDir(dir, func(path string, d os.DirEntry, err error) error {
+ if err != nil {
+ return err
+ }
+ if d.IsDir() {
+ if path != dir {
+ // 当前导入器只支持一层分类目录；出现嵌套时显式告警，
+ // 避免文件被静默平铺到错误的目录下。
+ slog.Warn("发现嵌套子目录，其内文件将被平铺到一级目录（如需多层请扩展导入器）", "subdir", path)
+ }
+ return nil
+ }
+ if strings.EqualFold(filepath.Ext(d.Name()), ".md") {
+ files = append(files, path)
+ }
+ return nil
+ })
+ if err != nil {
+ return nil, err
+ }
+ sort.Strings(files)
+ return files, nil
+}
+
+func parseLeadingNumber(name string) int {
+ m := leadingNumberRe.FindString(name)
+ if m == "" {
+ return 0
+ }
+ n, err := strconv.Atoi(m)
+ if err != nil {
+ return 0
+ }
+ return n
+}
+
+// findOrCreateDirectory 在同一知识库/同一父级(0)下按名称查找目录，没有则创建。
+func findOrCreateDirectory(db *gorm.DB, opt options, name string, sortNo int, now time.Time) (int64, bool, error) {
+ var existing models.KnowledgeDirectory
+ err := db.Where("knowledge_base_id = ? AND parent_id = 0 AND name = ?", opt.kbID, name).
+ First(&existing).Error
+ if err == nil {
+ return existing.ID, false, nil
+ }
+ if err != gorm.ErrRecordNotFound {
+ return 0, false, err
+ }
+
+ dir := &models.KnowledgeDirectory{
+ KnowledgeBaseID: opt.kbID,
+ ParentID: 0,
+ Name: name,
+ SortNo: sortNo,
+ Status: enums.StatusOk,
+ AuditFields: buildAuditFields(now),
+ }
+ if opt.dryRun {
+ slog.Info("[dry-run] 将创建目录", "name", name, "sort_no", sortNo)
+ return int64(sortNo), true, nil
+ }
+ if err := db.Create(dir).Error; err != nil {
+ return 0, false, err
+ }
+ return dir.ID, true, nil
+}
+
+type importCounters struct {
+ created int
+ skipped int
+}
+
+func importDocuments(db *gorm.DB, opt options, dirID int64, files []string, now time.Time) (importCounters, error) {
+ var c importCounters
+ for _, path := range files {
+ title := strings.TrimSuffix(filepath.Base(path), filepath.Ext(path))
+
+ var existing models.KnowledgeDocument
+ err := db.Where("knowledge_base_id = ? AND directory_id = ? AND title = ?", opt.kbID, dirID, title).
+ First(&existing).Error
+ if err == nil {
+ c.skipped++
+ continue
+ }
+ if err != gorm.ErrRecordNotFound {
+ return c, err
+ }
+
+ raw, err := os.ReadFile(path)
+ if err != nil {
+ return c, fmt.Errorf("读取文件 %s 失败: %w", path, err)
+ }
+ content := string(raw)
+ if opt.stripFrontmatter {
+ content = frontmatterRe.ReplaceAllString(content, "")
+ }
+ content = strings.TrimSpace(content)
+ if content == "" {
+ slog.Warn("文档内容为空，仍将导入", "file", path)
+ }
+
+ doc := &models.KnowledgeDocument{
+ KnowledgeBaseID: opt.kbID,
+ DirectoryID: dirID,
+ Title: title,
+ ContentType: enums.KnowledgeDocumentContentTypeMarkdown,
+ Content: content,
+ Status: enums.StatusOk,
+ IndexStatus: enums.KnowledgeDocumentIndexStatusPending,
+ AuditFields: buildAuditFields(now),
+ }
+ // 与正常建文档流程保持一致：hash 取正文纯文本的 SHA-256。
+ if plain := rag.ExtractPlainText(content, enums.KnowledgeDocumentContentTypeMarkdown); plain != "" {
+ sum := sha256.Sum256([]byte(plain))
+ doc.ContentHash = hex.EncodeToString(sum[:])
+ }
+
+ if opt.dryRun {
+ c.created++
+ continue
+ }
+ if err := db.Create(doc).Error; err != nil {
+ return c, fmt.Errorf("写入文档 %s 失败: %w", path, err)
+ }
+ c.created++
+ }
+ return c, nil
+}
+
+func buildAuditFields(now time.Time) models.AuditFields {
+ return models.AuditFields{
+ CreatedAt: now,
+ CreateUserID: 0,
+ CreateUserName: "system",
+ UpdatedAt: now,
+ UpdateUserID: 0,
+ UpdateUserName: "system",
+ }
+}
diff --git a/cmd/server/main.go b/cmd/server/main.go
index 1e478faf..500abcf3 100644
--- a/cmd/server/main.go
+++ b/cmd/server/main.go
@@ -3,9 +3,13 @@ package main
import (
"flag"
"log/slog"
+ "os"
+ "os/signal"
+ "syscall"
"agent-desk/internal/bootstrap"
"agent-desk/internal/pkg/config"
+ "agent-desk/internal/pkg/logx"
)
func main() {
@@ -25,6 +29,15 @@ func main() {
return
}
+ // 监听退出信号，确保 db sink 中缓冲的日志在进程退出前 flush 到数据库。
+ go func() {
+ stop := make(chan os.Signal, 1)
+ signal.Notify(stop, syscall.SIGINT, syscall.SIGTERM)
+ <-stop
+ _ = logx.Close()
+ os.Exit(0)
+ }()
+
if err := app.Run(cfg.Server.Address()); err != nil {
slog.Error("start server failed", "error", err)
return
diff --git a/docker-compose.qdrant.yml b/docker-compose.qdrant.yml
new file mode 100644
index 00000000..84e192d2
--- /dev/null
+++ b/docker-compose.qdrant.yml
@@ -0,0 +1,30 @@
+services:
+ qdrant:
+ image: qdrant/qdrant:latest
+ restart: unless-stopped
+ volumes:
+ - ./data/qdrant-data:/qdrant/storage
+ ports:
+ - "6333:6333"
+ - "6334:6334"
+
+ agent-desk:
+ image: yekay/agent-desk:1.6.3
+ restart: unless-stopped
+ depends_on:
+ qdrant:
+ condition: service_started
+ ports:
+ - "8083:8083"
+ volumes:
+ - ./data/agent-desk-data:/app/data
+ - ./docker/agent-desk.yaml:/app/config/config.yaml:ro
+ environment:
+ TZ: Asia/Shanghai
+ # 兼容 Linux 宿主机访问；Docker Desktop (Windows/Mac) 默认已提供 host.docker.internal
+ extra_hosts:
+ - "host.docker.internal:host-gateway"
+
+volumes:
+ qdrant-data:
+ agent-desk-data:
diff --git a/internal/ai/runtime/reply_commit_service.go b/internal/ai/runtime/reply_commit_service.go
index 56b7110b..d0067389 100644
--- a/internal/ai/runtime/reply_commit_service.go
+++ b/internal/ai/runtime/reply_commit_service.go
@@ -37,24 +37,37 @@ func (s *replyCommitService) SendAIReply(input replyCommitInput) (*models.Messag
if err != nil {
return nil, err
}
- replyMessage, err := svc.MessageService.SendAIMessageWithRequestIDAndWorkflowRunID(
- input.Conversation.ID,
- input.AIAgent.ID,
- fmt.Sprintf("%s_%d", strings.TrimSpace(input.ClientPrefix), input.Message.ID),
- enums.IMMessageTypeText,
+ // 优先原地替换 web 渠道的占位消息；不支持替换时回退为新消息
+ replyMessage := svc.MessageService.TryReplaceAIReplyPlaceholder(
+ &input.Conversation,
+ input.Message.ID,
replyText,
- "",
- s.buildAIPrincipal(input.AIAgent),
- input.Message.RequestID,
input.WorkflowRunID,
+ input.AIAgent,
)
- if err != nil || !input.IncrementRound {
- return replyMessage, err
+ if replyMessage == nil {
+ replyMessage, err = svc.MessageService.SendAIMessageWithRequestIDAndWorkflowRunID(
+ input.Conversation.ID,
+ input.AIAgent.ID,
+ fmt.Sprintf("%s_%d", strings.TrimSpace(input.ClientPrefix), input.Message.ID),
+ enums.IMMessageTypeText,
+ replyText,
+ "",
+ s.buildAIPrincipal(input.AIAgent),
+ input.Message.RequestID,
+ input.WorkflowRunID,
+ )
+ if err != nil {
+ return nil, err
+ }
+ }
+ if !input.IncrementRound {
+ return replyMessage, nil
}
if err := s.IncrementAIReplyRounds(input.Conversation.ID, input.Conversation.AIReplyRounds+1, input.AIAgent.Name); err != nil {
return nil, err
}
- return replyMessage, err
+ return replyMessage, nil
}
func (s *replyCommitService) CommitAIReply(input replyCommitInput) (*models.Message, error) {
diff --git a/internal/ai/runtime/reply_service_test.go b/internal/ai/runtime/reply_service_test.go
index 9f44e9d9..6ac41055 100644
--- a/internal/ai/runtime/reply_service_test.go
+++ b/internal/ai/runtime/reply_service_test.go
@@ -70,19 +70,29 @@ func TestResolveReplyTimeout(t *testing.T) {
service := newAIReplyService()
aiAgent := newAIAgentFixture()
- if got := service.resolveReplyTimeout(aiAgent); got != 180*time.Second {
+ if got := service.resolveReplyTimeout(nil, aiAgent); got != 120*time.Second {
t.Fatalf("expected default timeout, got %v", got)
}
aiAgent.ReplyTimeoutSeconds = 30
- if got := service.resolveReplyTimeout(aiAgent); got != 30*time.Second {
- t.Fatalf("expected exact timeout, got %v", got)
+ if got := service.resolveReplyTimeout(nil, aiAgent); got != 30*time.Second {
+ t.Fatalf("expected agent timeout, got %v", got)
}
aiAgent.ReplyTimeoutSeconds = 999
- if got := service.resolveReplyTimeout(aiAgent); got != 600*time.Second {
+ if got := service.resolveReplyTimeout(nil, aiAgent); got != 600*time.Second {
t.Fatalf("expected clamped timeout, got %v", got)
}
+
+ // 渠道配置优先于智能体配置
+ channel := &models.Channel{AIReplyTimeoutSeconds: 45}
+ if got := service.resolveReplyTimeout(channel, aiAgent); got != 45*time.Second {
+ t.Fatalf("expected channel timeout to take precedence, got %v", got)
+ }
+ channel.AIReplyTimeoutSeconds = 0
+ if got := service.resolveReplyTimeout(channel, models.AIAgent{}); got != 120*time.Second {
+ t.Fatalf("expected default timeout when channel and agent unset, got %v", got)
+ }
}
func TestResolveInterruptPrompt(t *testing.T) {
diff --git a/internal/ai/runtime/reply_trigger_service.go b/internal/ai/runtime/reply_trigger_service.go
index f3a18e03..b399c8c0 100644
--- a/internal/ai/runtime/reply_trigger_service.go
+++ b/internal/ai/runtime/reply_trigger_service.go
@@ -13,14 +13,22 @@ import (
svc "agent-desk/internal/services"
)
-func (s *aiReplyService) resolveReplyTimeout(aiAgent models.AIAgent) time.Duration {
- if aiAgent.ReplyTimeoutSeconds <= 0 {
- return time.Duration(defaultAIReplyAsyncTimeoutSeconds) * time.Second
+// resolveReplyTimeout 解析 AI 回复超时时长：接入渠道配置优先，其次智能体配置，最后使用系统默认。
+func (s *aiReplyService) resolveReplyTimeout(channel *models.Channel, aiAgent models.AIAgent) time.Duration {
+ seconds := 0
+ if channel != nil && channel.AIReplyTimeoutSeconds > 0 {
+ seconds = channel.AIReplyTimeoutSeconds
}
- if aiAgent.ReplyTimeoutSeconds > maxAIReplyAsyncTimeoutSeconds {
- return time.Duration(maxAIReplyAsyncTimeoutSeconds) * time.Second
+ if seconds <= 0 && aiAgent.ReplyTimeoutSeconds > 0 {
+ seconds = aiAgent.ReplyTimeoutSeconds
}
- return time.Duration(aiAgent.ReplyTimeoutSeconds) * time.Second
+ if seconds <= 0 {
+ seconds = models.DefaultAIReplyTimeoutSeconds
+ }
+ if seconds > maxAIReplyAsyncTimeoutSeconds {
+ seconds = maxAIReplyAsyncTimeoutSeconds
+ }
+ return time.Duration(seconds) * time.Second
}
func (s *aiReplyService) TriggerReplyAsync(conversation models.Conversation, message models.Message) {
@@ -29,8 +37,9 @@ func (s *aiReplyService) TriggerReplyAsync(conversation models.Conversation, mes
if aiAgent == nil || aiAgent.Status != enums.StatusOk {
return
}
+ channel := svc.ChannelService.Get(conversation.ChannelID)
startedAt := time.Now()
- timeout := s.resolveReplyTimeout(*aiAgent)
+ timeout := s.resolveReplyTimeout(channel, *aiAgent)
ctx, cancel := context.WithTimeout(tracex.ContextWithRequestID(context.Background(), message.RequestID), timeout)
defer cancel()
if err := s.TriggerReply(ctx, conversation, message, *aiAgent); err != nil {
@@ -40,6 +49,7 @@ func (s *aiReplyService) TriggerReplyAsync(conversation models.Conversation, mes
"timeout_ms", timeout.Milliseconds(),
"elapsed_ms", time.Since(startedAt).Milliseconds(),
"error", err)
+ svc.MessageService.CompleteAIReplyPlaceholderAsFailed(&conversation, aiAgent, &message, message.RequestID)
}
}()
}
@@ -58,9 +68,12 @@ func (s *aiReplyService) TriggerReply(ctx context.Context, conversation models.C
if s.eligibility != nil && !s.eligibility.CanReply(conversation, message, aiAgent) {
return nil
}
- if !IsAIAgentRolloutEligible(conversation, aiAgent, svc.ChannelService.Get(conversation.ChannelID)) {
+ channel := svc.ChannelService.Get(conversation.ChannelID)
+ if !IsAIAgentRolloutEligible(conversation, aiAgent, channel) {
return nil
}
+ // 正式回复生成前先发送占位提示，生成后由回复提交环节按渠道能力原地替换或追加新消息
+ svc.MessageService.SendAIReplyPlaceholder(&conversation, &aiAgent, &message, channel, message.RequestID)
if pendingInterrupt := svc.ConversationInterruptService.FindLatestPendingByConversationID(conversation.ID); pendingInterrupt != nil {
replyCtx.PendingInterrupt = pendingInterrupt
return s.resumePendingInterrupt(ctx, replyCtx)
@@ -108,6 +121,9 @@ func (s *aiReplyService) executeReply(ctx context.Context, replyCtx aiReplyConte
if err != nil {
return err
}
+ return nil
}
+ // 工作流执行完成但未产出回复文本，补发失败提示避免占位消息悬挂
+ svc.MessageService.CompleteAIReplyPlaceholderAsFailed(&replyCtx.Conversation, &replyCtx.AIAgent, &replyCtx.Message, replyCtx.Message.RequestID)
return nil
}
diff --git a/internal/ai/runtime/reply_types.go b/internal/ai/runtime/reply_types.go
index d16afb21..730edbd8 100644
--- a/internal/ai/runtime/reply_types.go
+++ b/internal/ai/runtime/reply_types.go
@@ -1,6 +1,6 @@
package runtime
-const (
- defaultAIReplyAsyncTimeoutSeconds = 180
- maxAIReplyAsyncTimeoutSeconds = 600
-)
+import "agent-desk/internal/models"
+
+// maxAIReplyAsyncTimeoutSeconds 为 AI 回复超时的上限；默认时长由 models.DefaultAIReplyTimeoutSeconds 提供。
+const maxAIReplyAsyncTimeoutSeconds = models.MaxAIReplyTimeoutSeconds
diff --git a/internal/bootstrap/init.go b/internal/bootstrap/init.go
index b3648e12..882efc3e 100644
--- a/internal/bootstrap/init.go
+++ b/internal/bootstrap/init.go
@@ -11,6 +11,8 @@ import (
"context"
"log/slog"
+ "github.com/mlogclub/simple/sqls"
+
_ "agent-desk/internal/services/event_handlers"
)
@@ -24,9 +26,10 @@ func Init(configPath string) error {
i18nx.SetDefaultLocale(cfg.LanguageOrDefault())
logx.Init(logx.Config{
- Level: cfg.Logger.Level,
- Format: cfg.Logger.Format,
- AddSource: cfg.Logger.AddSource,
+ Level: cfg.Logger.Level,
+ Format: cfg.Logger.Format,
+ AddSource: cfg.Logger.AddSource,
+ EnableDBSink: true,
})
if _, err := InitDB(cfg.DB); err != nil {
@@ -37,6 +40,7 @@ func Init(configPath string) error {
slog.Error("init migrations failed", "error", err)
return err
}
+ logx.AttachDB(sqls.DB())
if err := vectordb.Init(&cfg.VectorDB); err != nil {
slog.Error("init vector db failed", "error", err)
return err
diff --git a/internal/bootstrap/routes.go b/internal/bootstrap/routes.go
index 45a4a887..d5961c10 100644
--- a/internal/bootstrap/routes.go
+++ b/internal/bootstrap/routes.go
@@ -224,6 +224,7 @@ func registerDashboardChannelRoutes(group *gin.RouterGroup) {
group.POST("/update", dashboard.ChannelPostUpdate)
group.POST("/update_status", dashboard.ChannelPostUpdate_status)
group.Any("/wxwork/kf/accounts", dashboard.ChannelAnyWxworkKfAccounts)
+ group.POST("/wxwork/kf/test_read_messages", dashboard.ChannelPostWxworkKfTest_read_messages)
group.Any("/wxwork/outbox/failed/list", dashboard.ChannelAnyWxworkOutboxFailedList)
group.POST("/wxwork/outbox/retry", dashboard.ChannelPostWxworkOutboxRetry)
group.POST("/wxwork/outbox/ignore", dashboard.ChannelPostWxworkOutboxIgnore)
@@ -340,6 +341,7 @@ func registerDashboardKnowledgeDirectoryRoutes(group *gin.RouterGroup) {
func registerDashboardKnowledgeDocumentRoutes(group *gin.RouterGroup) {
group.GET("/:id", dashboard.KnowledgeDocumentGetBy)
group.POST("/batch_delete", dashboard.KnowledgeDocumentPostBatch_delete)
+ group.POST("/batch_build", dashboard.KnowledgeDocumentPostBatch_build)
group.POST("/batch_move", dashboard.KnowledgeDocumentPostBatch_move)
group.POST("/create", dashboard.KnowledgeDocumentPostCreate)
group.POST("/delete", dashboard.KnowledgeDocumentPostDelete)
@@ -422,6 +424,11 @@ func registerDashboardMCPRoutes(group *gin.RouterGroup) {
group.POST("/test_connection", dashboard.MCPPostTest_connection)
}
+func registerDashboardSystemLogRoutes(group *gin.RouterGroup) {
+ group.GET("/:id", dashboard.SystemLogGetBy)
+ group.Any("/list", dashboard.SystemLogAnyList)
+}
+
func registerThirdWechatRoutes(group *gin.RouterGroup) {
group.GET("/callback", third.WechatGetCallback)
group.POST("/callback", third.WechatPostCallback)
diff --git a/internal/bootstrap/server.go b/internal/bootstrap/server.go
index 71184100..4ad021b4 100644
--- a/internal/bootstrap/server.go
+++ b/internal/bootstrap/server.go
@@ -62,11 +62,35 @@ func corsMiddleware() gin.HandlerFunc {
}
allowedOriginSet[origin] = struct{}{}
}
+ // publicAnyOriginPaths 是可被任意来源跨域访问的公开只读接口。
+ // 这些接口不携带鉴权、不返回敏感信息，且供嵌入式 SDK 挂件在任意宿主站点
+ // 预拉取展示配置（之后聊天 iframe 与后端同源，不再触发跨域）。
+ publicAnyOriginPaths := map[string]struct{}{
+ "/api/config": {},
+ "/api/channel/config": {},
+ }
+ applyPublicCORS := func(ctx *gin.Context) {
+ ctx.Header("Access-Control-Allow-Origin", "*")
+ ctx.Header("Access-Control-Allow-Methods", allowMethods)
+ ctx.Header("Access-Control-Allow-Headers", allowHeaders)
+ ctx.Header("Access-Control-Expose-Headers", exposeHeaders)
+ ctx.Header("Access-Control-Max-Age", "600")
+ if ctx.Request.Method == http.MethodOptions {
+ ctx.AbortWithStatus(http.StatusNoContent)
+ return
+ }
+ ctx.Next()
+ }
return func(ctx *gin.Context) {
if isWebsocketUpgrade(ctx) {
ctx.Next()
return
}
+ // 公开只读接口：放行任意来源，无需白名单。
+ if _, isPublic := publicAnyOriginPaths[ctx.Request.URL.Path]; isPublic {
+ applyPublicCORS(ctx)
+ return
+ }
origin := strings.TrimRight(strings.TrimSpace(ctx.GetHeader("Origin")), "/")
if origin != "" {
ctx.Header("Vary", "Origin")
@@ -194,6 +218,7 @@ func addRouter(app *gin.Engine) {
registerDashboardCommunityPostRoutes(dashboardGroup.Group("/support-community/posts"))
registerDashboardSkillDefinitionRoutes(dashboardGroup.Group("/skill-definition"))
registerDashboardMCPRoutes(dashboardGroup.Group("/mcp"))
+ registerDashboardSystemLogRoutes(dashboardGroup.Group("/system-log"))
thirdGroup := app.Group("/api/third")
registerThirdWechatRoutes(thirdGroup.Group("/wechat"))
diff --git a/internal/bootstrap/server_route_test.go b/internal/bootstrap/server_route_test.go
index 31bd4f76..29801528 100644
--- a/internal/bootstrap/server_route_test.go
+++ b/internal/bootstrap/server_route_test.go
@@ -372,6 +372,114 @@ func TestNewServerRejectsUnconfiguredCORSOrigin(t *testing.T) {
}
}
+// TestNewServerPublicConfigEndpointsAllowAnyOrigin 验证嵌入式 SDK 挂件预拉取的
+// 两个公开只读接口对任意来源放行（含带 X-Channel-Id 头触发的预检请求），
+// 同时非公开接口仍受白名单约束。
+func TestNewServerPublicConfigEndpointsAllowAnyOrigin(t *testing.T) {
+ config.SetCurrent(&config.Config{
+ Language: "zh-CN",
+ Server: config.ServerConfig{
+ CORS: config.CORSConfig{
+ // 白名单为空：公开接口仍应放行，非公开接口应被拒。
+ AllowedOrigins: nil,
+ },
+ },
+ Storage: config.StorageConfig{
+ Local: config.LocalStorageConfig{
+ Root: "storage",
+ BaseURL: "/storage",
+ },
+ },
+ })
+
+ app, err := NewServer()
+ if err != nil {
+ t.Fatalf("NewServer() error = %v", err)
+ }
+
+ cases := []struct {
+ name string
+ method string
+ path string
+ origin string
+ extraHdrs map[string]string
+ wantStatus int
+ wantACAO string
+ }{
+ {
+ name: "GET /api/config with arbitrary origin",
+ method: http.MethodGet,
+ path: "/api/config",
+ origin: "http://localhost:5201",
+ wantStatus: http.StatusOK,
+ wantACAO: "*",
+ },
+ {
+ name: "OPTIONS /api/config preflight passes for arbitrary origin",
+ method: http.MethodOptions,
+ path: "/api/config",
+ origin: "http://localhost:5201",
+ extraHdrs: map[string]string{"Access-Control-Request-Method": http.MethodGet},
+ wantStatus: http.StatusNoContent,
+ wantACAO: "*",
+ },
+ {
+ name: "OPTIONS /api/channel/config preflight passes with X-Channel-Id request header",
+ method: http.MethodOptions,
+ path: "/api/channel/config",
+ origin: "http://localhost:5201",
+ extraHdrs: map[string]string{"Access-Control-Request-Method": http.MethodGet, "Access-Control-Request-Headers": "X-Channel-Id"},
+ wantStatus: http.StatusNoContent,
+ wantACAO: "*",
+ },
+ {
+ name: "GET /api/config without Origin header still works (same-origin)",
+ method: http.MethodGet,
+ path: "/api/config",
+ origin: "",
+ wantStatus: http.StatusOK,
+ wantACAO: "*",
+ },
+ }
+
+ for _, tt := range cases {
+ t.Run(tt.name, func(t *testing.T) {
+ rec := httptest.NewRecorder()
+ req := httptest.NewRequest(tt.method, tt.path, nil)
+ if tt.origin != "" {
+ req.Header.Set("Origin", tt.origin)
+ }
+ for k, v := range tt.extraHdrs {
+ req.Header.Set(k, v)
+ }
+ app.ServeHTTP(rec, req)
+
+ if rec.Code != tt.wantStatus {
+ t.Fatalf("status=%d want %d, body=%s", rec.Code, tt.wantStatus, rec.Body.String())
+ }
+ if got := rec.Header().Get("Access-Control-Allow-Origin"); got != tt.wantACAO {
+ t.Fatalf("Access-Control-Allow-Origin=%q want %q", got, tt.wantACAO)
+ }
+ if got := rec.Header().Get("Access-Control-Allow-Headers"); !strings.Contains(got, "X-Channel-Id") {
+ t.Fatalf("Access-Control-Allow-Headers=%q should contain X-Channel-Id", got)
+ }
+ })
+ }
+
+ // 回归：非公开接口在白名单为空时，预检应被拒。
+ rec := httptest.NewRecorder()
+ req := httptest.NewRequest(http.MethodOptions, "/api/auth/login", nil)
+ req.Header.Set("Origin", "http://localhost:5201")
+ req.Header.Set("Access-Control-Request-Method", http.MethodPost)
+ app.ServeHTTP(rec, req)
+ if rec.Code != http.StatusForbidden {
+ t.Fatalf("non-public preflight status=%d want %d", rec.Code, http.StatusForbidden)
+ }
+ if got := rec.Header().Get("Access-Control-Allow-Origin"); got != "" {
+ t.Fatalf("non-public Access-Control-Allow-Origin=%q want empty", got)
+ }
+}
+
func TestNewServerEchoesRequestID(t *testing.T) {
config.SetCurrent(&config.Config{
Storage: config.StorageConfig{
diff --git a/internal/builders/conversation_builder.go b/internal/builders/conversation_builder.go
index 352c66f3..0491d473 100644
--- a/internal/builders/conversation_builder.go
+++ b/internal/builders/conversation_builder.go
@@ -47,6 +47,10 @@ func BuildConversationWithLocale(item *models.Conversation, locale string) respo
if identity := services.ConversationService.GetConversationExternalIdentity(item); identity != nil {
ret.CustomerOnline = services.WsService.IsGuestOnline(identity.ExternalID)
}
+ if channel := services.ChannelService.Get(item.ChannelID); channel != nil {
+ ret.ChannelType = channel.ChannelType
+ ret.ChannelName = channel.Name
+ }
if item.CurrentAssigneeID > 0 {
if user := services.UserService.Get(item.CurrentAssigneeID); user != nil {
ret.CurrentAssigneeName = user.Nickname
diff --git a/internal/builders/system_log_builder.go b/internal/builders/system_log_builder.go
new file mode 100644
index 00000000..655169db
--- /dev/null
+++ b/internal/builders/system_log_builder.go
@@ -0,0 +1,33 @@
+package builders
+
+import (
+ "agent-desk/internal/models"
+ "agent-desk/internal/pkg/dto/response"
+)
+
+// BuildSystemLog 将 SystemLog 模型映射为响应 DTO。
+func BuildSystemLog(item *models.SystemLog) response.SystemLogResponse {
+ return response.SystemLogResponse{
+ ID: item.ID,
+ Level: item.Level,
+ LevelName: systemLogLevelName(item.Level),
+ Message: item.Message,
+ Source: item.Source,
+ LoggerName: item.LoggerName,
+ Attrs: item.Attrs,
+ CreatedAt: item.CreatedAt,
+ }
+}
+
+func systemLogLevelName(level string) string {
+ switch level {
+ case "INFO":
+ return "Info"
+ case "WARN":
+ return "Warn"
+ case "ERROR":
+ return "Error"
+ default:
+ return level
+ }
+}
diff --git a/internal/handlers/dashboard/channel_handler.go b/internal/handlers/dashboard/channel_handler.go
index bbf79ed3..2c5e4014 100644
--- a/internal/handlers/dashboard/channel_handler.go
+++ b/internal/handlers/dashboard/channel_handler.go
@@ -65,6 +65,26 @@ func ChannelAnyWxworkKfAccounts(ctx *gin.Context) {
httpx.WriteJSON(ctx, list)
}
+// ChannelPostWxworkKfTest_read_messages 测试企业微信客服渠道能否读取近 3 天的消息与事件。
+// 只读操作，使用 channel.view 权限；失败原因以结构化结果返回，不抛 JsonResult 错误。
+func ChannelPostWxworkKfTest_read_messages(ctx *gin.Context) {
+ if _, err := services.AuthService.RequirePermission(ctx, constants.PermissionChannelView); err != nil {
+ httpx.WriteJSON(ctx, err)
+ return
+ }
+ req := request.TestWxWorkKFReadMessagesRequest{}
+ if err := params.ReadJSON(ctx, &req); err != nil {
+ httpx.WriteJSON(ctx, err)
+ return
+ }
+ result, err := services.ChannelService.TestWxWorkKFReadMessages(req.ID)
+ if err != nil {
+ httpx.WriteJSON(ctx, err)
+ return
+ }
+ httpx.WriteJSON(ctx, result)
+}
+
func ChannelAnyWxworkOutboxFailedList(ctx *gin.Context) {
if _, err := services.AuthService.RequirePermission(ctx, constants.PermissionWxWorkOutboxView); err != nil {
httpx.WriteJSON(ctx, err)
diff --git a/internal/handlers/dashboard/knowledge_document_handler.go b/internal/handlers/dashboard/knowledge_document_handler.go
index cc36a536..9740907e 100644
--- a/internal/handlers/dashboard/knowledge_document_handler.go
+++ b/internal/handlers/dashboard/knowledge_document_handler.go
@@ -163,6 +163,24 @@ func KnowledgeDocumentPostBatch_move(ctx *gin.Context) {
httpx.WriteJSON(ctx, nil)
}
+func KnowledgeDocumentPostBatch_build(ctx *gin.Context) {
+ operator, err := services.AuthService.RequirePermission(ctx, constants.PermissionKnowledgeDocumentUpdate)
+ if err != nil {
+ httpx.WriteJSON(ctx, err)
+ return
+ }
+ req := request.BatchBuildKnowledgeDocumentRequest{}
+ if err := params.ReadJSON(ctx, &req); err != nil {
+ httpx.WriteJSON(ctx, err)
+ return
+ }
+ if err := services.KnowledgeDocumentService.BatchBuildKnowledgeDocuments(req, operator); err != nil {
+ httpx.WriteJSON(ctx, err)
+ return
+ }
+ httpx.WriteJSON(ctx, nil)
+}
+
func KnowledgeDocumentPostBatch_delete(ctx *gin.Context) {
if _, err := services.AuthService.RequirePermission(ctx, constants.PermissionKnowledgeDocumentDelete); err != nil {
httpx.WriteJSON(ctx, err)
diff --git a/internal/handlers/dashboard/system_log_handler.go b/internal/handlers/dashboard/system_log_handler.go
new file mode 100644
index 00000000..d9b71175
--- /dev/null
+++ b/internal/handlers/dashboard/system_log_handler.go
@@ -0,0 +1,56 @@
+package dashboard
+
+import (
+ "agent-desk/internal/builders"
+ "agent-desk/internal/pkg/constants"
+ "agent-desk/internal/pkg/dto/response"
+ "agent-desk/internal/pkg/httpx"
+ "agent-desk/internal/pkg/httpx/params"
+ "agent-desk/internal/services"
+
+ "github.com/gin-gonic/gin"
+ "github.com/mlogclub/simple/web"
+)
+
+// SystemLogAnyList 系统日志分页列表，支持按级别、关键字、时间范围筛选。
+func SystemLogAnyList(ctx *gin.Context) {
+ if _, err := services.AuthService.RequirePermission(ctx, constants.PermissionSystemLogView); err != nil {
+ httpx.WriteJSON(ctx, err)
+ return
+ }
+
+ cnd := params.NewPagedSqlCnd(ctx,
+ params.QueryFilter{ParamName: "level", Op: params.Eq},
+ params.QueryFilter{ParamName: "message", Op: params.Like},
+ params.QueryFilter{ParamName: "source", Op: params.Like},
+ params.QueryFilter{ParamName: "startTime", Op: params.Gte, ColumnName: "created_at"},
+ params.QueryFilter{ParamName: "endTime", Op: params.Lte, ColumnName: "created_at"},
+ ).Desc("id")
+
+ list, paging := services.SystemLogService.FindPageByCnd(cnd)
+ results := make([]response.SystemLogResponse, 0, len(list))
+ for i := range list {
+ results = append(results, builders.BuildSystemLog(&list[i]))
+ }
+ httpx.WriteJSON(ctx, &web.PageResult{Results: results, Page: paging})
+}
+
+// SystemLogGetBy 系统日志详情。
+func SystemLogGetBy(ctx *gin.Context) {
+ if _, err := services.AuthService.RequirePermission(ctx, constants.PermissionSystemLogView); err != nil {
+ httpx.WriteJSON(ctx, err)
+ return
+ }
+
+ id, ok := httpx.GetPathInt64(ctx, "id")
+ if !ok {
+ return
+ }
+
+ item := services.SystemLogService.Get(id)
+ if item == nil {
+ httpx.WriteJSON(ctx, httpx.JsonErrorMsg(ctx, "error.notFound"))
+ return
+ }
+ httpx.WriteJSON(ctx, builders.BuildSystemLog(item))
+}
diff --git a/internal/migration/000002_init_auth_data.go b/internal/migration/000002_init_auth_data.go
index 177b5379..b459cd3f 100644
--- a/internal/migration/000002_init_auth_data.go
+++ b/internal/migration/000002_init_auth_data.go
@@ -205,6 +205,7 @@ func ensureBootstrapAdmin(tx *gorm.DB, superAdminRole *models.Role) error {
Username: username,
Nickname: nickname,
Password: string(hashedPassword),
+ UserType: enums.UserTypeEmployee,
Status: enums.StatusOk,
Remark: "bootstrap super admin",
AuditFields: models.AuditFields{
@@ -223,6 +224,7 @@ func ensureBootstrapAdmin(tx *gorm.DB, superAdminRole *models.Role) error {
} else {
if err := repositories.UserRepository.Updates(tx, user.ID, map[string]any{
"nickname": nickname,
+ "user_type": enums.UserTypeEmployee,
"status": enums.StatusOk,
"update_user_id": constants.SystemAuditUserID,
"update_user_name": constants.SystemAuditUserName,
diff --git a/internal/migration/000010_backfill_employee_user_type.go b/internal/migration/000010_backfill_employee_user_type.go
new file mode 100644
index 00000000..3c3781ba
--- /dev/null
+++ b/internal/migration/000010_backfill_employee_user_type.go
@@ -0,0 +1,32 @@
+package migration
+
+import (
+ "agent-desk/internal/pkg/enums"
+ "log/slog"
+
+ "github.com/mlogclub/simple/sqls"
+)
+
+func init() {
+ register(10, "backfill employee user_type for staff users", func() error {
+ return sqls.WithTransaction(func(ctx *sqls.TxContext) error {
+ // t_user stores both staff accounts (user_type=employee, allowed on /api/dashboard)
+ // and support-portal customers (user_type=user). Existing staff accounts created
+ // before the user_type column was introduced kept the column default "user" and
+ // were rejected by the dashboard auth middleware. Staff accounts are identified
+ // by having at least one role binding in t_user_role.
+ res := ctx.Tx.Exec(
+ "UPDATE t_user SET user_type = ? WHERE user_type = ? "+
+ "AND EXISTS (SELECT 1 FROM t_user_role ur WHERE ur.user_id = t_user.id)",
+ enums.UserTypeEmployee, enums.UserTypeUser,
+ )
+ if res.Error != nil {
+ return res.Error
+ }
+ if res.RowsAffected > 0 {
+ slog.Info("backfilled employee user_type for staff users", "count", res.RowsAffected)
+ }
+ return nil
+ })
+ })
+}
diff --git a/internal/models/channel.go b/internal/models/channel.go
new file mode 100644
index 00000000..343a332d
--- /dev/null
+++ b/internal/models/channel.go
@@ -0,0 +1,31 @@
+package models
+
+import "strings"
+
+// AI 回复占位与超时的系统默认文案与上限；接入渠道可通过对应字段按渠道覆盖。
+const (
+ DefaultAIReplyPlaceholder = "正在查看，请稍候……"
+ DefaultAIReplyTimeoutSeconds = 120
+ MaxAIReplyTimeoutSeconds = 600
+ DefaultAIReplyTimeoutNotice = "抱歉，AI 客服暂时未能处理您的问题，请重新发送问题或转人工客服。"
+)
+
+// EffectiveAIReplyPlaceholder 返回渠道生效的 AI 接待占位提示语。
+func (c *Channel) EffectiveAIReplyPlaceholder() string {
+ if c != nil {
+ if value := strings.TrimSpace(c.AIReplyPlaceholder); value != "" {
+ return value
+ }
+ }
+ return DefaultAIReplyPlaceholder
+}
+
+// EffectiveAIReplyTimeoutNotice 返回渠道生效的 AI 回复超时/失败提示语。
+func (c *Channel) EffectiveAIReplyTimeoutNotice() string {
+ if c != nil {
+ if value := strings.TrimSpace(c.AIReplyTimeoutNotice); value != "" {
+ return value
+ }
+ }
+ return DefaultAIReplyTimeoutNotice
+}
diff --git a/internal/models/models.go b/internal/models/models.go
index 01b3e70d..b1ae9f97 100644
--- a/internal/models/models.go
+++ b/internal/models/models.go
@@ -77,6 +77,7 @@ var Models = []any{
&AIWorkflowNodeRun{},
&ConversationInterrupt{},
&SystemConfig{},
+ &SystemLog{},
}
// AgentToolInvocation persists the idempotency boundary for a business tool.
@@ -753,6 +754,9 @@ type Channel struct {
AIAgentID int64 `gorm:"type:bigint;not null;default:0;index"` // AIAgentID 为该渠道默认接入的 AI Agent。 当外部客户通过该渠道首次进入系统且尚未命中现有未结束会话时，系统会使用该 AI Agent 作为会话默认接待实例。
AIAgentRolloutPercent int `gorm:"type:int;not null;default:100"` // AIAgentRolloutPercent 为该渠道对 AI 自动回复施加的灰度百分比，100 表示不额外限制。
PreviousAIAgentRolloutPercent int `gorm:"type:int;not null;default:0"` // PreviousAIAgentRolloutPercent 保存渠道上一次生效的 Agent 灰度比例，0 表示尚无可回滚值。
+ AIReplyPlaceholder string `gorm:"type:varchar(255);not null;default:''"` // AIReplyPlaceholder 为 AI 接待占位提示语，AI 收到客户消息后先回复该内容，正式回复生成后原地替换；空值使用系统默认文案。
+ AIReplyTimeoutSeconds int `gorm:"type:int;not null;default:0"` // AIReplyTimeoutSeconds 为 AI 回复超时秒数，超时后向客户提示处理失败；0 表示使用系统默认（120 秒）。
+ AIReplyTimeoutNotice string `gorm:"type:varchar(500);not null;default:''"` // AIReplyTimeoutNotice 为 AI 回复超时或处理失败时向客户提示的文案；空值使用系统默认文案。
// ConfigJSON 为渠道专属扩展配置，使用 JSON 存储。
// 例如：
// 1. web 渠道可记录允许域名、品牌配置等；
diff --git a/internal/models/system_log.go b/internal/models/system_log.go
new file mode 100644
index 00000000..2b39f33b
--- /dev/null
+++ b/internal/models/system_log.go
@@ -0,0 +1,18 @@
+package models
+
+import "time"
+
+// SystemLog 系统日志记录，持久化 INFO/WARN/ERROR 级别的运行日志。
+type SystemLog struct {
+ ID int64 `gorm:"primaryKey;autoIncrement"`
+ Level string `gorm:"type:varchar(20);not null;default:'';index"` // INFO / WARN / ERROR
+ Message string `gorm:"type:text"` // 日志消息
+ Source string `gorm:"type:varchar(255);not null;default:'';index"` // file:line
+ LoggerName string `gorm:"type:varchar(128);not null;default:'';index"` // logger 名称
+ Attrs string `gorm:"type:text"` // JSON 序列化的 attrs
+ CreatedAt time.Time `gorm:"not null;index"` // 日志发生时间
+}
+
+func (SystemLog) TableName() string {
+ return "t_system_log"
+}
diff --git a/internal/pkg/constants/auth.go b/internal/pkg/constants/auth.go
index eae23100..0e095657 100644
--- a/internal/pkg/constants/auth.go
+++ b/internal/pkg/constants/auth.go
@@ -186,6 +186,9 @@ var (
// MCP 调试相关权限
PermissionMCPView = Permission{Name: "查看MCP调试信息", Code: "mcp.view", Type: "api", GroupName: "mcp", Method: "POST", APIPath: "/api/dashboard/mcp/list_tools", SortNo: 1710}
PermissionMCPCall = Permission{Name: "调用MCP工具", Code: "mcp.call", Type: "api", GroupName: "mcp", Method: "POST", APIPath: "/api/dashboard/mcp/call_tool", SortNo: 1720}
+
+ // 系统日志相关权限
+ PermissionSystemLogView = Permission{Name: "查看系统日志", Code: "systemLog.view", Type: "api", GroupName: "systemLog", Method: "ANY", APIPath: "/api/dashboard/system-log/list", SortNo: 1810}
)
// Permissions 内置权限列表
@@ -295,6 +298,7 @@ var Permissions = []Permission{
PermissionSkillDefinitionDelete,
PermissionMCPView,
PermissionMCPCall,
+ PermissionSystemLogView,
}
// PermissionMap 权限映射，用于通过 Code 查找 Permission
@@ -392,6 +396,7 @@ var builtinPermissionResourceLabels = map[string]string{
"knowledgeFAQ": "knowledge FAQs",
"skillDefinition": "Skill definitions",
"mcp": "MCP tools",
+ "systemLog": "system logs",
}
var builtinPermissionNameOverrides = map[string]string{
@@ -444,6 +449,7 @@ var RolePermissions = map[string][]Permission{
PermissionAIAgentView, PermissionAIAgentCreate, PermissionAIAgentUpdate, PermissionAIAgentDelete,
PermissionAIConfigView, PermissionAIConfigCreate, PermissionAIConfigUpdate, PermissionAIConfigDelete,
PermissionSkillDefinitionView, PermissionSkillDefinitionCreate, PermissionSkillDefinitionUpdate, PermissionSkillDefinitionDelete,
+ PermissionSystemLogView,
},
RoleCodeCsTeamLeader: {
PermissionUserView,
diff --git a/internal/pkg/dto/dto.go b/internal/pkg/dto/dto.go
index 276d03a1..85b1f002 100644
--- a/internal/pkg/dto/dto.go
+++ b/internal/pkg/dto/dto.go
@@ -33,6 +33,21 @@ type WechatMPChannelConfig struct {
UserTokenSecret string `json:"userTokenSecret,omitempty"`
}
+// WechatMiniProgramChannelConfig 微信小程序客服消息渠道配置。
+//
+// 注意与 WechatMPChannelConfig（微信公众号）区分。
+type WechatMiniProgramChannelConfig struct {
+ Title string `json:"title"`
+ Subtitle string `json:"subtitle"`
+ ThemeColor string `json:"themeColor"`
+ UserTokenSecret string `json:"userTokenSecret,omitempty"`
+ AppID string `json:"appId"`
+ Token string `json:"token"`
+ EncodingAESKey string `json:"encodingAESKey"`
+ TokenServiceURL string `json:"tokenServiceUrl"`
+ TokenServiceSecret string `json:"tokenServiceSecret,omitempty"`
+}
+
type TelegramChannelConfig struct {
BotToken string `json:"botToken"`
BotUsername string `json:"botUsername,omitempty"`
diff --git a/internal/pkg/dto/request/channel_request.go b/internal/pkg/dto/request/channel_request.go
index a5095cb3..0853a98a 100644
--- a/internal/pkg/dto/request/channel_request.go
+++ b/internal/pkg/dto/request/channel_request.go
@@ -4,6 +4,9 @@ type CreateChannelRequest struct {
ChannelType string `json:"channelType"`
AIAgentID int64 `json:"aiAgentId"`
AIAgentRolloutPercent int `json:"aiAgentRolloutPercent"`
+ AIReplyPlaceholder string `json:"aiReplyPlaceholder"`
+ AIReplyTimeoutSeconds int `json:"aiReplyTimeoutSeconds"`
+ AIReplyTimeoutNotice string `json:"aiReplyTimeoutNotice"`
Name string `json:"name"`
ConfigJSON string `json:"configJson"`
Status int `json:"status"`
@@ -32,6 +35,10 @@ type ResetChannelUserTokenSecretRequest struct {
ID int64 `json:"id"`
}
+type TestWxWorkKFReadMessagesRequest struct {
+ ID int64 `json:"id"`
+}
+
type ChannelMessageOutboxActionRequest struct {
ID int64 `json:"id"`
}
diff --git a/internal/pkg/dto/request/knowledge_request.go b/internal/pkg/dto/request/knowledge_request.go
index f0d20b02..a9e5305b 100644
--- a/internal/pkg/dto/request/knowledge_request.go
+++ b/internal/pkg/dto/request/knowledge_request.go
@@ -65,6 +65,10 @@ type BatchDeleteKnowledgeDocumentRequest struct {
IDs []int64 `json:"ids"`
}
+type BatchBuildKnowledgeDocumentRequest struct {
+ IDs []int64 `json:"ids"`
+}
+
type CreateKnowledgeFAQRequest struct {
KnowledgeBaseID int64 `json:"knowledgeBaseId"`
DirectoryID int64 `json:"directoryId"`
diff --git a/internal/pkg/dto/response/channel_response.go b/internal/pkg/dto/response/channel_response.go
index e1c36f99..e2a25a3d 100644
--- a/internal/pkg/dto/response/channel_response.go
+++ b/internal/pkg/dto/response/channel_response.go
@@ -13,6 +13,9 @@ type ChannelResponse struct {
AIAgentID int64 `json:"aiAgentId"`
AIAgentRolloutPercent int `json:"aiAgentRolloutPercent"`
PreviousAIAgentRolloutPercent int `json:"previousAiAgentRolloutPercent"`
+ AIReplyPlaceholder string `json:"aiReplyPlaceholder"`
+ AIReplyTimeoutSeconds int `json:"aiReplyTimeoutSeconds"`
+ AIReplyTimeoutNotice string `json:"aiReplyTimeoutNotice"`
AIAgentName string `json:"aiAgentName,omitempty"`
Name string `json:"name"`
ConfigJSON string `json:"configJson"`
@@ -55,6 +58,9 @@ func BuildChannelResponse(item *models.Channel) ChannelResponse {
AIAgentID: item.AIAgentID,
AIAgentRolloutPercent: item.AIAgentRolloutPercent,
PreviousAIAgentRolloutPercent: item.PreviousAIAgentRolloutPercent,
+ AIReplyPlaceholder: item.AIReplyPlaceholder,
+ AIReplyTimeoutSeconds: item.AIReplyTimeoutSeconds,
+ AIReplyTimeoutNotice: item.AIReplyTimeoutNotice,
Name: item.Name,
ConfigJSON: item.ConfigJSON,
Status: item.Status,
diff --git a/internal/pkg/dto/response/conversation_response.go b/internal/pkg/dto/response/conversation_response.go
index 697dbfdf..f357b5ae 100644
--- a/internal/pkg/dto/response/conversation_response.go
+++ b/internal/pkg/dto/response/conversation_response.go
@@ -21,6 +21,8 @@ type ConversationResponse struct {
ID int64 `json:"id"`
AIAgentID int64 `json:"aiAgentId"`
ChannelID int64 `json:"channelId"`
+ ChannelType string `json:"channelType,omitempty"`
+ ChannelName string `json:"channelName,omitempty"`
CustomerID int64 `json:"customerId"`
CustomerName string `json:"customerName"`
Status enums.IMConversationStatus `json:"status"`
diff --git a/internal/pkg/dto/response/system_log_response.go b/internal/pkg/dto/response/system_log_response.go
new file mode 100644
index 00000000..562e23ec
--- /dev/null
+++ b/internal/pkg/dto/response/system_log_response.go
@@ -0,0 +1,15 @@
+package response
+
+import "time"
+
+// SystemLogResponse 系统日志列表/详情响应。
+type SystemLogResponse struct {
+ ID int64 `json:"id"`
+ Level string `json:"level"`
+ LevelName string `json:"levelName"`
+ Message string `json:"message"`
+ Source string `json:"source"`
+ LoggerName string `json:"loggerName"`
+ Attrs string `json:"attrs"`
+ CreatedAt time.Time `json:"createdAt"`
+}
diff --git a/internal/pkg/dto/response/wxwork_kf_message_read_test_response.go b/internal/pkg/dto/response/wxwork_kf_message_read_test_response.go
new file mode 100644
index 00000000..e98f0b18
--- /dev/null
+++ b/internal/pkg/dto/response/wxwork_kf_message_read_test_response.go
@@ -0,0 +1,32 @@
+package response
+
+// WxWorkKFMessageReadTestResult 为“测试读取企业微信客服消息”的结果。
+// 该接口是只读连通性测试：不消费消息、不创建会话、不更新同步游标；
+// 调用失败也以 HTTP 200 返回结构化结果，由前端按错误码给出排查建议。
+type WxWorkKFMessageReadTestResult struct {
+ Success bool `json:"success"` // 是否成功读取
+ Stage string `json:"stage,omitempty"` // 失败环节：gettoken / syncmsg
+ ErrorCode string `json:"errorCode,omitempty"` // 企业微信原始 errcode，或本地错误码
+ ErrorMessage string `json:"errorMessage,omitempty"` // 企业微信原始 errmsg 或网络错误原文
+ OpenKfID string `json:"openKfId,omitempty"` // 测试使用的客服账号 ID
+
+ TotalScanned int `json:"totalScanned"` // 本次扫描到的消息/事件总条数（受分页上限约束）
+ MessageCount int `json:"messageCount"` // 普通消息条数
+ EventCount int `json:"eventCount"` // 事件条数
+ Truncated bool `json:"truncated"` // 是否因达到分页扫描上限而提前停止
+ EarliestTime string `json:"earliestTime,omitempty"`
+ LatestTime string `json:"latestTime,omitempty"`
+ Samples []WxWorkKFMessageReadSample `json:"samples"` // 最近若干条样例（新消息在前）
+}
+
+// WxWorkKFMessageReadSample 为测试结果中的单条消息/事件样例，仅携带展示所需的原始字段，本地化在前端完成。
+type WxWorkKFMessageReadSample struct {
+ MsgID string `json:"msgId,omitempty"`
+ SendTime string `json:"sendTime,omitempty"`
+ Origin int `json:"origin"` // 3-客户发送 4-系统事件 5-接待人员发送
+ MsgType string `json:"msgType,omitempty"` // text/image/file/voice/video/event 等
+ EventType string `json:"eventType,omitempty"` // msgtype=event 时的事件类型
+ TextContent string `json:"textContent,omitempty"` // 文本消息原文（已截断）
+ ExternalUserID string `json:"externalUserId,omitempty"` // 客户 external_userid
+ ServicerUserID string `json:"servicerUserId,omitempty"` // 接待人员 userid
+}
diff --git a/internal/pkg/enums/external_identity.go b/internal/pkg/enums/external_identity.go
index 2ace3f0a..15f24d91 100644
--- a/internal/pkg/enums/external_identity.go
+++ b/internal/pkg/enums/external_identity.go
@@ -6,21 +6,23 @@ package enums
type ExternalSource string
const (
- ExternalSourceGuest ExternalSource = "guest" // 访客
- ExternalSourceWxWorkKF ExternalSource = "wxwork_kf" // 企业微信客服
- ExternalSourceUser ExternalSource = "user" // 站内用户
- ExternalSourceExternal ExternalSource = "external" // 外部接入方用户
- ExternalSourceTelegram ExternalSource = "telegram" // Telegram
- ExternalSourceZaloOA ExternalSource = "zalo_oa" // Zalo OA
+ ExternalSourceGuest ExternalSource = "guest" // 访客
+ ExternalSourceWxWorkKF ExternalSource = "wxwork_kf" // 企业微信客服
+ ExternalSourceUser ExternalSource = "user" // 站内用户
+ ExternalSourceExternal ExternalSource = "external" // 外部接入方用户
+ ExternalSourceTelegram ExternalSource = "telegram" // Telegram
+ ExternalSourceZaloOA ExternalSource = "zalo_oa" // Zalo OA
+ ExternalSourceWechatMiniProgram ExternalSource = "wechat_miniprogram" // 微信小程序
)
var externalSourceLabelMap = map[ExternalSource]string{
- ExternalSourceGuest: "访客",
- ExternalSourceWxWorkKF: "企业微信客服",
- ExternalSourceUser: "站内用户",
- ExternalSourceExternal: "外部用户",
- ExternalSourceTelegram: "Telegram",
- ExternalSourceZaloOA: "Zalo OA",
+ ExternalSourceGuest: "访客",
+ ExternalSourceWxWorkKF: "企业微信客服",
+ ExternalSourceUser: "站内用户",
+ ExternalSourceExternal: "外部用户",
+ ExternalSourceTelegram: "Telegram",
+ ExternalSourceZaloOA: "Zalo OA",
+ ExternalSourceWechatMiniProgram: "微信小程序",
}
func GetExternalSourceLabel(v ExternalSource) string {
diff --git a/internal/pkg/enums/im.go b/internal/pkg/enums/im.go
index da23f4c3..0743b7fe 100644
--- a/internal/pkg/enums/im.go
+++ b/internal/pkg/enums/im.go
@@ -246,6 +246,7 @@ const (
IMRealtimeEventUnsubscribed = "unsubscribed"
IMRealtimeEventResyncRequired = "resyncRequired"
IMRealtimeEventMessageCreated = "message.created"
+ IMRealtimeEventMessageUpdated = "message.updated"
IMRealtimeEventMessageRecalled = "message.recalled"
IMRealtimeEventConversationCreated = "conversation.created"
IMRealtimeEventConversationUpdated = "conversation.updated"
diff --git a/internal/pkg/i18nx/locales/en-US.yml b/internal/pkg/i18nx/locales/en-US.yml
index ac67c301..0e4469d2 100644
--- a/internal/pkg/i18nx/locales/en-US.yml
+++ b/internal/pkg/i18nx/locales/en-US.yml
@@ -345,6 +345,7 @@ error.e0344: "Invalid attachment message payload format."
error.e0345: "Attachment message is missing assetId."
error.e0346: "Attachment message is missing payload."
error.e0347: "Default team queue mode requires at least one agent team."
+error.e0348: "Invalid AI reply timeout."
error.profile.nicknameRequired: "Enter a nickname."
error.profile.nicknameTooLong: "Nickname cannot exceed 100 characters."
error.profile.avatarTooLong: "Avatar link cannot exceed 255 characters."
diff --git a/internal/pkg/i18nx/locales/zh-CN.yml b/internal/pkg/i18nx/locales/zh-CN.yml
index e168083c..1b1cc564 100644
--- a/internal/pkg/i18nx/locales/zh-CN.yml
+++ b/internal/pkg/i18nx/locales/zh-CN.yml
@@ -345,6 +345,7 @@ error.e0344: "附件消息 payload 格式错误"
error.e0345: "附件消息缺少 assetId"
error.e0346: "附件消息缺少 payload"
error.e0347: "默认客服组待接入池模式必须至少选择一个客服组"
+error.e0348: "AI 回复超时时长不合法"
error.profile.nicknameRequired: "请输入昵称"
error.profile.nicknameTooLong: "昵称不能超过 100 个字符"
error.profile.avatarTooLong: "头像链接不能超过 255 个字符"
diff --git a/internal/pkg/logx/db_sink.go b/internal/pkg/logx/db_sink.go
new file mode 100644
index 00000000..1f34d3ee
--- /dev/null
+++ b/internal/pkg/logx/db_sink.go
@@ -0,0 +1,225 @@
+package logx
+
+import (
+ "context"
+ "encoding/json"
+ "fmt"
+ "log/slog"
+ "os"
+ "runtime"
+ "sync"
+ "sync/atomic"
+ "time"
+
+ "agent-desk/internal/models"
+
+ "gorm.io/gorm"
+)
+
+const (
+ dbSinkChannelCapacity = 4096
+ dbSinkBatchSize = 200
+ dbSinkFlushInterval = 1 * time.Second
+)
+
+// dbSink 包装底层 stdout handler，并将 INFO/WARN/ERROR 级别日志异步写入数据库。
+type dbSink struct {
+ inner slog.Handler
+
+ // DB 引用，通过 atomic 实现 lazy 注入。nil 时跳过 DB 写入。
+ db atomic.Pointer[gorm.DB]
+
+ // 日志 channel，worker goroutine 消费。
+ ch chan models.SystemLog
+
+ // 控制 worker 生命周期。
+ stopOnce sync.Once
+ stop chan struct{}
+ done chan struct{}
+}
+
+// dbSinkDropped 记录因 channel 满而丢弃的日志条数（进程级累计）。
+var dbSinkDropped atomic.Uint64
+
+// dbSinkLastDropReportSec 记录上次输出丢弃告警的秒级时间戳，用于限频，避免 INFO 高频时刷屏 stderr。
+var dbSinkLastDropReportSec atomic.Int64
+
+var sink *dbSink
+
+// AttachDB 注入 DB 并启动 worker goroutine。调用幂等。
+func AttachDB(db *gorm.DB) {
+ if sink == nil {
+ return
+ }
+ if sink.db.Load() != nil {
+ return
+ }
+ sink.db.Store(db)
+ go sink.worker()
+}
+
+// Close 触发 worker 最终 flush 并退出。在 server shutdown 时调用。
+func Close() error {
+ if sink == nil {
+ return nil
+ }
+ sink.stopOnce.Do(func() {
+ close(sink.stop)
+ })
+ select {
+ case <-sink.done:
+ case <-time.After(3 * time.Second):
+ }
+ return nil
+}
+
+func (h *dbSink) Handle(ctx context.Context, r slog.Record) error {
+ // 先走 stdout
+ if err := h.inner.Handle(ctx, r.Clone()); err != nil {
+ return err
+ }
+
+ // 只持久化 INFO 及以上级别（DEBUG 不写库）
+ if r.Level < slog.LevelInfo {
+ return nil
+ }
+
+ // DB 未注入时跳过
+ db := h.db.Load()
+ if db == nil {
+ return nil
+ }
+
+ // 构造 SystemLog
+ logEntry := buildSystemLog(r)
+
+ // 非阻塞写入 channel，满时丢弃（每秒最多输出一次 stderr 告警，避免高频日志刷屏）
+ select {
+ case h.ch <- logEntry:
+ default:
+ dropped := dbSinkDropped.Add(1)
+ nowSec := time.Now().Unix()
+ if dbSinkLastDropReportSec.Swap(nowSec) != nowSec {
+ fmt.Fprintf(os.Stderr, "logx: db sink channel full, dropped %d log entries\n", dropped)
+ }
+ }
+
+ return nil
+}
+
+func (h *dbSink) Enabled(ctx context.Context, level slog.Level) bool {
+ return h.inner.Enabled(ctx, level)
+}
+
+func (h *dbSink) WithAttrs(attrs []slog.Attr) slog.Handler {
+ return &dbSink{
+ inner: h.inner.WithAttrs(attrs),
+ db: h.db,
+ ch: h.ch,
+ stop: h.stop,
+ done: h.done,
+ }
+}
+
+func (h *dbSink) WithGroup(name string) slog.Handler {
+ return &dbSink{
+ inner: h.inner.WithGroup(name),
+ db: h.db,
+ ch: h.ch,
+ stop: h.stop,
+ done: h.done,
+ }
+}
+
+func (h *dbSink) worker() {
+ defer close(h.done)
+
+ batch := make([]models.SystemLog, 0, dbSinkBatchSize)
+ ticker := time.NewTicker(dbSinkFlushInterval)
+ defer ticker.Stop()
+
+ flush := func() {
+ if len(batch) == 0 {
+ return
+ }
+ db := h.db.Load()
+ if db == nil {
+ batch = batch[:0]
+ return
+ }
+ if err := db.CreateInBatches(batch, dbSinkBatchSize).Error; err != nil {
+ // 写入失败不影响主流程，输出到 stderr
+ fmt.Fprintf(os.Stderr, "logx: batch insert system logs failed: %v\n", err)
+ }
+ batch = batch[:0]
+ }
+
+ for {
+ select {
+ case <-h.stop:
+ // drain 剩余日志
+ for {
+ select {
+ case entry := <-h.ch:
+ batch = append(batch, entry)
+ if len(batch) >= dbSinkBatchSize {
+ flush()
+ }
+ default:
+ flush()
+ return
+ }
+ }
+ case entry := <-h.ch:
+ batch = append(batch, entry)
+ if len(batch) >= dbSinkBatchSize {
+ flush()
+ }
+ case <-ticker.C:
+ flush()
+ }
+ }
+}
+
+func buildSystemLog(r slog.Record) models.SystemLog {
+ // 提取 source（file:line）
+ source := ""
+ if r.PC != 0 {
+ frames := runtimeCallerFrames(r.PC)
+ if frames != nil {
+ source = fmt.Sprintf("%s:%d", frames.File, frames.Line)
+ }
+ }
+
+ // 提取 attrs
+ attrs := map[string]any{}
+ r.Attrs(func(a slog.Attr) bool {
+ attrs[a.Key] = a.Value.Any()
+ return true
+ })
+
+ attrsJSON := ""
+ if len(attrs) > 0 {
+ if b, err := json.Marshal(attrs); err == nil {
+ attrsJSON = string(b)
+ }
+ }
+
+ return models.SystemLog{
+ Level: r.Level.String(),
+ Message: r.Message,
+ Source: source,
+ LoggerName: "default",
+ Attrs: attrsJSON,
+ CreatedAt: r.Time,
+ }
+}
+
+func runtimeCallerFrames(pc uintptr) *runtime.Frame {
+ frames := runtime.CallersFrames([]uintptr{pc})
+ frame, _ := frames.Next()
+ if frame.File == "" {
+ return nil
+ }
+ return &frame
+}
diff --git a/internal/pkg/logx/logger.go b/internal/pkg/logx/logger.go
index da116583..de2b66af 100644
--- a/internal/pkg/logx/logger.go
+++ b/internal/pkg/logx/logger.go
@@ -4,28 +4,45 @@ import (
"log/slog"
"os"
"strings"
+
+ "agent-desk/internal/models"
)
// Config 定义日志初始化参数。
type Config struct {
- Level string `yaml:"level"`
- Format string `yaml:"format"`
- AddSource bool `yaml:"addSource"`
+ Level string `yaml:"level"`
+ Format string `yaml:"format"`
+ AddSource bool `yaml:"addSource"`
+ EnableDBSink bool `yaml:"enableDBSink"`
}
// Init 初始化全局 slog logger，并设置为默认 logger。
+// 当 EnableDBSink 为 true 时，创建复合 handler（stdout + dbSink），
+// dbSink 的 DB 引用在 AttachDB 调用前为 nil，不会写库。
func Init(cfg Config) *slog.Logger {
level := parseLevel(cfg.Level)
opts := &slog.HandlerOptions{
Level: level,
- AddSource: cfg.AddSource,
+ AddSource: true, // 强制开启，以便 DB sink 记录 source
}
- var handler slog.Handler
+ var stdoutHandler slog.Handler
if strings.EqualFold(cfg.Format, "json") {
- handler = slog.NewJSONHandler(os.Stdout, opts)
+ stdoutHandler = slog.NewJSONHandler(os.Stdout, opts)
} else {
- handler = slog.NewTextHandler(os.Stdout, opts)
+ stdoutHandler = slog.NewTextHandler(os.Stdout, opts)
+ }
+
+ var handler slog.Handler = stdoutHandler
+
+ if cfg.EnableDBSink {
+ sink = &dbSink{
+ inner: stdoutHandler,
+ ch: make(chan models.SystemLog, dbSinkChannelCapacity),
+ stop: make(chan struct{}),
+ done: make(chan struct{}),
+ }
+ handler = sink
}
logger := slog.New(handler)
diff --git a/internal/repositories/system_log_repository.go b/internal/repositories/system_log_repository.go
new file mode 100644
index 00000000..a42a0854
--- /dev/null
+++ b/internal/repositories/system_log_repository.go
@@ -0,0 +1,47 @@
+package repositories
+
+import (
+ "time"
+
+ "agent-desk/internal/models"
+
+ "github.com/mlogclub/simple/sqls"
+ "gorm.io/gorm"
+)
+
+var SystemLogRepository = newSystemLogRepository()
+
+func newSystemLogRepository() *systemLogRepository {
+ return &systemLogRepository{}
+}
+
+type systemLogRepository struct {
+}
+
+func (r *systemLogRepository) Get(db *gorm.DB, id int64) *models.SystemLog {
+ ret := &models.SystemLog{}
+ if err := db.First(ret, "id = ?", id).Error; err != nil {
+ return nil
+ }
+ return ret
+}
+
+func (r *systemLogRepository) FindPageByCnd(db *gorm.DB, cnd *sqls.Cnd) (list []models.SystemLog, paging *sqls.Paging) {
+ cnd.Find(db, &list)
+ count := cnd.Count(db, &models.SystemLog{})
+
+ paging = &sqls.Paging{
+ Page: cnd.Paging.Page,
+ Limit: cnd.Paging.Limit,
+ Total: count,
+ }
+ return
+}
+
+func (r *systemLogRepository) DeleteOlderThan(db *gorm.DB, before time.Time) (count int64) {
+ res := db.Where("created_at < ?", before).Delete(&models.SystemLog{})
+ if res.Error == nil {
+ count = res.RowsAffected
+ }
+ return
+}
diff --git a/internal/services/ai_reply_placeholder_service.go b/internal/services/ai_reply_placeholder_service.go
new file mode 100644
index 00000000..c4e8d613
--- /dev/null
+++ b/internal/services/ai_reply_placeholder_service.go
@@ -0,0 +1,205 @@
+package services
+
+import (
+ "log/slog"
+ "strconv"
+ "strings"
+ "time"
+
+ "agent-desk/internal/models"
+ "agent-desk/internal/pkg/dto"
+ "agent-desk/internal/pkg/enums"
+ "agent-desk/internal/repositories"
+
+ "github.com/mlogclub/simple/sqls"
+)
+
+// AI 回复占位消息使用确定性 clientMsgID 前缀，保证同一触发消息的占位与超时提示幂等；
+// aiReplyPendingPayload 为占位消息的 payload 标记，原地替换前用于守卫，避免覆盖已生成的正式回复。
+const (
+ aiReplyPlaceholderClientMsgIDPrefix = "ai_placeholder_"
+ aiReplyTimeoutNoticeClientMsgIDPrefix = "ai_timeout_"
+ aiReplyPendingPayload = `{"aiReplyPending":true}`
+)
+
+// aiReplyPrincipal 构建 AI 消息的操作者信息。
+func aiReplyPrincipal(aiAgent models.AIAgent) *dto.AuthPrincipal {
+ username := "AI"
+ if strings.TrimSpace(aiAgent.Name) != "" {
+ username = strings.TrimSpace(aiAgent.Name)
+ }
+ return &dto.AuthPrincipal{
+ UserID: 0,
+ Username: username,
+ Nickname: username,
+ }
+}
+
+// aiReplyPlaceholderClientMsgID 返回触发消息对应的占位消息 clientMsgID。
+func aiReplyPlaceholderClientMsgID(triggerMessageID int64) string {
+ return aiReplyPlaceholderClientMsgIDPrefix + strconv.FormatInt(triggerMessageID, 10)
+}
+
+// SendAIReplyPlaceholder 在正式 AI 回复生成前，向客户发送一条占位提示消息。
+// 通过确定性 clientMsgID 保证幂等；发送失败仅记录日志，不阻断 AI 回复流程。
+func (s *messageService) SendAIReplyPlaceholder(conversation *models.Conversation, aiAgent *models.AIAgent, triggerMessage *models.Message, channel *models.Channel, requestID string) {
+ if conversation == nil || aiAgent == nil || triggerMessage == nil {
+ return
+ }
+ content := models.DefaultAIReplyPlaceholder
+ if channel != nil {
+ content = channel.EffectiveAIReplyPlaceholder()
+ }
+ if _, err := s.SendAIMessageWithRequestIDAndWorkflowRunID(
+ conversation.ID,
+ aiAgent.ID,
+ aiReplyPlaceholderClientMsgID(triggerMessage.ID),
+ enums.IMMessageTypeText,
+ content,
+ aiReplyPendingPayload,
+ aiReplyPrincipal(*aiAgent),
+ requestID,
+ 0,
+ ); err != nil {
+ slog.Error("send ai reply placeholder failed",
+ "conversation_id", conversation.ID,
+ "message_id", triggerMessage.ID,
+ "error", err,
+ )
+ }
+}
+
+// TryReplaceAIReplyPlaceholder 尝试将 web 渠道仍处于待回复状态的占位消息原地替换为正式回复。
+// 仅 web 渠道支持原地替换；占位消息不存在或已被替换时返回 nil，由调用方回退为新消息。
+func (s *messageService) TryReplaceAIReplyPlaceholder(conversation *models.Conversation, triggerMessageID int64, replyText string, workflowRunID int64, aiAgent models.AIAgent) *models.Message {
+ if conversation == nil {
+ return nil
+ }
+ channel := ChannelService.Get(conversation.ChannelID)
+ if channel == nil || channel.ChannelType != enums.ChannelTypeWeb {
+ return nil
+ }
+ placeholder := repositories.MessageRepository.GetByClientMsgID(sqls.DB(), conversation.ID, aiReplyPlaceholderClientMsgID(triggerMessageID))
+ if placeholder == nil || strings.TrimSpace(placeholder.Payload) != aiReplyPendingPayload {
+ return nil
+ }
+ content, _, summary, err := s.normalizeMessageContent(conversation.ID, enums.IMMessageTypeText, replyText, "")
+ if err != nil {
+ slog.Error("normalize ai reply content failed",
+ "conversation_id", conversation.ID,
+ "message_id", placeholder.ID,
+ "error", err,
+ )
+ return nil
+ }
+ return s.replaceAIReplyPlaceholder(conversation, placeholder, content, summary, workflowRunID, aiAgent)
+}
+
+// CompleteAIReplyPlaceholderAsFailed 在 AI 处理超时或失败时向客户发送失败提示：
+// web 渠道且占位消息仍待回复时原地替换为提示语；否则以新消息补发（确定性 clientMsgID 保证幂等）。
+// 已转人工或已关闭的会话不再补发提示。
+func (s *messageService) CompleteAIReplyPlaceholderAsFailed(conversation *models.Conversation, aiAgent *models.AIAgent, triggerMessage *models.Message, requestID string) {
+ if conversation == nil || aiAgent == nil || triggerMessage == nil {
+ return
+ }
+ if conversation.Status == enums.IMConversationStatusClosed {
+ return
+ }
+ if conversation.CurrentAssigneeID > 0 || conversation.HandoffAt != nil {
+ return
+ }
+ notice := models.DefaultAIReplyTimeoutNotice
+ if channel := ChannelService.Get(conversation.ChannelID); channel != nil {
+ notice = channel.EffectiveAIReplyTimeoutNotice()
+ }
+ content, _, summary, err := s.normalizeMessageContent(conversation.ID, enums.IMMessageTypeText, notice, "")
+ if err != nil {
+ slog.Error("normalize ai timeout notice failed",
+ "conversation_id", conversation.ID,
+ "message_id", triggerMessage.ID,
+ "error", err,
+ )
+ return
+ }
+
+ placeholder := repositories.MessageRepository.GetByClientMsgID(sqls.DB(), conversation.ID, aiReplyPlaceholderClientMsgID(triggerMessage.ID))
+ if placeholder != nil {
+ if strings.TrimSpace(placeholder.Payload) != aiReplyPendingPayload {
+ // 正式回复已生成并替换占位消息，无需再提示失败
+ return
+ }
+ if channel := ChannelService.Get(conversation.ChannelID); channel != nil && channel.ChannelType == enums.ChannelTypeWeb {
+ s.replaceAIReplyPlaceholder(conversation, placeholder, content, summary, 0, *aiAgent)
+ return
+ }
+ }
+
+ // 外部渠道无法编辑已发送消息，或占位消息缺失时，以新消息补发失败提示
+ if _, err := s.SendAIMessageWithRequestIDAndWorkflowRunID(
+ conversation.ID,
+ aiAgent.ID,
+ aiReplyTimeoutNoticeClientMsgIDPrefix+strconv.FormatInt(triggerMessage.ID, 10),
+ enums.IMMessageTypeText,
+ content,
+ "",
+ aiReplyPrincipal(*aiAgent),
+ requestID,
+ 0,
+ ); err != nil {
+ slog.Error("send ai timeout notice failed",
+ "conversation_id", conversation.ID,
+ "message_id", triggerMessage.ID,
+ "error", err,
+ )
+ }
+}
+
+// replaceAIReplyPlaceholder 将占位消息原地更新为指定内容，并同步会话摘要与实时事件。
+func (s *messageService) replaceAIReplyPlaceholder(conversation *models.Conversation, placeholder *models.Message, content string, summary string, workflowRunID int64, aiAgent models.AIAgent) *models.Message {
+ now := time.Now()
+ agentName := strings.TrimSpace(aiAgent.Name)
+ // 占位消息内容与会话摘要的更新保持原子性
+ if err := sqls.WithTransaction(func(ctx *sqls.TxContext) error {
+ if err := repositories.MessageRepository.Updates(ctx.Tx, placeholder.ID, map[string]any{
+ "content": content,
+ "payload": "",
+ "workflow_run_id": workflowRunID,
+ "update_user_id": 0,
+ "update_user_name": agentName,
+ "updated_at": now,
+ }); err != nil {
+ return err
+ }
+
+ // 占位消息仍是会话最后一条消息时，同步列表摘要
+ if conversation.LastMessageID == placeholder.ID {
+ summaryText := limitText(summary, 255)
+ conversation.LastMessageSummary = summaryText
+ conversation.UpdatedAt = now
+ return repositories.ConversationRepository.Updates(ctx.Tx, conversation.ID, map[string]any{
+ "last_message_summary": summaryText,
+ "update_user_id": 0,
+ "update_user_name": agentName,
+ "updated_at": now,
+ })
+ }
+ return nil
+ }); err != nil {
+ slog.Error("replace ai reply placeholder failed",
+ "conversation_id", conversation.ID,
+ "message_id", placeholder.ID,
+ "error", err,
+ )
+ return nil
+ }
+ placeholder.Content = content
+ placeholder.Payload = ""
+ placeholder.WorkflowRunID = workflowRunID
+ placeholder.UpdatedAt = now
+ placeholder.UpdateUserID = 0
+ placeholder.UpdateUserName = agentName
+
+ WsService.PublishMessageUpdated(conversation, placeholder)
+ WsService.PublishConversationChanged(conversation, enums.IMRealtimeEventConversationUpdated)
+ return placeholder
+}
diff --git a/internal/services/channel_message_outbox_service.go b/internal/services/channel_message_outbox_service.go
index 2660a8bc..8a088503 100644
--- a/internal/services/channel_message_outbox_service.go
+++ b/internal/services/channel_message_outbox_service.go
@@ -254,12 +254,19 @@ func (s *channelMessageOutboxService) ListPending(channelType string, limit int)
if limit <= 0 {
limit = 20
}
+ // 只取"现在就可以尝试发送"的记录，保证每批取出的记录都会被真正尝试、投递循环必然收敛：
+ // pending：无重试计划限制（新入队或人工重试后 next_retry_at 为空）；
+ // failed：必须存在重试计划且已到期。达到最大重试次数（next_retry_at 为空）的记录
+ // 停止自动重试，等待管理端人工处置；退避窗口内的记录不占用批次。
+ now := time.Now()
cnd := sqls.NewCnd().
Eq("channel_type", strings.TrimSpace(channelType)).
- In("send_status", []string{
- string(enums.ChannelMessageOutboxStatusPending),
- string(enums.ChannelMessageOutboxStatusFailed),
- }).
+ Where(
+ "((send_status = ? AND (next_retry_at IS NULL OR next_retry_at <= ?)) "+
+ "OR (send_status = ? AND next_retry_at IS NOT NULL AND next_retry_at <= ?))",
+ string(enums.ChannelMessageOutboxStatusPending), now,
+ string(enums.ChannelMessageOutboxStatusFailed), now,
+ ).
Asc("id").
Limit(limit)
return s.Find(cnd)
diff --git a/internal/services/channel_message_outbox_service_test.go b/internal/services/channel_message_outbox_service_test.go
new file mode 100644
index 00000000..914f583d
--- /dev/null
+++ b/internal/services/channel_message_outbox_service_test.go
@@ -0,0 +1,201 @@
+package services
+
+import (
+ "strings"
+ "testing"
+ "time"
+
+ "agent-desk/internal/models"
+ "agent-desk/internal/pkg/config"
+ "agent-desk/internal/pkg/dto"
+ "agent-desk/internal/pkg/enums"
+ "agent-desk/internal/repositories"
+ "agent-desk/internal/wxwork"
+
+ "github.com/glebarez/sqlite"
+ "github.com/mlogclub/simple/sqls"
+ "gorm.io/gorm"
+ "gorm.io/gorm/schema"
+)
+
+func setupChannelMessageOutboxTestDB(t *testing.T) *gorm.DB {
+ t.Helper()
+
+ db, err := gorm.Open(sqlite.Open("file::memory:?cache=shared"), &gorm.Config{
+ NamingStrategy: schema.NamingStrategy{
+ TablePrefix: "t_",
+ SingularTable: true,
+ },
+ })
+ if err != nil {
+ t.Fatalf("open sqlite error = %v", err)
+ }
+ t.Cleanup(func() {
+ sqlDB, err := db.DB()
+ if err == nil {
+ _ = sqlDB.Close()
+ }
+ })
+ if err := db.AutoMigrate(&models.ChannelMessageOutbox{}, &models.Message{}); err != nil {
+ t.Fatalf("auto migrate error = %v", err)
+ }
+ sqls.SetDB(db)
+ return db
+}
+
+func createOutboxRecordForTest(t *testing.T, db *gorm.DB, item *models.ChannelMessageOutbox) {
+ t.Helper()
+ if err := repositories.ChannelMessageOutboxRepository.Create(db, item); err != nil {
+ t.Fatalf("create outbox error = %v", err)
+ }
+}
+
+// TestChannelMessageOutboxListPendingEligibility 校验 ListPending 只取"现在可以尝试发送"的记录：
+// failed 达到最大重试次数（next_retry_at 为空）后必须停止自动重试，退避窗口内的记录不能占用批次。
+func TestChannelMessageOutboxListPendingEligibility(t *testing.T) {
+ db := setupChannelMessageOutboxTestDB(t)
+
+ now := time.Now()
+ past := now.Add(-time.Minute)
+ future := now.Add(time.Hour)
+
+ cases := []struct {
+ name string
+ channel string
+ status enums.ChannelMessageOutboxStatus
+ retryCount int
+ nextAt *time.Time
+ expected bool
+ }{
+ {"pending 无重试时间", enums.ChannelTypeWxWorkKF, enums.ChannelMessageOutboxStatusPending, 0, nil, true},
+ {"failed 已到期", enums.ChannelTypeWxWorkKF, enums.ChannelMessageOutboxStatusFailed, 1, &past, true},
+ {"failed 退避窗口内", enums.ChannelTypeWxWorkKF, enums.ChannelMessageOutboxStatusFailed, 1, &future, false},
+ {"failed 达上限无重试时间", enums.ChannelTypeWxWorkKF, enums.ChannelMessageOutboxStatusFailed, 6, nil, false},
+ {"pending 未来重试时间", enums.ChannelTypeWxWorkKF, enums.ChannelMessageOutboxStatusPending, 0, &future, false},
+ {"sending 状态", enums.ChannelTypeWxWorkKF, enums.ChannelMessageOutboxStatusSending, 0, nil, false},
+ {"sent 状态", enums.ChannelTypeWxWorkKF, enums.ChannelMessageOutboxStatusSent, 0, nil, false},
+ {"其他渠道", enums.ChannelTypeTelegram, enums.ChannelMessageOutboxStatusPending, 0, nil, false},
+ }
+ for i, tc := range cases {
+ createOutboxRecordForTest(t, db, &models.ChannelMessageOutbox{
+ ChannelType: tc.channel,
+ MessageID: int64(i + 1),
+ Payload: "{}",
+ SendStatus: string(tc.status),
+ RetryCount: tc.retryCount,
+ NextRetryAt: tc.nextAt,
+ })
+ }
+
+ items := ChannelMessageOutboxService.ListPending(enums.ChannelTypeWxWorkKF, 20)
+ included := make(map[int64]bool, len(items))
+ for _, item := range items {
+ included[item.MessageID] = true
+ }
+ var mismatches []string
+ for i, tc := range cases {
+ messageID := int64(i + 1)
+ if included[messageID] != tc.expected {
+ mismatches = append(mismatches,
+ "case "+tc.name+": 期望 included="+boolText(tc.expected)+", 实际 included="+boolText(included[messageID]))
+ }
+ }
+ if len(mismatches) > 0 {
+ t.Fatalf("ListPending 资格判定不符合预期:\n%s", strings.Join(mismatches, "\n"))
+ }
+}
+
+func boolText(v bool) string {
+ if v {
+ return "true"
+ }
+ return "false"
+}
+
+// TestTelegramDispatchSkipsBackoffBatch 回归守卫：整批记录都处于退避窗口时投递必须零进度终止，
+// 而不是把 skip 当作成功导致外层 drain 循环空转。
+func TestTelegramDispatchSkipsBackoffBatch(t *testing.T) {
+ db := setupChannelMessageOutboxTestDB(t)
+ future := time.Now().Add(time.Hour)
+ for i := 1; i <= 3; i++ {
+ nextAt := future
+ createOutboxRecordForTest(t, db, &models.ChannelMessageOutbox{
+ ChannelType: enums.ChannelTypeTelegram,
+ MessageID: int64(i),
+ Payload: "{}",
+ SendStatus: string(enums.ChannelMessageOutboxStatusFailed),
+ RetryCount: 1,
+ NextRetryAt: &nextAt,
+ })
+ }
+
+ if got := TelegramOutboundService.doDispatchPendingOutbox(20); got != 0 {
+ t.Fatalf("全退避批次应零进度终止, got %d", got)
+ }
+}
+
+// TestWxWorkExhaustedOutboxNotAutoRetried 回归守卫：达到最大重试次数的记录不参与自动投递，
+// 状态与重试次数保持不变，等待管理端人工处置。
+func TestWxWorkExhaustedOutboxNotAutoRetried(t *testing.T) {
+ db := setupChannelMessageOutboxTestDB(t)
+ enableWxWorkForTest(t)
+ createOutboxRecordForTest(t, db, &models.ChannelMessageOutbox{
+ ChannelType: enums.ChannelTypeWxWorkKF,
+ MessageID: 1,
+ Payload: "{}",
+ SendStatus: string(enums.ChannelMessageOutboxStatusFailed),
+ RetryCount: wxWorkKFOutboxMaxRetry,
+ })
+
+ if got := WxWorkKFOutboundService.doDispatchPendingOutbox(20); got != 0 {
+ t.Fatalf("达上限记录不应被自动重试, got %d", got)
+ }
+ item := repositories.ChannelMessageOutboxRepository.Get(db, 1)
+ if item == nil {
+ t.Fatal("outbox record not found")
+ }
+ if item.SendStatus != string(enums.ChannelMessageOutboxStatusFailed) || item.RetryCount != wxWorkKFOutboxMaxRetry {
+ t.Fatalf("达上限记录应保持 failed 且重试次数不变, got status=%s retryCount=%d", item.SendStatus, item.RetryCount)
+ }
+}
+
+// enableWxWorkForTest 在测试期间启用 wxwork（doDispatchPendingOutbox 有 Enabled 门），结束后复位。
+func enableWxWorkForTest(t *testing.T) {
+ t.Helper()
+ config.SetCurrent(&config.Config{
+ WxWork: config.WxWorkConfig{
+ Enabled: true,
+ CorpID: "corp-test",
+ CorpSecret: "secret-test",
+ },
+ })
+ wxwork.Init()
+ t.Cleanup(func() {
+ config.SetCurrent(&config.Config{})
+ wxwork.Init()
+ })
+}
+
+// TestRetryWxWorkFailureRevivesExhaustedRecord 校验人工重试可以把达上限记录复活为 pending。
+func TestRetryWxWorkFailureRevivesExhaustedRecord(t *testing.T) {
+ db := setupChannelMessageOutboxTestDB(t)
+ createOutboxRecordForTest(t, db, &models.ChannelMessageOutbox{
+ ChannelType: enums.ChannelTypeWxWorkKF,
+ MessageID: 1,
+ Payload: "{}",
+ SendStatus: string(enums.ChannelMessageOutboxStatusFailed),
+ RetryCount: wxWorkKFOutboxMaxRetry,
+ })
+
+ if err := ChannelMessageOutboxService.RetryWxWorkFailure(1, &dto.AuthPrincipal{}); err != nil {
+ t.Fatalf("retry error = %v", err)
+ }
+
+ items := ChannelMessageOutboxService.ListPending(enums.ChannelTypeWxWorkKF, 20)
+ if len(items) != 1 {
+ t.Fatalf("人工重试后应重新可投递, got %d", len(items))
+ }
+ if items[0].SendStatus != string(enums.ChannelMessageOutboxStatusPending) {
+ t.Fatalf("人工重试后状态应为 pending, got %s", items[0].SendStatus)
+ }
+}
diff --git a/internal/services/channel_service.go b/internal/services/channel_service.go
index 6a5399fc..452e9c53 100644
--- a/internal/services/channel_service.go
+++ b/internal/services/channel_service.go
@@ -465,6 +465,9 @@ func (s *channelService) buildChannelModel(id int64, req request.CreateChannelRe
if req.AIAgentRolloutPercent < 1 || req.AIAgentRolloutPercent > 100 {
return nil, errorsx.InvalidParam("channel ai agent rollout percent must be between 1 and 100")
}
+ if req.AIReplyTimeoutSeconds < 0 || req.AIReplyTimeoutSeconds > models.MaxAIReplyTimeoutSeconds {
+ return nil, errorsx.InvalidParamI18n("error.e0348")
+ }
aiAgent := AIAgentService.Get(req.AIAgentID)
if aiAgent == nil || aiAgent.Status != enums.StatusOk {
return nil, errorsx.InvalidParamI18n("error.e0004")
@@ -603,6 +606,9 @@ func (s *channelService) buildChannelModel(id int64, req request.CreateChannelRe
ChannelID: channelID,
AIAgentID: req.AIAgentID,
AIAgentRolloutPercent: req.AIAgentRolloutPercent,
+ AIReplyPlaceholder: strings.TrimSpace(req.AIReplyPlaceholder),
+ AIReplyTimeoutSeconds: req.AIReplyTimeoutSeconds,
+ AIReplyTimeoutNotice: strings.TrimSpace(req.AIReplyTimeoutNotice),
Name: name,
ConfigJSON: configJSON,
Status: status,
diff --git a/internal/services/cronx/cron.go b/internal/services/cronx/cron.go
index 52ab00e2..d47d6cf3 100644
--- a/internal/services/cronx/cron.go
+++ b/internal/services/cronx/cron.go
@@ -4,12 +4,18 @@ import (
"agent-desk/internal/services"
"fmt"
"log/slog"
+ "time"
"github.com/robfig/cron/v3"
)
func Init() {
- c := cron.New()
+ // Recover：任务 panic 不拖垮整个 cron；
+ // SkipIfStillRunning：上一轮未结束前跳过本轮触发，避免任务慢于间隔时 goroutine 无限堆积。
+ c := cron.New(cron.WithChain(
+ cron.Recover(cron.DefaultLogger),
+ cron.SkipIfStillRunning(cron.DefaultLogger),
+ ))
addFunc(c, "0 4 ? * *", func() {
fmt.Println("cron test")
@@ -36,6 +42,15 @@ func Init() {
}
})
+ // 每天凌晨 3 点清理一个月以前的系统日志。
+ addFunc(c, "0 3 * * *", func() {
+ before := time.Now().AddDate(0, -1, 0)
+ deleted := services.SystemLogService.DeleteOlderThan(before)
+ if deleted > 0 {
+ slog.Info("system log cleanup completed", "deleted", deleted, "before", before.Format(time.DateTime))
+ }
+ })
+
c.Start()
}
diff --git a/internal/services/knowledge_document_service.go b/internal/services/knowledge_document_service.go
index 0e700473..1db89870 100644
--- a/internal/services/knowledge_document_service.go
+++ b/internal/services/knowledge_document_service.go
@@ -237,6 +237,31 @@ func (s *knowledgeDocumentService) BatchMoveKnowledgeDocuments(req request.Batch
return nil
}
+// BatchBuildKnowledgeDocuments 对所选文档逐个重建索引。
+// 单篇失败不中断整体（失败状态会由 IndexDocumentByID 落库为 failed），
+// 与 BatchMoveKnowledgeDocuments 移动后重建索引的处理保持一致。
+func (s *knowledgeDocumentService) BatchBuildKnowledgeDocuments(req request.BatchBuildKnowledgeDocumentRequest, operator *dto.AuthPrincipal) error {
+ if operator == nil {
+ return errorsx.UnauthorizedI18n("error.auth.expired")
+ }
+ ids := uniquePositiveIDs(req.IDs)
+ if len(ids) == 0 {
+ return errorsx.InvalidParamI18n("error.e0331")
+ }
+ for _, id := range ids {
+ current := s.Get(id)
+ if current == nil || current.Status == enums.StatusDeleted {
+ return errorsx.InvalidParamI18n("error.e0218")
+ }
+ }
+ for _, id := range ids {
+ if err := rag.Index.IndexDocumentByID(context.Background(), id); err != nil {
+ slog.Error("failed to batch rebuild knowledge document index", "document_id", id, "error", err)
+ }
+ }
+ return nil
+}
+
func (s *knowledgeDocumentService) BatchDeleteKnowledgeDocuments(req request.BatchDeleteKnowledgeDocumentRequest) error {
ids := uniquePositiveIDs(req.IDs)
if len(ids) == 0 {
diff --git a/internal/services/system_log_service.go b/internal/services/system_log_service.go
new file mode 100644
index 00000000..aec8c0a6
--- /dev/null
+++ b/internal/services/system_log_service.go
@@ -0,0 +1,32 @@
+package services
+
+import (
+ "time"
+
+ "agent-desk/internal/models"
+ "agent-desk/internal/repositories"
+
+ "github.com/mlogclub/simple/sqls"
+)
+
+var SystemLogService = newSystemLogService()
+
+func newSystemLogService() *systemLogService {
+ return &systemLogService{}
+}
+
+type systemLogService struct {
+}
+
+func (s *systemLogService) Get(id int64) *models.SystemLog {
+ return repositories.SystemLogRepository.Get(sqls.DB(), id)
+}
+
+func (s *systemLogService) FindPageByCnd(cnd *sqls.Cnd) (list []models.SystemLog, paging *sqls.Paging) {
+ return repositories.SystemLogRepository.FindPageByCnd(sqls.DB(), cnd)
+}
+
+// DeleteOlderThan 清理指定时间之前的日志，返回受影响行数。用于 cron 定时清理。
+func (s *systemLogService) DeleteOlderThan(before time.Time) int64 {
+ return repositories.SystemLogRepository.DeleteOlderThan(sqls.DB(), before)
+}
diff --git a/internal/services/ws_realtime_types.go b/internal/services/ws_realtime_types.go
index 14813840..7d2cd371 100644
--- a/internal/services/ws_realtime_types.go
+++ b/internal/services/ws_realtime_types.go
@@ -164,6 +164,19 @@ func (e RealtimeMessageCreatedEvent) EventPayload() RealtimeEventPayload {
return e.Payload
}
+// RealtimeMessageUpdatedEvent 通知客户端某条消息内容已被更新（如 AI 占位回复被正式回复替换）。
+type RealtimeMessageUpdatedEvent struct {
+ Payload RealtimeMessageCreatedPayload
+}
+
+func (e RealtimeMessageUpdatedEvent) EventType() string {
+ return enums.IMRealtimeEventMessageUpdated
+}
+
+func (e RealtimeMessageUpdatedEvent) EventPayload() RealtimeEventPayload {
+ return e.Payload
+}
+
type RealtimeMessageRecalledPayload struct {
ConversationID int64 `json:"conversationId,omitempty"`
MessageID int64 `json:"messageId,omitempty"`
diff --git a/internal/services/ws_service.go b/internal/services/ws_service.go
index 3bcd28e8..7067b294 100644
--- a/internal/services/ws_service.go
+++ b/internal/services/ws_service.go
@@ -318,6 +318,32 @@ func (s *wsService) PublishMessageCreated(conversation *models.Conversation, mes
s.PublishToTopics(s.routeConversationTopics(conversation), event)
}
+func (s *wsService) PublishMessageUpdated(conversation *models.Conversation, message *models.Message) {
+ if conversation == nil || message == nil {
+ return
+ }
+ content, payload := utils.BuildRenderableMessage(message)
+
+ event := s.newEvent(s.conversationTopic(conversation.ID), RealtimeMessageUpdatedEvent{
+ Payload: RealtimeMessageCreatedPayload{
+ ConversationID: conversation.ID,
+ MessageID: message.ID,
+ RequestID: message.RequestID,
+ Message: s.buildRealtimeMessage(message),
+ Status: conversation.Status,
+ CurrentAssigneeID: conversation.CurrentAssigneeID,
+ SenderType: message.SenderType,
+ SenderID: message.SenderID,
+ MessageType: message.MessageType,
+ Content: content,
+ Payload: payload,
+ SendStatus: message.SendStatus,
+ SentAt: formatWsTime(message.SentAt),
+ },
+ })
+ s.PublishToTopics(s.routeConversationTopics(conversation), event)
+}
+
func (s *wsService) buildRealtimeMessage(item *models.Message) response.MessageResponse {
if item == nil {
return response.MessageResponse{}
diff --git a/internal/services/wxwork_kf_message_read_test_service.go b/internal/services/wxwork_kf_message_read_test_service.go
new file mode 100644
index 00000000..993b63fa
--- /dev/null
+++ b/internal/services/wxwork_kf_message_read_test_service.go
@@ -0,0 +1,332 @@
+package services
+
+import (
+ "bytes"
+ "context"
+ "encoding/json"
+ "fmt"
+ "io"
+ "log/slog"
+ "net/http"
+ "net/url"
+ "strconv"
+ "strings"
+ "time"
+
+ "agent-desk/internal/pkg/config"
+ "agent-desk/internal/pkg/dto/response"
+ "agent-desk/internal/pkg/enums"
+ "agent-desk/internal/pkg/utils"
+)
+
+// 企业微信客服“测试读取消息”相关常量。
+// 说明：silenceper/wechat SDK 的 SyncMsg 在 errcode!=0 时只返回 errmsg 文本、丢失 errcode，
+// 无法按错误码给出排查建议，因此该测试直接调用官方 API 并自行解析 errcode。
+const (
+ wxWorkGetTokenURLTemplate = "https://qyapi.weixin.qq.com/cgi-bin/gettoken?corpid=%s&corpsecret=%s"
+ wxWorkSyncMsgURLTemplate = "https://qyapi.weixin.qq.com/cgi-bin/kf/sync_msg?access_token=%s"
+
+ wxWorkReadTestStageGetToken = "gettoken"
+ wxWorkReadTestStageSyncMsg = "syncmsg"
+
+ // 本地错误码（非企业微信返回），前端按这些码做本地化排查建议。
+ wxWorkReadTestErrInvalidChannel = "INVALID_CHANNEL"
+ wxWorkReadTestErrOpenKFMissing = "OPENKFID_MISSING"
+ wxWorkReadTestErrConfigJSON = "INVALID_CONFIG_JSON"
+ wxWorkReadTestErrDisabled = "WXWORK_DISABLED"
+ wxWorkReadTestErrNetwork = "NETWORK_ERROR"
+ wxWorkReadTestErrBadResponse = "BAD_RESPONSE"
+
+ wxWorkReadTestSyncLimit uint64 = 1000 // 单次 sync_msg 拉取条数（官方最大值）
+ wxWorkReadTestMaxPages = 5 // 最多翻页次数，限制测试请求耗时
+ wxWorkReadTestSampleSize = 20 // 返回最近样例条数
+ wxWorkReadTestMaxPreviewRunes = 500 // 文本样例最大字符数
+ wxWorkReadTestHTTPTimeout = 10 * time.Second
+)
+
+var wxWorkReadTestHTTPClient = &http.Client{Timeout: wxWorkReadTestHTTPTimeout}
+
+type wxWorkReadTestTokenResponse struct {
+ ErrCode int64 `json:"errcode"`
+ ErrMsg string `json:"errmsg"`
+ AccessToken string `json:"access_token"`
+ ExpiresIn int `json:"expires_in"`
+}
+
+type wxWorkReadTestSyncRequest struct {
+ Cursor string `json:"cursor"`
+ Limit uint64 `json:"limit"`
+ OpenKfID string `json:"open_kfid"`
+}
+
+type wxWorkReadTestSyncResponse struct {
+ ErrCode int64 `json:"errcode"`
+ ErrMsg string `json:"errmsg"`
+ NextCursor string `json:"next_cursor"`
+ HasMore uint32 `json:"has_more"`
+ MsgList []map[string]any `json:"msg_list"`
+}
+
+// TestWxWorkKFReadMessages 对指定企微客服渠道执行只读消息拉取测试：
+// 使用空游标从企业微信拉取该客服账号最近保留期（3 天）内的消息与事件，
+// 不消费消息、不创建会话、不更新同步游标。返回结构化结果供前端展示与错误码排查。
+func (s *channelService) TestWxWorkKFReadMessages(channelID int64) (*response.WxWorkKFMessageReadTestResult, error) {
+ channel := s.Get(channelID)
+ if channel == nil || channel.Status == enums.StatusDeleted || channel.ChannelType != enums.ChannelTypeWxWorkKF {
+ return s.failReadTestResult("", wxWorkReadTestErrInvalidChannel, ""), nil
+ }
+
+ openKfID := ""
+ if cfg, err := s.ParseWxWorkKFChannelConfig(channel.ConfigJSON); err != nil {
+ return s.failReadTestResult("", wxWorkReadTestErrConfigJSON, err.Error()), nil
+ } else if cfg != nil {
+ openKfID = cfg.OpenKfID
+ }
+ if openKfID == "" {
+ return s.failReadTestResult("", wxWorkReadTestErrOpenKFMissing, ""), nil
+ }
+
+ wxConfig := config.Current().WxWork
+ corpID := strings.TrimSpace(wxConfig.CorpID)
+ corpSecret := strings.TrimSpace(wxConfig.CorpSecret)
+ if !wxConfig.Enabled || corpID == "" || corpSecret == "" {
+ return s.failReadTestResult("", wxWorkReadTestErrDisabled, ""), nil
+ }
+
+ // 1. 获取 access_token（独立调用，不接触 SDK 令牌缓存；人工测试频率低，可接受）
+ accessToken, result := s.fetchReadTestAccessToken(corpID, corpSecret)
+ if result != nil {
+ return result, nil
+ }
+
+ // 2. 从空游标开始分页拉取（空游标返回保留期内最早的消息，按时间升序）
+ scanned := make([]map[string]any, 0)
+ cursor := ""
+ truncated := false
+ for page := 0; page < wxWorkReadTestMaxPages; page++ {
+ resp, err := s.callReadTestSyncMsg(accessToken, openKfID, cursor)
+ if err != nil {
+ slog.Warn("wxwork kf read test sync_msg failed",
+ "channel_id", channelID,
+ "open_kfid", openKfID,
+ "error", err,
+ )
+ return s.failReadTestResult(wxWorkReadTestStageSyncMsg, wxWorkReadTestErrNetwork, err.Error()), nil
+ }
+ if resp.ErrCode != 0 {
+ slog.Warn("wxwork kf read test sync_msg rejected",
+ "channel_id", channelID,
+ "open_kfid", openKfID,
+ "errcode", resp.ErrCode,
+ "errmsg", resp.ErrMsg,
+ )
+ return s.failReadTestResult(wxWorkReadTestStageSyncMsg, strconv.FormatInt(resp.ErrCode, 10), resp.ErrMsg), nil
+ }
+
+ scanned = append(scanned, resp.MsgList...)
+ if resp.HasMore != 1 || strings.TrimSpace(resp.NextCursor) == "" {
+ truncated = false
+ break
+ }
+ cursor = resp.NextCursor
+ if page == wxWorkReadTestMaxPages-1 {
+ truncated = true
+ }
+ }
+
+ result2 := s.buildReadTestResult(openKfID, scanned, truncated)
+ slog.Info("wxwork kf read test succeeded",
+ "channel_id", channelID,
+ "open_kfid", openKfID,
+ "total_scanned", result2.TotalScanned,
+ "message_count", result2.MessageCount,
+ "event_count", result2.EventCount,
+ "truncated", result2.Truncated,
+ )
+ return result2, nil
+}
+
+func (s *channelService) fetchReadTestAccessToken(corpID, corpSecret string) (string, *response.WxWorkKFMessageReadTestResult) {
+ requestURL := fmt.Sprintf(wxWorkGetTokenURLTemplate, url.QueryEscape(corpID), url.QueryEscape(corpSecret))
+ ctx, cancel := context.WithTimeout(context.Background(), wxWorkReadTestHTTPTimeout)
+ defer cancel()
+ req, err := http.NewRequestWithContext(ctx, http.MethodGet, requestURL, nil)
+ if err != nil {
+ return "", s.failReadTestResult(wxWorkReadTestStageGetToken, wxWorkReadTestErrNetwork, err.Error())
+ }
+ resp, err := wxWorkReadTestHTTPClient.Do(req)
+ if err != nil {
+ return "", s.failReadTestResult(wxWorkReadTestStageGetToken, wxWorkReadTestErrNetwork, err.Error())
+ }
+ defer resp.Body.Close()
+ body, err := io.ReadAll(io.LimitReader(resp.Body, 1<<20))
+ if err != nil {
+ return "", s.failReadTestResult(wxWorkReadTestStageGetToken, wxWorkReadTestErrNetwork, err.Error())
+ }
+ tokenResp := wxWorkReadTestTokenResponse{}
+ if err := json.Unmarshal(body, &tokenResp); err != nil {
+ return "", s.failReadTestResult(wxWorkReadTestStageGetToken, wxWorkReadTestErrBadResponse, truncateReadTestText(string(body), 300))
+ }
+ if tokenResp.ErrCode != 0 || strings.TrimSpace(tokenResp.AccessToken) == "" {
+ code := strconv.FormatInt(tokenResp.ErrCode, 10)
+ if tokenResp.ErrCode == 0 {
+ code = wxWorkReadTestErrBadResponse
+ }
+ return "", s.failReadTestResult(wxWorkReadTestStageGetToken, code, tokenResp.ErrMsg)
+ }
+ return tokenResp.AccessToken, nil
+}
+
+func (s *channelService) callReadTestSyncMsg(accessToken, openKfID, cursor string) (*wxWorkReadTestSyncResponse, error) {
+ payload, err := json.Marshal(wxWorkReadTestSyncRequest{
+ Cursor: cursor,
+ Limit: wxWorkReadTestSyncLimit,
+ OpenKfID: openKfID,
+ })
+ if err != nil {
+ return nil, err
+ }
+ ctx, cancel := context.WithTimeout(context.Background(), wxWorkReadTestHTTPTimeout)
+ defer cancel()
+ req, err := http.NewRequestWithContext(ctx, http.MethodPost,
+ fmt.Sprintf(wxWorkSyncMsgURLTemplate, url.QueryEscape(accessToken)),
+ bytes.NewReader(payload),
+ )
+ if err != nil {
+ return nil, err
+ }
+ req.Header.Set("Content-Type", "application/json; charset=utf-8")
+ resp, err := wxWorkReadTestHTTPClient.Do(req)
+ if err != nil {
+ return nil, err
+ }
+ defer resp.Body.Close()
+ body, err := io.ReadAll(io.LimitReader(resp.Body, 8<<20))
+ if err != nil {
+ return nil, err
+ }
+ syncResp := wxWorkReadTestSyncResponse{}
+ if err := json.Unmarshal(body, &syncResp); err != nil {
+ return nil, fmt.Errorf("invalid response: %s", truncateReadTestText(string(body), 300))
+ }
+ return &syncResp, nil
+}
+
+// buildReadTestResult 汇总扫描结果并抽取最近若干条样例（新消息在前）。
+func (s *channelService) buildReadTestResult(openKfID string, scanned []map[string]any, truncated bool) *response.WxWorkKFMessageReadTestResult {
+ result := &response.WxWorkKFMessageReadTestResult{
+ Success: true,
+ OpenKfID: openKfID,
+ TotalScanned: len(scanned),
+ Samples: make([]response.WxWorkKFMessageReadSample, 0),
+ Truncated: truncated,
+ }
+
+ var earliestUnix, latestUnix int64
+ for _, raw := range scanned {
+ msgType := readTestAsString(raw["msgtype"])
+ if msgType == "event" {
+ result.EventCount++
+ } else {
+ result.MessageCount++
+ }
+ sendTime := readTestAsInt64(raw["send_time"])
+ if sendTime > 0 {
+ if earliestUnix == 0 || sendTime < earliestUnix {
+ earliestUnix = sendTime
+ }
+ if sendTime > latestUnix {
+ latestUnix = sendTime
+ }
+ }
+ }
+ if earliestUnix > 0 {
+ result.EarliestTime = utils.FormatTime(time.Unix(earliestUnix, 0))
+ }
+ if latestUnix > 0 {
+ result.LatestTime = utils.FormatTime(time.Unix(latestUnix, 0))
+ }
+
+ // 接口按时间升序返回，取最后 N 条后反转为新消息在前
+ start := len(scanned) - wxWorkReadTestSampleSize
+ if start < 0 {
+ start = 0
+ }
+ for i := len(scanned) - 1; i >= start; i-- {
+ result.Samples = append(result.Samples, buildWxWorkReadSample(scanned[i]))
+ }
+ return result
+}
+
+func buildWxWorkReadSample(raw map[string]any) response.WxWorkKFMessageReadSample {
+ sample := response.WxWorkKFMessageReadSample{
+ MsgID: readTestAsString(raw["msgid"]),
+ Origin: int(readTestAsInt64(raw["origin"])),
+ MsgType: readTestAsString(raw["msgtype"]),
+ ExternalUserID: readTestAsString(raw["external_userid"]),
+ ServicerUserID: readTestAsString(raw["servicer_userid"]),
+ }
+ if sendTime := readTestAsInt64(raw["send_time"]); sendTime > 0 {
+ sample.SendTime = utils.FormatTime(time.Unix(sendTime, 0))
+ }
+ if sample.MsgType == "text" {
+ if textMap, ok := raw["text"].(map[string]any); ok {
+ sample.TextContent = truncateReadTestText(strings.TrimSpace(readTestAsString(textMap["content"])), wxWorkReadTestMaxPreviewRunes)
+ }
+ }
+ if sample.MsgType == "event" {
+ if eventMap, ok := raw["event"].(map[string]any); ok {
+ sample.EventType = readTestAsString(eventMap["event_type"])
+ // 事件消息的客户/客服账号在 event 对象内
+ if sample.ExternalUserID == "" {
+ sample.ExternalUserID = readTestAsString(eventMap["external_userid"])
+ }
+ if sample.ServicerUserID == "" {
+ sample.ServicerUserID = readTestAsString(eventMap["new_servicer_userid"])
+ }
+ }
+ }
+ return sample
+}
+
+func (s *channelService) failReadTestResult(stage, code, message string) *response.WxWorkKFMessageReadTestResult {
+ return &response.WxWorkKFMessageReadTestResult{
+ Success: false,
+ Stage: stage,
+ ErrorCode: code,
+ ErrorMessage: truncateReadTestText(strings.TrimSpace(message), 1000),
+ Samples: make([]response.WxWorkKFMessageReadSample, 0),
+ }
+}
+
+func readTestAsString(value any) string {
+ if value == nil {
+ return ""
+ }
+ if s, ok := value.(string); ok {
+ return strings.TrimSpace(s)
+ }
+ return ""
+}
+
+func readTestAsInt64(value any) int64 {
+ switch v := value.(type) {
+ case float64:
+ return int64(v)
+ case int64:
+ return v
+ case json.Number:
+ n, _ := v.Int64()
+ return n
+ default:
+ return 0
+ }
+}
+
+func truncateReadTestText(value string, maxRunes int) string {
+ runes := []rune(value)
+ if len(runes) <= maxRunes {
+ return value
+ }
+ return string(runes[:maxRunes]) + "…"
+}
diff --git a/web/app/(dashboard)/dashboard/channels/_components/edit.tsx b/web/app/(dashboard)/dashboard/channels/_components/edit.tsx
index c5b96168..c1631b5d 100644
--- a/web/app/(dashboard)/dashboard/channels/_components/edit.tsx
+++ b/web/app/(dashboard)/dashboard/channels/_components/edit.tsx
@@ -31,6 +31,7 @@ import {
resetChannelUserTokenSecret,
} from "@/lib/api/admin"
import { useI18n } from "@/i18n/provider"
+import { WxWorkReadTestButton } from "./read-test-button"
type ChannelFormDialogProps = {
open: boolean
@@ -90,6 +91,13 @@ function createSchema(t: Translate) {
channelType: z.enum(["web", "wechat_mp", "wxwork_kf", "telegram", "zalo_oa"], t("channel.typeRequired")),
aiAgentId: z.string().trim().regex(/^\d+$/, t("channel.agentRequired")),
aiAgentRolloutPercent: z.coerce.number().int().min(1).max(100),
+ aiReplyPlaceholder: z.string().trim().max(255, t("channel.aiReplyPlaceholderTooLong")),
+ aiReplyTimeoutSeconds: z.coerce
+ .number()
+ .int(t("channel.aiReplyTimeoutInvalid"))
+ .min(0, t("channel.aiReplyTimeoutInvalid"))
+ .max(600, t("channel.aiReplyTimeoutInvalid")),
+ aiReplyTimeoutNotice: z.string().trim().max(500, t("channel.aiReplyTimeoutNoticeTooLong")),
name: z.string().trim().min(1, t("channel.nameRequired")),
openKfId: z.string().trim(),
botToken: z.string().trim(),
@@ -136,6 +144,9 @@ type EditForm = {
channelType: "web" | "wechat_mp" | "wxwork_kf" | "telegram" | "zalo_oa"
aiAgentId: string
aiAgentRolloutPercent: number
+ aiReplyPlaceholder: string
+ aiReplyTimeoutSeconds: number
+ aiReplyTimeoutNotice: string
name: string
openKfId: string
botToken: string
@@ -160,6 +171,9 @@ function createEmptyForm(t: Translate): EditForm {
channelType: "web",
aiAgentId: "",
aiAgentRolloutPercent: 100,
+ aiReplyPlaceholder: "",
+ aiReplyTimeoutSeconds: 0,
+ aiReplyTimeoutNotice: "",
name: "",
openKfId: "",
botToken: "",
@@ -299,6 +313,9 @@ function buildForm(item: AdminChannel | null, t: Translate): EditForm {
: "web",
aiAgentId: item.aiAgentId > 0 ? String(item.aiAgentId) : "",
aiAgentRolloutPercent: item.aiAgentRolloutPercent || 100,
+ aiReplyPlaceholder: item.aiReplyPlaceholder || "",
+ aiReplyTimeoutSeconds: item.aiReplyTimeoutSeconds || 0,
+ aiReplyTimeoutNotice: item.aiReplyTimeoutNotice || "",
name: item.name,
openKfId: parseOpenKfId(item.configJson),
botToken: telegramConfig?.botToken ?? "",
@@ -359,6 +376,9 @@ function buildPayload(form: EditForm, status: number, t: Translate): CreateAdmin
channelType,
aiAgentId: Number(form.aiAgentId),
aiAgentRolloutPercent: form.aiAgentRolloutPercent,
+ aiReplyPlaceholder: form.aiReplyPlaceholder.trim(),
+ aiReplyTimeoutSeconds: Number.isFinite(form.aiReplyTimeoutSeconds) ? form.aiReplyTimeoutSeconds : 0,
+ aiReplyTimeoutNotice: form.aiReplyTimeoutNotice.trim(),
name: form.name.trim(),
configJson,
status,
@@ -837,6 +857,7 @@ function ChannelFormBody({
)}
/>
) : null}
@@ -967,6 +988,56 @@ function ChannelFormBody({
) : null}
+
+
+
{t("channel.aiReplySectionTitle")}
+
{t("channel.aiReplySectionDescription")}
+
+
+
+
+
+ {t("channel.aiReplyTimeoutNotice")}
+
+
+
+
+
{t("channel.remark")}
diff --git a/web/app/(dashboard)/dashboard/channels/_components/read-test-button.tsx b/web/app/(dashboard)/dashboard/channels/_components/read-test-button.tsx
new file mode 100644
index 00000000..42997cd2
--- /dev/null
+++ b/web/app/(dashboard)/dashboard/channels/_components/read-test-button.tsx
@@ -0,0 +1,303 @@
+"use client"
+
+import { useState } from "react"
+import {
+ CheckCircle2Icon,
+ FileSearchIcon,
+ Loader2Icon,
+ XCircleIcon,
+} from "lucide-react"
+
+import { ProjectDialog } from "@/components/project-dialog"
+import { Badge } from "@/components/ui/badge"
+import { Button } from "@/components/ui/button"
+import {
+ testWxWorkKFReadMessages,
+ type WxWorkKFMessageReadResult,
+ type WxWorkKFMessageReadSample,
+} from "@/lib/api/admin"
+import { useI18n } from "@/i18n/provider"
+
+type Translate = (key: string, values?: Record) => string
+
+const READ_TEST_STAGE_KEYS: Record = {
+ gettoken: "channel.readTestStageGettoken",
+ syncmsg: "channel.readTestStageSyncmsg",
+}
+
+const READ_TEST_HINT_KEYS: Record = {
+ "-1": "channel.readTestHintMinus1",
+ "40001": "channel.readTestHint40001",
+ "40013": "channel.readTestHint40013",
+ "40014": "channel.readTestHint40014",
+ "40056": "channel.readTestHint40056",
+ "42001": "channel.readTestHint42001",
+ "45009": "channel.readTestHint45009",
+ "48002": "channel.readTestHint48002",
+ "48007": "channel.readTestHint48007",
+ "60030": "channel.readTestHint60030",
+ WXWORK_DISABLED: "channel.readTestHintWxworkDisabled",
+ OPENKFID_MISSING: "channel.readTestHintOpenkfidMissing",
+ INVALID_CHANNEL: "channel.readTestHintInvalidChannel",
+ INVALID_CONFIG_JSON: "channel.readTestHintInvalidConfigJson",
+ NETWORK_ERROR: "channel.readTestHintNetwork",
+ BAD_RESPONSE: "channel.readTestHintBadResponse",
+}
+
+const READ_TEST_TYPE_KEYS: Record = {
+ text: "channel.readTestTypeText",
+ image: "channel.readTestTypeImage",
+ file: "channel.readTestTypeFile",
+ voice: "channel.readTestTypeVoice",
+ video: "channel.readTestTypeVideo",
+ location: "channel.readTestTypeLocation",
+ link: "channel.readTestTypeLink",
+ business_card: "channel.readTestTypeBusinessCard",
+ miniprogram: "channel.readTestTypeMiniProgram",
+ event: "channel.readTestTypeEvent",
+}
+
+const READ_TEST_EVENT_KEYS: Record = {
+ enter_session: "channel.readTestEventEnterSession",
+ session_status_change: "channel.readTestEventSessionStatusChange",
+ servicer_status_change: "channel.readTestEventServicerStatusChange",
+ msg_send_fail: "channel.readTestEventMsgSendFail",
+}
+
+function originLabel(t: Translate, origin: number): string {
+ if (origin === 3) return t("channel.readTestOriginCustomer")
+ if (origin === 4) return t("channel.readTestOriginEvent")
+ if (origin === 5) return t("channel.readTestOriginServicer")
+ return t("channel.readTestOriginUnknown", { origin })
+}
+
+function messageTypeLabel(t: Translate, msgType: string): string {
+ return t(READ_TEST_TYPE_KEYS[msgType] ?? "channel.readTestTypeUnknown")
+}
+
+function eventTypeLabel(t: Translate, eventType: string): string {
+ return READ_TEST_EVENT_KEYS[eventType] ? t(READ_TEST_EVENT_KEYS[eventType]) : eventType
+}
+
+function ReadTestSampleRow({
+ t,
+ sample,
+}: {
+ t: Translate
+ sample: WxWorkKFMessageReadSample
+}) {
+ const isEvent = sample.msgType === "event"
+ return (
+
+
+ {sample.sendTime || "—"}
+
+ {originLabel(t, sample.origin)}
+
+
+ {isEvent && sample.eventType
+ ? eventTypeLabel(t, sample.eventType)
+ : messageTypeLabel(t, sample.msgType ?? "")}
+
+
+ {!isEvent ? (
+
{sample.textContent || "—"}
+ ) : null}
+
+ {sample.externalUserId ? (
+
+ {t("channel.readTestExternalUser")}
+ {sample.externalUserId}
+
+ ) : null}
+ {sample.servicerUserId ? (
+
+ {t("channel.readTestServicerUser")}
+ {sample.servicerUserId}
+
+ ) : null}
+
+
(null)
+
+ async function runTest() {
+ if (channelId === null) return
+ setLoading(true)
+ setResult(null)
+ setOpen(true)
+ try {
+ setResult(await testWxWorkKFReadMessages(channelId))
+ } catch (error) {
+ setResult({
+ success: false,
+ errorCode: "NETWORK_ERROR",
+ errorMessage: error instanceof Error ? error.message : String(error),
+ totalScanned: 0,
+ messageCount: 0,
+ eventCount: 0,
+ truncated: false,
+ samples: [],
+ })
+ } finally {
+ setLoading(false)
+ }
+ }
+
+ const suggestion = result?.success
+ ? ""
+ : t(
+ (result?.errorCode && READ_TEST_HINT_KEYS[result.errorCode]) ||
+ "channel.readTestHintDefault",
+ )
+
+ return (
+
+
+ {loading ? (
+
+ {channelId === null ? (
+
{t("channel.readTestUnsavedHint")}
+ ) : null}
+
+
+
+ {t("channel.readTestRetry")}
+
+ setOpen(false)}>
+ {t("channel.readTestClose")}
+
+
+
+ ) : result ? (
+
+ {result.success ? (
+ <>
+
+
+
+
{t("channel.readTestSuccess")}
+
+ {t("channel.readTestSummary", {
+ total: result.totalScanned,
+ messages: result.messageCount,
+ events: result.eventCount,
+ })}
+
+ {result.earliestTime && result.latestTime ? (
+
+ {t("channel.readTestRange", {
+ earliest: result.earliestTime,
+ latest: result.latestTime,
+ })}
+
+ ) : null}
+
+
+
+ {result.truncated ? (
+
+ {t("channel.readTestTruncated", { count: result.samples.length })}
+
+ ) : null}
+
+ {result.totalScanned === 0 ? (
+
+ {t("channel.readTestEmpty")}
+
+ ) : (
+
+ {result.samples.map((sample) => (
+
+ )}
+
+ ) : (
+
+
+
+
+
+ {t("channel.readTestFailed")}
+
+
{suggestion}
+
+
+
+
+ {result.stage ? (
+
+
+ {t("channel.readTestStage")}
+
+ {t(READ_TEST_STAGE_KEYS[result.stage] ?? result.stage)}
+
+ ) : null}
+ {result.errorCode ? (
+
+
+ {t("channel.readTestErrCode")}
+
+ {result.errorCode}
+
+ ) : null}
+ {result.errorMessage ? (
+
+
+ {t("channel.readTestErrMessage")}
+
+
+ {result.errorMessage}
+
+
+ ) : null}
+
+
+ )}
+
-
{item.name}
diff --git a/web/app/(dashboard)/dashboard/conversations/_components/conversation-info-panel.tsx b/web/app/(dashboard)/dashboard/conversations/_components/conversation-info-panel.tsx
index 82e48026..00743af3 100644
--- a/web/app/(dashboard)/dashboard/conversations/_components/conversation-info-panel.tsx
+++ b/web/app/(dashboard)/dashboard/conversations/_components/conversation-info-panel.tsx
@@ -43,6 +43,7 @@ import {
type TagTree,
fetchTagsAll,
} from "@/lib/api/admin";
+import { getChannelTypeLabel } from "@/lib/channel-i18n";
import { updateCompany, type AdminCompany } from "@/lib/api/company";
import { fetchTickets, type TicketItem } from "@/lib/api/ticket";
import {
@@ -83,6 +84,19 @@ function contactTypeLabel(
}
}
+// buildSourceChannelValue 组装来源渠道展示文本：渠道类型本地化名称，附带渠道名称（若已配置）。
+function buildSourceChannelValue(
+ conversation: AgentConversation,
+ t: (key: string, values?: Record
) => string,
+): string {
+ if (!conversation.channelType) {
+ return "";
+ }
+ const typeLabel = getChannelTypeLabel(conversation.channelType, t);
+ const channelName = conversation.channelName?.trim();
+ return channelName ? `${typeLabel} · ${channelName}` : typeLabel;
+}
+
function ContactTypeIcon({ contactType }: { contactType: ContactType | string }) {
const cls = "size-3.5 shrink-0 text-muted-foreground";
switch (contactType) {
@@ -197,6 +211,7 @@ function MissingCustomerEmpty({ conversation }: { conversation: AgentConversatio
{t("conversation.conversationOwner")}
+
@@ -262,6 +277,12 @@ export function ConversationInfoPanel({
valueClassName="font-mono text-xs"
/>
+
diff --git a/web/app/(dashboard)/dashboard/conversations/_components/conversation-list.tsx b/web/app/(dashboard)/dashboard/conversations/_components/conversation-list.tsx
index 5e9ea02d..19d3d5b7 100644
--- a/web/app/(dashboard)/dashboard/conversations/_components/conversation-list.tsx
+++ b/web/app/(dashboard)/dashboard/conversations/_components/conversation-list.tsx
@@ -4,6 +4,7 @@ import { UserIcon } from "lucide-react";
import { Avatar, AvatarFallback, AvatarImage } from "@/components/ui/avatar";
import { ScrollArea } from "@/components/ui/scroll-area";
+import { ChannelTypeIcon, getChannelTypeLabel } from "@/lib/channel-i18n";
import { IMConversationStatus } from "@/lib/generated/enums";
import { useAgentConversationsStore } from "@/lib/stores/agent-conversations";
import { formatDateTime } from "@/lib/utils";
@@ -54,12 +55,25 @@ export function ConversationList({ onAfterSelect }: ConversationListProps) {
-
- {conversation.customerName ||
- t("conversation.customerFallback", {
- id: conversation.customerId || conversation.id,
- })}
-
+
+ {conversation.channelType ? (
+
+
+ ) : null}
+
+ {conversation.customerName ||
+ t("conversation.customerFallback", {
+ id: conversation.customerId || conversation.id,
+ })}
+
+
{conversation.agentUnreadCount > 0 ? (
{conversation.agentUnreadCount > 99
diff --git a/web/app/(dashboard)/dashboard/knowledge/_components/document-list.tsx b/web/app/(dashboard)/dashboard/knowledge/_components/document-list.tsx
index 662a533a..3cf79779 100644
--- a/web/app/(dashboard)/dashboard/knowledge/_components/document-list.tsx
+++ b/web/app/(dashboard)/dashboard/knowledge/_components/document-list.tsx
@@ -45,6 +45,7 @@ import {
TooltipTrigger,
} from "@/components/ui/tooltip";
import {
+ batchBuildKnowledgeDocumentIndex,
batchDeleteKnowledgeDocuments,
batchMoveKnowledgeDocuments,
buildKnowledgeDocumentIndex,
@@ -82,6 +83,23 @@ export type DocumentListActionState = {
type TFunction = (key: string, values?: Record
) => string;
+// 卡片整块绑定了 onClick 打开"查看"，点击内部的菜单触发器、复选框、菜单项时
+// 不能再冒泡触发查看，否则会出现"编辑"与"查看"两个窗口同时弹出。
+function isInteractiveClickTarget(target: EventTarget | null): boolean {
+ if (!(target instanceof HTMLElement)) {
+ return false;
+ }
+ return Boolean(
+ target.closest(
+ '[data-slot="dropdown-menu-trigger"],' +
+ '[data-slot="context-menu-trigger"],' +
+ '[data-slot="checkbox"],' +
+ '[data-slot="dropdown-menu-item"],' +
+ '[data-slot="context-menu-item"]',
+ ),
+ );
+}
+
function getStatusOptions(t: TFunction) {
return [
{ value: "all", label: t("knowledge.allStatus") },
@@ -153,6 +171,7 @@ export function DocumentList({ knowledgeBaseId, onActionStateChange }: DocumentL
const confirm = useConfirm();
const [saving, setSaving] = useState(false);
const [moving, setMoving] = useState(false);
+ const [batchBuilding, setBatchBuilding] = useState(false);
const [bulkMoveOpen, setBulkMoveOpen] = useState(false);
const [selectedIds, setSelectedIds] = useState([]);
const [moveTargetIds, setMoveTargetIds] = useState([]);
@@ -303,11 +322,17 @@ export function DocumentList({ knowledgeBaseId, onActionStateChange }: DocumentL
}, [onActionStateChange, loadData, openCreateDialog, viewMode, loading]);
function openEditDialog(item: KnowledgeDocumentListItem) {
+ // 互斥：打开编辑前关闭查看，避免两个窗口同时存在
+ setDetailOpen(false);
+ setDetailItemId(null);
setEditingItem(item);
setDialogOpen(true);
}
function openDetailDialog(item: KnowledgeDocumentListItem) {
+ // 互斥：打开查看前关闭编辑
+ setDialogOpen(false);
+ setEditingItem(null);
setDetailItemId(item.id);
setDetailOpen(true);
}
@@ -425,6 +450,23 @@ export function DocumentList({ knowledgeBaseId, onActionStateChange }: DocumentL
}
}
+ async function handleBatchBuildIndex() {
+ if (selectedIds.length === 0 || batchBuilding) {
+ return;
+ }
+ const ids = selectedIds;
+ setBatchBuilding(true);
+ try {
+ await batchBuildKnowledgeDocumentIndex(ids);
+ toast.success(t("knowledge.batchRebuilt", { count: ids.length }));
+ await loadData();
+ } catch (error) {
+ toast.error(error instanceof Error ? error.message : t("knowledge.batchRebuildFailed"));
+ } finally {
+ setBatchBuilding(false);
+ }
+ }
+
if (!knowledgeBaseId) {
return (
@@ -513,7 +555,12 @@ export function DocumentList({ knowledgeBaseId, onActionStateChange }: DocumentL
"bg-background p-3 transition-colors hover:bg-accent w-full cursor-pointer",
contextMenuDocumentId === item.id && "bg-accent text-accent-foreground",
)}
- onClick={() => openDetailDialog(item)}
+ onClick={(event) => {
+ if (isInteractiveClickTarget(event.target)) {
+ return;
+ }
+ openDetailDialog(item);
+ }}
>
@@ -621,7 +668,12 @@ export function DocumentList({ knowledgeBaseId, onActionStateChange }: DocumentL
"flex items-center gap-3 bg-background p-2 transition-colors hover:bg-accent w-full cursor-pointer",
contextMenuDocumentId === item.id && "bg-accent text-accent-foreground",
)}
- onClick={() => openDetailDialog(item)}
+ onClick={(event) => {
+ if (isInteractiveClickTarget(event.target)) {
+ return;
+ }
+ openDetailDialog(item);
+ }}
>
openMoveDialog(selectedIds)}
- disabled={saving || moving}
+ disabled={saving || moving || batchBuilding}
>
void handleBatchBuildIndex()}
+ disabled={saving || moving || batchBuilding}
+ >
+
void handleBatchDelete()}
- disabled={saving || moving}
+ disabled={saving || moving || batchBuilding}
>
(null)
+
+ async function openDetail(id: number) {
+ setOpen(true)
+ setLoading(true)
+ try {
+ setLog(await fetchSystemLog(id))
+ } catch (error) {
+ toast.error(error instanceof Error ? error.message : t("systemLog.loadDetailFailed"))
+ setOpen(false)
+ } finally {
+ setLoading(false)
+ }
+ }
+
+ return (
+ <>
+
+ filters={[
+ {
+ name: "level",
+ label: t("systemLog.level"),
+ type: "select",
+ defaultValue: "",
+ placeholder: t("systemLog.levelPlaceholder"),
+ className: "w-full sm:w-36",
+ options: [
+ { value: "INFO", label: t("systemLog.levelInfo") },
+ { value: "WARN", label: t("systemLog.levelWarn") },
+ { value: "ERROR", label: t("systemLog.levelError") },
+ ],
+ },
+ {
+ name: "message",
+ label: t("systemLog.message"),
+ defaultValue: "",
+ placeholder: t("systemLog.messagePlaceholder"),
+ className: "w-full sm:w-56",
+ },
+ {
+ name: "source",
+ label: t("systemLog.source"),
+ defaultValue: "",
+ placeholder: t("systemLog.sourcePlaceholder"),
+ className: "w-full sm:w-48",
+ },
+ {
+ name: "startTime",
+ label: t("systemLog.startTime"),
+ defaultValue: "",
+ placeholder: "2026-09-01 00:00:00",
+ className: "w-full sm:w-48",
+ },
+ {
+ name: "endTime",
+ label: t("systemLog.endTime"),
+ defaultValue: "",
+ placeholder: "2026-09-15 23:59:59",
+ className: "w-full sm:w-48",
+ },
+ ]}
+ fetchList={fetchSystemLogs}
+ getItemId={(item) => item.id}
+ getRowClassName={() => "cursor-pointer"}
+ onRowClick={(item) => void openDetail(item.id)}
+ columns={[
+ {
+ key: "createdAt",
+ label: t("systemLog.createdAt"),
+ className: "w-44 text-xs text-muted-foreground",
+ render: (item) => formatDateTime(item.createdAt),
+ },
+ {
+ key: "level",
+ label: t("systemLog.level"),
+ className: "w-24",
+ render: (item) => {item.levelName || item.level} ,
+ },
+ {
+ key: "message",
+ label: t("systemLog.message"),
+ className: "max-w-96",
+ render: (item) => (
+
+ {item.message}
+
+ ),
+ },
+ {
+ key: "source",
+ label: t("systemLog.source"),
+ className: "w-64 max-w-64 text-xs text-muted-foreground",
+ render: (item) => (
+
+ {item.source || "-"}
+
+ ),
+ },
+ {
+ key: "loggerName",
+ label: t("systemLog.logger"),
+ className: "w-28 text-xs text-muted-foreground",
+ render: (item) => item.loggerName || "-",
+ },
+ ]}
+ labels={{
+ refresh: t("systemLog.refresh"),
+ query: t("systemLog.query"),
+ loading: t("systemLog.loading"),
+ empty: t("systemLog.empty"),
+ loadFailed: t("systemLog.loadFailed"),
+ }}
+ />
+ {
+ setOpen(next)
+ if (!next) setLog(null)
+ }}
+ size="xl"
+ title={
+
+
+ }
+ description={log ? `#${log.id} · ${log.level}` : t("systemLog.detailDescription")}
+ footer={
+ setOpen(false)}>
+ {t("systemLog.close")}
+
+ }
+ >
+ {loading ? (
+ {t("systemLog.loadingDetail")}
+ ) : log ? (
+
+
+
+ {log.source ? (
+
+
{t("systemLog.source")}
+
{log.source}
+
+ ) : null}
+
+
{t("systemLog.message")}
+
+ {log.message}
+
+
+ {log.attrs ? (
+
+
{t("systemLog.attrs")}
+ {(() => {
+ const parsed = parseJSON(log.attrs)
+ return parsed !== null ? (
+
+ ) : (
+
+ {log.attrs}
+
+ )
+ })()}
+
+ ) : null}
+
{t("systemLog.notFound")}
+ )}
+
+
+ )
+}
+
+function Meta({ label, value }: { label: string; value: string }) {
+ return (
+
+ {label}
+ {value || "-"}
+
+ )
+}
diff --git a/web/components/support-chat/chat-shell.tsx b/web/components/support-chat/chat-shell.tsx
index 58e3287f..d6feedf1 100644
--- a/web/components/support-chat/chat-shell.tsx
+++ b/web/components/support-chat/chat-shell.tsx
@@ -363,16 +363,23 @@ export function SupportChatShell() {
- ) : (
- setIsCloseDialogOpen(true)}
- aria-label={t("supportChat.closeChatWindow")}
- title={t("supportChat.closeChatWindow")}
- className="hover:bg-rose-50 hover:text-rose-600 dark:hover:bg-rose-950/45 dark:hover:text-rose-300"
- >
-
- )}
+ ) : setIsCloseDialogOpen(true)}
+ aria-label={t("supportChat.closeWindow")}
+ title={t("supportChat.closeWindow")}
+ className="hover:bg-rose-50 hover:text-rose-600 dark:hover:bg-rose-950/45 dark:hover:text-rose-300"
+ >
+
+ }
+
+
{status !== "connected" ? (
diff --git a/web/hooks/use-agent-conversation-realtime.ts b/web/hooks/use-agent-conversation-realtime.ts
index 0453a4d7..f3633847 100644
--- a/web/hooks/use-agent-conversation-realtime.ts
+++ b/web/hooks/use-agent-conversation-realtime.ts
@@ -98,7 +98,8 @@ export function useAgentConversationRealtime() {
return
}
- if (eventType === "message.created") {
+ // message.updated 为 AI 占位回复被正式回复替换，合并语义一致（按 ID 覆盖）
+ if (eventType === "message.created" || eventType === "message.updated") {
const message = normalizeRealtimeMessage
(payload)
if (!message) {
void store.resyncRealtimeData(conversationId).catch((error) => {
diff --git a/web/lib/api/admin.ts b/web/lib/api/admin.ts
index b90ce9b7..e3303d11 100644
--- a/web/lib/api/admin.ts
+++ b/web/lib/api/admin.ts
@@ -187,6 +187,9 @@ export type AdminChannel = {
aiAgentId: number
aiAgentRolloutPercent: number
previousAiAgentRolloutPercent: number
+ aiReplyPlaceholder: string
+ aiReplyTimeoutSeconds: number
+ aiReplyTimeoutNotice: string
aiAgentName?: string
name: string
configJson: string
@@ -201,6 +204,32 @@ export type WxWorkKFAccount = {
managePrivilege: boolean
}
+export type WxWorkKFMessageReadSample = {
+ msgId?: string
+ sendTime?: string
+ origin: number
+ msgType?: string
+ eventType?: string
+ textContent?: string
+ externalUserId?: string
+ servicerUserId?: string
+}
+
+export type WxWorkKFMessageReadResult = {
+ success: boolean
+ stage?: string
+ errorCode?: string
+ errorMessage?: string
+ openKfId?: string
+ totalScanned: number
+ messageCount: number
+ eventCount: number
+ truncated: boolean
+ earliestTime?: string
+ latestTime?: string
+ samples: WxWorkKFMessageReadSample[]
+}
+
export type ChannelMessageOutbox = {
id: number
channelType: string
@@ -222,6 +251,9 @@ export type CreateAdminChannelPayload = {
channelType: string
aiAgentId: number
aiAgentRolloutPercent: number
+ aiReplyPlaceholder: string
+ aiReplyTimeoutSeconds: number
+ aiReplyTimeoutNotice: string
name: string
configJson: string
status: number
@@ -935,6 +967,16 @@ export function fetchWxWorkKFAccounts() {
return request("/api/dashboard/channel/wxwork/kf/accounts")
}
+export function testWxWorkKFReadMessages(id: number) {
+ return request(
+ "/api/dashboard/channel/wxwork/kf/test_read_messages",
+ {
+ method: "POST",
+ body: JSON.stringify({ id }),
+ }
+ )
+}
+
export function fetchWxWorkOutboxFailures(
query?: Record
) {
@@ -2213,6 +2255,13 @@ export function buildKnowledgeDocumentIndex(documentId: number) {
})
}
+export function batchBuildKnowledgeDocumentIndex(ids: number[]) {
+ return request("/api/dashboard/knowledge-document/batch_build", {
+ method: "POST",
+ body: JSON.stringify({ ids }),
+ })
+}
+
export function fetchKnowledgeFAQs(
query?: Record
) {
@@ -2410,6 +2459,27 @@ export function fetchSupportConfigAdmin() {
return request("/api/dashboard/support/config")
}
+export type SystemLog = {
+ id: number
+ level: string
+ levelName: string
+ message: string
+ source: string
+ loggerName: string
+ attrs: string
+ createdAt: string
+}
+
+export function fetchSystemLogs(query?: Record) {
+ return request>(
+ `/api/dashboard/system-log/list${toQueryString(query)}`
+ )
+}
+
+export function fetchSystemLog(id: number) {
+ return request(`/api/dashboard/system-log/${id}`)
+}
+
export function saveSupportConfigAdmin(payload: Partial) {
return request("/api/dashboard/support/config/save", {
method: "POST",
diff --git a/web/lib/api/agent.ts b/web/lib/api/agent.ts
index e2785dc9..a5cbdeb9 100644
--- a/web/lib/api/agent.ts
+++ b/web/lib/api/agent.ts
@@ -36,6 +36,8 @@ export type AgentConversation = {
id: number
aiAgentId?: number
channelId?: number
+ channelType?: string
+ channelName?: string
customerId?: number
customerName: string
status: number
diff --git a/web/lib/channel-i18n.ts b/web/lib/channel-i18n.ts
new file mode 100644
index 00000000..0563fb94
--- /dev/null
+++ b/web/lib/channel-i18n.ts
@@ -0,0 +1,48 @@
+"use client"
+
+import { createElement } from "react"
+
+import {
+ Building2Icon,
+ MessagesSquareIcon,
+ MessageSquareMoreIcon,
+ SendIcon,
+ type LucideIcon,
+} from "lucide-react"
+
+type Translate = (key: string, values?: Record) => string
+
+// CHANNEL_TYPE_LABEL_KEYS 为渠道类型后端标识到 i18n 键的映射。
+const CHANNEL_TYPE_LABEL_KEYS: Record = {
+ web: "channel.typeWeb",
+ wechat_mp: "channel.typeWechatMp",
+ wxwork_kf: "channel.typeWxworkKf",
+ telegram: "channel.typeTelegram",
+ zalo_oa: "channel.typeZaloOa",
+}
+
+// getChannelTypeLabel 返回渠道类型的本地化显示名；未知类型回退为原始标识。
+export function getChannelTypeLabel(channelType: string, t: Translate): string {
+ const key = CHANNEL_TYPE_LABEL_KEYS[channelType]
+ return key ? t(key) : channelType
+}
+
+// CHANNEL_TYPE_ICONS 为渠道类型到 Lucide 图标的映射。
+const CHANNEL_TYPE_ICONS: Record = {
+ web: Building2Icon,
+ wechat_mp: MessagesSquareIcon,
+ wxwork_kf: MessageSquareMoreIcon,
+ telegram: SendIcon,
+ zalo_oa: SendIcon,
+}
+
+export function ChannelTypeIcon({
+ channelType,
+ className,
+}: {
+ channelType: string
+ className?: string
+}) {
+ const Icon = CHANNEL_TYPE_ICONS[channelType] ?? Building2Icon
+ return createElement(Icon, { className, "aria-hidden": true })
+}
diff --git a/web/lib/navigation.tsx b/web/lib/navigation.tsx
index 74e1fe8b..e6b77b3d 100644
--- a/web/lib/navigation.tsx
+++ b/web/lib/navigation.tsx
@@ -12,6 +12,7 @@ import {
MessageSquareWarningIcon,
MessageSquareCodeIcon,
MessageSquareMoreIcon,
+ ScrollTextIcon,
SettingsIcon,
ShieldCheckIcon,
TagsIcon,
@@ -287,6 +288,12 @@ export const dashboardNavSections: DashboardNavSectionConfig[] = [
icon: ((set, get) => {
return
}
- if (event.type === "message.created") {
+ // message.updated 为 AI 占位回复被正式回复替换，按 ID 覆盖合并且不重复提醒
+ if (event.type === "message.created" || event.type === "message.updated") {
const message = normalizeRealtimeMessage(payload)
if (!message) {
void get().syncLatestMessages()
@@ -199,6 +200,7 @@ export const useSupportChatStore = create((set, get) => {
conversation: patchConversationWithMessage(state.conversation, message),
}))
if (
+ event.type === "message.created" &&
message.senderType !== "customer" &&
typeof document !== "undefined" &&
document.visibilityState !== "visible"
diff --git a/web/messages/en-US.json b/web/messages/en-US.json
index 082e0a21..ab2adf08 100644
--- a/web/messages/en-US.json
+++ b/web/messages/en-US.json
@@ -422,6 +422,7 @@
"conversationOwner": "Conversation Ownership",
"conversationId": "Conversation ID",
"channelId": "Channel ID",
+ "sourceChannel": "Source",
"customerId": "Customer ID",
"selectConversationForInfo": "Select a conversation to view its details",
"selectSidebarConversationForInfo": "Select a conversation on the left to view its details",
@@ -684,6 +685,72 @@
"configWxworkDescription": "Configure the WeCom customer service account used to match callbacks and send outbound messages.",
"configWechatDescription": "Configure the display settings for the WeChat menu chat page.",
"configWebDescription": "Configure how the web support widget appears on your site.",
+ "aiReplySectionTitle": "AI Reception Prompt",
+ "aiReplySectionDescription": "Send a placeholder reply when a customer message arrives, replace it with the actual AI reply once ready, and notify the customer if processing fails.",
+ "aiReplyPlaceholder": "Placeholder reply",
+ "aiReplyPlaceholderPlaceholder": "Leave empty to use the default: Looking into it, please wait…",
+ "aiReplyTimeoutSeconds": "AI reply timeout (seconds)",
+ "aiReplyTimeoutSecondsHint": "0 uses the default of 120 seconds; max 600 seconds.",
+ "aiReplyTimeoutNotice": "Timeout notice",
+ "aiReplyTimeoutNoticePlaceholder": "Leave empty to use the default: Sorry, the AI assistant could not handle your question…",
+ "aiReplyPlaceholderTooLong": "Placeholder reply cannot exceed 255 characters.",
+ "aiReplyTimeoutInvalid": "Invalid AI reply timeout.",
+ "aiReplyTimeoutNoticeTooLong": "Timeout notice cannot exceed 500 characters.",
+ "readTestButton": "Test message read",
+ "readTestRunning": "Reading messages, please wait…",
+ "readTestTitle": "Test reading WeCom customer service messages (last 3 days)",
+ "readTestRetry": "Run again",
+ "readTestClose": "Close",
+ "readTestUnsavedHint": "Save the channel before running the test.",
+ "readTestSuccess": "Read succeeded",
+ "readTestFailed": "Read failed",
+ "readTestSummary": "{total} records scanned ({messages} messages, {events} events)",
+ "readTestRange": "Time range: {earliest} – {latest}",
+ "readTestTruncated": "The scan reached the 5,000-record limit; only the {count} most recent samples within the scanned records are shown.",
+ "readTestEmpty": "The API call succeeded, but no messages or events were available for this service account in the last 3 days. Make sure a customer has already sent a message to this account, then try again.",
+ "readTestStage": "Failed at",
+ "readTestErrCode": "Error code",
+ "readTestErrMessage": "Error message",
+ "readTestExternalUser": "Customer: ",
+ "readTestServicerUser": "Agent: ",
+ "readTestStageGettoken": "Getting access_token",
+ "readTestStageSyncmsg": "Reading messages (sync_msg)",
+ "readTestOriginCustomer": "Customer message",
+ "readTestOriginEvent": "System event",
+ "readTestOriginServicer": "Service agent",
+ "readTestOriginUnknown": "Origin {origin}",
+ "readTestTypeText": "Text",
+ "readTestTypeImage": "Image",
+ "readTestTypeFile": "File",
+ "readTestTypeVoice": "Voice",
+ "readTestTypeVideo": "Video",
+ "readTestTypeLocation": "Location",
+ "readTestTypeLink": "Link",
+ "readTestTypeBusinessCard": "Business card",
+ "readTestTypeMiniProgram": "Mini program",
+ "readTestTypeEvent": "Event",
+ "readTestTypeUnknown": "Unknown type",
+ "readTestEventEnterSession": "Enter session (enter_session)",
+ "readTestEventSessionStatusChange": "Session status change (session_status_change)",
+ "readTestEventServicerStatusChange": "Agent status change (servicer_status_change)",
+ "readTestEventMsgSendFail": "Message send failed (msg_send_fail)",
+ "readTestHintMinus1": "WeCom is busy or a network fluctuation occurred. Please try again shortly.",
+ "readTestHint40001": "Incorrect CorpID or app secret. Verify that server settings wxwork.corpId and wxwork.corpSecret belong to this self-built app, then restart the service.",
+ "readTestHint40013": "Invalid CorpID. Verify the server setting wxwork.corpId (the enterprise ID starting with ww), then restart the service.",
+ "readTestHint40014": "Invalid access_token. This usually means the cached token does not match the current secret. Retry shortly; if it persists, restart the service and verify corpId/corpSecret.",
+ "readTestHint40056": "Incorrect AgentID. Verify that wxwork.agentId is the AgentId of this self-built app, then restart the service.",
+ "readTestHint42001": "The access_token has expired. Click “Run again”; if it persists, restart the service to refresh the token.",
+ "readTestHint45009": "API rate limit exceeded. Retry the test shortly.",
+ "readTestHint48002": "The API is not authorized for this app. Enable the WeCom customer service API permissions for this self-built app in the admin console.",
+ "readTestHint48007": "The self-built app lacks the “Read customer service messages” or “Send customer service messages” API permission. Go to the WeCom admin console → Apps → this self-built app → API permissions and add the customer service permissions.",
+ "readTestHint60030": "This service account is not within the self-built app's allowed range. Associate the service account with this app in the customer service admin console, and verify the app's visibility scope covers the users.",
+ "readTestHintWxworkDisabled": "WeCom is disabled or credentials are incomplete on the server. Check wxwork.enabled, wxwork.corpId and wxwork.corpSecret, then restart the service.",
+ "readTestHintOpenkfidMissing": "No service account selected (open_kfid is empty). Select a service account above and save the channel before testing.",
+ "readTestHintInvalidChannel": "The channel does not exist or is not a WeCom customer service channel. Refresh the page and retry.",
+ "readTestHintInvalidConfigJson": "The channel config JSON cannot be parsed. Check the channel configuration and save again.",
+ "readTestHintNetwork": "Unable to reach the WeCom API (qyapi.weixin.qq.com). Check the server's network, DNS, firewall or outbound proxy.",
+ "readTestHintBadResponse": "WeCom returned an unparseable response. Retry shortly; if it persists, check the server logs.",
+ "readTestHintDefault": "Review the error code and message: verify the self-built app's customer service API permissions, the association between the service account and the app, the app's visibility scope, and the server corpId/corpSecret settings.",
"wxworkAccount": "WeCom Customer Service Account",
"loadingWxworkAccount": "Loading service accounts",
"selectWxworkAccount": "Select a service account",
@@ -2121,6 +2188,9 @@
"batchDeleteConfirm": "Delete {count} selected items? This cannot be undone.",
"batchDeleted": "{count} items deleted.",
"batchDeleteFailed": "Could not delete selected items.",
+ "batchRebuildIndex": "Rebuild Index",
+ "batchRebuilt": "Index rebuild completed for {count} items.",
+ "batchRebuildFailed": "Could not rebuild indexes for selected items.",
"targetDirectory": "Target directory",
"directory": "Directory",
"resizeDirectoryPanel": "Resize directory panel",
@@ -3049,6 +3119,7 @@
"users": "Users",
"roles": "Roles",
"permissions": "Permissions",
+ "systemLogs": "System Logs",
"dashboardHome": "Dashboard",
"notifications": "Notifications",
"preferences": "Preferences",
@@ -3059,6 +3130,34 @@
"supportCommunityCategories": "Community Categories",
"supportConfig": "Support Settings"
},
+ "systemLog": {
+ "title": "System Logs",
+ "level": "Level",
+ "levelPlaceholder": "All levels",
+ "levelWarn": "Warn",
+ "levelError": "Error",
+ "levelInfo": "Info",
+ "message": "Message",
+ "messagePlaceholder": "Search message",
+ "source": "Source",
+ "sourcePlaceholder": "file:line",
+ "startTime": "Start time",
+ "endTime": "End time",
+ "createdAt": "Time",
+ "logger": "Logger",
+ "attrs": "Attributes",
+ "refresh": "Refresh",
+ "query": "Query",
+ "loading": "Loading...",
+ "empty": "No system logs",
+ "loadFailed": "Failed to load system logs",
+ "loadDetailFailed": "Failed to load log detail",
+ "detailTitle": "Log Detail",
+ "detailDescription": "View log details",
+ "loadingDetail": "Loading...",
+ "close": "Close",
+ "notFound": "Log not found"
+ },
"workspace": {
"dashboard": "Admin Dashboard",
"workbench": "Support Workbench",
diff --git a/web/messages/zh-CN.json b/web/messages/zh-CN.json
index 2e754eb2..5fbb9909 100644
--- a/web/messages/zh-CN.json
+++ b/web/messages/zh-CN.json
@@ -421,6 +421,7 @@
"relinkOrCreateCustomer": "重新关联或创建客户",
"conversationOwner": "会话归属",
"conversationId": "会话 ID",
+ "sourceChannel": "来源渠道",
"channelId": "渠道ID",
"customerId": "客户ID",
"selectConversationForInfo": "请选择会话以查看会话信息",
@@ -684,6 +685,72 @@
"configWxworkDescription": "配置企业微信客服账号，用于匹配回调消息和对外发送消息。",
"configWechatDescription": "配置公众号菜单直达聊天页的展示参数。",
"configWebDescription": "配置 Web 站点客服窗口的展示参数。",
+ "aiReplySectionTitle": "AI 接待提示",
+ "aiReplySectionDescription": "收到客户消息后先回复占位文案，AI 结果生成后自动替换为正式回复；超时未完成时向客户发送失败提示。",
+ "aiReplyPlaceholder": "占位回复文案",
+ "aiReplyPlaceholderPlaceholder": "留空使用默认：正在查看，请稍候……",
+ "aiReplyTimeoutSeconds": "AI 回复超时（秒）",
+ "aiReplyTimeoutSecondsHint": "0 表示使用默认 120 秒，最大 600 秒。",
+ "aiReplyTimeoutNotice": "超时提示文案",
+ "aiReplyTimeoutNoticePlaceholder": "留空使用默认：抱歉，AI 客服暂时未能处理您的问题……",
+ "aiReplyPlaceholderTooLong": "占位回复文案不能超过 255 个字符",
+ "aiReplyTimeoutInvalid": "AI 回复超时时长不合法",
+ "aiReplyTimeoutNoticeTooLong": "超时提示文案不能超过 500 个字符",
+ "readTestButton": "测试读取消息",
+ "readTestRunning": "正在读取消息，请稍候……",
+ "readTestTitle": "测试读取企业微信客服消息（近 3 天）",
+ "readTestRetry": "重新测试",
+ "readTestClose": "关闭",
+ "readTestUnsavedHint": "请先保存渠道后再进行测试。",
+ "readTestSuccess": "读取成功",
+ "readTestFailed": "读取失败",
+ "readTestSummary": "共扫描 {total} 条记录（消息 {messages} 条，事件 {events} 条）",
+ "readTestRange": "时间范围：{earliest} ～ {latest}",
+ "readTestTruncated": "消息量较大，已达到 5000 条扫描上限，仅展示已扫描部分中最近 {count} 条样例。",
+ "readTestEmpty": "接口调用成功，但近 3 天内该客服账号没有可读取的消息或事件。请确认已有客户向该客服账号发送过消息，或等待客户消息后再测试。",
+ "readTestStage": "失败环节",
+ "readTestErrCode": "错误码",
+ "readTestErrMessage": "错误信息",
+ "readTestExternalUser": "客户：",
+ "readTestServicerUser": "客服：",
+ "readTestStageGettoken": "获取 access_token",
+ "readTestStageSyncmsg": "读取消息（sync_msg）",
+ "readTestOriginCustomer": "客户消息",
+ "readTestOriginEvent": "系统事件",
+ "readTestOriginServicer": "客服人员",
+ "readTestOriginUnknown": "来源 {origin}",
+ "readTestTypeText": "文本",
+ "readTestTypeImage": "图片",
+ "readTestTypeFile": "文件",
+ "readTestTypeVoice": "语音",
+ "readTestTypeVideo": "视频",
+ "readTestTypeLocation": "位置",
+ "readTestTypeLink": "链接",
+ "readTestTypeBusinessCard": "名片",
+ "readTestTypeMiniProgram": "小程序",
+ "readTestTypeEvent": "事件",
+ "readTestTypeUnknown": "未知类型",
+ "readTestEventEnterSession": "进入会话（enter_session）",
+ "readTestEventSessionStatusChange": "会话状态变更（session_status_change）",
+ "readTestEventServicerStatusChange": "客服接待状态变更（servicer_status_change）",
+ "readTestEventMsgSendFail": "消息发送失败（msg_send_fail）",
+ "readTestHintMinus1": "企业微信系统繁忙或网络波动，请稍后重试。",
+ "readTestHint40001": "CorpID 或应用 Secret 不正确。请检查服务端配置 wxwork.corpId 和 wxwork.corpSecret 是否为该自建应用的凭据，修改配置后需重启服务。",
+ "readTestHint40013": "CorpID 不合法。请检查服务端配置 wxwork.corpId（企业 ID，以 ww 开头），修改后需重启服务。",
+ "readTestHint40014": "access_token 无效。通常是缓存令牌与当前 Secret 不匹配，请稍后重试；若持续出现，请重启服务并确认 corpId/corpSecret 配置正确。",
+ "readTestHint40056": "AgentID 配置错误。请检查服务端配置 wxwork.agentId 是否为该自建应用的 AgentId，修改后需重启服务。",
+ "readTestHint42001": "access_token 已过期。请点击“重新测试”再试一次；若持续出现，请重启服务刷新令牌。",
+ "readTestHint45009": "接口调用超过频率限制。请稍后再重试测试。",
+ "readTestHint48002": "API 接口无权限调用。请到企业微信管理后台为该自建应用开通微信客服相关接口权限。",
+ "readTestHint48007": "自建应用缺少「读取微信客服消息」或「发送微信客服消息」API 权限。请前往企业微信管理后台 → 应用管理 → 该自建应用 → API 权限，添加微信客服相关权限。",
+ "readTestHint60030": "该客服账号不在自建应用的可调用范围。请在微信客服后台把该客服账号关联到此自建应用，并检查自建应用的可见范围是否覆盖使用人员。",
+ "readTestHintWxworkDisabled": "服务端未启用企业微信或凭据配置不完整。请检查配置文件 wxwork.enabled、wxwork.corpId、wxwork.corpSecret，并重启服务。",
+ "readTestHintOpenkfidMissing": "渠道未选择客服账号（open_kfid 为空）。请先在上方选择客服账号并保存渠道，再执行测试。",
+ "readTestHintInvalidChannel": "渠道不存在或不是企业微信客服渠道。请刷新页面后重试。",
+ "readTestHintInvalidConfigJson": "渠道配置 JSON 无法解析。请检查渠道配置内容并重新保存。",
+ "readTestHintNetwork": "无法连接企业微信接口（qyapi.weixin.qq.com）。请检查服务器的网络、DNS、防火墙或出站代理配置。",
+ "readTestHintBadResponse": "企业微信返回了无法解析的响应。请稍后重试；若持续出现，请查看服务端运行日志。",
+ "readTestHintDefault": "请根据错误码与错误信息排查：重点确认自建应用的微信客服 API 权限、客服账号与自建应用的关联、应用可见范围，以及服务端 corpId/corpSecret 配置。",
"wxworkAccount": "企业微信客服账号",
"loadingWxworkAccount": "正在加载客服账号",
"selectWxworkAccount": "请选择客服账号",
@@ -2120,6 +2187,9 @@
"batchDeleteConfirm": "确定删除已选择的 {count} 项吗？此操作不可撤销。",
"batchDeleted": "已删除 {count} 项",
"batchDeleteFailed": "批量删除失败",
+ "batchRebuildIndex": "重建索引",
+ "batchRebuilt": "已完成 {count} 项索引重建",
+ "batchRebuildFailed": "批量重建索引失败",
"targetDirectory": "目标目录",
"directory": "目录",
"resizeDirectoryPanel": "调整目录面板宽度",
@@ -3048,6 +3118,7 @@
"users": "用户管理",
"roles": "角色管理",
"permissions": "权限管理",
+ "systemLogs": "系统日志",
"dashboardHome": "后台总览",
"notifications": "通知中心",
"preferences": "偏好设置",
@@ -3058,6 +3129,34 @@
"supportCommunityCategories": "社区分类",
"supportConfig": "支持中心配置"
},
+ "systemLog": {
+ "title": "系统日志",
+ "level": "级别",
+ "levelPlaceholder": "全部级别",
+ "levelWarn": "警告",
+ "levelError": "错误",
+ "levelInfo": "信息",
+ "message": "消息",
+ "messagePlaceholder": "搜索消息内容",
+ "source": "来源",
+ "sourcePlaceholder": "文件:行号",
+ "startTime": "开始时间",
+ "endTime": "结束时间",
+ "createdAt": "时间",
+ "logger": "Logger",
+ "attrs": "属性",
+ "refresh": "刷新",
+ "query": "查询",
+ "loading": "加载中...",
+ "empty": "暂无系统日志",
+ "loadFailed": "加载系统日志失败",
+ "loadDetailFailed": "加载日志详情失败",
+ "detailTitle": "日志详情",
+ "detailDescription": "查看日志详细信息",
+ "loadingDetail": "加载中...",
+ "close": "关闭",
+ "notFound": "日志不存在"
+ },
"workspace": {
"dashboard": "管理后台",
"workbench": "客服工作台",
diff --git a/web/pnpm-workspace.yaml b/web/pnpm-workspace.yaml
index 7150c25b..47214672 100644
--- a/web/pnpm-workspace.yaml
+++ b/web/pnpm-workspace.yaml
@@ -1,3 +1,8 @@
+allowBuilds:
+ '@parcel/watcher': set this to true or false
+ sharp: set this to true or false
+ unrs-resolver: set this to true or false
+
ignoredBuiltDependencies:
- sharp
- unrs-resolver
diff --git a/web/public/sdk/agent-desk-sdk.min.js b/web/public/sdk/agent-desk-sdk.min.js
index a40ee4b0..279e98f1 100644
--- a/web/public/sdk/agent-desk-sdk.min.js
+++ b/web/public/sdk/agent-desk-sdk.min.js
@@ -1 +1 @@
-var __rest=this&&this.__rest||function(e,t){var n={};for(var i in e)Object.prototype.hasOwnProperty.call(e,i)&&t.indexOf(i)<0&&(n[i]=e[i]);if(null!=e&&"function"==typeof Object.getOwnPropertySymbols){var a=0;for(i=Object.getOwnPropertySymbols(e);aString(e||"").trim())}catch(e){return Promise.reject(e)}}().then(e=>{if(!n.config)throw new Error("channelId is required");return n.frameUrl=function(e,t){const n=a(e),i=new URL(`${n}/support/chat/`);return i.searchParams.set("channelId",e.channelId),i.searchParams.set("baseUrl",e.baseUrl),e.apiBaseUrl&&i.searchParams.set("apiBaseUrl",e.apiBaseUrl),e.externalId&&i.searchParams.set("externalId",e.externalId),e.externalName&&i.searchParams.set("externalName",e.externalName),t&&i.searchParams.set("userToken",t),i}(n.config,e),n.frameConfig=r(n.config,e),n.frameUrl})}function s(){n.frameHideTimer&&(window.clearTimeout(n.frameHideTimer),n.frameHideTimer=null),n.frameDestroyTimer&&(window.clearTimeout(n.frameDestroyTimer),n.frameDestroyTimer=null)}function l(){const e=n.frame,t=n.config;if(e&&t){if(e.style.position="fixed",e.style.border="0",e.style.overflow="hidden",e.style.background="#fff",e.style.zIndex="2147483000",e.style.boxShadow="0 28px 80px rgba(15, 35, 65, 0.28)",e.style.willChange="top,right,bottom,left,width,height,opacity,transform,border-radius",e.style.transition="top 260ms cubic-bezier(0.22, 1, 0.36, 1), right 260ms cubic-bezier(0.22, 1, 0.36, 1), bottom 260ms cubic-bezier(0.22, 1, 0.36, 1), left 260ms cubic-bezier(0.22, 1, 0.36, 1), width 260ms cubic-bezier(0.22, 1, 0.36, 1), height 260ms cubic-bezier(0.22, 1, 0.36, 1), opacity 220ms ease, transform 260ms cubic-bezier(0.22, 1, 0.36, 1), border-radius 260ms cubic-bezier(0.22, 1, 0.36, 1), box-shadow 260ms ease",e.style.transformOrigin="left"===t.position?"left bottom":"right bottom",n.isMaximized)return e.style.top="max(12px, env(safe-area-inset-top))",e.style.right="max(12px, env(safe-area-inset-right))",e.style.bottom="max(12px, env(safe-area-inset-bottom))",e.style.left="max(12px, env(safe-area-inset-left))",e.style.width="calc(100vw - max(12px, env(safe-area-inset-left)) - max(12px, env(safe-area-inset-right)))",e.style.maxWidth="none",e.style.height="calc(100dvh - max(12px, env(safe-area-inset-top)) - max(12px, env(safe-area-inset-bottom)))",void(e.style.borderRadius="16px");e.style.top="",e.style.bottom="max(88px, calc(72px + env(safe-area-inset-bottom)))",e.style.right="left"===t.position?"":"max(12px, env(safe-area-inset-right))",e.style.left="left"===t.position?"max(12px, env(safe-area-inset-left))":"",e.style.width=t.width||"380px",e.style.maxWidth="calc(100vw - max(12px, env(safe-area-inset-left)) - max(12px, env(safe-area-inset-right)))",e.style.height="min(760px, calc(100dvh - max(104px, calc(88px + env(safe-area-inset-bottom))) - max(12px, env(safe-area-inset-top))))",e.style.borderRadius="18px"}}function d(e){var t;if((null===(t=n.frame)||void 0===t?void 0:t.contentWindow)&&n.frameUrl)try{n.frame.contentWindow.postMessage(e,n.frameUrl.origin)}catch(e){console.error("[agent-desk-widget] postMessage failed",e)}}function c(){n.frame&&n.frameLoaded&&n.frameReady&&n.config&&(n.initSent||(n.initSent=!0,d({type:"agent-desk:init",payload:n.frameConfig||r(n.config,"")})),d({type:n.isOpen?"agent-desk:open":"agent-desk:minimize"}),d({type:"agent-desk:maximized",payload:{isMaximized:n.isMaximized}}))}function f(){const e=n.frame;if(e){if(s(),l(),e.style.display="block",n.isOpen)return e.style.visibility="visible",e.style.pointerEvents="auto",n.frameHideTimer=window.setTimeout(()=>{n.frame&&(n.frame.style.opacity="1",n.frame.style.transform="translate3d(0, 0, 0) scale(1)")},16),void c();e.style.pointerEvents="none",e.style.opacity="0",e.style.transform=n.isMaximized?"translate3d(0, 10px, 0) scale(0.985)":"translate3d(0, 16px, 0) scale(0.96)",n.frameHideTimer=window.setTimeout(()=>{n.frame&&!n.isOpen&&(n.frame.style.visibility="hidden")},n.animationDuration),c()}}function m(e){const t=e||window.AgentDeskConfig||{channelId:""};n.config=i(t);const r=a(n.config);t.baseUrl||(n.config.baseUrl=r),n.config.channelId?(n.configLoading=!0,function(e){const t=String(e.apiBaseUrl||e.baseUrl||"").replace(/\/$/,"");return t&&"function"==typeof fetch?fetch(`${t}/api/config`,{method:"GET",cache:"no-store"}).then(e=>e.json()).then(t=>{var n;return t&&!1!==t.success?i(Object.assign(Object.assign({},e),{language:(null===(n=t.data)||void 0===n?void 0:n.language)||e.language})):e}).catch(()=>e):Promise.resolve(e)}(n.config).then(e=>function(e){const t=String(e.apiBaseUrl||e.baseUrl||"").replace(/\/$/,"");if(!t||!e.channelId||"function"!=typeof fetch)return Promise.resolve(e);const n=`${t}/api/channel/config?channelId=${encodeURIComponent(e.channelId)}`;return fetch(n,{method:"GET",cache:"no-store",headers:{"X-Channel-Id":e.channelId}}).then(e=>e.json()).then(t=>t&&!1!==t.success?function(e,t){if(!t)return e;const n=Object.assign({},e);return["title","subtitle","themeColor","position","width"].forEach(e=>{const i=t[e];null!=i&&(n[e]=i)}),n}(e,t.data||{}):e).catch(()=>e)}(e)).then(e=>{var t;n.configLoading=!1,n.config=i(e),(null===(t=n.button)||void 0===t?void 0:t.parentNode)&&(n.button.parentNode.removeChild(n.button),n.button=null),function(){if(n.button)return n.button;const e=n.config;if(!e)return null;const t=document.createElement("button"),i=document.createElementNS("http://www.w3.org/2000/svg","svg"),a=document.createElement("span");t.type="button",t.dataset.agentDeskWidget="launcher",t.setAttribute("aria-label",e.title||getDefaultWidgetTitle(e)),i.setAttribute("viewBox","0 0 24 24"),i.setAttribute("fill","none"),i.setAttribute("stroke","currentColor"),i.setAttribute("stroke-width","2"),i.setAttribute("stroke-linecap","round"),i.setAttribute("stroke-linejoin","round"),i.setAttribute("aria-hidden","true"),i.style.width="24px",i.style.height="24px",i.style.flex="0 0 auto",["M3 11a9 9 0 1 1 18 0","M3 11h3a2 2 0 0 1 2 2v3a2 2 0 0 1-2 2H5a2 2 0 0 1-2-2z","M21 11h-3a2 2 0 0 0-2 2v3a2 2 0 0 0 2 2h1a2 2 0 0 0 2-2z","M21 16v2a4 4 0 0 1-4 4h-5"].forEach(e=>{const t=document.createElementNS("http://www.w3.org/2000/svg","path");t.setAttribute("d",e),i.appendChild(t)}),a.textContent=getLauncherText(e),a.style.display="block",t.style.position="fixed",t.style.bottom="24px",t.style.right="left"===e.position?"":"24px",t.style.left="left"===e.position?"24px":"",t.style.zIndex="2147483000",t.style.display="inline-flex",t.style.flexDirection="column",t.style.alignItems="center",t.style.justifyContent="center",t.style.gap="4px",t.style.width="64px",t.style.height="64px",t.style.border="0",t.style.borderRadius="999px",t.style.padding="0",t.style.background=e.themeColor||"#0f6cbd",t.style.color="#fff",t.style.font="600 13px/1 sans-serif",t.style.boxShadow="0 18px 40px rgba(15, 35, 65, 0.24)",t.style.cursor="pointer",t.appendChild(i),t.appendChild(a),t.addEventListener("click",()=>{if(n.isOpen)return n.isOpen=!1,void f();u()}),document.body.appendChild(t),n.button=t}()})):console.error("[agent-desk-widget] channelId is required")}function u(){return o().then(()=>{n.frame||(n.frame?n.frame:n.frameUrl&&n.config&&(n.frame=document.createElement("iframe"),n.frame.dataset.agentDeskWidget="frame",n.frame.title=n.config.title||getDefaultWidgetTitle(n.config),n.frame.src=n.frameUrl.toString(),l(),n.frame.style.display="block",n.frame.style.visibility="hidden",n.frame.style.pointerEvents="none",n.frame.style.opacity="0",n.frame.style.transform="translate3d(0, 18px, 0) scale(0.96)",n.frame.addEventListener("load",()=>{n.frameLoaded=!0,f()}),document.body.appendChild(n.frame),n.frame)),n.frame&&(n.isOpen=!0,f())}).catch(e=>{console.error("[agent-desk-widget] open failed",e)})}t||(window.__CS_AI_AGENT_WIDGET_STATE__=n),window.AgentDeskWidget={mount:m,destroy:function(){var e,t;s(),(null===(e=n.frame)||void 0===e?void 0:e.parentNode)&&n.frame.parentNode.removeChild(n.frame),(null===(t=n.button)||void 0===t?void 0:t.parentNode)&&n.button.parentNode.removeChild(n.button),n.button=null,n.frame=null,n.frameLoaded=!1,n.frameReady=!1,n.initSent=!1,n.isOpen=!1,n.isMaximized=!1,n.configLoading=!1,n.frameConfig=null,n.frameUrl=null},open:()=>u(),close:()=>{n.isOpen=!1,f()},getChatUrl:()=>{var e;return n.config||m(window.AgentDeskConfig||{channelId:""}),(null===(e=n.config)||void 0===e?void 0:e.channelId)?o().then(e=>e.toString()):Promise.reject(new Error("channelId is required"))}},n.listenerBound||(window.addEventListener("message",function(e){if(!n.frame||e.source!==n.frame.contentWindow)return;const t=e.data||{};return"agent-desk:ready"===t.type?(n.frameReady=!0,void c()):"agent-desk:request-minimize"===t.type?(n.isOpen=!1,void f()):void("agent-desk:request-close"!==t.type?"agent-desk:request-toggle-maximize"===t.type&&(n.isMaximized=!n.isMaximized,f()):n.frame&&(s(),n.frame.style.pointerEvents="none",n.frame.style.opacity="0",n.frame.style.transform="translate3d(0, 18px, 0) scale(0.94)",n.frame.style.visibility="hidden",n.frameDestroyTimer=window.setTimeout(()=>{n.frame&&(n.frame.parentNode&&n.frame.parentNode.removeChild(n.frame),n.frame=null,n.frameLoaded=!1,n.frameReady=!1,n.initSent=!1,n.isOpen=!1,n.isMaximized=!1,s())},n.animationDuration)))}),n.listenerBound=!0),window.AgentDeskConfig&&m(window.AgentDeskConfig)}();
+var __rest=this&&this.__rest||function(e,n){var t={};for(var r in e)Object.prototype.hasOwnProperty.call(e,r)&&n.indexOf(r)<0&&(t[r]=e[r]);if(null!=e&&"function"==typeof Object.getOwnPropertySymbols){var a=0;for(r=Object.getOwnPropertySymbols(e);aString(e||"").trim())}catch(e){return Promise.reject(e)}}().then(e=>{if(!r.config)throw new Error("channelId is required");return r.frameUrl=function(e,n){const t=i(e),r=new URL(`${t}/support/chat/`);return r.searchParams.set("channelId",e.channelId),r.searchParams.set("baseUrl",e.baseUrl),e.apiBaseUrl&&r.searchParams.set("apiBaseUrl",e.apiBaseUrl),e.externalId&&r.searchParams.set("externalId",e.externalId),e.externalName&&r.searchParams.set("externalName",e.externalName),n&&r.searchParams.set("userToken",n),r}(r.config,e),r.frameConfig=o(r.config,e),r.frameUrl})}function s(){r.frameHideTimer&&(window.clearTimeout(r.frameHideTimer),r.frameHideTimer=null),r.frameDestroyTimer&&(window.clearTimeout(r.frameDestroyTimer),r.frameDestroyTimer=null)}function c(){const e=r.frame,n=r.config;if(e&&n){if(e.style.position="fixed",e.style.border="0",e.style.overflow="hidden",e.style.background="#fff",e.style.zIndex="2147483000",e.style.boxShadow="0 28px 80px rgba(15, 35, 65, 0.28)",e.style.willChange="top,right,bottom,left,width,height,opacity,transform,border-radius",e.style.transition="top 260ms cubic-bezier(0.22, 1, 0.36, 1), right 260ms cubic-bezier(0.22, 1, 0.36, 1), bottom 260ms cubic-bezier(0.22, 1, 0.36, 1), left 260ms cubic-bezier(0.22, 1, 0.36, 1), width 260ms cubic-bezier(0.22, 1, 0.36, 1), height 260ms cubic-bezier(0.22, 1, 0.36, 1), opacity 220ms ease, transform 260ms cubic-bezier(0.22, 1, 0.36, 1), border-radius 260ms cubic-bezier(0.22, 1, 0.36, 1), box-shadow 260ms ease",e.style.transformOrigin="left"===n.position?"left bottom":"right bottom",r.isMaximized)return e.style.top="max(12px, env(safe-area-inset-top))",e.style.right="max(12px, env(safe-area-inset-right))",e.style.bottom="max(12px, env(safe-area-inset-bottom))",e.style.left="max(12px, env(safe-area-inset-left))",e.style.width="calc(100vw - max(12px, env(safe-area-inset-left)) - max(12px, env(safe-area-inset-right)))",e.style.maxWidth="none",e.style.height="calc(100dvh - max(12px, env(safe-area-inset-top)) - max(12px, env(safe-area-inset-bottom)))",void(e.style.borderRadius="16px");e.style.top="",e.style.bottom="max(88px, calc(72px + env(safe-area-inset-bottom)))",e.style.right="left"===n.position?"":"max(12px, env(safe-area-inset-right))",e.style.left="left"===n.position?"max(12px, env(safe-area-inset-left))":"",e.style.width=n.width||"380px",e.style.maxWidth="calc(100vw - max(12px, env(safe-area-inset-left)) - max(12px, env(safe-area-inset-right)))",e.style.height="min(760px, calc(100dvh - max(104px, calc(88px + env(safe-area-inset-bottom))) - max(12px, env(safe-area-inset-top))))",e.style.borderRadius="18px"}}function d(e){var n;if((null===(n=r.frame)||void 0===n?void 0:n.contentWindow)&&r.frameUrl)try{r.frame.contentWindow.postMessage(e,r.frameUrl.origin)}catch(e){console.error("[agent-desk-widget] postMessage failed",e)}}function u(){r.frame&&r.frameLoaded&&r.frameReady&&r.config&&(r.initSent||(r.initSent=!0,d({type:"agent-desk:init",payload:r.frameConfig||o(r.config,"")})),d({type:r.isOpen?"agent-desk:open":"agent-desk:minimize"}),d({type:"agent-desk:maximized",payload:{isMaximized:r.isMaximized}}))}function h(){const e=r.frame;if(e){if(s(),c(),e.style.display="block",r.isOpen)return e.style.visibility="visible",e.style.pointerEvents="auto",r.frameHideTimer=window.setTimeout(()=>{r.frame&&(r.frame.style.opacity="1",r.frame.style.transform="translate3d(0, 0, 0) scale(1)")},16),void u();e.style.pointerEvents="none",e.style.opacity="0",e.style.transform=r.isMaximized?"translate3d(0, 10px, 0) scale(0.985)":"translate3d(0, 16px, 0) scale(0.96)",r.frameHideTimer=window.setTimeout(()=>{r.frame&&!r.isOpen&&(r.frame.style.visibility="hidden")},r.animationDuration),u()}}function f(){return{width:"number"==typeof window.innerWidth?window.innerWidth:0,height:"number"==typeof window.innerHeight?window.innerHeight:0}}function m(){const e=r.config,n=null==e?void 0:e.channelId;return n?`agent-desk:launcher-pos:${n}`:null}function g(){var e;if(r.launcherPos)return;const t=f();if(t.width<=0||t.height<=0)return;const a=function(){if("undefined"==typeof window)return null;try{const e=m();if(!e)return null;const n=window.localStorage;if(!n)return null;const t=n.getItem(e);if(!t)return null;const r=JSON.parse(t),a=Number(r.x),i=Number(r.y);return Number.isFinite(a)&&Number.isFinite(i)?{x:a,y:i,docked:!0===r.docked,dockSide:"left"===r.dockSide||"right"===r.dockSide?r.dockSide:null}:null}catch(e){return null}}();if(a&&function(e){const t=f();return!(t.width<=0||t.height<=0)&&e.x>=0&&e.y>=0&&e.x+n<=t.width&&e.y+n<=t.height}(a))return r.launcherPos={x:a.x,y:a.y},r.launcherDocked=a.docked,r.launcherDockSide=a.docked?a.dockSide:null,void(r.launcherExpanded=!1);const i="left"===(null===(e=r.config)||void 0===e?void 0:e.position)?"left":"right";r.launcherPos={x:"left"===i?24:Math.max(0,t.width-n-24),y:Math.max(0,t.height-n-24)},r.launcherDocked=!1,r.launcherDockSide=null,r.launcherExpanded=!1}function p(){r.launcherPos||g()}function y(e){const t=f();return{x:Math.max(0,Math.min(Math.max(0,t.width-n),e.x)),y:Math.max(0,Math.min(Math.max(0,t.height-n),e.y))}}function x(){const e=r.button;if(!e)return;if(p(),!r.launcherPos)return;e.style.left=`${r.launcherPos.x}px`,e.style.top=`${r.launcherPos.y}px`;const n=r.launcherDocked&&!r.launcherExpanded&&!r.launcherDragging;if(n){const n=48;"right"===r.launcherDockSide?e.style.transform=`translate3d(${n}px, 0, 0)`:"left"===r.launcherDockSide?e.style.transform=`translate3d(${-n}px, 0, 0)`:e.style.transform="translate3d(0, 0, 0)"}else e.style.transform="translate3d(0, 0, 0)";if(r.dockLabel){const e=n;r.dockLabel.style.display=e?"flex":"none",e&&("right"===r.launcherDockSide?r.dockLabel.style.margin="0 auto 0 0":"left"===r.launcherDockSide?r.dockLabel.style.margin="0 0 0 auto":r.dockLabel.style.margin="0 auto")}if(r.launcherContent){const e=!n;r.launcherContent.style.display=e?"flex":"none"}}function w(){if(p(),r.launcherPos){if(r.launcherPos=y(r.launcherPos),r.launcherDocked){const e=f();"right"===r.launcherDockSide?r.launcherPos={x:Math.max(0,e.width-n),y:r.launcherPos.y}:"left"===r.launcherDockSide&&(r.launcherPos={x:0,y:r.launcherPos.y})}x()}}function v(){if(r.button)return r.button;const e=r.config;if(!e)return null;const t=document.createElement("button"),a=document.createElementNS("http://www.w3.org/2000/svg","svg"),i=document.createElement("span"),o=document.createElement("span"),l=document.createElement("span");var s;if(t.type="button",t.dataset.agentDeskWidget="launcher",t.setAttribute("aria-label",e.title||getDefaultWidgetTitle(e)),a.setAttribute("viewBox","0 0 24 24"),a.setAttribute("fill","none"),a.setAttribute("stroke","currentColor"),a.setAttribute("stroke-width","2"),a.setAttribute("stroke-linecap","round"),a.setAttribute("stroke-linejoin","round"),a.setAttribute("aria-hidden","true"),a.style.width="24px",a.style.height="24px",a.style.flex="0 0 auto",["M3 11a9 9 0 1 1 18 0","M3 11h3a2 2 0 0 1 2 2v3a2 2 0 0 1-2 2H5a2 2 0 0 1-2-2z","M21 11h-3a2 2 0 0 0-2 2v3a2 2 0 0 0 2 2h1a2 2 0 0 0 2-2z","M21 16v2a4 4 0 0 1-4 4h-5"].forEach(e=>{const n=document.createElementNS("http://www.w3.org/2000/svg","path");n.setAttribute("d",e),a.appendChild(n)}),i.textContent=getLauncherText(e),i.style.display="block",o.style.display="flex",o.style.flexDirection="column",o.style.alignItems="center",o.style.justifyContent="center",o.style.gap="4px",o.style.width="100%",o.style.height="100%",o.appendChild(a),o.appendChild(i),l.textContent=getLauncherText(e),l.style.display="none",l.style.flexDirection="column",l.style.alignItems="center",l.style.justifyContent="center",l.style.width="16px",l.style.height="100%",l.style.margin="0 auto",l.style.padding="0",l.style.fontSize="12px",l.style.lineHeight="1",l.style.fontWeight="600",l.style.letterSpacing="1px",l.style.color="#fff",l.style.whiteSpace="nowrap",l.style.writingMode="vertical-rl",l.style.textOrientation="upright",t.style.position="fixed",t.style.top="0px",t.style.left="0px",t.style.right="",t.style.bottom="",t.style.zIndex="2147483000",t.style.display="inline-flex",t.style.flexDirection="column",t.style.alignItems="center",t.style.justifyContent="center",t.style.gap="0",t.style.width="64px",t.style.height="64px",t.style.border="0",t.style.borderRadius="999px",t.style.padding="0",t.style.background=e.themeColor||"#0f6cbd",t.style.color="#fff",t.style.font="600 13px/1 sans-serif",t.style.boxShadow="0 18px 40px rgba(15, 35, 65, 0.24)",t.style.cursor="pointer",t.style.transition="transform 240ms cubic-bezier(0.22, 1, 0.36, 1), box-shadow 240ms ease, background 240ms ease",t.style.touchAction="none",t.appendChild(o),t.appendChild(l),r.launcherContent=o,r.dockLabel=l,g(),x(),function(e){e.addEventListener("pointerdown",n=>{if((0===n.button||"mouse"!==n.pointerType)&&(p(),r.launcherPos)){try{e.setPointerCapture(n.pointerId)}catch(e){}r.launcherDragging=!0,r.launcherMoved=!1,r.launcherDragStart={x:n.clientX,y:n.clientY,px:r.launcherPos.x,py:r.launcherPos.y},e.style.transition="none"}}),e.addEventListener("pointermove",e=>{if(!r.launcherDragging||!r.launcherDragStart||!r.launcherPos)return;const n=e.clientX-r.launcherDragStart.x,t=e.clientY-r.launcherDragStart.y;!r.launcherMoved&&Math.hypot(n,t)>6&&(r.launcherMoved=!0,r.launcherDocked&&!r.launcherExpanded&&(r.launcherExpanded=!0,x())),r.launcherMoved&&(r.launcherPos=y({x:r.launcherDragStart.px+n,y:r.launcherDragStart.py+t}),x())});const t=t=>{if(r.launcherDragging){r.launcherDragging=!1,r.launcherDragStart=null,e.style.transition="";try{e.releasePointerCapture(t.pointerId)}catch(e){}r.launcherMoved&&function(){if(!r.launcherPos)return;const e=f(),t=r.launcherPos,a=t.x,i=e.width-(t.x+n);i<=80&&i<=a?(r.launcherPos={x:Math.max(0,e.width-n),y:t.y},r.launcherDocked=!0,r.launcherDockSide="right",r.launcherExpanded=!1):a<=80?(r.launcherPos={x:0,y:t.y},r.launcherDocked=!0,r.launcherDockSide="left",r.launcherExpanded=!1):(r.launcherDocked=!1,r.launcherDockSide=null,r.launcherExpanded=!1),x(),r.launcherPos&&function(e,n,t){if("undefined"!=typeof window)try{const r=m();if(!r)return;const a=window.localStorage;if(!a)return;a.setItem(r,JSON.stringify({x:e.x,y:e.y,docked:!!n,dockSide:null!=t?t:null}))}catch(e){}}(r.launcherPos,r.launcherDocked,r.launcherDockSide)}()}};e.addEventListener("pointerup",t),e.addEventListener("pointercancel",t),e.addEventListener("pointerenter",()=>{r.launcherDocked&&!r.launcherDragging&&(r.launcherHoverTimer&&(window.clearTimeout(r.launcherHoverTimer),r.launcherHoverTimer=null),r.launcherExpanded||(r.launcherExpanded=!0,x()))}),e.addEventListener("pointerleave",()=>{r.launcherDocked&&r.launcherExpanded&&!r.launcherDragging&&(r.launcherHoverTimer&&window.clearTimeout(r.launcherHoverTimer),r.launcherHoverTimer=window.setTimeout(()=>{r.launcherExpanded=!1,r.launcherHoverTimer=null,x()},1500))})}(t),t.addEventListener("click",()=>{if(!r.launcherMoved)return r.isOpen?(r.isOpen=!1,void h()):void k();r.launcherMoved=!1}),r.launcherResizeHandler||(r.launcherResizeHandler=w,window.addEventListener("resize",r.launcherResizeHandler),window.addEventListener("orientationchange",r.launcherResizeHandler)),document.body.appendChild(t),r.button=t,s=()=>{p(),x()},"function"==typeof window.requestAnimationFrame?window.requestAnimationFrame(()=>{try{s()}catch(e){}}):window.setTimeout(s,0),"complete"!==document.readyState){const e=()=>{window.removeEventListener("load",e),p(),x()};window.addEventListener("load",e)}return t}function b(e){const n=e||window.AgentDeskConfig||{channelId:""};r.config=a(n);const t=i(r.config);n.baseUrl||(r.config.baseUrl=t),r.config.channelId?(r.configLoading=!0,function(e){const n=String(e.apiBaseUrl||e.baseUrl||"").replace(/\/$/,"");return n&&"function"==typeof fetch?fetch(`${n}/api/config`,{method:"GET",cache:"no-store"}).then(e=>e.json()).then(n=>{var t;return n&&!1!==n.success?a(Object.assign(Object.assign({},e),{language:(null===(t=n.data)||void 0===t?void 0:t.language)||e.language})):e}).catch(()=>e):Promise.resolve(e)}(r.config).then(e=>function(e){const n=String(e.apiBaseUrl||e.baseUrl||"").replace(/\/$/,"");if(!n||!e.channelId||"function"!=typeof fetch)return Promise.resolve(e);const t=`${n}/api/channel/config?channelId=${encodeURIComponent(e.channelId)}`;return fetch(t,{method:"GET",cache:"no-store",headers:{"X-Channel-Id":e.channelId}}).then(e=>e.json()).then(n=>n&&!1!==n.success?function(e,n){if(!n)return e;const t=Object.assign({},e);return["title","subtitle","themeColor","position","width"].forEach(e=>{const r=n[e];null!=r&&(t[e]=r)}),t}(e,n.data||{}):e).catch(()=>e)}(e)).then(e=>{var n;r.configLoading=!1,r.config=a(e),(null===(n=r.button)||void 0===n?void 0:n.parentNode)&&(r.button.parentNode.removeChild(r.button),r.button=null),v()})):console.error("[agent-desk-widget] channelId is required")}function k(){return l().then(()=>{r.frame||(r.frame?r.frame:r.frameUrl&&r.config&&(r.frame=document.createElement("iframe"),r.frame.dataset.agentDeskWidget="frame",r.frame.title=r.config.title||getDefaultWidgetTitle(r.config),r.frame.src=r.frameUrl.toString(),c(),r.frame.style.display="block",r.frame.style.visibility="hidden",r.frame.style.pointerEvents="none",r.frame.style.opacity="0",r.frame.style.transform="translate3d(0, 18px, 0) scale(0.96)",r.frame.addEventListener("load",()=>{r.frameLoaded=!0,h()}),document.body.appendChild(r.frame),r.frame)),r.frame&&(r.isOpen=!0,h())}).catch(e=>{console.error("[agent-desk-widget] open failed",e)})}t||(window.__CS_AI_AGENT_WIDGET_STATE__=r),window.AgentDeskWidget={mount:b,destroy:function(){var e,n;s(),r.launcherHoverTimer&&(window.clearTimeout(r.launcherHoverTimer),r.launcherHoverTimer=null),r.launcherResizeHandler&&(window.removeEventListener("resize",r.launcherResizeHandler),window.removeEventListener("orientationchange",r.launcherResizeHandler),r.launcherResizeHandler=null),(null===(e=r.frame)||void 0===e?void 0:e.parentNode)&&r.frame.parentNode.removeChild(r.frame),(null===(n=r.button)||void 0===n?void 0:n.parentNode)&&r.button.parentNode.removeChild(r.button),r.button=null,r.frame=null,r.frameLoaded=!1,r.frameReady=!1,r.initSent=!1,r.isOpen=!1,r.isMaximized=!1,r.configLoading=!1,r.frameConfig=null,r.frameUrl=null,r.launcherPos=null,r.launcherDragging=!1,r.launcherDragStart=null,r.launcherMoved=!1,r.launcherDocked=!1,r.launcherDockSide=null,r.launcherExpanded=!1,r.launcherContent=null,r.dockLabel=null},open:()=>k(),close:()=>{r.isOpen=!1,h()},getChatUrl:()=>{var e;return r.config||b(window.AgentDeskConfig||{channelId:""}),(null===(e=r.config)||void 0===e?void 0:e.channelId)?l().then(e=>e.toString()):Promise.reject(new Error("channelId is required"))}},r.listenerBound||(window.addEventListener("message",function(e){if(!r.frame||e.source!==r.frame.contentWindow)return;const n=e.data||{};return"agent-desk:ready"===n.type?(r.frameReady=!0,void u()):"agent-desk:request-minimize"===n.type?(r.isOpen=!1,void h()):void("agent-desk:request-close"!==n.type?"agent-desk:request-toggle-maximize"===n.type&&(r.isMaximized=!r.isMaximized,h()):r.frame&&(s(),r.frame.style.pointerEvents="none",r.frame.style.opacity="0",r.frame.style.transform="translate3d(0, 18px, 0) scale(0.94)",r.frame.style.visibility="hidden",r.frameDestroyTimer=window.setTimeout(()=>{r.frame&&(r.frame.parentNode&&r.frame.parentNode.removeChild(r.frame),r.frame=null,r.frameLoaded=!1,r.frameReady=!1,r.initSent=!1,r.isOpen=!1,r.isMaximized=!1,s())},r.animationDuration)))}),r.listenerBound=!0),window.AgentDeskConfig&&b(window.AgentDeskConfig)}();
From 8aabf2229b65d8440175cb5494e4fa61ae7092ce Mon Sep 17 00:00:00 2001
From: ExtremelyTroublesome
Date: Wed, 16 Sep 2026 11:34:05 +0800
Subject: [PATCH 9/9] =?UTF-8?q?=E9=87=8D=E6=9E=84=E4=BC=81=E4=B8=9A?=
=?UTF-8?q?=E5=BE=AE=E4=BF=A1=E5=AE=A2=E6=9C=8D=E8=B4=A6=E5=8F=B7=E6=8E=A5?=
=?UTF-8?q?=E5=85=A5=E5=8F=8A=E5=9B=9E=E5=A4=8D=E6=96=B9=E5=BC=8F=EF=BC=8C?=
=?UTF-8?q?=E6=94=AF=E6=8C=81=E5=A4=9A=E4=B8=AA=E5=AE=A2=E6=9C=8D=E5=8F=8A?=
=?UTF-8?q?=E5=90=84=E8=87=AA=E6=8E=A5=E5=BE=85AIAgent=E5=A4=84=E7=90=86?=
=?UTF-8?q?=E4=BC=9A=E8=AF=9D=E3=80=82?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit
---
.gitignore | 5 +
internal/ai/rag/vectordb/qdrant.go | 9 +-
internal/bootstrap/routes.go | 1 +
.../handlers/dashboard/channel_handler.go | 9 ++
internal/pkg/config/config.go | 48 ++++++
internal/pkg/dto/dto.go | 3 +
internal/pkg/dto/response/channel_response.go | 5 +
internal/pkg/i18nx/locales/en-US.yml | 2 +
internal/pkg/i18nx/locales/zh-CN.yml | 2 +
internal/pkg/logx/db_sink.go | 6 +-
internal/services/channel_service.go | 32 ++++
internal/services/conversation_service.go | 25 ++-
.../services/wxwork_kf_inbound_service.go | 29 +++-
.../wxwork_kf_message_read_test_service.go | 49 +++---
.../services/wxwork_kf_outbound_service.go | 26 ++--
internal/wxwork/login.go | 14 +-
internal/wxwork/wxwork.go | 82 +++++++---
.../dashboard/channels/_components/edit.tsx | 147 ++++++++++++++----
.../channels/_components/read-test-button.tsx | 2 +
web/lib/api/admin.ts | 8 +
web/messages/en-US.json | 6 +
web/messages/zh-CN.json | 6 +
22 files changed, 409 insertions(+), 107 deletions(-)
diff --git a/.gitignore b/.gitignore
index 6cea5dbe..49af5db4 100644
--- a/.gitignore
+++ b/.gitignore
@@ -2,7 +2,10 @@
.worktrees
.idea
.pnpm-store
+.trae/
+doc/
+logs/
data/
config/config.yaml
.env
@@ -24,3 +27,5 @@ agent-desk
test-reports
web/public/flowgram-editor/
+
+*.tar
\ No newline at end of file
diff --git a/internal/ai/rag/vectordb/qdrant.go b/internal/ai/rag/vectordb/qdrant.go
index 5c005c75..144917fb 100644
--- a/internal/ai/rag/vectordb/qdrant.go
+++ b/internal/ai/rag/vectordb/qdrant.go
@@ -29,10 +29,11 @@ func NewQdrantProvider(cfg *config.QdrantVectorDBConfig) (*QdrantProvider, error
}
client, err := qdrant.NewClient(&qdrant.Config{
- Host: host,
- Port: port,
- APIKey: cfg.APIKey,
- UseTLS: cfg.UseTLS,
+ Host: host,
+ Port: port,
+ APIKey: cfg.APIKey,
+ UseTLS: cfg.UseTLS,
+ SkipCompatibilityCheck: true,
})
if err != nil {
return nil, fmt.Errorf("failed to create qdrant client: %w", err)
diff --git a/internal/bootstrap/routes.go b/internal/bootstrap/routes.go
index d5961c10..e04e2ecf 100644
--- a/internal/bootstrap/routes.go
+++ b/internal/bootstrap/routes.go
@@ -224,6 +224,7 @@ func registerDashboardChannelRoutes(group *gin.RouterGroup) {
group.POST("/update", dashboard.ChannelPostUpdate)
group.POST("/update_status", dashboard.ChannelPostUpdate_status)
group.Any("/wxwork/kf/accounts", dashboard.ChannelAnyWxworkKfAccounts)
+ group.GET("/wxwork/api_apps", dashboard.ChannelAnyWxworkApiApps)
group.POST("/wxwork/kf/test_read_messages", dashboard.ChannelPostWxworkKfTest_read_messages)
group.Any("/wxwork/outbox/failed/list", dashboard.ChannelAnyWxworkOutboxFailedList)
group.POST("/wxwork/outbox/retry", dashboard.ChannelPostWxworkOutboxRetry)
diff --git a/internal/handlers/dashboard/channel_handler.go b/internal/handlers/dashboard/channel_handler.go
index 2c5e4014..847fdbfe 100644
--- a/internal/handlers/dashboard/channel_handler.go
+++ b/internal/handlers/dashboard/channel_handler.go
@@ -65,6 +65,15 @@ func ChannelAnyWxworkKfAccounts(ctx *gin.Context) {
httpx.WriteJSON(ctx, list)
}
+// ChannelAnyWxworkApiApps 返回配置文件中可用的企业微信应用（agentId），供渠道表单选择。
+func ChannelAnyWxworkApiApps(ctx *gin.Context) {
+ if _, err := services.AuthService.RequirePermission(ctx, constants.PermissionChannelView); err != nil {
+ httpx.WriteJSON(ctx, err)
+ return
+ }
+ httpx.WriteJSON(ctx, services.ChannelService.ListWxWorkApiApps())
+}
+
// ChannelPostWxworkKfTest_read_messages 测试企业微信客服渠道能否读取近 3 天的消息与事件。
// 只读操作，使用 channel.view 权限；失败原因以结构化结果返回，不抛 JsonResult 错误。
func ChannelPostWxworkKfTest_read_messages(ctx *gin.Context) {
diff --git a/internal/pkg/config/config.go b/internal/pkg/config/config.go
index cbfff40e..b47e12e8 100644
--- a/internal/pkg/config/config.go
+++ b/internal/pkg/config/config.go
@@ -46,6 +46,15 @@ type WxWorkNotifyConfig struct {
DuplicateCheckInterval int `yaml:"duplicateCheckInterval"`
}
+// WxWorkApiAppConfig 定义一个企业微信自建应用（agentId + corpSecret）。
+// 不同应用的 corpSecret 换取各自独立的 access_token，必须按应用分开缓存与使用。
+type WxWorkApiAppConfig struct {
+ // AgentID 为企业微信自建应用 AgentID。
+ AgentID string `yaml:"agentId"`
+ // CorpSecret 为该应用的 Secret，用于换取该应用的 access_token。
+ CorpSecret string `yaml:"corpSecret"`
+}
+
type ServerConfig struct {
Port int `yaml:"port"`
CompanyName string `yaml:"companyName"`
@@ -203,9 +212,14 @@ type WxWorkConfig struct {
// CorpID 为企业微信公司 ID，例如 wwxxxxxxxxxxxxxxxx。
CorpID string `yaml:"corpId"`
// CorpSecret 为企业微信应用 Secret，用于换取 access_token。
+ // 仅用于单应用的旧配置；多应用场景请使用 APIApps。
CorpSecret string `yaml:"corpSecret"`
// AgentID 为企业微信自建应用 AgentID。
+ // 仅用于单应用的旧配置；多应用场景请使用 APIApps。
AgentID string `yaml:"agentId"`
+ // APIApps 为可用的企业微信自建应用列表，每项包含 agentId 与对应 corpSecret。
+ // 接入渠道按 agentId 选择应用，使用该应用的 corpSecret 换取独立 access_token。
+ APIApps []WxWorkApiAppConfig `yaml:"apiApps"`
// OAuthRedirect 为企业微信网页授权回调地址。
// 必须填写完整 URL，且通常指向后端接口 /api/auth/wxwork/callback。
OAuthRedirect string `yaml:"oauthRedirect"`
@@ -225,6 +239,40 @@ type WxWorkConfig struct {
Notify WxWorkNotifyConfig `yaml:"notify"`
}
+// NormalizedAPIApps 返回去除空白并过滤掉不完整项后的 apiApps。
+// 当 apiApps 为空且配置了顶层 corpSecret 时，回退为单应用列表，兼容旧配置。
+func (c WxWorkConfig) NormalizedAPIApps() []WxWorkApiAppConfig {
+ apps := make([]WxWorkApiAppConfig, 0, len(c.APIApps))
+ for _, app := range c.APIApps {
+ agentID := strings.TrimSpace(app.AgentID)
+ corpSecret := strings.TrimSpace(app.CorpSecret)
+ if agentID == "" || corpSecret == "" {
+ continue
+ }
+ apps = append(apps, WxWorkApiAppConfig{AgentID: agentID, CorpSecret: corpSecret})
+ }
+ if len(apps) == 0 {
+ if corpSecret := strings.TrimSpace(c.CorpSecret); corpSecret != "" {
+ apps = append(apps, WxWorkApiAppConfig{
+ AgentID: strings.TrimSpace(c.AgentID),
+ CorpSecret: corpSecret,
+ })
+ }
+ }
+ return apps
+}
+
+// FindAPIApp 按 agentID 查找已配置的应用。
+func (c WxWorkConfig) FindAPIApp(agentID string) (WxWorkApiAppConfig, bool) {
+ agentID = strings.TrimSpace(agentID)
+ for _, app := range c.NormalizedAPIApps() {
+ if app.AgentID == agentID {
+ return app, true
+ }
+ }
+ return WxWorkApiAppConfig{}, false
+}
+
type WebhookConfig struct {
OrgSyncSecret string `yaml:"orgSyncSecret"`
DOSOrgSyncSecret string `yaml:"dosOrgSyncSecret"`
diff --git a/internal/pkg/dto/dto.go b/internal/pkg/dto/dto.go
index 85b1f002..6f91c84a 100644
--- a/internal/pkg/dto/dto.go
+++ b/internal/pkg/dto/dto.go
@@ -15,6 +15,9 @@ type AuthPrincipal struct {
type WxWorkKFChannelConfig struct {
OpenKfID string `json:"openKfId"`
+ // AgentID 指定该渠道使用的企业微信自建应用。
+ // 系统据此找到对应的 corpSecret，换取并缓存该应用独立的 accessToken。
+ AgentID string `json:"agentId"`
}
type WebChannelConfig struct {
diff --git a/internal/pkg/dto/response/channel_response.go b/internal/pkg/dto/response/channel_response.go
index e2a25a3d..1009bfb7 100644
--- a/internal/pkg/dto/response/channel_response.go
+++ b/internal/pkg/dto/response/channel_response.go
@@ -30,6 +30,11 @@ type WxWorkKFAccountResponse struct {
ManagePrivilege bool `json:"managePrivilege"`
}
+// WxWorkApiAppResponse 为配置文件中可用的企业微信应用。
+type WxWorkApiAppResponse struct {
+ AgentID string `json:"agentId"`
+}
+
type ChannelMessageOutboxResponse struct {
ID int64 `json:"id"`
ChannelType string `json:"channelType"`
diff --git a/internal/pkg/i18nx/locales/en-US.yml b/internal/pkg/i18nx/locales/en-US.yml
index 0e4469d2..801247ab 100644
--- a/internal/pkg/i18nx/locales/en-US.yml
+++ b/internal/pkg/i18nx/locales/en-US.yml
@@ -377,6 +377,8 @@ error.wxwork.userIDTaken: "The WeCom user ID is already used as a system usernam
error.wxwork.mobileTaken: "The WeCom mobile number is already used by a system user."
error.wxwork.emailTaken: "The WeCom email address is already used by a system user."
error.wxwork.configIncomplete: "WeCom is not enabled or its configuration is incomplete."
+error.wxwork.appNotConfigured: "The WeCom app is not configured or enabled, agentId: %s"
+error.wxwork.agentIdRequired: "Please select a WeCom app (agentId)."
error.customerSession.secretMissing: "Customer session secret is not configured."
error.conversation.createFailed: "Failed to create conversation."
error.conversation.tagNotFound: "Tag not found."
diff --git a/internal/pkg/i18nx/locales/zh-CN.yml b/internal/pkg/i18nx/locales/zh-CN.yml
index 1b1cc564..c50106df 100644
--- a/internal/pkg/i18nx/locales/zh-CN.yml
+++ b/internal/pkg/i18nx/locales/zh-CN.yml
@@ -377,6 +377,8 @@ error.wxwork.userIDTaken: "企业微信用户ID已被系统用户名占用"
error.wxwork.mobileTaken: "企业微信手机号已被系统用户占用"
error.wxwork.emailTaken: "企业微信邮箱已被系统用户占用"
error.wxwork.configIncomplete: "企业微信未启用或配置不完整"
+error.wxwork.appNotConfigured: "企业微信应用未配置或未启用，agentId: %s"
+error.wxwork.agentIdRequired: "请选择企业微信应用（agentId）"
error.customerSession.secretMissing: "客服会话密钥未配置"
error.conversation.createFailed: "创建会话失败"
error.conversation.tagNotFound: "标签不存在"
diff --git a/internal/pkg/logx/db_sink.go b/internal/pkg/logx/db_sink.go
index 1f34d3ee..e670cb90 100644
--- a/internal/pkg/logx/db_sink.go
+++ b/internal/pkg/logx/db_sink.go
@@ -22,7 +22,7 @@ const (
dbSinkFlushInterval = 1 * time.Second
)
-// dbSink 包装底层 stdout handler，并将 INFO/WARN/ERROR 级别日志异步写入数据库。
+// dbSink 包装底层 stdout handler，并将 WARN/ERROR 级别日志异步写入数据库。
type dbSink struct {
inner slog.Handler
@@ -79,8 +79,8 @@ func (h *dbSink) Handle(ctx context.Context, r slog.Record) error {
return err
}
- // 只持久化 INFO 及以上级别（DEBUG 不写库）
- if r.Level < slog.LevelInfo {
+ // 只持久化 WARN 及以上级别（DEBUG/INFO 不写库）
+ if r.Level < slog.LevelWarn {
return nil
}
diff --git a/internal/services/channel_service.go b/internal/services/channel_service.go
index 452e9c53..6cb59179 100644
--- a/internal/services/channel_service.go
+++ b/internal/services/channel_service.go
@@ -2,6 +2,7 @@ package services
import (
"agent-desk/internal/models"
+ "agent-desk/internal/pkg/config"
"agent-desk/internal/pkg/dto"
"agent-desk/internal/pkg/dto/request"
"agent-desk/internal/pkg/dto/response"
@@ -22,6 +23,7 @@ import (
"github.com/gin-gonic/gin"
"github.com/mlogclub/simple/common/strs"
"github.com/mlogclub/simple/sqls"
+ "github.com/silenceper/wechat/v2/work"
"github.com/silenceper/wechat/v2/work/kf"
)
@@ -196,9 +198,33 @@ func (s *channelService) ParseWxWorkKFChannelConfig(raw string) (*dto.WxWorkKFCh
return nil, err
}
cfg.OpenKfID = strings.TrimSpace(cfg.OpenKfID)
+ cfg.AgentID = strings.TrimSpace(cfg.AgentID)
return cfg, nil
}
+// GetWxWorkCliByChannel 返回渠道绑定 agentId 对应的企微客户端。
+// 不同渠道可绑定不同应用，客户端与 access_token 均按应用隔离。
+func (s *channelService) GetWxWorkCliByChannel(channel *models.Channel) (*work.Work, error) {
+ if channel == nil {
+ return nil, errorsx.InvalidParamI18n("error.wxwork.appNotConfigured", "")
+ }
+ cfg, err := s.ParseWxWorkKFChannelConfig(channel.ConfigJSON)
+ if err != nil {
+ return nil, err
+ }
+ return wxwork.GetWorkCliByAgentID(cfg.AgentID)
+}
+
+// ListWxWorkApiApps 返回配置文件中可用的企业微信应用（agentId 列表），供渠道表单选择。
+func (s *channelService) ListWxWorkApiApps() []response.WxWorkApiAppResponse {
+ apps := config.Current().WxWork.NormalizedAPIApps()
+ ret := make([]response.WxWorkApiAppResponse, 0, len(apps))
+ for _, app := range apps {
+ ret = append(ret, response.WxWorkApiAppResponse{AgentID: app.AgentID})
+ }
+ return ret
+}
+
func (s *channelService) ListWxWorkKFAccounts() ([]response.WxWorkKFAccountResponse, error) {
if !wxwork.Enabled() || wxwork.GetWorkCli() == nil {
return nil, errorsx.BusinessErrorI18n(1, "error.wxwork.configIncomplete")
@@ -553,6 +579,12 @@ func (s *channelService) buildChannelModel(id int64, req request.CreateChannelRe
if cfg == nil || cfg.OpenKfID == "" {
return nil, errorsx.InvalidParamI18n("error.e0103")
}
+ if cfg.AgentID == "" {
+ return nil, errorsx.InvalidParamI18n("error.wxwork.agentIdRequired")
+ }
+ if _, err := wxwork.GetWorkCliByAgentID(cfg.AgentID); err != nil {
+ return nil, err
+ }
if channel := s.GetEnabledWxWorkKFChannelByOpenKfID(cfg.OpenKfID); channel != nil && channel.ID != id {
return nil, errorsx.InvalidParamI18n("error.e0069")
}
diff --git a/internal/services/conversation_service.go b/internal/services/conversation_service.go
index b4db8067..d866620b 100644
--- a/internal/services/conversation_service.go
+++ b/internal/services/conversation_service.go
@@ -85,12 +85,13 @@ func (s *conversationService) Updates(id int64, columns map[string]interface{})
return repositories.ConversationRepository.Updates(sqls.DB(), id, columns)
}
-func (s *conversationService) getLatestNotFinishedByCustomerID(db *gorm.DB, customerID int64) *models.Conversation {
+func (s *conversationService) getLatestNotFinishedByCustomerID(db *gorm.DB, customerID, channelID int64) *models.Conversation {
if customerID <= 0 {
return nil
}
cnd := sqls.NewCnd()
cnd.Eq("customer_id", customerID)
+ cnd.Eq("channel_id", channelID)
cnd.In("status", []enums.IMConversationStatus{
enums.IMConversationStatusAIServing,
enums.IMConversationStatusPending,
@@ -115,15 +116,27 @@ func (s *conversationService) Create(externalUser openidentity.ExternalUser, cha
return err
}
customerName := s.getCustomerName(ctx.Tx, customerID)
- if existing := s.getLatestNotFinishedByCustomerID(ctx.Tx, customerID); existing != nil {
+ if existing := s.getLatestNotFinishedByCustomerID(ctx.Tx, customerID, channelID); existing != nil {
conversation = existing
+ updates := map[string]any{"updated_at": time.Now()}
if customerName != "" && existing.CustomerName != customerName {
- if err := repositories.ConversationRepository.Updates(ctx.Tx, existing.ID, map[string]any{
- "customer_name": customerName,
- "updated_at": time.Now(),
- }); err != nil {
+ updates["customer_name"] = customerName
+ }
+ // 渠道绑定的 Agent 可能变更，复用会话时同步 Agent 及服务模式
+ if existing.AIAgentID != aiAgentID {
+ updates["ai_agent_id"] = aiAgentID
+ updates["service_mode"] = aiAgent.ServiceMode
+ updates["status"] = s.resolveInitialStatus(aiAgent.ServiceMode)
+ }
+ if len(updates) > 1 {
+ if err := repositories.ConversationRepository.Updates(ctx.Tx, existing.ID, updates); err != nil {
return err
}
+ conversation.AIAgentID = aiAgentID
+ conversation.ServiceMode = aiAgent.ServiceMode
+ conversation.Status = s.resolveInitialStatus(aiAgent.ServiceMode)
+ conversation.CustomerName = customerName
+ } else if customerName != "" {
conversation.CustomerName = customerName
}
return nil
diff --git a/internal/services/wxwork_kf_inbound_service.go b/internal/services/wxwork_kf_inbound_service.go
index 053c2580..3978f3a2 100644
--- a/internal/services/wxwork_kf_inbound_service.go
+++ b/internal/services/wxwork_kf_inbound_service.go
@@ -10,7 +10,6 @@ import (
"agent-desk/internal/pkg/enums"
"agent-desk/internal/pkg/errorsx"
"agent-desk/internal/pkg/openidentity"
- "agent-desk/internal/wxwork"
"github.com/mlogclub/simple/common/strs"
"github.com/silenceper/wechat/v2/work/kf"
@@ -31,8 +30,21 @@ func newWxWorkKFInboundService() *wxWorkKFInboundService {
type wxWorkKFInboundService struct {
}
+// kfClientByOpenKfID 按 openKfID 找到启用渠道，并返回该渠道绑定应用的客服客户端。
+func (s *wxWorkKFInboundService) kfClientByOpenKfID(openKfID string) (*kf.Client, error) {
+ channel := ChannelService.GetEnabledWxWorkKFChannelByOpenKfID(openKfID)
+ if channel == nil {
+ return nil, errorsx.InvalidParamI18n("error.e0231")
+ }
+ workCli, err := ChannelService.GetWxWorkCliByChannel(channel)
+ if err != nil {
+ return nil, err
+ }
+ return workCli.GetKF()
+}
+
func (s *wxWorkKFInboundService) SyncCallbackMessages(message kf.CallbackMessage) error {
- cli, err := wxwork.GetWorkCli().GetKF()
+ cli, err := s.kfClientByOpenKfID(message.OpenKfID)
if err != nil {
return err
}
@@ -139,7 +151,7 @@ func (s *wxWorkKFInboundService) handleImageMessage(item syncmsg.Message) error
if err != nil {
return err
}
- canonicalPayload, content, err := s.buildInboundAssetPayload(conversation.ID, strings.TrimSpace(payload.Image.MediaID))
+ canonicalPayload, content, err := s.buildInboundAssetPayload(conversation, strings.TrimSpace(payload.Image.MediaID))
if err != nil {
return err
}
@@ -169,7 +181,7 @@ func (s *wxWorkKFInboundService) handleFileMessage(item syncmsg.Message) error {
if err != nil {
return err
}
- canonicalPayload, content, err := s.buildInboundAssetPayload(conversation.ID, strings.TrimSpace(payload.File.MediaID))
+ canonicalPayload, content, err := s.buildInboundAssetPayload(conversation, strings.TrimSpace(payload.File.MediaID))
if err != nil {
return err
}
@@ -514,12 +526,17 @@ func (s *wxWorkKFInboundService) appendConversationEvent(conversationID int64, c
})
}
-func (s *wxWorkKFInboundService) buildInboundAssetPayload(conversationID int64, mediaID string) (string, string, error) {
+func (s *wxWorkKFInboundService) buildInboundAssetPayload(conversation *models.Conversation, mediaID string) (string, string, error) {
mediaID = strings.TrimSpace(mediaID)
if mediaID == "" {
return "", "", errorsx.InvalidParamI18n("error.e0095")
}
- materialCli := wxwork.GetWorkCli().GetMaterial()
+ channel := ChannelService.Get(conversation.ChannelID)
+ workCli, err := ChannelService.GetWxWorkCliByChannel(channel)
+ if err != nil {
+ return "", "", err
+ }
+ materialCli := workCli.GetMaterial()
data, err := materialCli.GetTempFile(mediaID)
if err != nil {
return "", "", err
diff --git a/internal/services/wxwork_kf_message_read_test_service.go b/internal/services/wxwork_kf_message_read_test_service.go
index 993b63fa..d2c9cd4a 100644
--- a/internal/services/wxwork_kf_message_read_test_service.go
+++ b/internal/services/wxwork_kf_message_read_test_service.go
@@ -30,18 +30,19 @@ const (
wxWorkReadTestStageSyncMsg = "syncmsg"
// 本地错误码（非企业微信返回），前端按这些码做本地化排查建议。
- wxWorkReadTestErrInvalidChannel = "INVALID_CHANNEL"
- wxWorkReadTestErrOpenKFMissing = "OPENKFID_MISSING"
- wxWorkReadTestErrConfigJSON = "INVALID_CONFIG_JSON"
- wxWorkReadTestErrDisabled = "WXWORK_DISABLED"
- wxWorkReadTestErrNetwork = "NETWORK_ERROR"
- wxWorkReadTestErrBadResponse = "BAD_RESPONSE"
+ wxWorkReadTestErrInvalidChannel = "INVALID_CHANNEL"
+ wxWorkReadTestErrOpenKFMissing = "OPENKFID_MISSING"
+ wxWorkReadTestErrAgentIDMissing = "AGENTID_MISSING"
+ wxWorkReadTestErrAppNotConfigured = "AGENTID_NOT_CONFIGURED"
+ wxWorkReadTestErrConfigJSON = "INVALID_CONFIG_JSON"
+ wxWorkReadTestErrNetwork = "NETWORK_ERROR"
+ wxWorkReadTestErrBadResponse = "BAD_RESPONSE"
wxWorkReadTestSyncLimit uint64 = 1000 // 单次 sync_msg 拉取条数（官方最大值）
- wxWorkReadTestMaxPages = 5 // 最多翻页次数，限制测试请求耗时
- wxWorkReadTestSampleSize = 20 // 返回最近样例条数
- wxWorkReadTestMaxPreviewRunes = 500 // 文本样例最大字符数
- wxWorkReadTestHTTPTimeout = 10 * time.Second
+ wxWorkReadTestMaxPages = 5 // 最多翻页次数，限制测试请求耗时
+ wxWorkReadTestSampleSize = 20 // 返回最近样例条数
+ wxWorkReadTestMaxPreviewRunes = 500 // 文本样例最大字符数
+ wxWorkReadTestHTTPTimeout = 10 * time.Second
)
var wxWorkReadTestHTTPClient = &http.Client{Timeout: wxWorkReadTestHTTPTimeout}
@@ -60,10 +61,10 @@ type wxWorkReadTestSyncRequest struct {
}
type wxWorkReadTestSyncResponse struct {
- ErrCode int64 `json:"errcode"`
- ErrMsg string `json:"errmsg"`
- NextCursor string `json:"next_cursor"`
- HasMore uint32 `json:"has_more"`
+ ErrCode int64 `json:"errcode"`
+ ErrMsg string `json:"errmsg"`
+ NextCursor string `json:"next_cursor"`
+ HasMore uint32 `json:"has_more"`
MsgList []map[string]any `json:"msg_list"`
}
@@ -76,21 +77,25 @@ func (s *channelService) TestWxWorkKFReadMessages(channelID int64) (*response.Wx
return s.failReadTestResult("", wxWorkReadTestErrInvalidChannel, ""), nil
}
- openKfID := ""
- if cfg, err := s.ParseWxWorkKFChannelConfig(channel.ConfigJSON); err != nil {
- return s.failReadTestResult("", wxWorkReadTestErrConfigJSON, err.Error()), nil
- } else if cfg != nil {
- openKfID = cfg.OpenKfID
+ kfCfg, cfgErr := s.ParseWxWorkKFChannelConfig(channel.ConfigJSON)
+ if cfgErr != nil {
+ return s.failReadTestResult("", wxWorkReadTestErrConfigJSON, cfgErr.Error()), nil
}
+ openKfID := strings.TrimSpace(kfCfg.OpenKfID)
if openKfID == "" {
return s.failReadTestResult("", wxWorkReadTestErrOpenKFMissing, ""), nil
}
+ agentID := strings.TrimSpace(kfCfg.AgentID)
+ if agentID == "" {
+ return s.failReadTestResult("", wxWorkReadTestErrAgentIDMissing, ""), nil
+ }
wxConfig := config.Current().WxWork
corpID := strings.TrimSpace(wxConfig.CorpID)
- corpSecret := strings.TrimSpace(wxConfig.CorpSecret)
- if !wxConfig.Enabled || corpID == "" || corpSecret == "" {
- return s.failReadTestResult("", wxWorkReadTestErrDisabled, ""), nil
+ app, appFound := wxConfig.FindAPIApp(agentID)
+ corpSecret := strings.TrimSpace(app.CorpSecret)
+ if !wxConfig.Enabled || corpID == "" || !appFound || corpSecret == "" {
+ return s.failReadTestResult("", wxWorkReadTestErrAppNotConfigured, agentID), nil
}
// 1. 获取 access_token（独立调用，不接触 SDK 令牌缓存；人工测试频率低，可接受）
diff --git a/internal/services/wxwork_kf_outbound_service.go b/internal/services/wxwork_kf_outbound_service.go
index e2f428a5..3180ee1c 100644
--- a/internal/services/wxwork_kf_outbound_service.go
+++ b/internal/services/wxwork_kf_outbound_service.go
@@ -168,7 +168,7 @@ func (s *wxWorkKFOutboundService) processOutbox(outboxID int64) error {
wxMsgIDs := make([]string, 0, len(chunks))
for i := range chunks {
- wxMsgID, sendErr := s.sendOutboundChunk(mapping, message, chunks[i], i)
+ wxMsgID, sendErr := s.sendOutboundChunk(channel, mapping, message, chunks[i], i)
if sendErr != nil {
return s.markOutboxFailed(outbox, sendErr.Error())
}
@@ -229,19 +229,23 @@ func (s *wxWorkKFOutboundService) processOutbox(outboxID int64) error {
})
}
-func (s *wxWorkKFOutboundService) sendOutboundChunk(mapping *models.WxWorkKFConversation, message *models.Message, chunk wxWorkKFOutboundChunk, chunkIndex int) (string, error) {
+func (s *wxWorkKFOutboundService) sendOutboundChunk(channel *models.Channel, mapping *models.WxWorkKFConversation, message *models.Message, chunk wxWorkKFOutboundChunk, chunkIndex int) (string, error) {
switch chunk.MessageType {
case enums.IMMessageTypeText:
- return s.sendTextMessage(mapping, message, chunk.Content, chunkIndex)
+ return s.sendTextMessage(channel, mapping, message, chunk.Content, chunkIndex)
case enums.IMMessageTypeImage:
- return s.sendImageMessage(mapping, message, chunk, chunkIndex)
+ return s.sendImageMessage(channel, mapping, message, chunk, chunkIndex)
default:
return "", i18nx.Errorf("error.wxwork.unsupportedOutboundMessageType", chunk.MessageType)
}
}
-func (s *wxWorkKFOutboundService) sendTextMessage(mapping *models.WxWorkKFConversation, message *models.Message, content string, chunkIndex int) (string, error) {
- cli, err := wxwork.GetWorkCli().GetKF()
+func (s *wxWorkKFOutboundService) sendTextMessage(channel *models.Channel, mapping *models.WxWorkKFConversation, message *models.Message, content string, chunkIndex int) (string, error) {
+ workCli, err := ChannelService.GetWxWorkCliByChannel(channel)
+ if err != nil {
+ return "", err
+ }
+ cli, err := workCli.GetKF()
if err != nil {
return "", err
}
@@ -282,7 +286,7 @@ func (s *wxWorkKFOutboundService) sendTextMessage(mapping *models.WxWorkKFConver
return strings.TrimSpace(resp.MsgID), nil
}
-func (s *wxWorkKFOutboundService) sendImageMessage(mapping *models.WxWorkKFConversation, message *models.Message, chunk wxWorkKFOutboundChunk, chunkIndex int) (string, error) {
+func (s *wxWorkKFOutboundService) sendImageMessage(channel *models.Channel, mapping *models.WxWorkKFConversation, message *models.Message, chunk wxWorkKFOutboundChunk, chunkIndex int) (string, error) {
if strings.TrimSpace(chunk.AssetID) == "" {
return "", i18nx.Errorf("error.e0145")
}
@@ -312,7 +316,11 @@ func (s *wxWorkKFOutboundService) sendImageMessage(mapping *models.WxWorkKFConve
"external_userid", mapping.ExternalUserID,
)
- materialCli := wxwork.GetWorkCli().GetMaterial()
+ workCli, err := ChannelService.GetWxWorkCliByChannel(channel)
+ if err != nil {
+ return "", err
+ }
+ materialCli := workCli.GetMaterial()
uploadResp, err := materialCli.UploadTempFileFromReader(asset.Filename, "image", fileReader)
if err != nil {
return "", err
@@ -321,7 +329,7 @@ func (s *wxWorkKFOutboundService) sendImageMessage(mapping *models.WxWorkKFConve
return "", i18nx.Errorf("error.e0113")
}
- kfCli, err := wxwork.GetWorkCli().GetKF()
+ kfCli, err := workCli.GetKF()
if err != nil {
return "", err
}
diff --git a/internal/wxwork/login.go b/internal/wxwork/login.go
index d7044f2b..afb2f222 100644
--- a/internal/wxwork/login.go
+++ b/internal/wxwork/login.go
@@ -48,14 +48,15 @@ func BuildLoginURL(state string) (string, error) {
if strings.TrimSpace(wxCfg.OAuthRedirect) == "" {
return "", i18nx.Errorf("error.e0107")
}
- if strings.TrimSpace(wxCfg.AgentID) == "" {
+ agentID := DefaultAgentID()
+ if strings.TrimSpace(agentID) == "" {
return "", i18nx.Errorf("error.e0093")
}
return fmt.Sprintf(
"https://open.weixin.qq.com/connect/oauth2/authorize?appid=%s&redirect_uri=%s&response_type=code&scope=snsapi_privateinfo&agentid=%s&state=%s#wechat_redirect",
url.QueryEscape(strings.TrimSpace(wxCfg.CorpID)),
url.QueryEscape(strings.TrimSpace(wxCfg.OAuthRedirect)),
- url.QueryEscape(strings.TrimSpace(wxCfg.AgentID)),
+ url.QueryEscape(strings.TrimSpace(agentID)),
url.QueryEscape(strings.TrimSpace(state)),
), nil
}
@@ -67,13 +68,14 @@ func BuildQRCodeLoginURL(state string) (string, error) {
if strings.TrimSpace(wxCfg.OAuthRedirect) == "" {
return "", i18nx.Errorf("error.e0107")
}
- if strings.TrimSpace(wxCfg.AgentID) == "" {
+ agentID := DefaultAgentID()
+ if strings.TrimSpace(agentID) == "" {
return "", i18nx.Errorf("error.e0093")
}
return fmt.Sprintf(
"https://open.work.weixin.qq.com/wwopen/sso/qrConnect?appid=%s&agentid=%s&redirect_uri=%s&state=%s",
url.QueryEscape(strings.TrimSpace(wxCfg.CorpID)),
- url.QueryEscape(strings.TrimSpace(wxCfg.AgentID)),
+ url.QueryEscape(strings.TrimSpace(agentID)),
url.QueryEscape(strings.TrimSpace(wxCfg.OAuthRedirect)),
url.QueryEscape(strings.TrimSpace(state)),
), nil
@@ -202,7 +204,7 @@ func GetUserDetail(code string) (*LoginUser, error) {
return nil, i18nx.Errorf("error.e0202")
}
- oauthClient := w.GetOauth()
+ oauthClient := defaultWork.GetOauth()
userInfo, err := oauthClient.GetUserInfo(code)
if err != nil {
return nil, err
@@ -230,7 +232,7 @@ func GetUserDetail(code string) (*LoginUser, error) {
}
}
- if profile, profileErr := w.GetAddressList().UserGet(ret.UserID); profileErr == nil {
+ if profile, profileErr := defaultWork.GetAddressList().UserGet(ret.UserID); profileErr == nil {
ret.UserProfile = profile
if strings.TrimSpace(profile.Name) != "" {
ret.Name = strings.TrimSpace(profile.Name)
diff --git a/internal/wxwork/wxwork.go b/internal/wxwork/wxwork.go
index 6525ad68..1364a4d9 100644
--- a/internal/wxwork/wxwork.go
+++ b/internal/wxwork/wxwork.go
@@ -2,6 +2,7 @@ package wxwork
import (
"agent-desk/internal/pkg/config"
+ "agent-desk/internal/pkg/i18nx"
"strings"
"github.com/silenceper/wechat/v2/cache"
@@ -12,8 +13,9 @@ import (
)
var (
- w *work.Work
- wxCfg config.WxWorkConfig
+ defaultWork *work.Work
+ appWorks map[string]*work.Work
+ wxCfg config.WxWorkConfig
)
type LoginUser struct {
@@ -33,38 +35,82 @@ type LoginUser struct {
}
func Init() {
- w = nil
+ defaultWork = nil
+ appWorks = nil
wxCfg = config.WxWorkConfig{}
cfg := config.Current()
if !cfg.WxWork.Enabled {
return
}
wxCfg = cfg.WxWork
- if strings.TrimSpace(wxCfg.CorpID) == "" || strings.TrimSpace(wxCfg.CorpSecret) == "" {
+ if strings.TrimSpace(wxCfg.CorpID) == "" {
return
}
- w = work.NewWork(&wxconfig.Config{
- CorpID: wxCfg.CorpID,
- CorpSecret: wxCfg.CorpSecret,
- AgentID: wxCfg.AgentID,
- RasPrivateKey: wxCfg.RSAPrivateKey,
- Token: wxCfg.Token,
- EncodingAESKey: wxCfg.EncodingAESKey,
- Cache: cache.NewMemory(),
- })
+ apps := wxCfg.NormalizedAPIApps()
+ if len(apps) == 0 {
+ return
+ }
+
+ // 每个应用使用各自的 corpSecret 构建独立客户端，
+ // SDK 令牌缓存随客户端实例隔离，不同应用的 access_token 天然分开缓存。
+ appWorks = make(map[string]*work.Work, len(apps))
+ for i := range apps {
+ app := apps[i]
+ cli := work.NewWork(&wxconfig.Config{
+ CorpID: wxCfg.CorpID,
+ CorpSecret: app.CorpSecret,
+ AgentID: app.AgentID,
+ RasPrivateKey: wxCfg.RSAPrivateKey,
+ Token: wxCfg.Token,
+ EncodingAESKey: wxCfg.EncodingAESKey,
+ Cache: cache.NewMemory(),
+ })
+ appWorks[app.AgentID] = cli
+ if defaultWork == nil {
+ defaultWork = cli
+ }
+ }
}
func Enabled() bool {
- return w != nil && wxCfg.Enabled
+ return defaultWork != nil && wxCfg.Enabled
}
func StateSecret() string {
- if strings.TrimSpace(wxCfg.StateSecret) != "" {
- return strings.TrimSpace(wxCfg.StateSecret)
+ if secret := strings.TrimSpace(wxCfg.StateSecret); secret != "" {
+ return secret
}
- return strings.TrimSpace(wxCfg.CorpSecret)
+ if secret := strings.TrimSpace(wxCfg.CorpSecret); secret != "" {
+ return secret
+ }
+ if apps := wxCfg.NormalizedAPIApps(); len(apps) > 0 {
+ return strings.TrimSpace(apps[0].CorpSecret)
+ }
+ return ""
}
func GetWorkCli() *work.Work {
- return w
+ return defaultWork
+}
+
+// GetWorkCliByAgentID 按 agentId 返回对应应用的企微客户端；
+// 各应用客户端持有独立的 corpSecret 与 token 缓存，不能混用。
+func GetWorkCliByAgentID(agentID string) (*work.Work, error) {
+ agentID = strings.TrimSpace(agentID)
+ if cli := appWorks[agentID]; cli != nil {
+ return cli, nil
+ }
+ return nil, i18nx.Errorf("error.wxwork.appNotConfigured", agentID)
+}
+
+// DefaultAgentID 返回默认（第一个已配置）应用的 agentId；
+// 供 OAuth 登录等不区分具体应用的流程使用。
+func DefaultAgentID() string {
+ if agentID := strings.TrimSpace(wxCfg.AgentID); agentID != "" {
+ return agentID
+ }
+ if apps := wxCfg.NormalizedAPIApps(); len(apps) > 0 {
+ return strings.TrimSpace(apps[0].AgentID)
+ }
+ return ""
}
diff --git a/web/app/(dashboard)/dashboard/channels/_components/edit.tsx b/web/app/(dashboard)/dashboard/channels/_components/edit.tsx
index c1631b5d..cf44e6bc 100644
--- a/web/app/(dashboard)/dashboard/channels/_components/edit.tsx
+++ b/web/app/(dashboard)/dashboard/channels/_components/edit.tsx
@@ -23,9 +23,11 @@ import {
type AIAgent,
type AdminChannel,
type CreateAdminChannelPayload,
+ type WxWorkApiApp,
type WxWorkKFAccount,
fetchAIAgentsAll,
fetchChannel,
+ fetchWxWorkApiApps,
fetchWxWorkKFAccounts,
rollbackChannelAIAgentRollout,
resetChannelUserTokenSecret,
@@ -100,6 +102,7 @@ function createSchema(t: Translate) {
aiReplyTimeoutNotice: z.string().trim().max(500, t("channel.aiReplyTimeoutNoticeTooLong")),
name: z.string().trim().min(1, t("channel.nameRequired")),
openKfId: z.string().trim(),
+ wxAgentId: z.string().trim(),
botToken: z.string().trim(),
botUsername: z.string().trim(),
webhookSecret: z.string().trim(),
@@ -123,6 +126,13 @@ function createSchema(t: Translate) {
message: t("channel.wxworkAccountRequired"),
})
}
+ if (values.channelType === "wxwork_kf" && !values.wxAgentId.trim()) {
+ ctx.addIssue({
+ code: "custom",
+ path: ["wxAgentId"],
+ message: t("channel.wxworkAppRequired"),
+ })
+ }
if (values.channelType === "telegram" && !values.botToken.trim()) {
ctx.addIssue({
code: "custom",
@@ -149,6 +159,7 @@ type EditForm = {
aiReplyTimeoutNotice: string
name: string
openKfId: string
+ wxAgentId: string
botToken: string
botUsername: string
webhookSecret: string
@@ -176,6 +187,7 @@ function createEmptyForm(t: Translate): EditForm {
aiReplyTimeoutNotice: "",
name: "",
openKfId: "",
+ wxAgentId: "",
botToken: "",
botUsername: "",
webhookSecret: "",
@@ -193,15 +205,18 @@ function createEmptyForm(t: Translate): EditForm {
}
}
-function parseOpenKfId(configJson: string): string {
+function parseWxWorkKfConfig(configJson: string): { openKfId: string; agentId: string } {
if (!configJson.trim()) {
- return ""
+ return { openKfId: "", agentId: "" }
}
try {
- const parsed = JSON.parse(configJson) as { openKfId?: string }
- return typeof parsed.openKfId === "string" ? parsed.openKfId.trim() : ""
+ const parsed = JSON.parse(configJson) as { openKfId?: string; agentId?: string }
+ return {
+ openKfId: typeof parsed.openKfId === "string" ? parsed.openKfId.trim() : "",
+ agentId: typeof parsed.agentId === "string" ? parsed.agentId.trim() : "",
+ }
} catch {
- return ""
+ return { openKfId: "", agentId: "" }
}
}
@@ -300,6 +315,7 @@ function buildForm(item: AdminChannel | null, t: Translate): EditForm {
const zaloConfig = isZaloOA
? parseZaloOAChannelConfig(item.configJson)
: null
+ const wxWorkConfig = parseWxWorkKfConfig(item.configJson)
return {
channelType:
item.channelType === "wxwork_kf"
@@ -317,7 +333,8 @@ function buildForm(item: AdminChannel | null, t: Translate): EditForm {
aiReplyTimeoutSeconds: item.aiReplyTimeoutSeconds || 0,
aiReplyTimeoutNotice: item.aiReplyTimeoutNotice || "",
name: item.name,
- openKfId: parseOpenKfId(item.configJson),
+ openKfId: wxWorkConfig.openKfId,
+ wxAgentId: wxWorkConfig.agentId,
botToken: telegramConfig?.botToken ?? "",
botUsername: telegramConfig?.botUsername ?? "",
webhookSecret: telegramConfig?.webhookSecret ?? zaloConfig?.webhookSecret ?? "",
@@ -349,7 +366,7 @@ function buildPayload(form: EditForm, status: number, t: Translate): CreateAdmin
}
const configJson =
channelType === "wxwork_kf"
- ? JSON.stringify({ openKfId: form.openKfId.trim() })
+ ? JSON.stringify({ openKfId: form.openKfId.trim(), agentId: form.wxAgentId.trim() })
: channelType === "telegram"
? JSON.stringify({
botToken: form.botToken.trim(),
@@ -436,6 +453,8 @@ function ChannelFormBody({
const [loading, setLoading] = useState(false)
const [aiAgents, setAIAgents] = useState([])
const [wxWorkKFAccounts, setWxWorkKFAccounts] = useState([])
+ const [wxWorkApiApps, setWxWorkApiApps] = useState([])
+ const [wxWorkApiAppsLoading, setWxWorkApiAppsLoading] = useState(false)
const [wxWorkKFAccountsLoading, setWxWorkKFAccountsLoading] = useState(false)
const [wxWorkKFAccountsError, setWxWorkKFAccountsError] = useState("")
const [channelDetail, setChannelDetail] = useState(null)
@@ -460,6 +479,7 @@ function ChannelFormBody({
const channelType = useWatch({ control, name: "channelType" })
const aiAgentId = useWatch({ control, name: "aiAgentId" })
const openKfId = useWatch({ control, name: "openKfId" })
+ const wxAgentId = useWatch({ control, name: "wxAgentId" })
const userTokenSecret = useWatch({ control, name: "userTokenSecret" })
const previousRolloutPercent = channelDetail?.previousAiAgentRolloutPercent ?? 0
@@ -550,6 +570,27 @@ function ChannelFormBody({
t,
])
+ useEffect(() => {
+ if (
+ channelType !== "wxwork_kf" ||
+ wxWorkApiApps.length > 0 ||
+ wxWorkApiAppsLoading
+ ) {
+ return
+ }
+ async function loadWxWorkApiApps() {
+ setWxWorkApiAppsLoading(true)
+ try {
+ setWxWorkApiApps(await fetchWxWorkApiApps())
+ } catch (error) {
+ console.error("Failed to load WeCom apps:", error)
+ } finally {
+ setWxWorkApiAppsLoading(false)
+ }
+ }
+ void loadWxWorkApiApps()
+ }, [channelType, wxWorkApiApps.length, wxWorkApiAppsLoading])
+
const selectedAIAgent = aiAgents.find((item) => String(item.id) === aiAgentId)
const aiAgentOptions = aiAgents.map((item) => ({
value: String(item.id),
@@ -560,6 +601,10 @@ function ChannelFormBody({
value: item.openKfId,
label: item.name ? `${item.name} (${item.openKfId})` : item.openKfId,
}))
+ const wxWorkApiAppOptions = wxWorkApiApps.map((item) => ({
+ value: item.agentId,
+ label: item.agentId,
+ }))
const channelTypeOptions = [
{ value: "web", label: t("channel.typeWeb") },
{ value: "telegram", label: t("channel.typeTelegram") },
@@ -580,6 +625,16 @@ function ChannelFormBody({
label: openKfId,
})
}
+ if (
+ channelType === "wxwork_kf" &&
+ wxAgentId &&
+ !wxWorkApiAppOptions.some((item) => item.value === wxAgentId)
+ ) {
+ wxWorkApiAppOptions.unshift({
+ value: wxAgentId,
+ label: wxAgentId,
+ })
+ }
async function onFormSubmit(values: EditForm) {
const selected = aiAgents.find((item) => String(item.id) === values.aiAgentId)
@@ -834,32 +889,58 @@ function ChannelFormBody({
) : null}
{channelType === "wxwork_kf" ? (
-
- {t("channel.wxworkAccount")}
-
- (
-
-
+
+
+ {t("channel.wxworkAccount")}
+
+ (
+
+
+
+
+ {t("channel.wxworkApp")}
+
+ (
+
+
+
) : null}
{channelType === "web" || channelType === "wechat_mp" ? (
diff --git a/web/app/(dashboard)/dashboard/channels/_components/read-test-button.tsx b/web/app/(dashboard)/dashboard/channels/_components/read-test-button.tsx
index 42997cd2..f1a5b6fd 100644
--- a/web/app/(dashboard)/dashboard/channels/_components/read-test-button.tsx
+++ b/web/app/(dashboard)/dashboard/channels/_components/read-test-button.tsx
@@ -38,6 +38,8 @@ const READ_TEST_HINT_KEYS: Record = {
"60030": "channel.readTestHint60030",
WXWORK_DISABLED: "channel.readTestHintWxworkDisabled",
OPENKFID_MISSING: "channel.readTestHintOpenkfidMissing",
+ AGENTID_MISSING: "channel.readTestHintAgentidMissing",
+ AGENTID_NOT_CONFIGURED: "channel.readTestHintAgentidNotConfigured",
INVALID_CHANNEL: "channel.readTestHintInvalidChannel",
INVALID_CONFIG_JSON: "channel.readTestHintInvalidConfigJson",
NETWORK_ERROR: "channel.readTestHintNetwork",
diff --git a/web/lib/api/admin.ts b/web/lib/api/admin.ts
index e3303d11..f24b86df 100644
--- a/web/lib/api/admin.ts
+++ b/web/lib/api/admin.ts
@@ -963,10 +963,18 @@ export function fetchChannel(id: number) {
return request(`/api/dashboard/channel/${id}`)
}
+export type WxWorkApiApp = {
+ agentId: string
+}
+
export function fetchWxWorkKFAccounts() {
return request("/api/dashboard/channel/wxwork/kf/accounts")
}
+export function fetchWxWorkApiApps() {
+ return request("/api/dashboard/channel/wxwork/api_apps")
+}
+
export function testWxWorkKFReadMessages(id: number) {
return request(
"/api/dashboard/channel/wxwork/kf/test_read_messages",
diff --git a/web/messages/en-US.json b/web/messages/en-US.json
index ab2adf08..0e61a239 100644
--- a/web/messages/en-US.json
+++ b/web/messages/en-US.json
@@ -746,12 +746,18 @@
"readTestHint60030": "This service account is not within the self-built app's allowed range. Associate the service account with this app in the customer service admin console, and verify the app's visibility scope covers the users.",
"readTestHintWxworkDisabled": "WeCom is disabled or credentials are incomplete on the server. Check wxwork.enabled, wxwork.corpId and wxwork.corpSecret, then restart the service.",
"readTestHintOpenkfidMissing": "No service account selected (open_kfid is empty). Select a service account above and save the channel before testing.",
+ "readTestHintAgentidMissing": "No WeCom app specified (agentId is empty). Select an app above and save the channel before testing.",
+ "readTestHintAgentidNotConfigured": "The agentId does not exist in wxwork.apiApps, or its corpSecret is missing. Check the server configuration and restart.",
"readTestHintInvalidChannel": "The channel does not exist or is not a WeCom customer service channel. Refresh the page and retry.",
"readTestHintInvalidConfigJson": "The channel config JSON cannot be parsed. Check the channel configuration and save again.",
"readTestHintNetwork": "Unable to reach the WeCom API (qyapi.weixin.qq.com). Check the server's network, DNS, firewall or outbound proxy.",
"readTestHintBadResponse": "WeCom returned an unparseable response. Retry shortly; if it persists, check the server logs.",
"readTestHintDefault": "Review the error code and message: verify the self-built app's customer service API permissions, the association between the service account and the app, the app's visibility scope, and the server corpId/corpSecret settings.",
"wxworkAccount": "WeCom Customer Service Account",
+ "wxworkApp": "WeCom App (agentId)",
+ "wxworkAppRequired": "Please select a WeCom app",
+ "selectWxworkApp": "Select an app",
+ "emptyWxworkApp": "No WeCom apps found in the configuration",
"loadingWxworkAccount": "Loading service accounts",
"selectWxworkAccount": "Select a service account",
"searchWxworkAccount": "Search service accounts",
diff --git a/web/messages/zh-CN.json b/web/messages/zh-CN.json
index 5fbb9909..53f1c5b5 100644
--- a/web/messages/zh-CN.json
+++ b/web/messages/zh-CN.json
@@ -746,12 +746,18 @@
"readTestHint60030": "该客服账号不在自建应用的可调用范围。请在微信客服后台把该客服账号关联到此自建应用，并检查自建应用的可见范围是否覆盖使用人员。",
"readTestHintWxworkDisabled": "服务端未启用企业微信或凭据配置不完整。请检查配置文件 wxwork.enabled、wxwork.corpId、wxwork.corpSecret，并重启服务。",
"readTestHintOpenkfidMissing": "渠道未选择客服账号（open_kfid 为空）。请先在上方选择客服账号并保存渠道，再执行测试。",
+ "readTestHintAgentidMissing": "渠道未指定企业微信应用（agentId 为空）。请先在上方选择应用并保存渠道，再执行测试。",
+ "readTestHintAgentidNotConfigured": "配置文件 wxwork.apiApps 中不存在该 agentId，或其 corpSecret 未配置。请检查服务端配置并重启。",
"readTestHintInvalidChannel": "渠道不存在或不是企业微信客服渠道。请刷新页面后重试。",
"readTestHintInvalidConfigJson": "渠道配置 JSON 无法解析。请检查渠道配置内容并重新保存。",
"readTestHintNetwork": "无法连接企业微信接口（qyapi.weixin.qq.com）。请检查服务器的网络、DNS、防火墙或出站代理配置。",
"readTestHintBadResponse": "企业微信返回了无法解析的响应。请稍后重试；若持续出现，请查看服务端运行日志。",
"readTestHintDefault": "请根据错误码与错误信息排查：重点确认自建应用的微信客服 API 权限、客服账号与自建应用的关联、应用可见范围，以及服务端 corpId/corpSecret 配置。",
"wxworkAccount": "企业微信客服账号",
+ "wxworkApp": "企业微信应用（agentId）",
+ "wxworkAppRequired": "请选择企业微信应用",
+ "selectWxworkApp": "请选择应用",
+ "emptyWxworkApp": "配置文件中未找到企业微信应用",
"loadingWxworkAccount": "正在加载客服账号",
"selectWxworkAccount": "请选择客服账号",
"searchWxworkAccount": "搜索客服账号",