limitless-ai-mcp-server/dist/resources/handlers.js

MCP server for integrating Limitless AI Pendant recordings with AI assistants

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.ResourceHandlers = void 0;
const manager_1 = require("./manager");
const logger_1 = require("../utils/logger");
const format_1 = require("../utils/format");
class ResourceHandlers {
    resourceManager;
    constructor(resourceManager) {
        this.resourceManager = resourceManager;
    }
    /**
     * Handle list resources request
     */
    async handleListResources(request) {
        try {
            const baseUri = typeof request.params?.baseUri === 'string' ? request.params.baseUri : undefined;
            logger_1.logger.debug('Handling list resources request', { baseUri });
            const resources = await this.resourceManager.listResources(baseUri);
            return {
                resources: resources.map((resource) => ({
                    uri: resource.uri,
                    name: resource.name,
                    description: resource.description,
                    mimeType: resource.mimeType,
                })),
            };
        }
        catch (error) {
            logger_1.logger.error('Failed to list resources', error);
            throw error;
        }
    }
    /**
     * Handle list resource templates request
     */
    async handleListResourceTemplates(_request) {
        try {
            logger_1.logger.debug('Handling list resource templates request');
            return {
                resourceTemplates: manager_1.ResourceManager.RESOURCE_TEMPLATES.map((template) => ({
                    ...template,
                })),
            };
        }
        catch (error) {
            logger_1.logger.error('Failed to list resource templates', error);
            throw error;
        }
    }
    /**
     * Handle read resource request
     */
    async handleReadResource(request) {
        try {
            const { uri } = request.params;
            logger_1.logger.debug('Handling read resource request', { uri });
            if (!this.resourceManager.isValidUri(uri)) {
                throw new Error(`Invalid resource URI: ${uri}`);
            }
            const resource = await this.resourceManager.readResource(uri);
            if (!resource) {
                throw new Error(`Resource not found: ${uri}`);
            }
            // Format the response based on the resource type
            const lifelogs = Array.isArray(resource) ? resource : [resource];
            const formattedContent = (0, format_1.formatLifelogResponse)(lifelogs, {
                includeMarkdown: true,
                includeHeadings: true,
            });
            return {
                contents: [
                    {
                        uri,
                        mimeType: 'text/plain',
                        text: formattedContent,
                    },
                ],
            };
        }
        catch (error) {
            logger_1.logger.error('Failed to read resource', error);
            throw error;
        }
    }
    /**
     * Handle resource subscription (if needed in future)
     */
    async handleSubscribeResource(request) {
        // Placeholder for future implementation
        logger_1.logger.info('Resource subscription not yet implemented', request);
    }
    /**
     * Handle resource unsubscription (if needed in future)
     */
    async handleUnsubscribeResource(request) {
        // Placeholder for future implementation
        logger_1.logger.info('Resource unsubscription not yet implemented', request);
    }
}
exports.ResourceHandlers = ResourceHandlers;
//# sourceMappingURL=handlers.js.map