@kafca/agentdock 0.1.45 → 0.1.47

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

@@ -7,6 +7,7 @@ const node_module_1 = require("node:module");
 const node_child_process_1 = require("node:child_process");
 const desktop_js_1 = require("../../../../shared/desktop.js");
 const index_js_1 = require("../agents/index.js");
+const env_utils_js_1 = require("./env-utils.js");
 function detectInstalledAgentRuntimes(options = {}) {
     const env = options.env || process.env;
     const configuredCommands = collectConfiguredAgentCommands(options.config);
@@ -131,7 +132,7 @@ function resolveCommand(command, env) {
     if ((0, node_path_1.isAbsolute)(normalized) || normalized.includes('/') || normalized.includes('\\')) {
         return isExecutableFile(normalized) ? normalized : null;
     }
-    for (const dir of String(env.PATH || '').split(node_path_1.delimiter).filter(Boolean)) {
+    for (const dir of (0, env_utils_js_1.getPathEnv)(env).split(node_path_1.delimiter).filter(Boolean)) {
         for (const candidate of commandCandidates(normalized, env)) {
             const fullPath = (0, node_path_1.join)(dir, candidate);
             if (isExecutableFile(fullPath)) {

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

@@ -0,0 +1,150 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ChannelService = void 0;
+class ChannelService {
+    runtimes;
+    constructor(runtimes) {
+        this.runtimes = runtimes;
+    }
+    async listStatuses(platform) {
+        if (!platform) {
+            const statuses = await Promise.all([...this.runtimes.values()].map((runtime) => runtime.listStatuses()));
+            return statuses.flat();
+        }
+        return this.resolve(platform).listStatuses();
+    }
+    async getStatus(platform, workspaceId, instanceId) {
+        return this.resolve(platform).getStatus(workspaceId, instanceId);
+    }
+    async testConnection(platform, workspaceId, instanceId) {
+        return this.resolve(platform).testConnection(workspaceId, instanceId);
+    }
+    async enable(platform, workspaceId, instanceId) {
+        return this.resolve(platform).enable(workspaceId, instanceId);
+    }
+    async disable(platform, workspaceId, instanceId) {
+        return this.resolve(platform).disable(workspaceId, instanceId);
+    }
+    async listPendingPairings(platform, workspaceId) {
+        return this.resolve(platform).listPendingPairings(workspaceId);
+    }
+    async approvePairing(platform, code) {
+        return this.resolve(platform).approvePairing(code);
+    }
+    async rejectPairing(platform, code) {
+        return this.resolve(platform).rejectPairing(code);
+    }
+    async listAuthorizedUsers(platform, workspaceId) {
+        return this.resolve(platform).listAuthorizedUsers(workspaceId);
+    }
+    async sendFile(platform, workspaceId, input) {
+        const runtime = this.resolve(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 sendMessage(platform, workspaceId, input) {
+        const runtime = this.resolve(platform);
+        if (!runtime.sendOutboundMessage) {
+            throw new Error(`Channel platform does not support outbound messages: ${platform}`);
+        }
+        return runtime.sendOutboundMessage(workspaceId, input);
+    }
+    async getQrCode(platform, workspaceId, instanceId) {
+        const runtime = this.resolve(platform);
+        if (!runtime.getQrCode) {
+            throw new Error(`Channel platform does not support QR setup: ${platform}`);
+        }
+        return runtime.getQrCode(workspaceId, instanceId);
+    }
+    async checkQrCodeStatus(platform, workspaceId, ticket, instanceId) {
+        const runtime = this.resolve(platform);
+        if (!runtime.checkQrCodeStatus) {
+            throw new Error(`Channel platform does not support QR setup: ${platform}`);
+        }
+        return runtime.checkQrCodeStatus(workspaceId, ticket, instanceId);
+    }
+    async getWeixinQrCode(workspaceId, instanceId) {
+        return this.getQrCode('weixin', workspaceId, instanceId);
+    }
+    async checkWeixinQrCodeStatus(workspaceId, ticket, instanceId) {
+        return this.checkQrCodeStatus('weixin', workspaceId, ticket, instanceId);
+    }
+    // Lark convenience wrappers
+    async listLarkStatuses() {
+        return this.listStatuses('lark');
+    }
+    async getLarkStatus(workspaceId, instanceId) {
+        return this.getStatus('lark', workspaceId, instanceId);
+    }
+    async testLarkConnection(workspaceId, instanceId) {
+        return this.testConnection('lark', workspaceId, instanceId);
+    }
+    async enableLark(workspaceId, instanceId) {
+        return this.enable('lark', workspaceId, instanceId);
+    }
+    async disableLark(workspaceId, instanceId) {
+        return this.disable('lark', workspaceId, instanceId);
+    }
+    async listLarkPendingPairings(workspaceId) {
+        return this.listPendingPairings('lark', workspaceId);
+    }
+    async approveLarkPairing(code) {
+        return this.approvePairing('lark', code);
+    }
+    async rejectLarkPairing(code) {
+        return this.rejectPairing('lark', code);
+    }
+    async listLarkAuthorizedUsers(workspaceId) {
+        return this.listAuthorizedUsers('lark', workspaceId);
+    }
+    async getLarkQrCode(workspaceId, instanceId) {
+        return this.getQrCode('lark', workspaceId, instanceId);
+    }
+    async checkLarkQrCodeStatus(workspaceId, ticket, instanceId) {
+        return this.checkQrCodeStatus('lark', workspaceId, ticket, instanceId);
+    }
+    async refreshBindings() {
+        await Promise.all([...this.runtimes.values()].map((runtime) => runtime.refreshBindings?.()));
+    }
+    assertPlatform(platform) {
+        this.resolve(platform);
+    }
+    resolve(platform) {
+        const runtime = this.runtimes.get(platform);
+        if (runtime) {
+            return runtime;
+        }
+        throw new Error(`Unsupported channel platform: ${platform}`);
+    }
+}
+exports.ChannelService = ChannelService;

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

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getPathEnv = getPathEnv;
+function getPathEnv(env) {
+    let pathValue = '';
+    for (const [key, value] of Object.entries(env)) {
+        if (key.toLowerCase() === 'path') {
+            pathValue = String(value || '');
+        }
+    }
+    return pathValue;
+}

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

@@ -0,0 +1,234 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ExternalService = void 0;
+const node_crypto_1 = require("node:crypto");
+const node_fs_1 = require("node:fs");
+const node_path_1 = require("node:path");
+const provider_config_migration_js_1 = require("./provider-config-migration.js");
+class ExternalService {
+    store;
+    workspaceRouter;
+    deps;
+    userDataPath;
+    constructor(store, workspaceRouter, deps, userDataPath) {
+        this.store = store;
+        this.workspaceRouter = workspaceRouter;
+        this.deps = deps;
+        this.userDataPath = userDataPath;
+    }
+    async ensureProject(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.resolveProvider(input.provider_id || existing?.providerId);
+        const workspaceId = externalWorkspaceId(userId, externalProjectId);
+        const workspacePath = this.projectBasePath(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.ensureWorkspaceConfig(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 createRun(input) {
+        if (!String(input.prompt || '').trim()) {
+            throw new Error('prompt is required.');
+        }
+        const project = await this.ensureProject(input);
+        const thread = await this.ensureThread(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 getRunSnapshot(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,
+        };
+    }
+    resolveProvider(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 ensureWorkspaceConfig(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.deps.saveStructuredConfig(config);
+    }
+    async ensureThread(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.threadWorkspacePath(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,
+        });
+    }
+    async readAndMigrateConfigFile() {
+        const current = await this.deps.readConfigState();
+        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.deps.saveStructuredConfig(migrated.config);
+        return {
+            ...saved,
+            warnings: [
+                ...(current.warnings || []),
+                ...(saved.warnings || []),
+                ...migrated.warnings,
+            ],
+        };
+    }
+    projectBasePath(userId, externalProjectId) {
+        return (0, node_path_1.join)(this.workspaceRoot(), 'users', normalizeExternalSegment(userId, 'user'), 'projects', normalizeExternalSegment(externalProjectId, 'project'));
+    }
+    threadWorkspacePath(userId, externalProjectId, externalThreadId) {
+        return (0, node_path_1.join)(this.projectBasePath(userId, externalProjectId), 'threads', normalizeExternalSegment(externalThreadId, 'thread'), 'workspace');
+    }
+    workspaceRoot() {
+        return String(process.env.AGENTDOCK_EXTERNAL_WORKSPACE_ROOT || '').trim()
+            || (0, node_path_1.join)(this.userDataPath, 'external-workspaces');
+    }
+}
+exports.ExternalService = ExternalService;
+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}`;
+}

package/dist-electron/services/local-ai-core/src/runtime/handlers/automation-handler.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerAutomationHandlers = registerAutomationHandlers;
+const server_helpers_js_1 = require("../server-helpers.js");
+function registerAutomationHandlers(map, automationMonitors) {
+    map.set('automation.monitors.list', async (_route, _req, res, url) => {
+        const workspaceId = String(url.searchParams.get('workspace_id') || '');
+        (0, server_helpers_js_1.json)(res, 200, { monitors: await automationMonitors.listMonitors(workspaceId || undefined) });
+    });
+    map.set('automation.monitors.create', async (_route, req, res) => {
+        const body = await (0, server_helpers_js_1.readJsonBody)(req);
+        (0, server_helpers_js_1.json)(res, 200, await automationMonitors.createMonitor(body));
+    });
+    map.set('automation.monitor.get', async (route, _req, res) => {
+        const monitor = automationMonitors.getMonitor(route.monitorId);
+        if (!monitor) {
+            throw new Error(`Automation monitor not found: ${route.monitorId}`);
+        }
+        (0, server_helpers_js_1.json)(res, 200, monitor);
+    });
+    map.set('automation.monitor.runs', async (route, _req, res) => {
+        (0, server_helpers_js_1.json)(res, 200, { runs: await automationMonitors.listRuns(route.monitorId) });
+    });
+    map.set('automation.monitor.run', async (route, _req, res) => {
+        (0, server_helpers_js_1.json)(res, 200, await automationMonitors.runMonitorNow(route.monitorId));
+    });
+    map.set('automation.monitor.update', async (route, req, res) => {
+        const body = await (0, server_helpers_js_1.readJsonBody)(req);
+        (0, server_helpers_js_1.json)(res, 200, await automationMonitors.updateMonitor(route.monitorId, body));
+    });
+    map.set('automation.monitor.delete', async (route, _req, res) => {
+        (0, server_helpers_js_1.json)(res, 200, await automationMonitors.deleteMonitor(route.monitorId));
+    });
+}

package/dist-electron/services/local-ai-core/src/runtime/handlers/capabilities-handler.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerCapabilitiesHandlers = registerCapabilitiesHandlers;
+const server_helpers_js_1 = require("../server-helpers.js");
+function registerCapabilitiesHandlers(map, kernel) {
+    map.set('capabilities.read', async (_route, _req, res) => {
+        (0, server_helpers_js_1.json)(res, 200, await kernel.getCapabilitySnapshot());
+    });
+    map.set('capabilities.snapshot', async (_route, _req, res) => {
+        (0, server_helpers_js_1.json)(res, 200, (await kernel.getCapabilitySnapshot()).snapshot);
+    });
+}

package/dist-electron/services/local-ai-core/src/runtime/handlers/channel-handler.js

@@ -0,0 +1,65 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerChannelHandlers = registerChannelHandlers;
+const server_helpers_js_1 = require("../server-helpers.js");
+function registerChannelHandlers(map, channelService) {
+    const cid = (url) => String(url.searchParams.get('instance_id') || url.searchParams.get('instanceId') || '').trim() || undefined;
+    map.set('platform.gateways.list', async (route, _req, res) => {
+        (0, server_helpers_js_1.json)(res, 200, { gateways: await channelService.listStatuses(route.platform) });
+    });
+    map.set('platform.pairings.list', async (route, _req, res, url) => {
+        const workspaceId = String(url.searchParams.get('workspace_id') || '');
+        (0, server_helpers_js_1.json)(res, 200, { pairings: await channelService.listPendingPairings(route.platform, workspaceId || undefined) });
+    });
+    map.set('platform.users.list', async (route, _req, res, url) => {
+        const workspaceId = String(url.searchParams.get('workspace_id') || '');
+        (0, server_helpers_js_1.json)(res, 200, { users: await channelService.listAuthorizedUsers(route.platform, workspaceId || undefined) });
+    });
+    map.set('platform.gateway.get', async (route, _req, res, url) => {
+        const p = route.platform;
+        (0, server_helpers_js_1.json)(res, 200, await channelService.getStatus(p, route.workspaceId, cid(url)));
+    });
+    map.set('platform.qrcode.status', async (route, _req, res, url) => {
+        const ticket = String(url.searchParams.get('ticket') || '');
+        if (!ticket) {
+            (0, server_helpers_js_1.jsonError)(res, 400, new Error('Missing ticket parameter'));
+            return;
+        }
+        const p = route.platform;
+        (0, server_helpers_js_1.json)(res, 200, await channelService.checkQrCodeStatus(p, route.workspaceId, ticket, cid(url)));
+    });
+    map.set('platform.pairing.approve', async (route, req, res) => {
+        const body = await (0, server_helpers_js_1.readJsonBody)(req);
+        (0, server_helpers_js_1.json)(res, 200, await channelService.approvePairing(route.platform, String(body.code || '')));
+    });
+    map.set('platform.pairing.reject', async (route, req, res) => {
+        const body = await (0, server_helpers_js_1.readJsonBody)(req);
+        (0, server_helpers_js_1.json)(res, 200, await channelService.rejectPairing(route.platform, String(body.code || '')));
+    });
+    map.set('platform.gateway.test', async (route, _req, res, url) => {
+        const p = route.platform;
+        (0, server_helpers_js_1.json)(res, 200, await channelService.testConnection(p, route.workspaceId, cid(url)));
+    });
+    map.set('platform.gateway.enable', async (route, _req, res, url) => {
+        const p = route.platform;
+        (0, server_helpers_js_1.json)(res, 200, await channelService.enable(p, route.workspaceId, cid(url)));
+    });
+    map.set('platform.gateway.disable', async (route, _req, res, url) => {
+        const p = route.platform;
+        (0, server_helpers_js_1.json)(res, 200, await channelService.disable(p, route.workspaceId, cid(url)));
+    });
+    map.set('platform.file.send', async (route, req, res) => {
+        const body = await (0, server_helpers_js_1.readJsonBody)(req);
+        const p = route.platform;
+        (0, server_helpers_js_1.json)(res, 200, await channelService.sendFile(p, route.workspaceId, body));
+    });
+    map.set('platform.message.send', async (route, req, res) => {
+        const body = await (0, server_helpers_js_1.readJsonBody)(req);
+        const p = route.platform;
+        (0, server_helpers_js_1.json)(res, 200, await channelService.sendMessage(p, route.workspaceId, body));
+    });
+    map.set('platform.qrcode.create', async (route, _req, res, url) => {
+        const p = route.platform;
+        (0, server_helpers_js_1.json)(res, 200, await channelService.getQrCode(p, route.workspaceId, cid(url)));
+    });
+}

package/dist-electron/services/local-ai-core/src/runtime/handlers/external-handler.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerExternalHandlers = registerExternalHandlers;
+const server_helpers_js_1 = require("../server-helpers.js");
+function registerExternalHandlers(map, externalService, attachExternalRunSseClient) {
+    map.set('external.project.ensure', async (_route, req, res) => {
+        const body = await (0, server_helpers_js_1.readJsonBody)(req);
+        (0, server_helpers_js_1.json)(res, 200, await externalService.ensureProject(body));
+    });
+    map.set('external.run.create', async (_route, req, res) => {
+        const body = await (0, server_helpers_js_1.readJsonBody)(req);
+        (0, server_helpers_js_1.json)(res, 200, await externalService.createRun(body));
+    });
+    map.set('external.run.events', async (route, _req, res) => {
+        await attachExternalRunSseClient(route.runId, res);
+    });
+}

package/dist-electron/services/local-ai-core/src/runtime/handlers/knowledge-handler.js

@@ -0,0 +1,65 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerKnowledgeHandlers = registerKnowledgeHandlers;
+const server_helpers_js_1 = require("../server-helpers.js");
+function registerKnowledgeHandlers(map, knowledgeProvider) {
+    map.set('knowledge.sources.list', async (_route, _req, res) => {
+        (0, server_helpers_js_1.json)(res, 200, { sources: await knowledgeProvider.listSources() });
+    });
+    map.set('knowledge.config.read', async (_route, _req, res) => {
+        (0, server_helpers_js_1.json)(res, 200, await knowledgeProvider.getConfig());
+    });
+    map.set('knowledge.config.update', async (_route, req, res) => {
+        const body = await (0, server_helpers_js_1.readJsonBody)(req);
+        (0, server_helpers_js_1.json)(res, 200, await knowledgeProvider.updateConfig(body));
+    });
+    map.set('knowledge.folders.list', async (_route, _req, res) => {
+        (0, server_helpers_js_1.json)(res, 200, { folders: await knowledgeProvider.listFolders() });
+    });
+    map.set('knowledge.folders.create', async (_route, req, res) => {
+        const body = await (0, server_helpers_js_1.readJsonBody)(req);
+        (0, server_helpers_js_1.json)(res, 200, await knowledgeProvider.createFolder(body));
+    });
+    map.set('knowledge.folder.update', async (route, req, res) => {
+        const body = await (0, server_helpers_js_1.readJsonBody)(req);
+        (0, server_helpers_js_1.json)(res, 200, await knowledgeProvider.updateFolder(route.folderId, body));
+    });
+    map.set('knowledge.folder.delete', async (route, _req, res) => {
+        (0, server_helpers_js_1.json)(res, 200, await knowledgeProvider.deleteFolder(route.folderId));
+    });
+    map.set('knowledge.bases.list', async (_route, _req, res) => {
+        (0, server_helpers_js_1.json)(res, 200, { bases: await knowledgeProvider.listKnowledgeBases() });
+    });
+    map.set('knowledge.bases.create', async (_route, req, res) => {
+        const body = await (0, server_helpers_js_1.readJsonBody)(req);
+        (0, server_helpers_js_1.json)(res, 200, await knowledgeProvider.createKnowledgeBase(body));
+    });
+    map.set('knowledge.base.get', async (route, _req, res) => {
+        (0, server_helpers_js_1.json)(res, 200, await knowledgeProvider.getKnowledgeBase(route.knowledgeBaseId));
+    });
+    map.set('knowledge.base.update', async (route, req, res) => {
+        const body = await (0, server_helpers_js_1.readJsonBody)(req);
+        (0, server_helpers_js_1.json)(res, 200, await knowledgeProvider.updateKnowledgeBase(route.knowledgeBaseId, body));
+    });
+    map.set('knowledge.base.delete', async (route, _req, res) => {
+        (0, server_helpers_js_1.json)(res, 200, await knowledgeProvider.deleteKnowledgeBase(route.knowledgeBaseId));
+    });
+    map.set('knowledge.base.files.list', async (route, _req, res) => {
+        (0, server_helpers_js_1.json)(res, 200, { files: await knowledgeProvider.listKnowledgeBaseFiles(route.knowledgeBaseId) });
+    });
+    map.set('knowledge.base.files.upload', async (route, req, res) => {
+        const contentType = String(req.headers['content-type'] || '').trim();
+        if (!contentType) {
+            throw new Error('Upload content type is required.');
+        }
+        const body = await (0, server_helpers_js_1.readRawBody)(req);
+        (0, server_helpers_js_1.json)(res, 200, { results: await knowledgeProvider.uploadKnowledgeBaseFiles(route.knowledgeBaseId, { contentType, body }) });
+    });
+    map.set('knowledge.base.file.delete', async (route, _req, res) => {
+        (0, server_helpers_js_1.json)(res, 200, await knowledgeProvider.deleteKnowledgeBaseFile(route.knowledgeBaseId, route.fileId));
+    });
+    map.set('knowledge.base.search', async (route, req, res) => {
+        const body = await (0, server_helpers_js_1.readJsonBody)(req);
+        (0, server_helpers_js_1.json)(res, 200, { results: await knowledgeProvider.searchKnowledgeBase(route.knowledgeBaseId, body) });
+    });
+}