@comake/skl-js-engine/src/JsExecutor/transport/utils/MessageUtils.ts

Standard Knowledge Language Javascript Engine

import type { JsonRpcResponse } from '../../jsonRpc/types';

/**
 * Safely parse a JSON message, returning undefined if parsing fails
 * @param message - String message to parse
 * @returns Parsed object or undefined if invalid JSON
 */
export function safeParse(message: string): any {
  try {
    return JSON.parse(message);
  } catch {
    return undefined;
  }
}

/**
 * Check if a message is a JSON-RPC response (vs request/notification)
 * @param message - Parsed message object
 * @returns True if message is a response
 */
export function isResponse(message: any): boolean {
  return message &&
         typeof message === 'object' &&
         ('result' in message || 'error' in message) &&
         'id' in message &&
         !('method' in message);
}

/**
 * Check if a message is a JSON-RPC request
 * @param message - Parsed message object
 * @returns True if message is a request
 */
export function isRequest(message: any): boolean {
  return message &&
         typeof message === 'object' &&
         'method' in message &&
         'id' in message;
}

/**
 * Check if a message is a JSON-RPC notification
 * @param message - Parsed message object
 * @returns True if message is a notification
 */
export function isNotification(message: any): boolean {
  return message &&
         typeof message === 'object' &&
         'method' in message &&
         !('id' in message);
}

/**
 * Create a JSON-RPC error response
 * @param id - Request ID
 * @param code - Error code
 * @param message - Error message
 * @param data - Optional error data
 * @returns JSON-RPC error response object
 */
export function createErrorResponse(
  id: string | number | null,
  code: number,
  message: string,
  data?: any
): JsonRpcResponse {
  return {
    jsonrpc: '2.0',
    id,
    error: {
      code,
      message,
      ...data && { data }
    }
  };
}

/**
 * Create a JSON-RPC success response
 * @param id - Request ID
 * @param result - Response result
 * @returns JSON-RPC success response object
 */
export function createSuccessResponse(id: string | number, result: any): JsonRpcResponse {
  return {
    jsonrpc: '2.0',
    id,
    result
  };
}

/**
 * Validate that a message is a valid JSON-RPC message
 * @param message - Message to validate
 * @returns True if valid JSON-RPC message
 */
export function isValidJsonRpc(message: any): boolean {
  return message &&
         typeof message === 'object' &&
         message.jsonrpc === '2.0' &&
         (isRequest(message) || isNotification(message) || isResponse(message));
}

/**
 * Buffer manager for handling streaming message data
 */
export class MessageBuffer {
  private buffer = '';

  /**
   * Add data to the buffer and extract complete messages
   * @param data - Incoming data chunk
   * @returns Array of complete message strings
   */
  public addData(data: string): string[] {
    this.buffer += data;

    // Process complete JSON messages (newline-delimited)
    const lines = this.buffer.split('\n');
    // Keep incomplete line in buffer
    this.buffer = lines.pop() ?? '';

    return lines.filter((line): string => line.trim());
  }

  /**
   * Clear the buffer
   */
  public clear(): void {
    this.buffer = '';
  }

  /**
   * Get current buffer content (for debugging)
   */
  public getContent(): string {
    return this.buffer;
  }
}