@jingyi0605/codingns 0.9.0 → 0.9.5

package/dist/server/modules/workspace/teable-mirror-sync-service.js

@@ -0,0 +1,917 @@
+import { randomUUID } from "node:crypto";
+import { AppError } from "../../shared/errors/app-error.js";
+import { nowIso } from "../../shared/utils/time.js";
+import { HOST_TASK_TYPES } from "../tasks/task-types.js";
+import { TeableApiClient } from "./teable-api-client.js";
+const SUPPORTED_MIRROR_TYPES = ["tags", "sessions", "todos"];
+const SUPPORTED_READ_ONLY_MODES = ["role_based", "matrix_based", "unknown"];
+export class TeableMirrorSyncService {
+    mirrorTableBindingRepository;
+    mirrorRecordMappingRepository;
+    taskManager;
+    teableGlobalBindingService;
+    teableCredentialService;
+    teableWorkbenchSyncConfigService;
+    affairsTagService;
+    affairsLightweightSessionService;
+    butlerInboxItemRepository;
+    butlerProjectRepository;
+    butlerFollowUpTaskRepository;
+    workspaceRepository;
+    teableFieldMappingService;
+    syncLogRepository;
+    constructor(mirrorTableBindingRepository, mirrorRecordMappingRepository, extra1, extra2, extra3, extra4, extra5, extra6, extra7, extra8, extra9, extra10, extra11, extra12) {
+        this.mirrorTableBindingRepository = mirrorTableBindingRepository;
+        this.mirrorRecordMappingRepository = mirrorRecordMappingRepository;
+        if (isTaskManagerLike(extra1)) {
+            this.taskManager = extra1;
+            this.teableGlobalBindingService = extra2;
+            this.teableCredentialService = extra3;
+            this.teableWorkbenchSyncConfigService = extra4;
+            this.affairsTagService = extra5;
+            this.affairsLightweightSessionService = extra6;
+            this.butlerInboxItemRepository = extra7;
+            this.butlerProjectRepository = extra8;
+            this.butlerFollowUpTaskRepository = extra9;
+            this.workspaceRepository = extra10;
+            this.teableFieldMappingService = extra11;
+            this.syncLogRepository = extra12;
+        }
+        else {
+            this.taskManager = undefined;
+            this.teableGlobalBindingService = extra1;
+            this.teableCredentialService = extra2;
+            this.teableWorkbenchSyncConfigService = extra3;
+            this.affairsTagService = extra4;
+            this.affairsLightweightSessionService = extra5;
+            this.butlerInboxItemRepository = extra6;
+            this.butlerProjectRepository = extra7;
+            this.butlerFollowUpTaskRepository = extra8;
+            this.workspaceRepository = extra9;
+            this.teableFieldMappingService = extra10;
+            this.syncLogRepository = extra11;
+        }
+        this.registerBackgroundTasks();
+    }
+    listMirrorTableBindings(userId) {
+        return this.mirrorTableBindingRepository.listByUserId(userId).map(mapBindingRecordToDto);
+    }
+    saveMirrorTableBinding(userId, input) {
+        const mirrorType = normalizeMirrorType(input.mirrorType);
+        const tableId = normalizeRequiredText(input.tableId, "tableId", "镜像表 tableId 不能为空");
+        const tableName = normalizeRequiredText(input.tableName, "tableName", "镜像表 tableName 不能为空");
+        const readOnlyMode = normalizeReadOnlyMode(input.readOnlyMode ?? "unknown");
+        const current = this.mirrorTableBindingRepository.findByUserIdAndMirrorType(userId, mirrorType);
+        const updatedAt = nowIso();
+        const record = {
+            bindingId: current?.bindingId ?? `teable-mirror-binding-${mirrorType}-${randomUUID()}`,
+            userId,
+            mirrorType,
+            tableId,
+            tableName,
+            readOnlyMode,
+            lastSyncedAt: normalizeOptionalText(input.lastSyncedAt),
+            createdAt: current?.createdAt ?? updatedAt,
+            updatedAt
+        };
+        return mapBindingRecordToDto(this.mirrorTableBindingRepository.upsert(record));
+    }
+    listMirrorRecordMappings(userId, mirrorType) {
+        return this.mirrorRecordMappingRepository.listByUserIdAndMirrorType(userId, normalizeMirrorType(mirrorType)).map(mapRecordMappingToDto);
+    }
+    saveMirrorRecordMapping(userId, input) {
+        const mirrorType = normalizeMirrorType(input.mirrorType);
+        const localId = normalizeRequiredText(input.localId, "localId", "localId 不能为空");
+        const teableRecordId = normalizeRequiredText(input.teableRecordId, "teableRecordId", "teableRecordId 不能为空");
+        const fingerprint = normalizeRequiredText(input.fingerprint, "fingerprint", "fingerprint 不能为空");
+        const current = this.mirrorRecordMappingRepository.findByUserIdAndMirrorTypeAndLocalId(userId, mirrorType, localId);
+        const updatedAt = nowIso();
+        const record = {
+            mappingId: current?.mappingId ?? `teable-mirror-record-${mirrorType}-${randomUUID()}`,
+            userId,
+            mirrorType,
+            localId,
+            teableRecordId,
+            fingerprint,
+            lastSyncedAt: normalizeRequiredText(input.lastSyncedAt ?? updatedAt, "lastSyncedAt", "lastSyncedAt 不能为空"),
+            deletedAt: normalizeOptionalText(input.deletedAt),
+            createdAt: current?.createdAt ?? updatedAt,
+            updatedAt
+        };
+        return mapRecordMappingToDto(this.mirrorRecordMappingRepository.upsert(record));
+    }
+    requestMirrorSync(userId, input) {
+        return this.enqueueMirrorSync(userId, {
+            mirrorTypes: input.mirrorTypes,
+            triggerType: "manual",
+            reason: "manual_request",
+            source: "teable.mirror_sync.request"
+        });
+    }
+    requestLocalChangeMirrorSync(userId, input) {
+        if (!this.teableGlobalBindingService || !this.teableWorkbenchSyncConfigService) {
+            return null;
+        }
+        const binding = this.teableGlobalBindingService.getGlobalBinding(userId);
+        if (!binding?.enabled || binding.mirrorMode !== "event_driven") {
+            return null;
+        }
+        const requestedMirrorTypes = normalizeRequestedMirrorTypes(input.mirrorTypes);
+        const enabledMirrorTypes = this.teableWorkbenchSyncConfigService.getConfigs(userId)
+            .filter((item) => item.enabled && requestedMirrorTypes.includes(item.sourceType))
+            .map((item) => item.sourceType);
+        if (enabledMirrorTypes.length === 0) {
+            return null;
+        }
+        return this.enqueueMirrorSync(userId, {
+            mirrorTypes: enabledMirrorTypes,
+            triggerType: "local_change",
+            reason: input.reason,
+            source: "teable.mirror_sync.local_change"
+        });
+    }
+    listSyncLogs(userId, input = {}) {
+        return this.syncLogRepository?.listByUserId(userId, input).map(mapSyncLogRecordToDto) ?? [];
+    }
+    enqueueMirrorSync(userId, input) {
+        this.ensureTaskManager();
+        const mirrorTypes = normalizeRequestedMirrorTypes(input.mirrorTypes);
+        const createdAt = nowIso();
+        const pendingLog = this.createSyncLog(userId, {
+            triggerType: input.triggerType,
+            sourceTypes: mirrorTypes,
+            state: "queued",
+            summary: input.triggerType === "local_change" ? "本地数据变化，已准备同步到 Teable" : "Teable 镜像同步任务已入队",
+            reason: input.reason ?? null,
+            createdAt
+        });
+        const handle = this.taskManager.enqueue(HOST_TASK_TYPES.teableMirrorSync, {
+            key: buildMirrorSyncTaskKey(userId),
+            source: input.source,
+            input: {
+                userId,
+                mirrorTypes,
+                triggerType: input.triggerType,
+                reason: input.reason ?? null,
+                logId: pendingLog?.logId ?? null
+            }
+        });
+        if (pendingLog) {
+            this.updateSyncLog(userId, pendingLog.logId, {
+                taskId: handle.taskId,
+                state: handle.deduped ? "running" : "queued",
+                summary: handle.deduped ? "已合并到正在运行的 Teable 同步任务" : pendingLog.summary,
+                startedAt: handle.deduped ? nowIso() : null
+            });
+            if (handle.deduped) {
+                void handle.promise
+                    .then((result) => {
+                    this.updateSyncLog(userId, pendingLog.logId, {
+                        state: result.state,
+                        summary: result.summary,
+                        counts: result.counts,
+                        errorDetail: result.failedMirrorTypes.length > 0
+                            ? result.failedMirrorTypes.map((item) => `${resolveMirrorTypeLabel(item.mirrorType)}：${item.detail}`).join("\n")
+                            : null,
+                        finishedAt: nowIso()
+                    });
+                })
+                    .catch((error) => {
+                    this.updateSyncLog(userId, pendingLog.logId, {
+                        state: "failed",
+                        summary: "Teable 镜像同步失败",
+                        errorDetail: error instanceof Error ? error.message : String(error),
+                        finishedAt: nowIso()
+                    });
+                });
+            }
+        }
+        void handle.promise.catch(() => undefined);
+        return {
+            taskId: handle.taskId,
+            deduped: handle.deduped,
+            taskType: "mirror_sync",
+            state: "queued",
+            summary: handle.deduped ? "Teable 镜像同步任务已在队列中" : "Teable 镜像同步任务已入队",
+            updatedAt: nowIso()
+        };
+    }
+    getMirrorSyncTaskSnapshot(userId, _workspaceIdsOrWorkspaceId, _workspaceId) {
+        this.ensureTaskManager();
+        const snapshot = this.taskManager.peek(HOST_TASK_TYPES.teableMirrorSync, buildMirrorSyncTaskKey(userId));
+        return mapTaskSnapshotToDto(snapshot);
+    }
+    getOverview(userId, workspaceIdsOrWorkspaceId, workspaceId) {
+        if (!this.teableGlobalBindingService || !this.teableWorkbenchSyncConfigService) {
+            throw new AppError({
+                statusCode: 500,
+                errorCode: "TEABLE_OVERVIEW_DEPENDENCY_MISSING",
+                detail: "Teable 总览依赖没有完整注入"
+            });
+        }
+        return {
+            binding: this.teableGlobalBindingService.getOverview(userId),
+            syncConfigs: this.teableWorkbenchSyncConfigService.getConfigs(userId),
+            mirrorBindings: this.listMirrorTableBindings(userId),
+            latestMirrorSyncTask: this.getMirrorSyncTaskSnapshot(userId, workspaceIdsOrWorkspaceId, workspaceId)
+        };
+    }
+    async runMirrorSync(userId, input) {
+        this.ensureSyncDependencies();
+        const binding = this.teableGlobalBindingService.getGlobalBinding(userId);
+        if (!binding || !binding.enabled) {
+            throw new AppError({
+                statusCode: 400,
+                errorCode: "TEABLE_BINDING_REQUIRED",
+                detail: "当前事务工作台还没有可用的 Teable 绑定"
+            });
+        }
+        const token = this.teableCredentialService.loadToken(userId, binding.authRef);
+        if (!token) {
+            throw new AppError({
+                statusCode: 400,
+                errorCode: "TEABLE_AUTH_REQUIRED",
+                detail: "当前 Teable 认证引用没有可用 token"
+            });
+        }
+        const client = new TeableApiClient(binding.baseUrl, token);
+        const allConfigs = this.teableWorkbenchSyncConfigService.getConfigs(userId);
+        const requestedMirrorTypes = normalizeRequestedMirrorTypes(input.mirrorTypes);
+        const configs = allConfigs.filter((item) => item.enabled && requestedMirrorTypes.includes(item.sourceType));
+        if (configs.length === 0) {
+            return {
+                state: "succeeded",
+                summary: "当前没有启用的镜像配置需要同步",
+                syncedMirrorTypes: [],
+                failedMirrorTypes: [],
+                counts: buildEmptyCounts()
+            };
+        }
+        const result = {
+            state: "succeeded",
+            summary: "Teable 镜像同步完成",
+            syncedMirrorTypes: [],
+            failedMirrorTypes: [],
+            counts: buildEmptyCounts()
+        };
+        for (const config of configs) {
+            try {
+                const sourceRecords = await this.readMirrorSourceRecords(userId, config);
+                const tableBinding = await this.ensureMirrorTable(client, userId, binding.baseId, config);
+                const mapping = this.resolveFieldMapping(userId, config.configId, config.sourceType, config.targetTableId ?? tableBinding.tableId);
+                const counts = await this.syncMirrorRecords(client, userId, config.sourceType, tableBinding.tableId, sourceRecords, mapping);
+                result.counts[config.sourceType] = counts;
+                result.syncedMirrorTypes.push(config.sourceType);
+            }
+            catch (error) {
+                result.failedMirrorTypes.push({
+                    mirrorType: config.sourceType,
+                    detail: error instanceof Error ? error.message : String(error)
+                });
+            }
+        }
+        if (result.failedMirrorTypes.length > 0 && result.syncedMirrorTypes.length > 0) {
+            result.state = "partial_failed";
+            result.summary = "Teable 镜像同步部分成功，部分失败";
+        }
+        else if (result.failedMirrorTypes.length > 0) {
+            result.state = "failed";
+            result.summary = "Teable 镜像同步失败";
+        }
+        return result;
+    }
+    async ensureMirrorTable(client, userId, baseId, config) {
+        const mirrorType = config.sourceType;
+        const targetTableId = config.targetTableId?.trim() ?? "";
+        if (!targetTableId) {
+            throw new AppError({
+                statusCode: 400,
+                errorCode: "TEABLE_TARGET_TABLE_REQUIRED",
+                detail: `${resolveMirrorTypeLabel(mirrorType)} 镜像还没有指定目标表，请先到设置里绑定目标表`
+            });
+        }
+        const existingBinding = this.mirrorTableBindingRepository.findByUserIdAndMirrorType(userId, mirrorType);
+        if (existingBinding?.tableId === targetTableId) {
+            return mapBindingRecordToDto(existingBinding);
+        }
+        const table = await this.findExistingTable(client, baseId, targetTableId);
+        if (!table) {
+            throw new AppError({
+                statusCode: 400,
+                errorCode: "TEABLE_TARGET_TABLE_NOT_FOUND",
+                detail: `${resolveMirrorTypeLabel(mirrorType)} 镜像指定的目标表不存在，请先检查 Teable 连接和表 ID`
+            });
+        }
+        return this.saveMirrorTableBinding(userId, {
+            mirrorType,
+            tableId: table.id,
+            tableName: table.name,
+            readOnlyMode: existingBinding?.readOnlyMode ?? "unknown",
+            lastSyncedAt: existingBinding?.lastSyncedAt ?? null
+        });
+    }
+    async syncMirrorRecords(client, userId, mirrorType, tableId, sourceRecords, mapping) {
+        const currentMappings = this.mirrorRecordMappingRepository.listByUserIdAndMirrorType(userId, mirrorType);
+        const mappingByLocalId = new Map(currentMappings.map((item) => [item.localId, item]));
+        const sourceByLocalId = new Map(sourceRecords.map((item) => [item.localId, item]));
+        const createdPayload = [];
+        const createdLocalIds = [];
+        const updatedPayload = [];
+        const deletedRecordIds = [];
+        let skipped = 0;
+        for (const source of sourceRecords) {
+            const existing = mappingByLocalId.get(source.localId);
+            const fields = this.teableFieldMappingService.applyMapping(mapping, source.payload);
+            if (Object.keys(fields).length === 0) {
+                skipped += 1;
+                continue;
+            }
+            if (!existing) {
+                createdPayload.push({ fields });
+                createdLocalIds.push(source.localId);
+                continue;
+            }
+            if (existing.fingerprint === source.fingerprint && !existing.deletedAt) {
+                skipped += 1;
+                continue;
+            }
+            updatedPayload.push({ id: existing.teableRecordId, fields });
+        }
+        for (const existing of currentMappings) {
+            if (!sourceByLocalId.has(existing.localId) && !existing.deletedAt) {
+                deletedRecordIds.push(existing.teableRecordId);
+            }
+        }
+        let created = 0;
+        let updated = 0;
+        let deleted = 0;
+        const syncedAt = nowIso();
+        if (createdPayload.length > 0) {
+            const createdResponse = await client.createRecords(tableId, {
+                fieldKeyType: "id",
+                records: createdPayload
+            });
+            created = createdResponse.records.length;
+            createdResponse.records.forEach((record, index) => {
+                const localId = createdLocalIds[index];
+                const source = localId ? sourceByLocalId.get(localId) : null;
+                if (!localId || !source) {
+                    return;
+                }
+                this.saveMirrorRecordMapping(userId, {
+                    mirrorType,
+                    localId,
+                    teableRecordId: record.id,
+                    fingerprint: source.fingerprint,
+                    lastSyncedAt: syncedAt,
+                    deletedAt: null
+                });
+            });
+        }
+        if (updatedPayload.length > 0) {
+            await client.updateRecords(tableId, {
+                fieldKeyType: "id",
+                records: updatedPayload
+            });
+            updated = updatedPayload.length;
+            for (const item of updatedPayload) {
+                const localEntry = currentMappings.find((entry) => entry.teableRecordId === item.id);
+                const source = localEntry ? sourceByLocalId.get(localEntry.localId) : null;
+                if (!localEntry || !source) {
+                    continue;
+                }
+                this.saveMirrorRecordMapping(userId, {
+                    mirrorType,
+                    localId: localEntry.localId,
+                    teableRecordId: localEntry.teableRecordId,
+                    fingerprint: source.fingerprint,
+                    lastSyncedAt: syncedAt,
+                    deletedAt: null
+                });
+            }
+        }
+        if (deletedRecordIds.length > 0) {
+            await client.deleteRecords(tableId, deletedRecordIds);
+            deleted = deletedRecordIds.length;
+            for (const mappingRecord of currentMappings) {
+                if (!deletedRecordIds.includes(mappingRecord.teableRecordId)) {
+                    continue;
+                }
+                this.saveMirrorRecordMapping(userId, {
+                    mirrorType,
+                    localId: mappingRecord.localId,
+                    teableRecordId: mappingRecord.teableRecordId,
+                    fingerprint: mappingRecord.fingerprint,
+                    lastSyncedAt: syncedAt,
+                    deletedAt: syncedAt
+                });
+            }
+        }
+        const currentBinding = this.mirrorTableBindingRepository.findByUserIdAndMirrorType(userId, mirrorType);
+        this.saveMirrorTableBinding(userId, {
+            mirrorType,
+            tableId,
+            tableName: currentBinding?.tableName ?? getDefaultMirrorTableName(mirrorType),
+            readOnlyMode: currentBinding?.readOnlyMode ?? "unknown",
+            lastSyncedAt: syncedAt
+        });
+        return { created, updated, deleted, skipped };
+    }
+    async readMirrorSourceRecords(userId, config) {
+        switch (config.sourceType) {
+            case "tags":
+                return this.readTagMirrorSourceRecords(userId, config);
+            case "sessions":
+                return this.readSessionMirrorSourceRecords(userId, config);
+            case "todos":
+                return this.readTodoMirrorSourceRecords(config);
+            default:
+                return [];
+        }
+    }
+    readTagMirrorSourceRecords(userId, config) {
+        const rootTagIds = Array.isArray(config.scope.rootTagIds)
+            ? config.scope.rootTagIds
+            : [];
+        if (rootTagIds.length === 0) {
+            return [];
+        }
+        const tagList = this.affairsTagService.listGlobalTags(userId, { includeDisabled: true });
+        const roots = tagList.items.filter((item) => rootTagIds.includes(item.id));
+        if (roots.length === 0) {
+            return [];
+        }
+        return tagList.items
+            .filter((item) => roots.some((root) => item.id === root.id || item.path === root.path || item.path.startsWith(`${root.path}/`)))
+            .map((item) => {
+            const payload = {
+                tag_id: item.id,
+                path: item.path,
+                name: item.name,
+                parent_id: item.parentId,
+                parent_path: item.parentPath,
+                root_type: item.rootType,
+                status: item.status,
+                description: item.description ?? "",
+                document_count: item.documentCount,
+                updated_at: item.updatedAt
+            };
+            return {
+                localId: item.id,
+                payload,
+                fingerprint: JSON.stringify(payload)
+            };
+        });
+    }
+    async readSessionMirrorSourceRecords(userId, config) {
+        const workspaces = resolveScopedWorkspaces(this.workspaceRepository, config.scope);
+        const groups = await Promise.all(workspaces.map(async (workspace) => ({
+            workspace,
+            sessions: await this.affairsLightweightSessionService.listSessions(workspace.id, userId)
+        })));
+        return groups.flatMap(({ workspace, sessions }) => sessions.map((item) => {
+            const payload = {
+                workspace_id: workspace.id,
+                workspace_name: workspace.name,
+                session_id: item.sessionId,
+                title: item.title,
+                provider: item.provider,
+                message_count: item.messageCount,
+                last_message_at: item.lastMessageAt ?? null,
+                running_state: item.runningState ?? null,
+                activity_state: item.activityState,
+                updated_at: item.updatedAt
+            };
+            return {
+                localId: buildScopedLocalId(workspace.id, item.sessionId),
+                payload,
+                fingerprint: JSON.stringify(payload)
+            };
+        }));
+    }
+    readTodoMirrorSourceRecords(config) {
+        const workspaces = resolveScopedWorkspaces(this.workspaceRepository, config.scope);
+        const workspaceById = new Map(workspaces.map((item) => [item.id, item]));
+        const selectedWorkspaceIds = new Set(workspaces.map((item) => item.id));
+        const projects = this.butlerProjectRepository.list().filter((item) => selectedWorkspaceIds.has(item.workspaceId));
+        const projectById = new Map(projects.map((item) => [item.id, item]));
+        const scope = config.scope;
+        const records = [];
+        if (scope.includeWorkspaceTodos !== false) {
+            const items = this.butlerInboxItemRepository.list({}).filter((item) => projectById.has(item.projectId));
+            for (const item of items) {
+                const project = projectById.get(item.projectId);
+                const workspace = workspaceById.get(project.workspaceId) ?? null;
+                const payload = {
+                    workspace_id: workspace?.id ?? null,
+                    workspace_name: workspace?.name ?? null,
+                    todo_id: item.id,
+                    title: item.title,
+                    content: item.content,
+                    source_type: "workspace",
+                    item_type: item.itemType,
+                    priority: item.priority,
+                    status: item.status,
+                    project_id: item.projectId,
+                    updated_at: item.updatedAt
+                };
+                records.push({
+                    localId: `workspace:${item.id}`,
+                    payload,
+                    fingerprint: JSON.stringify(payload)
+                });
+            }
+        }
+        if (scope.includeAffairsTodos !== false) {
+            const items = this.butlerFollowUpTaskRepository.list({}).filter((item) => projectById.has(item.projectId));
+            for (const item of items) {
+                const project = projectById.get(item.projectId);
+                const workspace = workspaceById.get(project.workspaceId) ?? null;
+                const payload = {
+                    workspace_id: workspace?.id ?? null,
+                    workspace_name: workspace?.name ?? null,
+                    todo_id: item.id,
+                    title: item.objective,
+                    content: item.completionCriteria,
+                    source_type: "affairs",
+                    item_type: "follow_up",
+                    priority: null,
+                    status: item.status,
+                    project_id: item.projectId,
+                    updated_at: item.updatedAt
+                };
+                records.push({
+                    localId: `affairs:${item.id}`,
+                    payload,
+                    fingerprint: JSON.stringify(payload)
+                });
+            }
+        }
+        return records;
+    }
+    resolveFieldMapping(userId, configId, sourceType, targetTableId) {
+        const mapping = this.teableFieldMappingService.resolveMapping(userId, configId);
+        if (!mapping) {
+            throw new AppError({
+                statusCode: 400,
+                errorCode: "TEABLE_FIELD_MAPPING_REQUIRED",
+                detail: `${resolveMirrorTypeLabel(sourceType)} 镜像还没有配置字段映射`
+            });
+        }
+        if (mapping.targetTableId !== targetTableId) {
+            throw new AppError({
+                statusCode: 400,
+                errorCode: "TEABLE_FIELD_MAPPING_TARGET_MISMATCH",
+                detail: `${resolveMirrorTypeLabel(sourceType)} 镜像的字段映射和目标表不一致，请重新保存映射`
+            });
+        }
+        return mapping;
+    }
+    ensureSyncDependencies() {
+        if (!this.teableGlobalBindingService || !this.teableCredentialService || !this.teableWorkbenchSyncConfigService || !this.affairsTagService || !this.affairsLightweightSessionService || !this.butlerInboxItemRepository || !this.butlerProjectRepository || !this.butlerFollowUpTaskRepository || !this.workspaceRepository || !this.teableFieldMappingService) {
+            throw new AppError({
+                statusCode: 500,
+                errorCode: "TEABLE_SYNC_DEPENDENCY_MISSING",
+                detail: "Teable 镜像同步依赖没有完整注入"
+            });
+        }
+    }
+    ensureTaskManager() {
+        if (!this.taskManager) {
+            throw new AppError({
+                statusCode: 500,
+                errorCode: "TEABLE_TASK_MANAGER_MISSING",
+                detail: "Teable 镜像同步任务管理器没有注入"
+            });
+        }
+    }
+    registerBackgroundTasks() {
+        if (!this.taskManager || this.taskManager.has(HOST_TASK_TYPES.teableMirrorSync)) {
+            return;
+        }
+        this.taskManager.register({
+            taskType: HOST_TASK_TYPES.teableMirrorSync,
+            executionLane: "host_background",
+            timeoutMs: 60_000,
+            concurrency: 1,
+            run: async (input, context) => {
+                const mirrorTypes = normalizeRequestedMirrorTypes(input.mirrorTypes);
+                if (input.logId) {
+                    this.updateSyncLog(input.userId, input.logId, {
+                        taskId: context.taskId,
+                        state: "running",
+                        summary: "Teable 镜像同步进行中",
+                        startedAt: nowIso()
+                    });
+                }
+                context.reportProgress({
+                    phase: "queued",
+                    label: "开始准备 Teable 镜像同步",
+                    detail: `本次共 ${mirrorTypes.length} 类：${mirrorTypes.map(resolveMirrorTypeLabel).join("、")}`,
+                    percent: 0
+                });
+                let result;
+                try {
+                    result = await this.runMirrorSync(input.userId, { mirrorTypes });
+                }
+                catch (error) {
+                    if (input.logId) {
+                        this.updateSyncLog(input.userId, input.logId, {
+                            state: "failed",
+                            summary: "Teable 镜像同步失败",
+                            errorDetail: error instanceof Error ? error.message : String(error),
+                            finishedAt: nowIso()
+                        });
+                    }
+                    throw error;
+                }
+                if (input.logId) {
+                    this.updateSyncLog(input.userId, input.logId, {
+                        state: result.state,
+                        summary: result.summary,
+                        counts: result.counts,
+                        errorDetail: result.failedMirrorTypes.length > 0
+                            ? result.failedMirrorTypes.map((item) => `${resolveMirrorTypeLabel(item.mirrorType)}：${item.detail}`).join("\n")
+                            : null,
+                        finishedAt: nowIso()
+                    });
+                }
+                context.reportProgress({
+                    phase: result.state,
+                    label: result.summary,
+                    detail: buildMirrorSyncProgressDetail(result),
+                    current: mirrorTypes.length,
+                    total: mirrorTypes.length,
+                    percent: 100
+                });
+                return result;
+            }
+        });
+    }
+    async findExistingTable(client, baseId, targetTableId) {
+        const tables = await client.listTables(baseId);
+        return tables.find((item) => item.id === targetTableId) ?? null;
+    }
+    createSyncLog(userId, input) {
+        if (!this.syncLogRepository) {
+            return null;
+        }
+        const record = {
+            logId: `teable-sync-log-${randomUUID()}`,
+            userId,
+            triggerType: input.triggerType,
+            sourceTypesJson: JSON.stringify(input.sourceTypes),
+            taskId: null,
+            state: input.state,
+            summary: input.summary,
+            countsJson: "{}",
+            errorDetail: null,
+            reason: input.reason,
+            startedAt: null,
+            finishedAt: null,
+            createdAt: input.createdAt,
+            updatedAt: input.createdAt
+        };
+        return this.syncLogRepository.create(record);
+    }
+    updateSyncLog(userId, logId, patch) {
+        if (!this.syncLogRepository) {
+            return;
+        }
+        const current = this.syncLogRepository.findById(userId, logId);
+        if (!current) {
+            return;
+        }
+        this.syncLogRepository.update({
+            ...current,
+            taskId: patch.taskId !== undefined ? patch.taskId : current.taskId,
+            state: patch.state ?? current.state,
+            summary: patch.summary ?? current.summary,
+            countsJson: patch.counts ? JSON.stringify(patch.counts) : current.countsJson,
+            errorDetail: patch.errorDetail !== undefined ? patch.errorDetail : current.errorDetail,
+            reason: patch.reason !== undefined ? patch.reason : current.reason,
+            startedAt: patch.startedAt !== undefined ? patch.startedAt : current.startedAt,
+            finishedAt: patch.finishedAt !== undefined ? patch.finishedAt : current.finishedAt,
+            updatedAt: nowIso()
+        });
+    }
+}
+function buildEmptyCounts() {
+    return {
+        tags: { created: 0, updated: 0, deleted: 0, skipped: 0 },
+        sessions: { created: 0, updated: 0, deleted: 0, skipped: 0 },
+        todos: { created: 0, updated: 0, deleted: 0, skipped: 0 }
+    };
+}
+function resolveScopedWorkspaces(workspaceRepository, scope) {
+    const all = workspaceRepository.list();
+    const normalizedScope = scope && typeof scope === "object" && !Array.isArray(scope)
+        ? scope
+        : {};
+    const mode = normalizedScope.mode === "selected_workspaces" ? "selected_workspaces" : "all_workspaces";
+    if (mode !== "selected_workspaces") {
+        return all;
+    }
+    const ids = Array.isArray(normalizedScope.workspaceIds)
+        ? Array.from(new Set(normalizedScope.workspaceIds.map((item) => typeof item === "string" ? item.trim() : "").filter(Boolean)))
+        : [];
+    return ids.map((id) => workspaceRepository.findById(id)).filter((item) => Boolean(item));
+}
+function getDefaultMirrorTableName(mirrorType) {
+    switch (mirrorType) {
+        case "tags":
+            return "cn_tags";
+        case "sessions":
+            return "cn_sessions";
+        case "todos":
+            return "cn_todos";
+        default:
+            return `cn_${mirrorType}`;
+    }
+}
+function mapBindingRecordToDto(record) {
+    return {
+        mirrorType: record.mirrorType,
+        tableId: record.tableId,
+        tableName: record.tableName,
+        readOnlyMode: record.readOnlyMode,
+        lastSyncedAt: record.lastSyncedAt,
+        updatedAt: record.updatedAt
+    };
+}
+function mapRecordMappingToDto(record) {
+    return {
+        mirrorType: record.mirrorType,
+        localId: record.localId,
+        teableRecordId: record.teableRecordId,
+        fingerprint: record.fingerprint,
+        lastSyncedAt: record.lastSyncedAt,
+        deletedAt: record.deletedAt,
+        updatedAt: record.updatedAt
+    };
+}
+function mapSyncLogRecordToDto(record) {
+    return {
+        logId: record.logId,
+        triggerType: record.triggerType,
+        sourceTypes: parseMirrorTypesJson(record.sourceTypesJson),
+        taskId: record.taskId,
+        state: record.state,
+        summary: record.summary,
+        counts: parseCountsJson(record.countsJson),
+        errorDetail: record.errorDetail,
+        reason: record.reason,
+        startedAt: record.startedAt,
+        finishedAt: record.finishedAt,
+        createdAt: record.createdAt,
+        updatedAt: record.updatedAt
+    };
+}
+function parseMirrorTypesJson(raw) {
+    try {
+        const parsed = JSON.parse(raw);
+        return Array.isArray(parsed) ? normalizeRequestedMirrorTypes(parsed) : [];
+    }
+    catch {
+        return [];
+    }
+}
+function parseCountsJson(raw) {
+    try {
+        const parsed = JSON.parse(raw);
+        return parsed && typeof parsed === "object" && !Array.isArray(parsed)
+            ? parsed
+            : {};
+    }
+    catch {
+        return {};
+    }
+}
+function normalizeMirrorType(value) {
+    if (SUPPORTED_MIRROR_TYPES.includes(value)) {
+        return value;
+    }
+    throw new AppError({
+        statusCode: 400,
+        errorCode: "INVALID_INPUT",
+        field: "mirrorType",
+        detail: "mirrorType 只允许 tags、sessions、todos"
+    });
+}
+function normalizeReadOnlyMode(value) {
+    if (SUPPORTED_READ_ONLY_MODES.includes(value)) {
+        return value;
+    }
+    throw new AppError({
+        statusCode: 400,
+        errorCode: "INVALID_INPUT",
+        field: "readOnlyMode",
+        detail: "readOnlyMode 只允许 role_based、matrix_based、unknown"
+    });
+}
+function normalizeRequiredText(value, field, detail) {
+    const normalized = value.trim();
+    if (!normalized) {
+        throw new AppError({ statusCode: 400, errorCode: "INVALID_INPUT", field, detail });
+    }
+    return normalized;
+}
+function normalizeOptionalText(value) {
+    const normalized = value?.trim() ?? "";
+    return normalized ? normalized : null;
+}
+function normalizeRequestedMirrorTypes(values) {
+    const target = values?.length ? values : SUPPORTED_MIRROR_TYPES;
+    return Array.from(new Set(target.map(normalizeMirrorType)));
+}
+function buildMirrorSyncTaskKey(userId) {
+    return `${userId}:global`;
+}
+function buildScopedLocalId(scopeId, localId) {
+    return `${scopeId}:${localId}`;
+}
+function mapTaskSnapshotToDto(snapshot) {
+    if (!snapshot) {
+        return null;
+    }
+    return {
+        taskId: snapshot.taskId,
+        taskType: "mirror_sync",
+        state: resolveMirrorSyncTaskState(snapshot),
+        summary: resolveMirrorSyncTaskSummary(snapshot),
+        lastError: snapshot.status === "failed" || snapshot.status === "queue_timeout" || snapshot.status === "timeout"
+            ? snapshot.errorMessage ?? snapshot.errorDetail ?? "Teable 镜像同步失败"
+            : null,
+        updatedAt: new Date(snapshot.finishedAt ?? snapshot.progress?.updatedAt ?? snapshot.startedAt ?? snapshot.enqueuedAt).toISOString(),
+        startedAt: snapshot.startedAt === null ? null : new Date(snapshot.startedAt).toISOString(),
+        finishedAt: snapshot.finishedAt === null ? null : new Date(snapshot.finishedAt).toISOString(),
+        progress: snapshot.progress ? {
+            phase: snapshot.progress.phase,
+            label: snapshot.progress.label ?? null,
+            detail: snapshot.progress.detail ?? null,
+            current: snapshot.progress.current ?? null,
+            total: snapshot.progress.total ?? null,
+            percent: snapshot.progress.percent ?? null,
+            updatedAt: new Date(snapshot.progress.updatedAt).toISOString()
+        } : null,
+        result: snapshot.result ?? null
+    };
+}
+function resolveMirrorSyncTaskState(snapshot) {
+    if (snapshot.status === "succeeded") {
+        return snapshot.result?.state ?? "succeeded";
+    }
+    if (snapshot.status === "failed" || snapshot.status === "timeout" || snapshot.status === "queue_timeout" || snapshot.status === "cancelled") {
+        return "failed";
+    }
+    if (snapshot.status === "running") {
+        return "running";
+    }
+    return "queued";
+}
+function resolveMirrorSyncTaskSummary(snapshot) {
+    if (snapshot.result?.summary?.trim()) {
+        return snapshot.result.summary.trim();
+    }
+    if (snapshot.progress?.label?.trim()) {
+        return snapshot.progress.label.trim();
+    }
+    if (snapshot.status === "queued") {
+        return "Teable 镜像同步任务排队中";
+    }
+    if (snapshot.status === "running") {
+        return "Teable 镜像同步进行中";
+    }
+    if (snapshot.status === "failed" || snapshot.status === "timeout" || snapshot.status === "queue_timeout" || snapshot.status === "cancelled") {
+        return snapshot.errorMessage ?? "Teable 镜像同步失败";
+    }
+    return null;
+}
+function resolveMirrorTypeLabel(mirrorType) {
+    switch (mirrorType) {
+        case "tags":
+            return "标签";
+        case "sessions":
+            return "会话";
+        case "todos":
+            return "代办";
+        default:
+            return mirrorType;
+    }
+}
+function buildMirrorSyncProgressDetail(result) {
+    const succeeded = result.syncedMirrorTypes.map(resolveMirrorTypeLabel);
+    const failed = result.failedMirrorTypes.map((item) => resolveMirrorTypeLabel(item.mirrorType));
+    const segments = [];
+    if (succeeded.length > 0) {
+        segments.push(`已完成：${succeeded.join("、")}`);
+    }
+    if (failed.length > 0) {
+        segments.push(`失败：${failed.join("、")}`);
+    }
+    return segments.join("；");
+}
+function isTaskManagerLike(value) {
+    return typeof value === "object" && value !== null && typeof value.has === "function" && typeof value.enqueue === "function";
+}
+//# sourceMappingURL=teable-mirror-sync-service.js.map