fix(http): name yolocoder in User-Agent and show a refused preselection (ENG-3022) - #11

User story

As a MindsHub on-call engineer blocking the Jev flood at the Cloudflare edge
I want yolocoder to name itself in every request it sends
So that the edge rule that blocks Go's default user agent on api.mindshub.ai/v1/decisions stops the fleet without breaking our own coding agent

Why this matters

A bot fleet flooded api.mindshub.ai/v1/decisions on 2026-09-26 and took the shared prod database down. mindsdb/terraform#227 blocked the fleet by its exact user agent, Go-http-client/1.1, and about 70 minutes later the fleet switched to Go-http-client/2.0 and the floods came back. mindsdb/terraform#231 widened the rule to every Go-http-client/ agent on /v1/decisions. It merged on 2026-09-27 at 11:17 UTC and is live: a Go-http-client/2.0 request to that path gets a 403 at the edge.

yolocoder's file chooser never set a User-Agent, so it sends Go-http-client/2.0 too, and the edge now refuses it. The chooser also swallowed every failure. So right now every installed build with /preselect on loses its file preselection on every turn, with nothing on screen. This PR makes yolocoder name itself, which ends that at each user's next launch, and makes a refused, stalled or unreachable call say so on the trail.

What happens today

sequenceDiagram
    participant Fleet as Flood fleet
    participant Yolo as yolocoder
    participant Edge as Cloudflare edge
    participant Jev as /v1/decisions
    Fleet->>Edge: POST with User-Agent Go-http-client/2.0
    Edge-->>Fleet: 403 from the Go-http-client/ prefix rule
    Yolo->>Edge: POST with User-Agent Go-http-client/2.0
    Edge-->>Yolo: 403 from the same rule
    Note over Jev: neither request arrives
    Note over Yolo: the chooser returns nil<br/>and prints nothing

What should happen

sequenceDiagram
    participant Fleet as Flood fleet
    participant Yolo as yolocoder
    participant Edge as Cloudflare edge
    participant Jev as /v1/decisions
    Fleet->>Edge: POST with User-Agent Go-http-client/2.0
    Edge-->>Fleet: 403 from the Go-http-client/ prefix rule
    Yolo->>Edge: POST with User-Agent yolocoder/main
    Note over Edge: the rule stops Go's default agents,<br/>the fleet included, and not yolocoder
    Edge->>Jev: yolocoder passes
    Note over Yolo: a refused, stalled or unreachable call<br/>prints file preselection skipped

Acceptance criteria

• The file chooser, the edit router, the Responses and chat-completions calls, model listing, the dialect probe, both sign-in calls (token exchange and API key) and the self-update check all send User-Agent: yolocoder/<version> (+https://github.com/mindsdb/yolocoder), where <version> is what the build stamped. Pinned by TestEveryProviderCallNamesYoloCoder, TestSignInCallsNameYoloCoder and TestTheLaunchCheckNamesYoloCoder.
• Over HTTP/2 the request carries the yolocoder agent, not Go-http-client/2.0 (TestTheAgentRidesOnHTTP2).
• No non-test Go file outside the client itself and the --web preview proxy uses http.DefaultClient, http.DefaultTransport, http.Get/Head/Post/PostForm, or makes its own http.Client or http.Transport value, including through an aliased or dot import (TestNoCodeBypassesTheSharedClient). Each form, and the comments, strings and http-named fields it must not flag, is pinned by TestTheGuardSeesEveryBypassAndNothingElse.
• With /preselect on, a non-2xx reply from /v1/decisions prints exactly one trail line, file preselection skipped: decisions returned <code> <name>, and the turn still finishes (TestABlockedDecisionsCallIsOnTheTrailAndTheTurnCarriesOn). A code Go has no name for, such as Cloudflare's 522, prints as the bare code (TestAnythingGoingWrongJustChoosesNothing).
• A call that runs past the 6-second limit prints file preselection skipped: decisions timed out after 6s, a call that cannot connect prints file preselection skipped: decisions unreachable, and a call whose turn context has already ended prints nothing (TestAStalledOrUnreachableDecisionsCallIsOnTheTrail).
• A 2xx reply prints no skip line, including a shrug, one whose body fails to parse, and one cut off mid-body (TestPreselectionRemovesTheCallThatOnlyPicked, TestAShrugChoosesNothing, TestAnythingGoingWrongJustChoosesNothing).
• The transport leaves the caller's own request unchanged, a redirect hop carries the header too (TestEveryHopCarriesTheAgentAndTheCallersRequestIsUntouched), and the caller's deadline still applies (TestTheCallersDeadlineStillApplies).

How to test

1. In a clone of this branch, run go test ./.... Every package reports ok.
2. Build with the version the Release workflow stamps: go build -ldflags "-X github.com/mindsdb/yolocoder/internal/version.Version=main" -o /tmp/yolocoder ./cmd/yolocoder. The agent string uses only the version, and a build with no stamped commit never self-updates, so a re-run cannot swap the binary for the published one.
3. Start the local server in the block below on port 18765. It logs each request's User-Agent to /tmp/ua.log, returns a Cloudflare-style 403 on /v1/decisions, and returns a finished reply everywhere else.
4. Make a throwaway home: mkdir -p /tmp/yh/.config/yolocoder /tmp/yw && echo 'const x = 1;' > /tmp/yw/a.ts, then write {"version":1,"provider":"openai-compatible","base_url":"http://127.0.0.1:18765","model":"m","api":"responses","preselect":true} to /tmp/yh/.config/yolocoder/config.json and {"api_key":"not-a-real-key"} to credentials.json beside it.
5. Run cd /tmp/yw && HOME=/tmp/yh YOLOCODER_NO_AUTOUPDATE=1 /tmp/yolocoder "look at x". The trail shows file preselection skipped: decisions returned 403 Forbidden, then file choice, then the reply Nothing to change.
6. Read /tmp/ua.log. Both POST /v1/decisions and POST /v1/responses show UA=yolocoder/main (+https://github.com/mindsdb/yolocoder).
7. After merge, once the Release run on main is green, start yolocoder once so it self-updates, turn on /preselect, and run a task against MindsHub. In Cloudflare Security Events or the HTTP request logs for api.mindshub.ai, the /v1/decisions request from your IP shows yolocoder/main (+https://github.com/mindsdb/yolocoder) and no Go-http-client/2.0. This is the check most likely to expose a partial fix: any call path that still sends Go's default shows up here.

import http.server, json
log = open('/tmp/ua.log', 'a')
class H(http.server.BaseHTTPRequestHandler):
    def do_POST(self):
        self.rfile.read(int(self.headers.get('Content-Length') or 0))
        log.write(f"{self.command} {self.path} UA={self.headers.get('User-Agent')}\n"); log.flush()
        if self.path.endswith('/decisions'):
            body, status, kind = b'<html><title>Attention Required! | Cloudflare</title></html>', 403, 'text/html'
        else:
            body = json.dumps({"id": "r", "output": [{"type": "message", "content": [{"type": "output_text", "text": "Nothing to change."}]}]}).encode()
            status, kind = 200, 'application/json'
        self.send_response(status); self.send_header('Content-Type', kind)
        self.send_header('Content-Length', str(len(body))); self.end_headers(); self.wfile.write(body)
    do_GET = do_POST
    def log_message(self, *args): pass
http.server.HTTPServer(('127.0.0.1', 18765), H).serve_forever()

Notes for the reviewer

• One transport owns the header. internal/httpclient.Client wraps http.DefaultTransport and sets User-Agent on a clone of every request, redirects included. Every call site uses it. The edit router's per-call YoloCoder/experimental-edit-router header is gone because the transport would overwrite it anyway. The transport sets the header unconditionally rather than only when empty, since no caller has a reason to send anything else.
• Sign-in and the self-updater use it too. They call auth.mindshub.ai and github.com, not api.mindshub.ai. Putting them on the same client keeps the guard's exempt list to two files: the client itself, and the --web preview proxy in internal/web/proxy.go, which forwards the browser's own requests to the local dev server.
• Two sends sit outside the client. The CONNECT that opens a tunnel through an HTTPS_PROXY carries Go-http-client/1.1, because net/http writes it below any RoundTripper. The request inside the tunnel carries the yolocoder agent, so the edge never sees Go's default. The --web preview proxy forwards the browser's agent to localhost. The README says both.
• The version is main on every rolling build. The Release workflow stamps main on pushes and the tag name on v* tags. I left the commit out of the header: version.Display() renders main (abc1234), which is not a valid product token, and the edge only needs to tell yolocoder apart from Go's default.
• What goes on the trail. A non-2xx reply, a call past the 6-second limit, and a call that cannot connect each print one file preselection skipped: line. No turn can be cancelled today, because every turn runs on context.Background() (cmd/yolocoder/main.go, internal/web/server.go), so those errors are always the call's own. A call whose turn context has already ended still prints nothing, so a cancel added later stays quiet. A 2xx that fails to read or parse stays in the YOLOCODER_DEBUG_LOG trace. The status comes from the code and Go's name for it, not the server's reason phrase.
• A custom provider with no /v1/decisions and /preselect on now prints decisions returned 404 Not Found every turn. That line is accurate. Typing /preselect in a terminal session turns it off. The --web window does not take commands, and a running --web server keeps the setting it started with, so it picks up the change when it restarts.
• The header is forgeable. The fleet can copy yolocoder/main (+https://github.com/mindsdb/yolocoder) from this public repo with one line of code. Treat the prefix block as a speed bump, not as proof that a request is ours. Per-key and per-IP limits are the durable signal.
• Merging to main cuts the release. .github/workflows/release.yml rebuilds the six binaries with Version=main and republishes the rolling latest GitHub release. Installed release builds check latest on every launch (throttleChecks = false in internal/update/update.go) and replace themselves, so most users get this the next time they start yolocoder. A v* tag would make a permanent release, but none exist and the self-updater never reads them. The update check goes to GitHub, so a block on api.mindshub.ai cannot stop the upgrade itself.
• Older builds are failing soft now, until they upgrade. Since #231 went live, three groups keep the old agent: sessions already running (interactive or --web) until they restart, anyone with YOLOCODER_NO_AUTOUPDATE=1, and source builds with no stamped commit (go run, plain go build), which never self-update. For them, /preselect stops picking files and the turn runs as if it were off, with nothing on screen. /preselect is off by default, so only users who turned it on see a difference. Coding calls are untouched while the rule stays scoped to /v1/decisions.
• Missing models, left alone. selectEditFiles builds its payload and questions as map[string]any, while decide.go uses typed decisionRequest and question structs. It also builds its decisions URL inline instead of calling decisionsEndpoint. Both predate this PR and stay out of scope.
• yolocoder is not MindsDB's only Go client of MindsHub. mindsdb/setfree is public Go code that sends through http.DefaultClient, so it also sends Go's default agent. It calls GET /v1/models on api.mindshub.ai (internal/catalog/catalog.go, internal/adapters/modelprobe.go) and the usage and sign-in routes on auth.mindshub.ai (internal/usage/usage.go, internal/auth/auth.go). It never calls /v1/decisions, so a Go-http-client/ rule scoped to that path leaves it alone. A rule that widens past /v1/decisions would break it, and this PR does nothing for it.
• The scaffold's own Jev calls run on Node. internal/web/template/scratch/backend/decisions.ts runs inside the user's generated app, so it sends Node's agent, and a Go-http-client/ rule does not touch it.

Verified locally

Ships with

• Ticket: ENG-3022
• Follows mindsdb/terraform#227 and mindsdb/terraform#231. #227 blocked the exact Go-http-client/1.1 agent on api.mindshub.ai/v1/decisions. #231 widened that rule in place to starts_with(http.user_agent, "Go-http-client/"), merged on 2026-09-27 at 11:17 UTC, and is live. Its rule comment and its test already describe the agents this PR sends, so no terraform follow-up is needed.
• Merge order: none left. The terraform side is already live, so until this merges, every build with /preselect on loses preselection on every turn. Merging cuts the release, and each user recovers at their next launch. There is no deploy coupling, and yolocoder has no per-PR environment.