leshan-mcp-server/src/handlers/observeResource.js

A standards-compliant MCP server for Leshan LwM2M, exposing Leshan as Model Context Protocol tools.

import { post } from "../utils/leshanClient.js";
import { validateLwM2MPath } from "../utils/validation.js";
import logger from "../utils/loggerConfig.js";

/**
 * Start observing a LwM2M resource for changes
 * @param {Object} params - Parameters
 * @param {string} params.deviceId - Device endpoint
 * @param {string} params.objectId - Object ID
 * @param {string} params.instanceId - Instance ID
 * @param {string} params.resourceId - Resource ID
 * @returns {Promise<Object>} MCP tool response
 */
export async function observeResource({ deviceId, objectId, instanceId, resourceId }) {
  const operationId = `observe-resource-${Date.now()}`;
  
  try {
    logger.info("Observe resource operation started", {
      operationId,
      deviceId,
      path: `${objectId}/${instanceId}/${resourceId}`
    });

    // Validate path parameters
    const validatedParams = validateLwM2MPath(deviceId, objectId, instanceId, resourceId);
    
    const endpoint = `/clients/${encodeURIComponent(validatedParams.deviceId)}/${validatedParams.objectId}/${validatedParams.instanceId}/${validatedParams.resourceId}/observe`;
    
    logger.debug("Making observe request", { operationId, endpoint });
    
    const result = await post(endpoint, {});
    
    logger.info("Resource observation started successfully", {
      operationId,
      deviceId: validatedParams.deviceId,
      path: `${validatedParams.objectId}/${validatedParams.instanceId}/${validatedParams.resourceId}`
    });

    return {
      content: [{
        type: "text",
        text: JSON.stringify({
          success: true,
          operation: "observeResource",
          operationId,
          timestamp: new Date().toISOString(),
          device: {
            endpoint: validatedParams.deviceId,
            path: `${validatedParams.objectId}/${validatedParams.instanceId}/${validatedParams.resourceId}`
          },
          observation: {
            status: "active",
            startTime: new Date().toISOString()
          },
          result,
          note: "Observation started. Use cancel-observation to stop monitoring this resource."
        }, null, 2)
      }]
    };

  } catch (error) {
    logger.error("Observe resource operation failed", {
      operationId,
      deviceId,
      path: `${objectId}/${instanceId}/${resourceId}`,
      error: error.message,
      errorType: error.constructor.name
    });

    return {
      content: [{
        type: "text",
        text: JSON.stringify({
          success: false,
          operation: "observeResource",
          operationId,
          timestamp: new Date().toISOString(),
          error: {
            message: error.message,
            type: error.constructor.name,
            ...(error.statusCode && { statusCode: error.statusCode })
          },
          request: {
            deviceId,
            path: `${objectId}/${instanceId}/${resourceId}`
          }
        }, null, 2)
      }],
      isError: true
    };
  }
}

export default observeResource;