parse-stack-next 4.5.0

data/scripts/eval_mcp_with_lm_studio.rb

@@ -0,0 +1,274 @@
+#!/usr/bin/env ruby
+# encoding: UTF-8
+# frozen_string_literal: true
+
+# Evaluate MCP Server with LM Studio
+#
+# This script connects LM Studio to the Parse MCP Server, allowing the
+# LLM to query Parse data using the MCP tools.
+#
+# Usage:
+#   ruby scripts/eval_mcp_with_lm_studio.rb
+#
+# Prerequisites:
+#   - LM Studio running at http://127.0.0.1:1234
+#   - MCP Server running at http://localhost:3001
+#   - Parse Server running with test data
+
+require "net/http"
+require "json"
+require "uri"
+
+class MCPLMStudioEvaluator
+  LM_STUDIO_URL = ENV["LM_STUDIO_URL"] || "http://127.0.0.1:1234"
+  MCP_SERVER_URL = ENV["MCP_SERVER_URL"] || "http://localhost:3001"
+
+  def initialize
+    @conversation = []
+    @tool_definitions = nil
+  end
+
+  # Fetch tool definitions from MCP server
+  def fetch_tools
+    uri = URI("#{MCP_SERVER_URL}/tools")
+    response = Net::HTTP.get_response(uri)
+
+    unless response.is_a?(Net::HTTPSuccess)
+      raise "Failed to fetch tools: #{response.code} #{response.message}"
+    end
+
+    tools = JSON.parse(response.body)
+
+    # Convert MCP format to OpenAI function calling format
+    @tool_definitions = tools.map do |tool|
+      {
+        type: "function",
+        function: {
+          name: tool["name"],
+          description: tool["description"],
+          parameters: tool["inputSchema"]
+        }
+      }
+    end
+
+    puts "Loaded #{@tool_definitions.size} tools from MCP server"
+    @tool_definitions
+  end
+
+  # Call a tool via MCP server
+  def call_mcp_tool(tool_name, arguments)
+    uri = URI("#{MCP_SERVER_URL}/mcp")
+    http = Net::HTTP.new(uri.host, uri.port)
+
+    request = Net::HTTP::Post.new(uri.path)
+    request["Content-Type"] = "application/json"
+    request.body = JSON.generate({
+      jsonrpc: "2.0",
+      id: rand(10000),
+      method: "tools/call",
+      params: {
+        name: tool_name,
+        arguments: arguments
+      }
+    })
+
+    response = http.request(request)
+    result = JSON.parse(response.body)
+
+    if result["error"]
+      { error: result["error"]["message"] }
+    else
+      result["result"]
+    end
+  end
+
+  # Send a message to LM Studio
+  def chat_with_lm(user_message, tools: true)
+    uri = URI("#{LM_STUDIO_URL}/v1/chat/completions")
+    http = Net::HTTP.new(uri.host, uri.port)
+    http.read_timeout = 300  # LLMs can be slow, especially larger models
+    http.open_timeout = 30
+
+    @conversation << { role: "user", content: user_message }
+
+    request_body = {
+      model: "qwen2.5-32b-instruct",
+      messages: @conversation,
+      temperature: 0.1,
+      max_tokens: 2000
+    }
+
+    # Add tools if available and requested
+    if tools && @tool_definitions
+      request_body[:tools] = @tool_definitions
+      request_body[:tool_choice] = "auto"
+    end
+
+    request = Net::HTTP::Post.new(uri.path)
+    request["Content-Type"] = "application/json"
+    request.body = JSON.generate(request_body)
+
+    puts "\n>>> Sending to LM Studio..."
+    response = http.request(request)
+
+    unless response.is_a?(Net::HTTPSuccess)
+      raise "LM Studio error: #{response.code} #{response.message}\n#{response.body}"
+    end
+
+    result = JSON.parse(response.body)
+    assistant_message = result["choices"][0]["message"]
+
+    @conversation << assistant_message
+
+    assistant_message
+  end
+
+  # Check if message has actual tool calls
+  def has_tool_calls?(message)
+    return false unless message
+    tool_calls = message["tool_calls"]
+    return false unless tool_calls.is_a?(Array) && !tool_calls.empty?
+    tool_calls.any? { |tc| tc["function"] && tc["function"]["name"] }
+  end
+
+  # Process tool calls from the LLM
+  def process_tool_calls(message)
+    tool_calls = message["tool_calls"]
+    return nil unless tool_calls && !tool_calls.empty?
+
+    tool_results = []
+
+    tool_calls.each do |tool_call|
+      function = tool_call["function"]
+      next unless function && function["name"]
+
+      tool_name = function["name"]
+      arguments = JSON.parse(function["arguments"] || "{}")
+
+      puts "\n🔧 LLM calling tool: #{tool_name}"
+      puts "   Arguments: #{JSON.pretty_generate(arguments)}"
+
+      result = call_mcp_tool(tool_name, arguments)
+
+      puts "   Result preview: #{result.to_s[0..200]}..."
+
+      tool_results << {
+        role: "tool",
+        tool_call_id: tool_call["id"],
+        content: JSON.generate(result)
+      }
+    end
+
+    return message if tool_results.empty?
+
+    # Add tool results to conversation
+    tool_results.each { |r| @conversation << r }
+
+    # Get LLM's response after tool calls - allow more tool calls
+    chat_with_lm("", tools: true)
+  end
+
+  # Run a full evaluation with a user prompt
+  def evaluate(prompt)
+    puts "=" * 60
+    puts "MCP + LM Studio Evaluation"
+    puts "=" * 60
+    puts "\nLM Studio: #{LM_STUDIO_URL}"
+    puts "MCP Server: #{MCP_SERVER_URL}"
+    puts "\nUser prompt: #{prompt}"
+    puts "=" * 60
+
+    # Initialize
+    fetch_tools
+
+    # Add system message
+    @conversation = [{
+      role: "system",
+      content: <<~SYSTEM
+        You are a helpful assistant with access to a Parse database.
+        Use the available tools to answer questions about the data.
+        Always start by getting the schema if you need to understand the database structure.
+        When querying, be specific and use appropriate constraints.
+      SYSTEM
+    }]
+
+    # Send user message
+    response = chat_with_lm(prompt)
+
+    # Handle tool calls in a loop
+    max_iterations = 5
+    iterations = 0
+
+    while has_tool_calls?(response) && iterations < max_iterations
+      iterations += 1
+      puts "\n--- Tool call iteration #{iterations} ---"
+      new_response = process_tool_calls(response)
+      break if new_response.nil? || new_response == response
+      response = new_response
+    end
+
+    puts "\n" + "=" * 60
+    puts "Final Response:"
+    puts "=" * 60
+    puts response["content"]
+    puts "=" * 60
+
+    response["content"]
+  end
+
+  # Check if services are available
+  def check_services
+    puts "Checking services..."
+
+    # Check LM Studio
+    begin
+      uri = URI("#{LM_STUDIO_URL}/v1/models")
+      response = Net::HTTP.get_response(uri)
+      if response.is_a?(Net::HTTPSuccess)
+        models = JSON.parse(response.body)
+        puts "✓ LM Studio is running"
+        puts "  Available models: #{models["data"]&.map { |m| m["id"] }&.join(", ") || "unknown"}"
+      else
+        puts "✗ LM Studio returned: #{response.code}"
+        return false
+      end
+    rescue => e
+      puts "✗ Cannot connect to LM Studio at #{LM_STUDIO_URL}: #{e.message}"
+      return false
+    end
+
+    # Check MCP Server
+    begin
+      uri = URI("#{MCP_SERVER_URL}/health")
+      response = Net::HTTP.get_response(uri)
+      if response.is_a?(Net::HTTPSuccess)
+        puts "✓ MCP Server is running"
+      else
+        puts "✗ MCP Server returned: #{response.code}"
+        return false
+      end
+    rescue => e
+      puts "✗ Cannot connect to MCP Server at #{MCP_SERVER_URL}: #{e.message}"
+      return false
+    end
+
+    puts ""
+    true
+  end
+end
+
+# Main execution
+if __FILE__ == $0
+  evaluator = MCPLMStudioEvaluator.new
+
+  unless evaluator.check_services
+    puts "\nPlease ensure both LM Studio and MCP Server are running."
+    puts "Start MCP Server with: ruby scripts/start_mcp_server.rb"
+    exit 1
+  end
+
+  # Default prompt if none provided
+  prompt = ARGV[0] || "What tables are in the database? Show me a sample of data from one of them."
+
+  evaluator.evaluate(prompt)
+end

data/scripts/start-parse.sh

@@ -0,0 +1,90 @@
+#!/bin/sh
+set -e
+
+# Parse Server startup script — TEST STACK ONLY.
+#
+# This script is bind-mounted into the parse-server container started by
+# scripts/docker/docker-compose.test.yml for `rake test:integration`. It
+# is NOT a template for production deployment.
+#
+# Required environment variables (provided by the test docker-compose
+# via `${PARSE_APP_ID}`, `${PARSE_MASTER_KEY}`, … which themselves fall
+# through to the compose's own defaults). The script aborts immediately
+# if any required variable is missing — preventing a silent boot with
+# placeholder credentials when an env-var name has drifted or a secret-
+# manager binding fails.
+
+echo "=== Parse Server Startup Script (test stack) ==="
+
+# Hard-fail on any required env var being missing. The compose file
+# is expected to supply each one via env interpolation; if it's not,
+# we want a loud failure here rather than a silent boot with whatever
+# default Parse Server itself would have applied.
+require_env() {
+  eval "value=\${$1:-}"
+  if [ -z "$value" ]; then
+    echo "[start-parse] Refusing to start: required environment variable $1 is not set." >&2
+    exit 1
+  fi
+}
+
+require_env PARSE_SERVER_APPLICATION_ID
+require_env PARSE_SERVER_MASTER_KEY
+require_env PARSE_SERVER_DATABASE_URI
+
+# masterKeyIps restricts which client IPs are allowed to present the
+# master key. Default to loopback only. To allow other ranges (e.g. a
+# private VPC subnet hosting the Ruby app dynos), override before
+# invoking this script:
+#
+#   PARSE_SERVER_MASTER_KEY_IPS="10.0.0.0/8,::1/128" ./start-parse.sh
+#
+# DO NOT set this to "0.0.0.0/0,::/0" in any environment reachable from
+# the public internet. Doing so lets any caller that knows the master
+# key bypass every ACL and CLP from any source IP.
+export PARSE_SERVER_MASTER_KEY_IPS="${PARSE_SERVER_MASTER_KEY_IPS:-127.0.0.1/32,::1/128}"
+
+# Optional REST API key — accept a default of empty when not provided
+# by the compose file. Parse Server tolerates an unset REST key.
+export PARSE_SERVER_REST_API_KEY="${PARSE_SERVER_REST_API_KEY:-}"
+export PARSE_SERVER_MOUNT_PATH="${PARSE_SERVER_MOUNT_PATH:-/parse}"
+export PARSE_SERVER_CLOUD="${PARSE_SERVER_CLOUD:-/parse-server/cloud/main.js}"
+export PARSE_SERVER_LOG_LEVEL="${PARSE_SERVER_LOG_LEVEL:-info}"
+export PARSE_SERVER_ALLOW_CLIENT_CLASS_CREATION="${PARSE_SERVER_ALLOW_CLIENT_CLASS_CREATION:-true}"
+# Accept client-supplied objectId on create. Required by the
+# `parse_reference precompute: true` DSL, which client-generates an
+# objectId in a before_create callback and embeds it in the initial
+# POST body. The SDK only forwards the client objectId when the save
+# runs with master-key authority; the server flag is global, so any
+# additional non-master client-objectId enforcement must be applied
+# in cloud code (see lib/parse/model/core/parse_reference.rb).
+export PARSE_SERVER_ALLOW_CUSTOM_OBJECT_ID="${PARSE_SERVER_ALLOW_CUSTOM_OBJECT_ID:-true}"
+
+# LiveQuery configuration via environment variables
+export PARSE_SERVER_LIVE_QUERY="${PARSE_SERVER_LIVE_QUERY:-{\"classNames\":[\"Song\",\"Album\",\"User\",\"_User\",\"TestLiveQuery\"]}}"
+export PARSE_SERVER_START_LIVE_QUERY_SERVER="${PARSE_SERVER_START_LIVE_QUERY_SERVER:-true}"
+
+echo "Environment configured:"
+echo "  PARSE_SERVER_APPLICATION_ID: $PARSE_SERVER_APPLICATION_ID"
+echo "  PARSE_SERVER_LIVE_QUERY: $PARSE_SERVER_LIVE_QUERY"
+echo "  PARSE_SERVER_START_LIVE_QUERY_SERVER: $PARSE_SERVER_START_LIVE_QUERY_SERVER"
+
+# Start Parse Server
+echo "Starting Parse Server..."
+echo "PATH: $PATH"
+echo "Looking for parse-server..."
+which node
+ls -la /parse-server/
+
+# Try different ways to start parse-server
+if [ -f "/parse-server/bin/parse-server" ]; then
+  echo "Using /parse-server/bin/parse-server"
+  exec /parse-server/bin/parse-server
+elif [ -f "/usr/src/app/bin/parse-server" ]; then
+  echo "Using /usr/src/app/bin/parse-server"
+  exec /usr/src/app/bin/parse-server
+else
+  echo "Trying with node and index.js"
+  cd /parse-server
+  exec node ./bin/parse-server
+fi

data/scripts/start_mcp_server.rb

@@ -0,0 +1,78 @@
+#!/usr/bin/env ruby
+# encoding: UTF-8
+# frozen_string_literal: true
+
+# Start the Parse MCP Server for AI agent integration.
+#
+# Required environment variables (no defaults — the script aborts if any
+# is missing):
+#   PARSE_SERVER_URL  - Parse Server URL (e.g. http://localhost:2337/parse)
+#   PARSE_APP_ID      - Application ID
+#   PARSE_MASTER_KEY  - Master Key
+#
+# Optional:
+#   PARSE_API_KEY     - REST API Key (defaults unset; configure if your
+#                       deployment requires it)
+#   MCP_PORT          - MCP Server port (default: 3001)
+#   MCP_API_KEY       - Bearer token gating the /mcp endpoint when
+#                       binding to a non-loopback host
+#
+# Why no fallback values: previously this script accepted
+# `ENV["PARSE_APP_ID"] || "myAppId"` and the equivalent for the master
+# key. A deployment that forgot to set the env var (typo'd name, missing
+# secret manager binding, container startup race) would silently boot
+# with the placeholder credentials documented in the README — credentials
+# that any reader of this repo knows. Failing closed here is a one-line
+# safety net against that class of foot-gun.
+
+$LOAD_PATH.unshift File.expand_path("../lib", __dir__)
+
+require "parse-stack"
+
+# Hard-fail on any missing required env var. The error message names the
+# variable so the operator can fix it without having to re-read the
+# header comment.
+def require_env!(name)
+  value = ENV[name]
+  if value.nil? || value.empty?
+    abort "[start_mcp_server] Refusing to start: required environment variable #{name} is not set."
+  end
+  value
+end
+
+server_url     = require_env!("PARSE_SERVER_URL")
+application_id = require_env!("PARSE_APP_ID")
+master_key     = require_env!("PARSE_MASTER_KEY")
+api_key        = ENV["PARSE_API_KEY"]  # optional
+
+# Configure Parse client
+Parse.setup(
+  server_url: server_url,
+  application_id: application_id,
+  api_key: api_key,
+  master_key: master_key,
+)
+
+port = (ENV["MCP_PORT"] || 3001).to_i
+
+puts "=" * 60
+puts "Parse MCP Server"
+puts "=" * 60
+puts ""
+puts "Parse Server: #{Parse.client.server_url}"
+puts "MCP Port: #{port}"
+puts ""
+puts "Endpoints:"
+puts "  Health:  http://localhost:#{port}/health"
+puts "  Tools:   http://localhost:#{port}/tools"
+puts "  MCP:     http://localhost:#{port}/mcp (POST)"
+puts ""
+puts "For LM Studio, configure the API endpoint as:"
+puts "  http://localhost:#{port}/mcp"
+puts ""
+puts "=" * 60
+
+# Enable MCP server feature (experimental)
+Parse.mcp_server_enabled = true
+Parse::Agent.enable_mcp!(port: port)
+Parse::Agent::MCPServer.run(port: port)

data/scripts/test_server_connection.rb

@@ -0,0 +1,82 @@
+#!/usr/bin/env ruby
+require_relative '../lib/parse/stack'
+require_relative '../test/support/test_server'
+require_relative '../test/support/docker_helper'
+
+puts "Parse Stack Test Server Connection Test"
+puts "=" * 40
+
+# Try to start Docker containers
+puts "\n1. Starting Docker containers..."
+if Parse::Test::DockerHelper.start!
+  puts "✓ Docker containers started successfully"
+else
+  puts "✗ Failed to start Docker containers"
+  exit 1
+end
+
+# Wait a moment for services to fully initialize
+puts "\n2. Waiting for services to initialize..."
+sleep 5
+
+# Test Parse Server connection
+puts "\n3. Testing Parse Server connection..."
+if Parse::Test::ServerHelper.setup
+  puts "✓ Parse Server connection successful"
+  
+  # Test a basic operation
+  puts "\n4. Testing basic Parse operations..."
+  begin
+    # Check client configuration
+    client = Parse::Client.client
+    puts "  Client server_url: #{client.server_url}"
+    puts "  Client app_id: #{client.app_id}"
+    puts "  Client has master_key: #{client.master_key.present?}"
+    
+    # Reset any existing data
+    Parse::Test::ServerHelper.reset_database!
+    
+    # Create a test user
+    user = Parse::Test::ServerHelper.create_test_user(
+      username: 'testuser',
+      password: 'testpass',
+      email: 'test@example.com'
+    )
+    
+    puts "✓ Created test user: #{user.username} (ID: #{user.id})"
+    
+    # Create a test object
+    test_obj = Parse::Object.new({'className' => 'TestObject', 'name' => 'Test Item', 'value' => 42})
+    test_obj.save
+    
+    puts "✓ Created test object: #{test_obj['name']} (ID: #{test_obj.id})"
+    
+    # Query the object back
+    query = Parse::Query.new('TestObject')
+    query = query.limit(10)  # Use limit() method instead of limit=
+    results = query.results
+    puts "✓ Retrieved #{results.count} test objects"
+    
+    # Test cloud function
+    result = Parse.call_function('hello', name: 'Parse Stack')
+    puts "✓ Cloud function result: #{result}"
+    
+    puts "\n✅ All tests passed! Parse Server is working correctly."
+    
+  rescue => e
+    puts "✗ Error during testing: #{e.message}"
+    puts e.backtrace.first(3) if ENV['DEBUG']
+    exit 1
+  end
+else
+  puts "✗ Parse Server connection failed"
+  exit 1
+end
+
+puts "\n5. Connection information:"
+puts "  Parse Server: http://localhost:1337/parse"
+puts "  Parse Dashboard: http://localhost:4040"
+puts "  Dashboard login: admin/admin"
+
+puts "\nTo stop the containers, run:"
+puts "  docker-compose -f docker-compose.test.yml down"