@spacex110/core 0.1.11

package/src/channel-manager.ts

@@ -0,0 +1,790 @@
+/**
+ * AI Channel Manager - Headless AI Channel Management
+ * 统一的 AI 通道管理接口，无需 UI 即可集成到任何项目
+ *
+ * 功能分类：
+ * 1. 通道 CRUD：addChannel / updateChannel / deleteChannel / getChannel / getChannels
+ * 2. 通道查询：getChannelsByProvider / getChannelsByCapability / getChannelsByFormat / searchChannels
+ * 3. 激活管理：setActiveChannel / getActiveChannel / clearActiveChannel
+ * 4. 模型查询：getProviderModels / getChannelModels / getStaticModelList / getModelsByCapability
+ * 5. API Key 管理：updateApiKey / validateApiKey / maskApiKey
+ * 6. 聊天执行：chat (active channel) / chatWith (specific channel)
+ * 7. 连接测试：testChannel / testChannelById / testAllChannels
+ * 8. Provider 查询：getAvailableProviders / getProvider / getProvidersByFormat
+ * 9. 导入导出：exportChannels / importChannels
+ * 10. 事件系统：on / off / emit
+ */
+
+import type { AIConfig, Provider, Model, ModelCapability, StorageAdapter, ApiFormat } from './types';
+import { getProvider, getAllProviders, getProvidersByFormat } from './providers';
+import { defaultStorageAdapter } from './storage';
+import { sendDirectChat, sendDirectChatStream, testDirectConnection } from './strategies';
+import { fetchModels } from './api';
+import { getStaticModels } from './models';
+
+// ============ Types ============
+
+/** 通道配置（扩展 AIConfig，包含更多元数据） */
+export interface ChannelConfig extends AIConfig {
+    /** 通道唯一标识 */
+    id: string;
+    /** 通道名称（用户自定义） */
+    name?: string;
+    /** Provider 名称 */
+    providerName: string;
+    /** 模型显示名称 */
+    modelName: string;
+    /** API 格式 */
+    apiFormat: ApiFormat;
+    /** 模型能力列表 */
+    capabilities?: ModelCapability[];
+    /** 上下文窗口大小 */
+    contextLength?: number;
+    /** 创建时间 */
+    createdAt: number;
+    /** 最后使用时间 */
+    lastUsedAt?: number;
+    /** 连接状态 */
+    status?: 'untested' | 'connected' | 'error';
+    /** 最后错误信息 */
+    lastError?: string;
+}
+
+/** 通道管理器配置选项 */
+export interface ChannelManagerOptions {
+    /** 存储适配器（默认使用加密存储） */
+    storageAdapter?: StorageAdapter;
+    /** 存储键名前缀 */
+    storagePrefix?: string;
+    /** 当前激活通道的存储键 */
+    activeChannelKey?: string;
+    /** 后端代理地址（可选，用于解决 CORS 问题） */
+    proxyUrl?: string;
+}
+
+/** 通道查询过滤条件 */
+export interface ChannelFilter {
+    /** 按 Provider ID 过滤 */
+    providerId?: string;
+    /** 按 API 格式过滤 */
+    apiFormat?: ApiFormat;
+    /** 按模型能力过滤 */
+    capability?: ModelCapability;
+    /** 按连接状态过滤 */
+    status?: ChannelConfig['status'];
+    /** 关键字搜索（匹配名称、模型名、Provider 名） */
+    keyword?: string;
+}
+
+/** 聊天结果 */
+export interface ChatResult {
+    success: boolean;
+    content?: string;
+    message?: string;
+    latencyMs?: number;
+    channelId?: string;
+    model?: string;
+}
+
+/** 事件类型 */
+export type ChannelEventType = 'add' | 'update' | 'delete' | 'activate' | 'chat' | 'test' | 'clear';
+type ChannelEventListener = (data: any) => void;
+
+// ============ AIChannelManager ============
+
+export class AIChannelManager {
+    private storageAdapter: StorageAdapter;
+    private channels: ChannelConfig[] = [];
+    private activeChannelId: string | null = null;
+    private storagePrefix: string;
+    private activeChannelKey: string;
+    private proxyUrl?: string;
+    private listeners: Map<ChannelEventType, Set<ChannelEventListener>> = new Map();
+
+    constructor(options: ChannelManagerOptions = {}) {
+        this.storagePrefix = options.storagePrefix || 'ai_channel';
+        this.activeChannelKey = options.activeChannelKey || 'ai_active_channel';
+        this.proxyUrl = options.proxyUrl;
+        this.storageAdapter = options.storageAdapter || defaultStorageAdapter;
+
+        this.loadChannels();
+        this.loadActiveChannel();
+    }
+
+    // ==================== 事件系统 ====================
+
+    /** 监听事件 */
+    on(event: ChannelEventType, listener: ChannelEventListener): () => void {
+        if (!this.listeners.has(event)) {
+            this.listeners.set(event, new Set());
+        }
+        this.listeners.get(event)!.add(listener);
+        return () => this.off(event, listener);
+    }
+
+    /** 取消监听 */
+    off(event: ChannelEventType, listener: ChannelEventListener): void {
+        this.listeners.get(event)?.delete(listener);
+    }
+
+    private emit(event: ChannelEventType, data: any): void {
+        this.listeners.get(event)?.forEach(fn => fn(data));
+    }
+
+    // ==================== 存储相关 ====================
+
+    private getStorageKey(id: string): string {
+        return `${this.storagePrefix}_${id}`;
+    }
+
+    private loadChannels(): void {
+        try {
+            const keys = Object.keys(localStorage || {}).filter(key =>
+                key.startsWith(this.storagePrefix)
+            );
+            this.channels = keys.map(key => {
+                const raw = this.storageAdapter.get(key);
+                if (raw) return JSON.parse(raw) as ChannelConfig;
+                return null;
+            }).filter((c): c is ChannelConfig => c !== null);
+        } catch (e) {
+            console.error('Failed to load channels:', e);
+            this.channels = [];
+        }
+    }
+
+    private loadActiveChannel(): void {
+        try {
+            const raw = this.storageAdapter.get(this.activeChannelKey);
+            if (raw) this.activeChannelId = raw;
+        } catch (e) {
+            console.error('Failed to load active channel:', e);
+        }
+    }
+
+    private saveChannel(channel: ChannelConfig): void {
+        try {
+            this.storageAdapter.set(this.getStorageKey(channel.id), JSON.stringify(channel));
+        } catch (e) {
+            console.error('Failed to save channel:', e);
+        }
+    }
+
+    private deleteChannelFromStorage(id: string): void {
+        try {
+            this.storageAdapter.remove(this.getStorageKey(id));
+        } catch (e) {
+            console.error('Failed to delete channel from storage:', e);
+        }
+    }
+
+    private saveActiveChannel(): void {
+        try {
+            if (this.activeChannelId) {
+                this.storageAdapter.set(this.activeChannelKey, this.activeChannelId);
+            } else {
+                this.storageAdapter.remove(this.activeChannelKey);
+            }
+        } catch (e) {
+            console.error('Failed to save active channel:', e);
+        }
+    }
+
+    // ==================== 通道 CRUD ====================
+
+    /** 添加通道 */
+    async addChannel(config: AIConfig, name?: string): Promise<ChannelConfig> {
+        const provider = getProvider(config.providerId);
+        if (!provider) {
+            throw new Error(`Provider not found: ${config.providerId}`);
+        }
+
+        let modelName = config.modelName || config.model;
+        let capabilities: ModelCapability[] = [];
+        let contextLength: number | undefined;
+
+        try {
+            const models = await this.getProviderModels(config.providerId, config.apiKey, config.baseUrl);
+            const model = models.find(m => m.id === config.model);
+            if (model) {
+                modelName = model.name;
+                capabilities = model.capabilities || [];
+                contextLength = model.contextLength;
+            }
+        } catch (e) {
+            console.warn('Failed to fetch models, using static info:', e);
+        }
+
+        const channel: ChannelConfig = {
+            id: Date.now().toString() + Math.random().toString(36).slice(2, 6),
+            providerId: config.providerId,
+            providerName: provider.name,
+            model: config.model,
+            modelName,
+            apiKey: config.apiKey,
+            baseUrl: config.baseUrl,
+            apiFormat: provider.apiFormat,
+            capabilities,
+            contextLength,
+            name,
+            createdAt: Date.now(),
+            status: 'untested',
+        };
+
+        // 去重：相同 providerId + model + baseUrl 视为同一通道
+        const existingIndex = this.channels.findIndex(
+            c => c.providerId === channel.providerId &&
+                 c.model === channel.model &&
+                 c.baseUrl === channel.baseUrl
+        );
+
+        if (existingIndex >= 0) {
+            this.channels[existingIndex] = { ...channel, id: this.channels[existingIndex].id };
+            this.saveChannel(this.channels[existingIndex]);
+            this.emit('update', this.channels[existingIndex]);
+            return this.channels[existingIndex];
+        } else {
+            this.channels.unshift(channel);
+            this.saveChannel(channel);
+            this.emit('add', channel);
+            return channel;
+        }
+    }
+
+    /** 删除通道 */
+    deleteChannel(id: string): void {
+        const channel = this.getChannel(id);
+        if (!channel) return;
+
+        this.channels = this.channels.filter(c => c.id !== id);
+        this.deleteChannelFromStorage(id);
+
+        if (this.activeChannelId === id) {
+            this.activeChannelId = null;
+            this.saveActiveChannel();
+        }
+
+        this.emit('delete', { id, channel });
+    }
+
+    /** 更新通道 */
+    async updateChannel(id: string, config: Partial<AIConfig>, name?: string): Promise<ChannelConfig> {
+        const channel = this.channels.find(c => c.id === id);
+        if (!channel) {
+            throw new Error(`Channel not found: ${id}`);
+        }
+
+        const updated: ChannelConfig = { ...channel, ...config };
+        if (name !== undefined) updated.name = name;
+
+        // 如果关键字段变更，重新获取模型信息
+        if (config.providerId || config.model || config.baseUrl) {
+            const provider = getProvider(updated.providerId);
+            if (provider) {
+                updated.providerName = provider.name;
+                updated.apiFormat = provider.apiFormat;
+                try {
+                    const models = await this.getProviderModels(updated.providerId, updated.apiKey, updated.baseUrl);
+                    const model = models.find(m => m.id === updated.model);
+                    if (model) {
+                        updated.modelName = model.name;
+                        updated.capabilities = model.capabilities || [];
+                        updated.contextLength = model.contextLength;
+                    }
+                } catch (e) {
+                    console.warn('Failed to fetch models:', e);
+                }
+            }
+        }
+
+        const index = this.channels.findIndex(c => c.id === id);
+        this.channels[index] = updated;
+        this.saveChannel(updated);
+        this.emit('update', updated);
+
+        return updated;
+    }
+
+    // ==================== 通道查询 ====================
+
+    /** 获取所有通道 */
+    getChannels(): ChannelConfig[] {
+        return [...this.channels];
+    }
+
+    /** 根据 ID 获取通道 */
+    getChannel(id: string): ChannelConfig | undefined {
+        return this.channels.find(c => c.id === id);
+    }
+
+    /** 按 Provider ID 过滤通道 */
+    getChannelsByProvider(providerId: string): ChannelConfig[] {
+        return this.channels.filter(c => c.providerId === providerId);
+    }
+
+    /** 按模型能力过滤通道（如 vision, reasoning, audio） */
+    getChannelsByCapability(capability: ModelCapability): ChannelConfig[] {
+        return this.channels.filter(c => c.capabilities?.includes(capability));
+    }
+
+    /** 按 API 格式过滤通道（如 openai, anthropic, gemini） */
+    getChannelsByFormat(format: ApiFormat): ChannelConfig[] {
+        return this.channels.filter(c => c.apiFormat === format);
+    }
+
+    /** 按连接状态过滤通道 */
+    getChannelsByStatus(status: ChannelConfig['status']): ChannelConfig[] {
+        return this.channels.filter(c => c.status === status);
+    }
+
+    /** 综合条件查询通道 */
+    queryChannels(filter: ChannelFilter): ChannelConfig[] {
+        return this.channels.filter(c => {
+            if (filter.providerId && c.providerId !== filter.providerId) return false;
+            if (filter.apiFormat && c.apiFormat !== filter.apiFormat) return false;
+            if (filter.capability && !c.capabilities?.includes(filter.capability)) return false;
+            if (filter.status && c.status !== filter.status) return false;
+            if (filter.keyword) {
+                const kw = filter.keyword.toLowerCase();
+                const haystack = `${c.name || ''} ${c.modelName} ${c.providerName} ${c.model}`.toLowerCase();
+                if (!haystack.includes(kw)) return false;
+            }
+            return true;
+        });
+    }
+
+    /** 获取通道数量 */
+    getChannelCount(): number {
+        return this.channels.length;
+    }
+
+    // ==================== 激活管理 ====================
+
+    /** 获取当前激活的通道 */
+    getActiveChannel(): ChannelConfig | undefined {
+        if (!this.activeChannelId) return undefined;
+        return this.getChannel(this.activeChannelId);
+    }
+
+    /** 设置当前激活的通道 */
+    setActiveChannel(id: string): void {
+        const channel = this.getChannel(id);
+        if (!channel) {
+            throw new Error(`Channel not found: ${id}`);
+        }
+        this.activeChannelId = id;
+        this.saveActiveChannel();
+
+        const index = this.channels.findIndex(c => c.id === id);
+        this.channels[index].lastUsedAt = Date.now();
+        this.saveChannel(this.channels[index]);
+
+        this.emit('activate', channel);
+    }
+
+    /** 清除当前激活的通道 */
+    clearActiveChannel(): void {
+        this.activeChannelId = null;
+        this.saveActiveChannel();
+    }
+
+    // ==================== 模型查询 ====================
+
+    /** 获取 Provider 的可用模型列表（动态获取 + 静态兜底） */
+    async getProviderModels(providerId: string, apiKey?: string, baseUrl?: string): Promise<Model[]> {
+        const provider = getProvider(providerId);
+        if (!provider) {
+            throw new Error(`Provider not found: ${providerId}`);
+        }
+        return fetchModels({
+            provider,
+            apiKey,
+            baseUrl,
+            proxyUrl: this.proxyUrl,
+            fallbackToStatic: true,
+        });
+    }
+
+    /** 获取通道对应的 Provider 的模型列表 */
+    async getChannelModels(id: string): Promise<Model[]> {
+        const channel = this.getChannel(id);
+        if (!channel) {
+            throw new Error(`Channel not found: ${id}`);
+        }
+        return this.getProviderModels(channel.providerId, channel.apiKey, channel.baseUrl);
+    }
+
+    /** 获取 Provider 的静态模型列表（不发起网络请求） */
+    getStaticModelList(providerId: string): Model[] {
+        return getStaticModels(providerId);
+    }
+
+    /** 按能力过滤模型列表 */
+    getModelsByCapability(models: Model[], capability: ModelCapability): Model[] {
+        return models.filter(m => m.capabilities?.includes(capability));
+    }
+
+    /** 获取所有已配置的模型摘要列表 */
+    getConfiguredModels(): Array<{
+        channelId: string;
+        providerId: string;
+        providerName: string;
+        model: string;
+        modelName: string;
+        apiFormat: ApiFormat;
+        capabilities: ModelCapability[];
+        status: ChannelConfig['status'];
+    }> {
+        return this.channels.map(c => ({
+            channelId: c.id,
+            providerId: c.providerId,
+            providerName: c.providerName,
+            model: c.model,
+            modelName: c.modelName,
+            apiFormat: c.apiFormat,
+            capabilities: c.capabilities || [],
+            status: c.status,
+        }));
+    }
+
+    // ==================== API Key 管理 ====================
+
+    /** 更新通道的 API Key */
+    async updateApiKey(id: string, apiKey: string): Promise<ChannelConfig> {
+        return this.updateChannel(id, { apiKey });
+    }
+
+    /** 验证 API Key 格式（简单校验，非空且长度合理） */
+    validateApiKey(providerId: string, apiKey: string): { valid: boolean; message?: string } {
+        const provider = getProvider(providerId);
+        if (!provider) {
+            return { valid: false, message: `Provider not found: ${providerId}` };
+        }
+        if (!provider.needsApiKey) {
+            return { valid: true, message: '此 Provider 不需要 API Key' };
+        }
+        if (!apiKey || apiKey.trim().length === 0) {
+            return { valid: false, message: 'API Key 不能为空' };
+        }
+        if (apiKey.length < 10) {
+            return { valid: false, message: 'API Key 长度过短' };
+        }
+        return { valid: true };
+    }
+
+    /** 脱敏显示 API Key（如 sk-••••••••J4xK） */
+    maskApiKey(apiKey: string): string {
+        if (!apiKey || apiKey.length <= 8) return '••••••••';
+        return `${apiKey.slice(0, 4)}••••••••${apiKey.slice(-4)}`;
+    }
+
+    /** 获取通道的脱敏 API Key */
+    getMaskedApiKey(id: string): string {
+        const channel = this.getChannel(id);
+        if (!channel) return '';
+        return this.maskApiKey(channel.apiKey);
+    }
+
+    // ==================== 聊天执行 ====================
+
+    /** 使用当前激活的通道发送聊天请求 */
+    async chat(
+        message: string,
+        options?: {
+            messages?: Array<{ role: string; content: string }>;
+            maxTokens?: number;
+        }
+    ): Promise<ChatResult> {
+        const channel = this.getActiveChannel();
+        if (!channel) {
+            throw new Error('No active channel. Please set an active channel first.');
+        }
+        return this.chatWith(channel.id, message, options);
+    }
+
+    /** 使用指定通道发送聊天请求 */
+    async chatWith(
+        channelId: string,
+        message: string,
+        options?: {
+            messages?: Array<{ role: string; content: string }>;
+            maxTokens?: number;
+        }
+    ): Promise<ChatResult> {
+        const channel = this.getChannel(channelId);
+        if (!channel) {
+            throw new Error(`Channel not found: ${channelId}`);
+        }
+
+        const provider = getProvider(channel.providerId);
+        if (!provider) {
+            throw new Error(`Provider not found: ${channel.providerId}`);
+        }
+
+        const messages = options?.messages || [{ role: 'user', content: message }];
+
+        const result = await sendDirectChat({
+            apiFormat: channel.apiFormat,
+            baseUrl: channel.baseUrl || provider.baseUrl,
+            apiKey: channel.apiKey,
+            model: channel.model,
+            messages,
+            maxTokens: options?.maxTokens,
+        });
+
+        const chatResult: ChatResult = {
+            ...result,
+            channelId: channel.id,
+            model: channel.model,
+        };
+
+        if (result.success) {
+            const index = this.channels.findIndex(c => c.id === channel.id);
+            this.channels[index].lastUsedAt = Date.now();
+            this.channels[index].status = 'connected';
+            this.channels[index].lastError = undefined;
+            this.saveChannel(this.channels[index]);
+        } else {
+            const index = this.channels.findIndex(c => c.id === channel.id);
+            this.channels[index].status = 'error';
+            this.channels[index].lastError = result.message;
+            this.saveChannel(this.channels[index]);
+        }
+
+        this.emit('chat', chatResult);
+        return chatResult;
+    }
+
+    /** 使用当前激活通道发送流式聊天。onDelta 每次收到「累计完整文本」。 */
+    async chatStream(
+        message: string,
+        options: {
+            messages?: Array<{ role: string; content: string }>;
+            maxTokens?: number;
+            onDelta: (full: string) => void;
+            signal?: AbortSignal;
+        }
+    ): Promise<ChatResult> {
+        const channel = this.getActiveChannel();
+        if (!channel) {
+            throw new Error('No active channel. Please set an active channel first.');
+        }
+        return this.chatWithStream(channel.id, message, options);
+    }
+
+    /** 使用指定通道发送流式聊天。onDelta 每次收到「累计完整文本」。 */
+    async chatWithStream(
+        channelId: string,
+        message: string,
+        options: {
+            messages?: Array<{ role: string; content: string }>;
+            maxTokens?: number;
+            onDelta: (full: string) => void;
+            signal?: AbortSignal;
+        }
+    ): Promise<ChatResult> {
+        const channel = this.getChannel(channelId);
+        if (!channel) {
+            throw new Error(`Channel not found: ${channelId}`);
+        }
+
+        const provider = getProvider(channel.providerId);
+        if (!provider) {
+            throw new Error(`Provider not found: ${channel.providerId}`);
+        }
+
+        const messages = options.messages || [{ role: 'user', content: message }];
+
+        const result = await sendDirectChatStream({
+            apiFormat: channel.apiFormat,
+            baseUrl: channel.baseUrl || provider.baseUrl,
+            apiKey: channel.apiKey,
+            model: channel.model,
+            messages,
+            maxTokens: options.maxTokens,
+            onDelta: options.onDelta,
+            signal: options.signal,
+        });
+
+        const chatResult: ChatResult = {
+            ...result,
+            channelId: channel.id,
+            model: channel.model,
+        };
+
+        const index = this.channels.findIndex(c => c.id === channel.id);
+        if (result.success) {
+            this.channels[index].lastUsedAt = Date.now();
+            this.channels[index].status = 'connected';
+            this.channels[index].lastError = undefined;
+        } else {
+            this.channels[index].status = 'error';
+            this.channels[index].lastError = result.message;
+        }
+        this.saveChannel(this.channels[index]);
+        this.emit('chat', chatResult);
+        return chatResult;
+    }
+
+    /** 测试指定通道的连接 */
+    async testChannel(id: string): Promise<{ success: boolean; latencyMs?: number; message?: string }> {
+        const channel = this.getChannel(id);
+        if (!channel) {
+            throw new Error(`Channel not found: ${id}`);
+        }
+
+        const provider = getProvider(channel.providerId);
+        if (!provider) {
+            throw new Error(`Provider not found: ${channel.providerId}`);
+        }
+
+        const result = await testDirectConnection({
+            apiFormat: channel.apiFormat,
+            baseUrl: channel.baseUrl || provider.baseUrl,
+            apiKey: channel.apiKey,
+            model: channel.model,
+        });
+
+        // 更新通道状态
+        const index = this.channels.findIndex(c => c.id === id);
+        if (result.success) {
+            this.channels[index].status = 'connected';
+            this.channels[index].lastError = undefined;
+        } else {
+            this.channels[index].status = 'error';
+            this.channels[index].lastError = result.message;
+        }
+        this.saveChannel(this.channels[index]);
+
+        this.emit('test', { id, ...result });
+        return result;
+    }
+
+    /** 测试所有通道连接 */
+    async testAllChannels(): Promise<Array<{ id: string; channel: ChannelConfig; result: { success: boolean; latencyMs?: number; message?: string } }>> {
+        const results = await Promise.all(
+            this.channels.map(async channel => {
+                try {
+                    const result = await this.testChannel(channel.id);
+                    return { id: channel.id, channel, result };
+                } catch (e) {
+                    return { id: channel.id, channel, result: { success: false, message: e instanceof Error ? e.message : String(e) } };
+                }
+            })
+        );
+        return results;
+    }
+
+    // ==================== Provider 查询 ====================
+
+    /** 获取所有可用的 Provider */
+    getAvailableProviders(): Provider[] {
+        return getAllProviders();
+    }
+
+    /** 获取单个 Provider 信息 */
+    getProvider(providerId: string): Provider | undefined {
+        return getProvider(providerId);
+    }
+
+    /** 按 API 格式获取 Provider 列表 */
+    getProvidersByFormat(format: ApiFormat): Provider[] {
+        return getProvidersByFormat(format);
+    }
+
+    // ==================== 导入导出 ====================
+
+    /** 导出所有通道配置（不包含 API Key 明文） */
+    exportChannels(includeApiKeys?: boolean): string {
+        const data = this.channels.map(c => {
+            if (includeApiKeys) return c;
+            const { apiKey, ...rest } = c;
+            return { ...rest, apiKey: this.maskApiKey(apiKey) };
+        });
+        return JSON.stringify({
+            version: 1,
+            exportedAt: Date.now(),
+            channels: data,
+        }, null, 2);
+    }
+
+    /** 导入通道配置 */
+    async importChannels(json: string, merge: boolean = true): Promise<ChannelConfig[]> {
+        const data = JSON.parse(json);
+        if (!data.channels || !Array.isArray(data.channels)) {
+            throw new Error('Invalid import format: missing channels array');
+        }
+
+        if (!merge) {
+            this.clearAllChannels();
+        }
+
+        const imported: ChannelConfig[] = [];
+        for (const ch of data.channels) {
+            // 跳过被脱敏的 API Key
+            if (ch.apiKey && ch.apiKey.includes('••••')) {
+                console.warn(`Skipping channel ${ch.modelName}: API Key is masked`);
+                continue;
+            }
+
+            const config: AIConfig = {
+                providerId: ch.providerId,
+                apiKey: ch.apiKey,
+                model: ch.model,
+                modelName: ch.modelName,
+                baseUrl: ch.baseUrl,
+            };
+            const channel = await this.addChannel(config, ch.name);
+            imported.push(channel);
+        }
+
+        return imported;
+    }
+
+    // ==================== 批量操作 ====================
+
+    /** 清空所有通道 */
+    clearAllChannels(): void {
+        this.channels.forEach(channel => {
+            this.deleteChannelFromStorage(channel.id);
+        });
+        this.channels = [];
+        this.activeChannelId = null;
+        this.saveActiveChannel();
+        this.emit('clear', {});
+    }
+
+    /** 批量删除通道 */
+    deleteChannels(ids: string[]): void {
+        ids.forEach(id => this.deleteChannel(id));
+    }
+
+    /** 获取统计信息 */
+    getStats(): {
+        total: number;
+        byStatus: Record<string, number>;
+        byFormat: Record<string, number>;
+        byProvider: Record<string, number>;
+        byCapability: Record<string, number>;
+    } {
+        const stats = {
+            total: this.channels.length,
+            byStatus: {} as Record<string, number>,
+            byFormat: {} as Record<string, number>,
+            byProvider: {} as Record<string, number>,
+            byCapability: {} as Record<string, number>,
+        };
+
+        for (const c of this.channels) {
+            const status = c.status || 'untested';
+            stats.byStatus[status] = (stats.byStatus[status] || 0) + 1;
+            stats.byFormat[c.apiFormat] = (stats.byFormat[c.apiFormat] || 0) + 1;
+            stats.byProvider[c.providerId] = (stats.byProvider[c.providerId] || 0) + 1;
+            for (const cap of c.capabilities || []) {
+                stats.byCapability[cap] = (stats.byCapability[cap] || 0) + 1;
+            }
+        }
+
+        return stats;
+    }
+}