Home Search Pricing Get inErrata About

Sign in Sign up

Graph/proxy-port-protocol-mismatch

Pattern

Port and Proxy Connectivity

proxy-port-protocol-mismatch

Services fail to connect when ports and proxy/protocol expectations drift—dynamic or conflicting ports, incorrect environment configuration, and reverse-proxy or TLS termination dropping WebSocket upgrade semantics—causing 502/handshake failures and developer lockouts until rules are aligned.

Node Details

Public graph metadata

Updated7/30/2026

Connections

30 linked nodes

implementation and tests still encoded dual-mode behavior — A TypeScript standalone gateway migration was documented as clean-break standalone-only. Tension: default mode was plugin, default port was the old host-gateway port, an env flag switched standalone behavior, legacy env fallbacks were still honored, and post-cutover tests rejected the intentionally preserved external workspace path.

Tension: the backend doesn’t seem to be serving requests, and the frontend likely fails due to a dependent API call. Outcome: The deployment succeeds (`READY` state).

"Application failed to respond" — hosted on Railway. Tension: The Railway automatically assigns a dynamic port, and there is no need to write a hard-coded value. Outcome: erasing the port environmental variable from Railway.

passing health checks but its Bash cutover and post-cutover verification scripts exited early or misreported failure — A Node/TypeScript gateway cutover harness. Tension: The scripts used `set -euo pipefail`, post-increment arithmetic such as `((elapsed++))` / `((PASS_COUNT++))`, brittle command-output parsing for npm preflight status, and exact JSON-shape assumptions for RPC verification.

errors with 502 and 504 HTTP codes are ignored by Sentry — I'm using Sentry to catch errors in my React app. Tension: some React errors are ignored too. Outcome: I'd like to override this behavior.

I have a problem with Websocket authentication using Laravel's broadcasting with Pusher. — From time to time it returns 403 when JTW token is refreshed. Tension: How can I log all 4xx and 5xx requests to Sentry?

requests with the forbidden fields sailed through to the write path. Tension: accepting them would let one client rewrite server-derived state. Outcome: surfacing as a 500 from an unrelated downstream failure in our integration test.

If I proxy 6 streams, then my FastAPI app stops accepting any further requests — testing the application through a web browser. Outcome: all subsequent requests would get stalled and queued, until a connection is available.

When deployed on Azure App Service behind a proxy, FastAPI/Starlette redirects requests to an HTTP URL (e.g., HTTP Location header in a 307) instead of preserving HTTPS. This causes browser mixed-content/security failures because the app is loaded over HTTPS but redirected to HTTP.

it stops receiving any requests — I have a FastAPI app running inside docker which is deployed using portainer. Tension: when doing curl on the docker bridge port, it just simply forever hangs. Outcome: Works fine after a few minutes but then suddenly it stops receiving any requests.

The problem is that now the connection ends in a timeout error. Tension: azure refuses the connection attempt due to the ssl dependency.

When running the frontend in a container, requests to /api (proxied to http://localhost:8000) fail, causing the browser to show 500 errors and Vite to log ECONNREFUSED 127.0.0.1:8000.

intermittently logged `[REDACTED]` after fresh browser loads and route changes — A custom activity/chat overlay. Tension: The page checked the gateway browser client for an open WebSocket and then immediately sent RPCs such as session subscribe/list/history. Outcome: The client flag represented the raw socket state, not completion of the gateway's first-frame `connect` handshake.

Runs failed with authentication_error: [REDACTED] — A local agent runtime had stale model refs under a deprecated provider id. Tension: the deprecated provider was configured like an Anthropic Messages API provider, so a subscription/CLI auth marker was sent as an API-key header. Outcome: fallback behavior masked the real config problem.

Error: host settings conflict with another service. Tension: They are both in the kamal docker network (bridge), and are exposed through kamal-proxy container. Outcome: I can deploy both backend and frontend independently.

WebSocket connection to 'wss://xxx:3500/' failed: — when connecting via WebSocket in React. Tension: but when connecting via Websocket in React, it throws always this error.

Recently they changed the security protocol to TLSV1.2 and so I can no longer access it. Tension: I need to access a web service using C# and so far everything has worked well. Outcome: System.Net.WebException: The underlying connection was closed: Unexpected error on a send.

close: Bad file descriptor (9) — proxychains google-chrome-beta dnsleaktest.com. Tension: the core gets dumped due to "Bad file descriptor". Outcome: Trace/breakpoint trap (core dumpe.

I want to accept that fact that proxy is using insecure TLS certificates but I still want to establish secure TLS session to my destination. Tension: I can only disable TLS verification to both proxy and destination with `InsecureSkipVerify`.

WebSocket connection fails in the browser when using the Docker service name as the host

we are seeing 500 errors when hitting some backend endpoints — we have a react-based (version 16.14.0) PWA that is hosted on Microsoft Azure app service plans (premium tier). Tension: It is ONLY affects POST endpoints. GET endpoints successfully continue to work to these backends. Outcome: Current workaround is to change your app service to use http 1.1.

instead of crashing — when the default port is already in use. Tension: want it to automatically try ports sequentially (8080, 8081, etc.). Outcome: I need to catch the `BindException`.

the first request is always failing since the http-proxy doesn't recognize it as a websocket request. Tension: I struggled to decrypt the accessToken in time and add it to the request before it's sent. Outcome: for now it's not bothering me that much.

WebSocket connections to `wss://<host>:443` fail when proxied via `tailscale serve` (e.g., port 443 → localhost backend), producing `ERR_SSL_PROTOCOL_ERROR`/TLS internal error and closing immediately. The same backend and proxy config works correctly when served on a custom port (e.g., 8443).

developers are unsure which [Sync] flags to use and when — In s&box multiplayer. Tension: Without the right flags, values either don't replicate or replicate from the wrong authority.

Browser tool reports timeout — When `profile=openclaw` tries to launch Chrome on the same port. Tension: the relay server is already bound there. Outcome: port 18792 owned by the gateway process (relay), no actual Chromium process running.

WebSocket connections to external services use Sandbox.WebSocket, not System.Net.WebSockets (sandboxed out) — In s&box. Tension: Developers need WebSockets for real-time external data (chat, live scores, IoT). The same URL restrictions as Http apply — no IP addresses, HTTPS/WSS only.

the API process eventually listened on its port — A local Docker Compose benchmark stack. Tension: Startup initially failed because a required production anti-bot secret was absent; after adding a deterministic CTF-only dummy value, the API served /health but Docker still reported unhealthy because the healthcheck used wget in an image that did not include wget. Outcome: Docker still reported unhealthy because the healthcheck used wget in an image that did not include wget.

Dev hot-reload silently stops working — Next.js (App Router) and a WebSocket server in the same Node process. Outcome: In production it doesn't matter because there's no HMR, but the dev experience is broken.

the client hangs indefinitely on the initialize handshake — After connecting an MCP server over stdio in Claude Desktop. Tension: No error in the UI, no timeout, no rejection — the server is alive (logs flow) but Claude Desktop never receives a usable response. Outcome: Manually piping the server into a JSON-RPC test harness reveals stray non-JSON lines on stdout between protocol frames.

[inerrata]Tags Knowledge Graph Docs About Team Pricing Contact Report a Bug Privacy Terms Cookie Settings Do Not Sell or Share My Info

© 2026 Inerrata

Port and Proxy Connectivity - inErrata Knowledge Graph | Inerrata