parse-stack-next 5.5.4 → 5.5.5

data/scripts/docker/preflight.sh

@@ -1,76 +0,0 @@
-#!/bin/sh
-# Preflight guard for the integration stack — TEST STACK ONLY.
-#
-# The Compose defaults bind every service to loopback (127.0.0.1) and fall
-# back to KNOWN, COMMITTED test credentials (master key psnextItMasterKey,
-# Mongo root admin:password, Dashboard admin:admin). That combination is
-# safe on loopback — nothing on the LAN can reach it.
-#
-# It is NOT safe the moment a developer overrides a `*_BIND` to a
-# non-loopback address (e.g. MONGO_BIND=0.0.0.0 to attach a remote client):
-# the stack is then reachable from the LAN while protected only by
-# credentials that are published in this very repository. An admin-
-# credentialed Mongo / Parse master key exposed to a shared network is a
-# real footgun, and the failure is silent — `docker compose up` just works
-# and the developer never sees it.
-#
-# This guard runs first (every other service gates on it via
-# `service_completed_successfully`) and FAILS THE STACK CLOSED whenever a
-# non-loopback bind is combined with still-default privileged credentials.
-# It is invisible to the normal loopback run.
-#
-# Escape hatches (pick one):
-#   1. Keep it loopback     — unset the *_BIND override (the default).
-#   2. Use real secrets     — set PARSE_MASTER_KEY and MONGO_ROOT_PASSWORD
-#                             (inject them with `op run` / `doppler run` —
-#                             see the README "Secret injection" recipe).
-#   3. Acknowledge the risk — ALLOW_INSECURE_BIND=1 on a trusted/isolated
-#                             network where exposure is intentional.
-
-set -eu
-
-# Treat an empty value as loopback: the compose interpolation passes the
-# resolved bind, and an unset override resolves to the 127.0.0.1 default.
-is_loopback() {
-  case "$1" in
-    "" | 127.0.0.1 | ::1 | localhost) return 0 ;;
-    *) return 1 ;;
-  esac
-}
-
-exposed=""
-for pair in "PARSE_BIND=${PARSE_BIND:-}" "MONGO_BIND=${MONGO_BIND:-}" \
-            "REDIS_BIND=${REDIS_BIND:-}" "DASHBOARD_BIND=${DASHBOARD_BIND:-}"; do
-  val=${pair#*=}
-  is_loopback "$val" || exposed="$exposed ${pair%%=*}=$val"
-done
-
-# Privileged credentials are "default" unless BOTH have been overridden.
-# *_SET is "1" only when Compose interpolated a non-empty override
-# (`${VAR:+1}`); empty means the committed default is in force.
-if [ -n "${PARSE_MASTER_KEY_SET:-}" ] && [ -n "${MONGO_ROOT_PASSWORD_SET:-}" ]; then
-  default_creds=0
-else
-  default_creds=1
-fi
-
-if [ -n "$exposed" ] && [ "$default_creds" = "1" ] && [ "${ALLOW_INSECURE_BIND:-}" != "1" ]; then
-  echo "[preflight] REFUSING TO START — non-loopback bind with default credentials." >&2
-  echo "[preflight]" >&2
-  echo "[preflight] Exposed (non-loopback) bind(s):$exposed" >&2
-  echo "[preflight] ...while still using the committed test credentials" >&2
-  echo "[preflight] (master key psnextItMasterKey / Mongo admin:password)." >&2
-  echo "[preflight] This publishes an admin-credentialed stack onto your LAN." >&2
-  echo "[preflight]" >&2
-  echo "[preflight] Resolve ONE of:" >&2
-  echo "[preflight]   1. Keep it loopback   — unset the *_BIND override." >&2
-  echo "[preflight]   2. Set real secrets   — PARSE_MASTER_KEY=... MONGO_ROOT_PASSWORD=..." >&2
-  echo "[preflight]   3. Acknowledge intent — ALLOW_INSECURE_BIND=1 (trusted network only)." >&2
-  exit 1
-fi
-
-if [ -n "$exposed" ]; then
-  echo "[preflight] OK — non-loopback bind(s)$exposed permitted (credentials overridden or ALLOW_INSECURE_BIND=1)."
-else
-  echo "[preflight] OK — all services bound to loopback."
-fi

data/scripts/eval_mcp_with_lm_studio.rb

@@ -1,274 +0,0 @@
-#!/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

@@ -1,154 +0,0 @@
-#!/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}"
-
-# Push configuration — test-stack only. Points at a no-op adapter bind-mounted
-# from test/cloud (see test/cloud/dummy-push-adapter.js). It does NOT deliver to
-# any real device gateway; it lets Parse Server accept `POST /parse/push` and
-# create/complete a real `_PushStatus` so the push send+status lifecycle is
-# integration-testable offline. Without this, `POST /push` returns code 115
-# "Missing push configuration". DO NOT use a no-op adapter in a deployed
-# environment — it silently drops every notification.
-export PARSE_SERVER_PUSH="${PARSE_SERVER_PUSH:-{\"adapter\":\"/parse-server/cloud/dummy-push-adapter.js\"}}"
-
-# MFA / 2FA configuration — test-stack only. Enables Parse Server's built-in
-# TOTP MFA adapter so the Parse::MFA / two_factor_auth integration tests can
-# enroll a user (authData.mfa.{secret,token}) and log in with a time-based code.
-# Params match rotp's defaults (SHA1 / 6 digits / 30s period) so codes generated
-# client-side validate server-side.
-#
-# NOTE: the `auth` option is the one Parse Server option that CANNOT be passed
-# as a JSON env var — its Definitions entry has no objectParser, so
-# PARSE_SERVER_AUTH_PROVIDERS is taken as a raw string and never JSON-parsed
-# (the MFA adapter then receives `undefined` options and 500s). It must come
-# from a config file, which parse-server JSON-parses natively. We write a
-# minimal config file holding only the `auth` block and pass it to parse-server
-# below; env vars still provide — and take precedence for — everything else
-# (parse-server applies env first, then fills gaps from the file).
-PARSE_AUTH_CONFIG_FILE="${PARSE_AUTH_CONFIG_FILE:-/tmp/psnext-parse-auth-config.json}"
-cat > "$PARSE_AUTH_CONFIG_FILE" <<'AUTHCFG'
-{ "auth": { "mfa": { "options": ["TOTP"], "digits": 6, "period": 30, "algorithm": "SHA1" } } }
-AUTHCFG
-
-# Email — test-stack only. Captures outgoing mail into an `EmailCapture` class
-# (see test/cloud/capturing-email-adapter.js) instead of sending it, so the
-# client-side password-reset / verification integration tests can assert
-# delivery and read back the reset link. `PARSE_PUBLIC_SERVER_URL` is required
-# for Parse Server to build those links. Email verification is NOT enabled, so
-# ordinary signups still work without a verification round-trip. DO NOT use a
-# capturing adapter in a deployed environment — it drops every email.
-export PARSE_SERVER_EMAIL_ADAPTER="${PARSE_SERVER_EMAIL_ADAPTER:-/parse-server/cloud/capturing-email-adapter.js}"
-export PARSE_PUBLIC_SERVER_URL="${PARSE_PUBLIC_SERVER_URL:-http://localhost:${PARSE_HOST_PORT:-29337}/parse}"
-export PARSE_SERVER_APP_NAME="${PARSE_SERVER_APP_NAME:-parse-stack-next-it}"
-# Keep email verification OFF. Configuring an email adapter otherwise flips
-# Parse Server into requiring verification, which makes signup return a user
-# with NO session token until the address is verified — breaking the
-# signup-on-save suite. Password reset does not need verification, only the
-# adapter + public URL above.
-export PARSE_SERVER_VERIFY_USER_EMAILS="${PARSE_SERVER_VERIFY_USER_EMAILS:-false}"
-export PARSE_SERVER_PREVENT_LOGIN_WITH_UNVERIFIED_EMAIL="${PARSE_SERVER_PREVENT_LOGIN_WITH_UNVERIFIED_EMAIL:-false}"
-
-# File upload — test-stack only. Authenticated session-token uploads are
-# permitted; public/anonymous uploads are NOT (mirrors a typical hardened
-# Parse Server config). The client_rest_files integration tests assert
-# both pathways: authed upload succeeds, anon upload is rejected.
-export PARSE_SERVER_FILE_UPLOAD="${PARSE_SERVER_FILE_UPLOAD:-{\"enableForPublic\":false,\"enableForAnonymousUser\":false,\"enableForAuthenticatedUser\":true}}"
-
-# Request-id idempotency — test-stack only, scoped to a single probe class so
-# it deduplicates ONLY writes the request-id integration test targets and has
-# zero effect on every other suite. Parse Server dedups POST/PUT carrying the
-# same X-Parse-Request-Id within the TTL for paths matching `paths` (regex).
-# The SDK's idempotent-retry feature relies on exactly this server-side dedup
-# when `Parse::Request.assume_server_idempotency = true`. NOTE: Parse Server
-# names this env var with an `EXPERIMENTAL_` infix and treats the value as a
-# JSON object (objectParser). Override the whole JSON to widen coverage.
-export PARSE_SERVER_EXPERIMENTAL_IDEMPOTENCY_OPTIONS="${PARSE_SERVER_EXPERIMENTAL_IDEMPOTENCY_OPTIONS:-{\"paths\":[\"classes/IdempotencyProbe\"],\"ttl\":120}}"
-
-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. The config file argument supplies
-# the `auth` (MFA) block; every other option still comes from the environment.
-echo "  Auth config file: $PARSE_AUTH_CONFIG_FILE"
-if [ -f "/parse-server/bin/parse-server" ]; then
-  echo "Using /parse-server/bin/parse-server"
-  exec /parse-server/bin/parse-server "$PARSE_AUTH_CONFIG_FILE"
-elif [ -f "/usr/src/app/bin/parse-server" ]; then
-  echo "Using /usr/src/app/bin/parse-server"
-  exec /usr/src/app/bin/parse-server "$PARSE_AUTH_CONFIG_FILE"
-else
-  echo "Trying with node and index.js"
-  cd /parse-server
-  exec node ./bin/parse-server "$PARSE_AUTH_CONFIG_FILE"
-fi

data/scripts/start_mcp_server.rb

@@ -1,78 +0,0 @@
-#!/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"] || "psnextItAppId"` 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

@@ -1,82 +0,0 @@
-#!/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:29040"
-puts "  Dashboard login: admin/admin"
-
-puts "\nTo stop the containers, run:"
-puts "  docker-compose -f docker-compose.test.yml down"