@kafca/agentdock 0.1.46 → 0.1.47

package/dist-electron/services/local-ai-core/src/runtime/local-core-controller.js

@@ -2,28 +2,28 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.LocalCoreController = void 0;
 const node_events_1 = require("node:events");
-const node_crypto_1 = require("node:crypto");
-const node_fs_1 = require("node:fs");
-const node_path_1 = require("node:path");
 const desktop_js_1 = require("../../../../shared/desktop.js");
 const bootstrap_js_1 = require("../kernel/bootstrap.js");
 const local_core_errors_js_1 = require("../kernel/local-core-errors.js");
 const runtime_detection_service_js_1 = require("./runtime-detection-service.js");
 const provider_config_migration_js_1 = require("./provider-config-migration.js");
+const channel_service_js_1 = require("./channel-service.js");
+const external_service_js_1 = require("./external-service.js");
 const deployment_diagnostics_js_1 = require("./deployment-diagnostics.js");
 class LocalCoreController extends node_events_1.EventEmitter {
     userDataPath;
-    state;
+    store;
     workspaceRouter;
     knowledgeProvider;
-    channelRuntimes;
+    channelService;
+    externalService;
     scheduledJobs;
     automationMonitors;
-    store;
-    kernel;
-    runtime;
     runtimeDetection;
+    kernel;
     errorReporter;
+    state;
+    runtime;
     busUnsubscribers = [];
     pendingLogs = [];
     handlingLog = false;
@@ -41,7 +41,12 @@ class LocalCoreController extends node_events_1.EventEmitter {
         this.knowledgeProvider = this.runtime.knowledgeProvider;
         this.workspaceRouter = this.runtime.workspaceRouter;
         const runtimeChannels = this.runtime.channelRuntimes || [this.runtime.channelRuntime, this.runtime.weixinChannelRuntime];
-        this.channelRuntimes = new Map(runtimeChannels.filter(Boolean).map((runtime) => [runtime.platform, runtime]));
+        const channelRuntimes = new Map(runtimeChannels.filter(Boolean).map((ch) => [ch.platform, ch]));
+        this.channelService = new channel_service_js_1.ChannelService(channelRuntimes);
+        this.externalService = new external_service_js_1.ExternalService(this.store, this.workspaceRouter, {
+            readConfigState: () => this.readConfigFile(),
+            saveStructuredConfig: (config) => this.saveStructuredConfigFile(config),
+        }, userDataPath);
         this.scheduledJobs = this.runtime.scheduledJobs;
         this.automationMonitors = this.runtime.automationMonitors || {
             listMonitors: () => [],
@@ -132,7 +137,7 @@ class LocalCoreController extends node_events_1.EventEmitter {
         return { status: 'running' };
     }
     async restartService() {
-        await this.refreshChannelBindings();
+        await this.channelService.refreshBindings();
         await this.emitRuntime();
         return { status: 'running' };
     }
@@ -147,437 +152,30 @@ class LocalCoreController extends node_events_1.EventEmitter {
     }
     async saveRawConfigFile(raw) {
         const next = await this.state.saveRawConfigFile(raw);
-        await this.refreshChannelBindings();
+        await this.channelService.refreshBindings();
         await this.emitRuntime();
         return next;
     }
     async saveStructuredConfigFile(config) {
         const migrated = (0, provider_config_migration_js_1.migrateLegacyProjectProvidersToStore)(config, this.store);
         const next = await this.state.saveStructuredConfigFile(migrated.config);
-        await this.refreshChannelBindings();
+        await this.channelService.refreshBindings();
         await this.emitRuntime();
         return next;
     }
-    async listModelProviders() {
-        return { providers: this.store.listModelProviders() };
-    }
-    async createModelProvider(input) {
-        return this.store.upsertModelProvider(input);
-    }
-    async updateModelProvider(providerId, input) {
-        const existing = this.store.getModelProvider(providerId);
-        if (!existing) {
-            throw new Error(`Provider not found: ${providerId}`);
-        }
-        return this.store.upsertModelProvider({ ...input, id: providerId });
-    }
-    async deleteModelProvider(providerId) {
-        const config = await this.readAndMigrateConfigFile();
-        const referencingProjects = (config.parsed?.projects || [])
-            .filter((project) => project.agent?.options?.provider_id === providerId)
-            .map((project) => project.name);
-        if (referencingProjects.length > 0) {
-            throw new Error(`Provider "${providerId}" is still used by projects: ${referencingProjects.join(', ')}`);
-        }
-        return this.store.deleteModelProvider(providerId);
-    }
     async saveSettings(input) {
         const settings = await this.state.saveSettings(input);
-        await this.refreshChannelBindings();
+        await this.channelService.refreshBindings();
         await this.emitRuntime();
         return settings;
     }
-    async ensureExternalProject(input) {
-        const userId = normalizeExternalId(input.user_id, 'user_id');
-        const externalProjectId = normalizeExternalId(input.external_project_id, 'external_project_id');
-        const agentType = normalizeExternalSegment(input.agent_type || 'pi', 'pi');
-        const existing = this.store.getExternalProject(userId, externalProjectId);
-        const provider = this.resolveExternalProvider(input.provider_id || existing?.providerId);
-        const workspaceId = externalWorkspaceId(userId, externalProjectId);
-        const workspacePath = this.externalProjectBasePath(userId, externalProjectId);
-        const displayName = String(input.display_name || externalProjectId).trim() || externalProjectId;
-        (0, node_fs_1.mkdirSync)(workspacePath, { recursive: true, mode: 0o700 });
-        const now = new Date().toISOString();
-        const project = this.store.upsertExternalProject({
-            userId,
-            externalProjectId,
-            workspaceId,
-            workspacePath,
-            displayName,
-            agentType,
-            providerId: provider.id,
-            metadata: input.metadata || existing?.metadata || {},
-            createdAt: existing?.createdAt || now,
-            updatedAt: now,
-        });
-        await this.ensureExternalWorkspaceConfig(project, input.model);
-        this.store.upsertWorkspaceRegistryEntry({
-            workspaceId: project.workspaceId,
-            displayName: project.displayName,
-            path: project.workspacePath,
-            deviceId: 'external',
-            defaultRuntimeId: project.agentType,
-            health: { status: 'healthy', summary: 'External workspace is available.', issues: [], checkedAt: now },
-            metadata: {
-                external: true,
-                userId: project.userId,
-                externalProjectId: project.externalProjectId,
-            },
-        });
-        return project;
-    }
-    async createExternalRun(input) {
-        if (!String(input.prompt || '').trim()) {
-            throw new Error('prompt is required.');
-        }
-        const project = await this.ensureExternalProject(input);
-        const thread = await this.ensureExternalThread(project, input);
-        const sent = await this.workspaceRouter.sendThreadMessage(thread.threadId, input.prompt, {
-            permissionMode: input.permission_mode,
-            runtimeEnv: input.runtime_env,
-        });
-        const task = this.store.getAgentTaskByRunId(sent.runId);
-        return {
-            project,
-            thread,
-            workspace_id: project.workspaceId,
-            thread_id: thread.threadId,
-            run_id: sent.runId,
-            task_id: task?.taskId,
-            events_url: `/api/local/v1/external/runs/${encodeURIComponent(sent.runId)}/events`,
-        };
-    }
-    async getExternalRunSnapshot(runId) {
-        const task = this.store.getAgentTaskByRunId(runId);
-        const run = this.store.getRun(runId);
-        const threadId = task?.threadId || run?.thread_id || '';
-        const thread = threadId
-            ? await this.workspaceRouter.getThread(threadId).catch(() => undefined)
-            : undefined;
-        return {
-            runId,
-            task,
-            thread,
-        };
-    }
-    async readAndMigrateConfigFile() {
-        const current = await this.state.readConfigFile();
-        if (!current.parsed) {
-            return current;
-        }
-        const migrated = (0, provider_config_migration_js_1.migrateLegacyProjectProvidersToStore)(current.parsed, this.store);
-        if (!migrated.changed) {
-            return current;
-        }
-        const saved = await this.state.saveStructuredConfigFile(migrated.config);
-        return {
-            ...saved,
-            warnings: [
-                ...(current.warnings || []),
-                ...(saved.warnings || []),
-                ...migrated.warnings,
-            ],
-        };
-    }
-    resolveExternalProvider(providerId) {
-        const requested = String(providerId || '').trim();
-        if (requested) {
-            const provider = this.store.getModelProvider(requested);
-            if (!provider) {
-                throw new Error(`Provider not found: ${requested}`);
-            }
-            return provider;
-        }
-        const provider = this.store.listModelProviders()[0];
-        if (!provider) {
-            throw new Error('No model provider is configured. Create a provider before starting an external run.');
-        }
-        return provider;
-    }
-    async ensureExternalWorkspaceConfig(project, model) {
-        const current = await this.readAndMigrateConfigFile();
-        const config = {
-            ...(current.parsed || {}),
-            projects: Array.isArray(current.parsed?.projects) ? [...current.parsed.projects] : [],
-        };
-        const existingIndex = config.projects.findIndex((item) => item?.name === project.workspaceId);
-        const existing = existingIndex >= 0 ? config.projects[existingIndex] : undefined;
-        const defaultRuntimeImageId = Array.isArray(config.sandbox_runtime_images)
-            ? config.sandbox_runtime_images.find((image) => image?.agent_type === project.agentType)?.id
-            : undefined;
-        const options = {
-            ...(existing?.agent?.options || {}),
-            work_dir: project.workspacePath,
-            user_id: project.userId,
-            provider_id: project.providerId,
-            ...(model ? { model } : {}),
-            sandbox: {
-                ...(existing?.agent?.options?.sandbox || {}),
-                enabled: true,
-                ...(defaultRuntimeImageId ? { runtime_image_id: defaultRuntimeImageId } : {}),
-                state_scope: 'project',
-                sandbox_lifecycle: 'per_thread',
-            },
-        };
-        const nextProject = {
-            name: project.workspaceId,
-            agent: {
-                ...(existing?.agent || {}),
-                type: project.agentType,
-                options,
-            },
-            platforms: Array.isArray(existing?.platforms) ? existing.platforms : [],
-            admin_from: existing?.admin_from,
-            disabled_commands: existing?.disabled_commands,
-        };
-        if (existingIndex >= 0) {
-            config.projects[existingIndex] = nextProject;
-        }
-        else {
-            config.projects.push(nextProject);
-        }
-        await this.saveStructuredConfigFile(config);
-    }
-    async ensureExternalThread(project, input) {
-        const externalThreadId = normalizeExternalId(input.external_thread_id || `thread-${(0, node_crypto_1.randomUUID)()}`, 'external_thread_id');
-        const existing = this.store.getExternalThread(project.userId, project.externalProjectId, externalThreadId);
-        if (existing) {
-            const thread = await this.workspaceRouter.getThread(existing.threadId).catch(() => undefined);
-            if (thread) {
-                return existing;
-            }
-        }
-        const workspacePath = this.externalThreadWorkspacePath(project.userId, project.externalProjectId, externalThreadId);
-        (0, node_fs_1.mkdirSync)(workspacePath, { recursive: true, mode: 0o700 });
-        const title = String(input.title || externalThreadId).trim() || externalThreadId;
-        const thread = await this.workspaceRouter.createThread(project.workspaceId, title);
-        const now = new Date().toISOString();
-        return this.store.upsertExternalThread({
-            userId: project.userId,
-            externalProjectId: project.externalProjectId,
-            externalThreadId,
-            workspaceId: project.workspaceId,
-            threadId: thread.id,
-            workspacePath,
-            metadata: input.metadata || {},
-            createdAt: now,
-            updatedAt: now,
-        });
-    }
-    externalProjectBasePath(userId, externalProjectId) {
-        return (0, node_path_1.join)(this.externalWorkspaceRoot(), 'users', normalizeExternalSegment(userId, 'user'), 'projects', normalizeExternalSegment(externalProjectId, 'project'));
-    }
-    externalThreadWorkspacePath(userId, externalProjectId, externalThreadId) {
-        return (0, node_path_1.join)(this.externalProjectBasePath(userId, externalProjectId), 'threads', normalizeExternalSegment(externalThreadId, 'thread'), 'workspace');
-    }
-    externalWorkspaceRoot() {
-        return String(process.env.AGENTDOCK_EXTERNAL_WORKSPACE_ROOT || '').trim()
-            || (0, node_path_1.join)(this.userDataPath, 'external-workspaces');
-    }
-    async listWorkspaces() {
-        return this.workspaceRouter.listWorkspaces();
-    }
-    async listWorkspaceRegistry() {
-        return this.workspaceRouter.listWorkspaceRegistry();
-    }
-    async getWorkspaceRegistryEntry(workspaceId) {
-        return this.workspaceRouter.getWorkspaceRegistryEntry(workspaceId);
-    }
-    async createWorkspaceRegistryEntry(input) {
-        return this.workspaceRouter.createWorkspaceRegistryEntry(input);
-    }
-    async updateWorkspaceRegistryEntry(workspaceId, input) {
-        return this.workspaceRouter.updateWorkspaceRegistryEntry(workspaceId, input);
-    }
-    async deleteWorkspaceRegistryEntry(workspaceId) {
-        return this.workspaceRouter.deleteWorkspaceRegistryEntry(workspaceId);
-    }
-    async listAgentTasks(query = {}) {
-        return this.workspaceRouter.listAgentTasks(query);
-    }
-    async getAgentTask(taskId) {
-        return this.workspaceRouter.getAgentTask(taskId);
-    }
-    async createAgentTask(input) {
-        return this.workspaceRouter.createAgentTask(input);
-    }
-    async updateAgentTask(taskId, input) {
-        return this.workspaceRouter.updateAgentTask(taskId, input);
-    }
-    async getWorkspaceSecuritySettings(workspaceId) {
-        return this.workspaceRouter.getWorkspaceSecuritySettings(workspaceId);
-    }
-    async updateWorkspaceSecuritySettings(workspaceId, input) {
-        return this.workspaceRouter.updateWorkspaceSecuritySettings(workspaceId, input);
-    }
-    async classifyCommand(command, workspaceId) {
-        return this.workspaceRouter.classifyCommand(command, workspaceId);
-    }
-    async listApprovalRequests(query = {}) {
-        return this.workspaceRouter.listApprovalRequests(query);
-    }
-    async getApprovalRequest(approvalId) {
-        return this.workspaceRouter.getApprovalRequest(approvalId);
-    }
-    async createApprovalRequest(input) {
-        return this.workspaceRouter.createApprovalRequest(input);
-    }
-    async resolveApprovalRequest(approvalId, input) {
-        return this.workspaceRouter.resolveApprovalRequest(approvalId, input);
-    }
-    async listAuditEvents(query = {}) {
-        return this.workspaceRouter.listAuditEvents(query);
-    }
-    async listScheduledJobs(workspaceId) {
-        return this.scheduledJobs.listJobs(workspaceId);
-    }
-    async getScheduledJob(jobId) {
-        const job = this.scheduledJobs.getJob(jobId);
-        if (!job) {
-            throw new Error(`Scheduled job not found: ${jobId}`);
-        }
-        return job;
-    }
-    async createScheduledJob(input) {
-        return this.scheduledJobs.createJob(input);
-    }
-    async updateScheduledJob(jobId, input) {
-        return this.scheduledJobs.updateJob(jobId, input);
-    }
-    async deleteScheduledJob(jobId) {
-        return this.scheduledJobs.deleteJob(jobId);
-    }
-    async runScheduledJob(jobId) {
-        return this.scheduledJobs.runJobNow(jobId);
-    }
-    async listScheduledJobRuns(jobId) {
-        return this.scheduledJobs.listJobRuns(jobId);
-    }
-    async listAutomationMonitors(workspaceId) {
-        return this.automationMonitors.listMonitors(workspaceId);
-    }
-    async getAutomationMonitor(monitorId) {
-        const monitor = this.automationMonitors.getMonitor(monitorId);
-        if (!monitor) {
-            throw new Error(`Automation monitor not found: ${monitorId}`);
-        }
-        return monitor;
-    }
-    async createAutomationMonitor(input) {
-        return this.automationMonitors.createMonitor(input);
-    }
-    async updateAutomationMonitor(monitorId, input) {
-        return this.automationMonitors.updateMonitor(monitorId, input);
-    }
-    async deleteAutomationMonitor(monitorId) {
-        return this.automationMonitors.deleteMonitor(monitorId);
-    }
-    async runAutomationMonitor(monitorId) {
-        return this.automationMonitors.runMonitorNow(monitorId);
-    }
-    async listAutomationMonitorRuns(monitorId) {
-        return this.automationMonitors.listRuns(monitorId);
-    }
-    async listThreads(workspaceId) {
-        return this.workspaceRouter.listThreads(workspaceId);
-    }
-    async createThread(workspaceId, title) {
-        return this.workspaceRouter.createThread(workspaceId, title);
-    }
-    async getThread(threadId) {
-        return this.workspaceRouter.getThread(threadId);
-    }
-    async renameThread(threadId, title) {
-        return this.workspaceRouter.renameThread(threadId, title);
-    }
-    async updateThreadKnowledgeBases(threadId, knowledgeBaseIds) {
-        return this.workspaceRouter.updateThreadKnowledgeBases(threadId, knowledgeBaseIds);
-    }
-    async deleteThread(threadId) {
-        return this.workspaceRouter.deleteThread(threadId);
-    }
-    async sendThreadMessage(threadId, content) {
-        return this.workspaceRouter.sendThreadMessage(threadId, content);
-    }
-    async sendThreadAction(threadId, content) {
-        return this.workspaceRouter.sendThreadAction(threadId, content);
-    }
-    async interruptRun(runId) {
-        return this.workspaceRouter.interruptRun(runId);
-    }
-    async listKnowledgeSources() {
-        return this.knowledgeProvider.listSources();
-    }
-    async getKnowledgeConfig() {
-        return this.knowledgeProvider.getConfig();
-    }
-    async updateKnowledgeConfig(input) {
-        return this.knowledgeProvider.updateConfig(input);
-    }
-    async listKnowledgeFolders() {
-        return this.knowledgeProvider.listFolders();
-    }
-    async createKnowledgeFolder(input) {
-        return this.knowledgeProvider.createFolder(input);
-    }
-    async updateKnowledgeFolder(id, input) {
-        return this.knowledgeProvider.updateFolder(id, input);
-    }
-    async deleteKnowledgeFolder(id) {
-        return this.knowledgeProvider.deleteFolder(id);
-    }
-    async listKnowledgeBases() {
-        return this.knowledgeProvider.listKnowledgeBases();
-    }
-    async getKnowledgeBase(id) {
-        return this.knowledgeProvider.getKnowledgeBase(id);
-    }
-    async createKnowledgeBase(input) {
-        return this.knowledgeProvider.createKnowledgeBase(input);
-    }
-    async updateKnowledgeBase(id, input) {
-        return this.knowledgeProvider.updateKnowledgeBase(id, input);
-    }
-    async deleteKnowledgeBase(id) {
-        return this.knowledgeProvider.deleteKnowledgeBase(id);
-    }
-    async listKnowledgeBaseFiles(knowledgeBaseId) {
-        return this.knowledgeProvider.listKnowledgeBaseFiles(knowledgeBaseId);
-    }
-    async uploadKnowledgeBaseFiles(knowledgeBaseId, request) {
-        return this.knowledgeProvider.uploadKnowledgeBaseFiles(knowledgeBaseId, request);
-    }
-    async deleteKnowledgeBaseFile(knowledgeBaseId, fileId) {
-        return this.knowledgeProvider.deleteKnowledgeBaseFile(knowledgeBaseId, fileId);
-    }
-    async searchKnowledgeBase(knowledgeBaseId, input) {
-        return this.knowledgeProvider.searchKnowledgeBase(knowledgeBaseId, input);
-    }
-    async getCapabilities() {
-        return this.kernel.getCapabilitySnapshot();
-    }
-    async getCapabilitySnapshot() {
-        return this.kernel.getCapabilitySnapshot().snapshot;
-    }
-    async listInstalledAgentRuntimes() {
-        return this.runtimeDetection.list();
-    }
-    async refreshInstalledAgentRuntimes(runtimeId) {
-        return this.runtimeDetection.refresh(runtimeId);
-    }
-    isRuntimeDetectionRunning(runtimeId) {
-        return this.runtimeDetection.isChecking(runtimeId);
-    }
     async getPluginDiagnostics() {
         return this.kernel.diagnostics.snapshot();
     }
-    async listDiagnosticErrors() {
-        return this.errorReporter.list();
-    }
     async runDiagnosticsDoctor() {
         const checkedAt = new Date().toISOString();
         const configFile = await this.readConfigFile();
-        const runtimeChecks = await this.refreshInstalledAgentRuntimes().catch((error) => {
+        const runtimeChecks = await this.runtimeDetection.refresh().catch((error) => {
             const errorInfo = (0, local_core_errors_js_1.toLocalCoreErrorInfo)(error, 'internal_error');
             return [{
                     agentType: 'runtime',
@@ -595,7 +193,7 @@ class LocalCoreController extends node_events_1.EventEmitter {
                     lastLaunchError: errorInfo,
                 }];
         });
-        const channelStatuses = await this.listChannelGatewayStatuses().catch(() => []);
+        const channelStatuses = await this.channelService.listStatuses().catch(() => []);
         const checks = [
             configFile.error
                 ? {
@@ -642,144 +240,15 @@ class LocalCoreController extends node_events_1.EventEmitter {
         const configFile = await this.readConfigFile();
         return (0, deployment_diagnostics_js_1.runDeploymentDiagnostics)({ config: configFile.parsed });
     }
-    async probeWorkspaceStreaming(workspaceId) {
-        return this.workspaceRouter.probeWorkspaceStreaming(workspaceId);
-    }
-    handleRuntimeDetectionEvent(event) {
-        this.emit('runtime-detection', event);
-    }
-    async listChannelGatewayStatuses(platform) {
-        if (!platform) {
-            const statuses = await Promise.all([...this.channelRuntimes.values()].map((runtime) => runtime.listStatuses()));
-            return statuses.flat();
-        }
-        return this.resolveChannelRuntime(platform).listStatuses();
-    }
-    async getChannelGatewayStatus(platform, workspaceId, instanceId) {
-        return this.resolveChannelRuntime(platform).getStatus(workspaceId, instanceId);
-    }
-    async testChannelConnection(platform, workspaceId, instanceId) {
-        return this.resolveChannelRuntime(platform).testConnection(workspaceId, instanceId);
-    }
-    async enableChannelGateway(platform, workspaceId, instanceId) {
-        return this.resolveChannelRuntime(platform).enable(workspaceId, instanceId);
-    }
-    async disableChannelGateway(platform, workspaceId, instanceId) {
-        return this.resolveChannelRuntime(platform).disable(workspaceId, instanceId);
-    }
-    async listChannelPendingPairings(platform, workspaceId) {
-        return this.resolveChannelRuntime(platform).listPendingPairings(workspaceId);
-    }
-    async approveChannelPairing(platform, code) {
-        return this.resolveChannelRuntime(platform).approvePairing(code);
-    }
-    async rejectChannelPairing(platform, code) {
-        return this.resolveChannelRuntime(platform).rejectPairing(code);
-    }
-    async listChannelAuthorizedUsers(platform, workspaceId) {
-        return this.resolveChannelRuntime(platform).listAuthorizedUsers(workspaceId);
-    }
-    async sendChannelFile(platform, workspaceId, input) {
-        const runtime = this.resolveChannelRuntime(platform);
-        if (runtime.sendOutboundMessage) {
-            const result = await runtime.sendOutboundMessage(workspaceId, {
-                route: {
-                    type: 'channel.chat',
-                    channelId: input.channelId,
-                    participantId: input.participantId,
-                },
-                parts: [{
-                        type: 'file',
-                        path: input.path,
-                        fileName: input.fileName,
-                        metadata: input.workspacePath ? { workspacePath: input.workspacePath } : undefined,
-                    }],
-            });
-            const attachment = result.attachments?.[0];
-            return {
-                platform: result.platform,
-                workspaceId: result.workspaceId,
-                channelId: result.channelId,
-                messageId: result.messageIds[0] || '',
-                messageIds: result.messageIds,
-                fileKey: String(attachment?.metadata?.fileKey || attachment?.attachmentId || ''),
-                attachmentId: attachment?.attachmentId,
-                fileName: attachment?.fileName || input.fileName || '',
-                fileSize: attachment?.fileSize || 0,
-                metadata: result.metadata,
-            };
-        }
-        if (!runtime.sendFile) {
-            throw new Error(`Channel platform does not support sending files: ${platform}`);
-        }
-        return runtime.sendFile(workspaceId, input);
-    }
-    async sendChannelMessage(platform, workspaceId, input) {
-        const runtime = this.resolveChannelRuntime(platform);
-        if (!runtime.sendOutboundMessage) {
-            throw new Error(`Channel platform does not support outbound messages: ${platform}`);
-        }
-        return runtime.sendOutboundMessage(workspaceId, input);
-    }
-    async getWeixinQrCode(workspaceId, instanceId) {
-        return this.getChannelQrCode('weixin', workspaceId, instanceId);
-    }
-    async checkWeixinQrCodeStatus(workspaceId, ticket, instanceId) {
-        return this.checkChannelQrCodeStatus('weixin', workspaceId, ticket, instanceId);
-    }
-    async getLarkQrCode(workspaceId, instanceId) {
-        return this.getChannelQrCode('lark', workspaceId, instanceId);
-    }
-    async checkLarkQrCodeStatus(workspaceId, ticket, instanceId) {
-        return this.checkChannelQrCodeStatus('lark', workspaceId, ticket, instanceId);
-    }
-    async getChannelQrCode(platform, workspaceId, instanceId) {
-        const runtime = this.resolveChannelRuntime(platform);
-        if (!runtime.getQrCode) {
-            throw new Error(`Channel platform does not support QR setup: ${platform}`);
-        }
-        return runtime.getQrCode(workspaceId, instanceId);
-    }
-    async checkChannelQrCodeStatus(platform, workspaceId, ticket, instanceId) {
-        const runtime = this.resolveChannelRuntime(platform);
-        if (!runtime.checkQrCodeStatus) {
-            throw new Error(`Channel platform does not support QR setup: ${platform}`);
-        }
-        return runtime.checkQrCodeStatus(workspaceId, ticket, instanceId);
-    }
-    async listLarkGatewayStatuses() {
-        return this.listChannelGatewayStatuses('lark');
-    }
-    async getLarkGatewayStatus(workspaceId, instanceId) {
-        return this.getChannelGatewayStatus('lark', workspaceId, instanceId);
-    }
-    async testLarkConnection(workspaceId, instanceId) {
-        return this.testChannelConnection('lark', workspaceId, instanceId);
-    }
-    async enableLarkGateway(workspaceId, instanceId) {
-        return this.enableChannelGateway('lark', workspaceId, instanceId);
-    }
-    async disableLarkGateway(workspaceId, instanceId) {
-        return this.disableChannelGateway('lark', workspaceId, instanceId);
-    }
-    async listLarkPendingPairings(workspaceId) {
-        return this.listChannelPendingPairings('lark', workspaceId);
-    }
-    async approveLarkPairing(code) {
-        return this.approveChannelPairing('lark', code);
-    }
-    async rejectLarkPairing(code) {
-        return this.rejectChannelPairing('lark', code);
-    }
-    async listLarkAuthorizedUsers(workspaceId) {
-        return this.listChannelAuthorizedUsers('lark', workspaceId);
-    }
     emitBridge(event) {
         this.emit('bridge', event);
     }
     async emitRuntime() {
         this.emit('runtime', await this.getRuntimeStatus());
     }
+    handleRuntimeDetectionEvent(event) {
+        this.emit('runtime-detection', event);
+    }
     handleLog(message) {
         if (this.handlingLog) {
             return;
@@ -814,45 +283,24 @@ class LocalCoreController extends node_events_1.EventEmitter {
             this.handlingLog = false;
         }
     }
-    async refreshChannelBindings() {
-        await Promise.all([...this.channelRuntimes.values()].map((runtime) => runtime.refreshBindings?.()));
-    }
-    resolveChannelRuntime(platform) {
-        const runtime = this.channelRuntimes.get(platform);
-        if (runtime) {
-            return runtime;
+    async readAndMigrateConfigFile() {
+        const current = await this.state.readConfigFile();
+        if (!current.parsed) {
+            return current;
         }
-        throw new Error(`Unsupported channel platform: ${platform}`);
-    }
-    assertPlatform(platform) {
-        this.resolveChannelRuntime(platform);
+        const migrated = (0, provider_config_migration_js_1.migrateLegacyProjectProvidersToStore)(current.parsed, this.store);
+        if (!migrated.changed) {
+            return current;
+        }
+        const saved = await this.state.saveStructuredConfigFile(migrated.config);
+        return {
+            ...saved,
+            warnings: [
+                ...(current.warnings || []),
+                ...(saved.warnings || []),
+                ...migrated.warnings,
+            ],
+        };
     }
 }
 exports.LocalCoreController = LocalCoreController;
-function normalizeExternalId(value, label) {
-    const normalized = String(value || '').trim();
-    if (!normalized) {
-        throw new Error(`${label} is required.`);
-    }
-    return normalized;
-}
-function normalizeExternalSegment(value, fallback) {
-    return String(value || '')
-        .trim()
-        .toLowerCase()
-        .replace(/[^a-z0-9._-]+/g, '-')
-        .replace(/^-+|-+$/g, '')
-        || fallback;
-}
-function externalWorkspaceId(userId, externalProjectId) {
-    const base = [
-        'external',
-        normalizeExternalSegment(userId, 'user'),
-        normalizeExternalSegment(externalProjectId, 'project'),
-    ].join('-');
-    const digest = (0, node_crypto_1.createHash)('sha256')
-        .update(`${userId}\0${externalProjectId}`)
-        .digest('hex')
-        .slice(0, 8);
-    return `${base}-${digest}`;
-}