9 Commits

Author	SHA1	Message	Date
Anso	0947a80cda	fix(mesh): trust central for cross-node dial auth and regenerate overrides at boot (#1014) ... Two bugs in the same Phase D follow-up surface, fixed together because they both block declaring B-verify complete on the production fleet. Cross-node mesh dials returned `denied` at the agent. The pilot's `tcp_open` handler in `agent.ts::resolveMeshTarget` consulted the local SQLite `mesh_stacks` table, which is no longer written to under the post-Phase D control plane (state lives only on central). Drop the check. The pilot tunnel JWT (scope `pilot_tunnel`, signed with central's `auth_jwt_secret`) authenticates the caller; the same trust model already applies to filesystem ops, exec, and container control over the same tunnel. Threat-model trade-off: a leaked `pilot_tunnel` JWT or compromised central can now dial any compose-managed service on the pilot. Containers without `com.docker.compose.project` + `com.docker.compose.service` labels remain unreachable via this path. `MeshService.start()` did not regenerate compose override files at boot. After a Sencho restart with missing overrides on disk, meshed user containers had no `extra_hosts` / `networks: [sencho_mesh]` injection until each stack was opted out and back in. Add `regenerateAllOverrides()` that walks every `mesh_stacks` row and re-pushes via `pushOverrideToNode`. Best-effort: per-stack failures log to the mesh activity buffer; `MeshService.start()` is fire-and-forget at startup so a slow remote node does not delay boot. Tests: - `pilot-agent-mesh-resolve.test.ts` (new): mocks dockerode and proves `resolveMeshTarget` no longer returns `denied` with an empty `mesh_stacks` table. - `mesh-service.test.ts`: three new cases for `regenerateAllOverrides` - fan-out across the fleet, skip when `senchoIp` is null, log per-stack warning on push failure without throwing.	2026-05-09 03:27:39 -04:00
Anso	567e524450	feat(mesh): bidirectional routing via tcp_open_reverse and central relay (#1003) ... * feat(mesh): bidirectional routing via tcp_open_reverse and central relay Phase B of the mesh redesign. Adds the reverse-direction protocol so a pilot's MeshForwarder can route cross-node traffic to central or to another pilot. Central relays pilot-to-pilot streams transparently; pilots keep their existing single outbound WS to central. Protocol additions (backend/src/pilot/protocol.ts): - TcpOpenReverseFrame { s, targetNodeId, stack, service, port } sent agent to primary. Reuses existing tcp_open_ack, tcp_close, and TcpData binary frames for the response and byte plane. - AGENT_REVERSE_ID_BASE = 0x40000001 splits the 32-bit id space so agent-allocated reverse stream ids never collide with primary- allocated forward ids on the same tunnel. - StreamIdAllocator now wraps to its configured start (not always 1) so an allocator parameterized with the agent base stays in the agent half across the wrap. Agent (backend/src/pilot/agent.ts): - New ReverseTcpStreamHandle exported class, EventEmitter facade matching PilotTunnelBridge.TcpStream's surface (write, end, destroy plus open, data, error, close events). - Public openMeshTcpStream(target) allocates a reverse id, sends tcp_open_reverse, returns the handle. - onTcpOpenAckReverse handles inbound ack, dispatches open or error+close to the matching handle. - TcpData and tcp_close binary/JSON paths route ids in the reverse range to reverseTcpStreams; existing primary-allocated paths unchanged. - streamCount, cleanupAfterDisconnect, onStreamIdle include reverse streams. The allocator is reset to a fresh base on disconnect so long-lived agents that reconnect many times do not drift up the id space. - startPilotAgent registers the agent as MeshService's reverse dialer via lazy import. Bridge (backend/src/services/PilotTunnelBridge.ts): - Two new StreamState kinds: reverse_local (target = central, dial Dockerode container IP) and reverse_relay (target = another pilot, open a forward TcpStream on the target pilot's bridge). - handleTcpOpenReverse validates the agent-id range and stream cap, then dispatches to acceptReverseLocal or acceptReverseRelay via lazy imports of MeshService, NodeRegistry, and PilotTunnelManager (avoids module cycles). - acceptReverseLocal calls MeshService.resolveContainerIp (now public), opens net.createConnection, splices bytes through the tunnel. Pre-connect error handler is removed inside connect to avoid double-firing with the mid-stream error path. - acceptReverseRelay opens a forward TcpStream on the target bridge, splices bytes between the two tunnels. - Existing tcp_close and TcpData handlers extended for the new state kinds. teardownStream extended. MeshService (backend/src/services/MeshService.ts): - resolveContainerIp made public so the bridge's local-target path can dial the same shape. - New reverseDialer field plus setReverseDialer setter. Pilot mode registers the agent at boot; central mode leaves it null. - New private dialMeshTcpStream dispatcher: pilot side uses the reverse dialer, central side uses PilotTunnelManager.getBridge. - openCrossNode refactored to call the dispatcher and use the active-stream record's id for activity logging. - New exported MeshTcpStreamLike interface that both PilotTunnelBridge.TcpStream and ReverseTcpStreamHandle satisfy structurally; ReverseMeshDialer is the contract for the setter. Tests (3 files, 16 new cases, 172 total pass): - pilot-protocol-tcp.test.ts: tcp_open_reverse round-trip; agent base invariant. - pilot-agent-reverse-stream.test.ts: openMeshTcpStream allocation, ws-not-open, frame shape, write encoding, end emits tcp_close, ack-success, ack-failure, low-id ack ignored, inbound TcpData routing. - pilot-bridge-reverse.test.ts: id-range validation, no-target failure, successful local dial against a real upstream server. Together with PR #1000 (Phase A) and PR #1001 (deps), Phase B completes the central-pilot-pilot mesh routing matrix. Phase C (mesh over proxy-mode remotes) is the planned follow-up. * test(pilot): drop unused encodeJsonFrame import Lint failed on pilot-agent-reverse-stream.test.ts after the test changed from constructing tcp_open_reverse frames inline to driving the agent's frame-dispatch path with synthetic objects. The import is no longer referenced; ESLint's no-unused-vars rule rejected it.	2026-05-08 16:21:34 -04:00
Anso	a6d3e5d052	fix(pilot): inject loopback auth on agent-side HTTP/WS forwarding (#990) ... After the central proxy forwards a request through the pilot tunnel, the agent receives an http_req or ws_open frame and opens a local loopback request to its own Sencho server. The forwarder previously copied the inbound headers verbatim with no Authorization header, so the local authMiddleware rejected every proxied call with 401 Authentication required. The central cannot sign the missing token because each Sencho instance has its own auth_jwt_secret generated at first-run setup. The agent process runs in the same Node process as the local Sencho server and shares the local DatabaseService, so it can mint a fresh pilot_tunnel-scoped JWT signed with the local secret. Token TTL is 5 minutes with a refresh-on-use 4-minute cache to avoid jwt.sign on every request. The header is built once per request via buildLoopbackHeaders and applied to both onHttpReq and onWsOpen so the two forwarder paths stay in lockstep. The local authMiddleware accepts the scope through its existing pilot_tunnel branch with no special-case bypass. Together with the proxy-side change in the previous commit, this completes the central, bridge, agent, local-Sencho HTTP path for pilot-agent-mode nodes.	2026-05-08 10:00:15 -04:00
Anso	8f13a7faf3	fix(pilot): stop silently swallowing fs errors in agent token helpers (#985) ... * fix(pilot): stop silently swallowing fs errors in agent token helpers The pilot-agent audit found that both filesystem-touching helpers in the agent process discarded every fs error class: - readPersistedToken caught all errors and returned null. ENOENT (normal first boot) and EACCES / EIO / EROFS (a real disk or volume-permission failure) were indistinguishable; the latter silently fell back to "no persisted token", and on a node where the enrollment token had already been consumed the agent would enter a re-enrollment loop with no log signal pointing at the disk. - persistToken caught all errors and logged at console.warn. The operator saw the next-boot loop with the same diagnostic gap. Replace both with errno-aware handling: - readPersistedToken calls fs.readFileSync directly (no TOCTOU race against existsSync), treats ENOENT as silent, and logs every other errno at ERROR with the path. - persistToken logs at ERROR (not WARN) with the failing errno and an explicit "next agent restart will require re-enrollment until the volume is writable" message. The agent still continues with the in-memory token so the current session is unaffected. Both helpers are now exported (marked @internal) so the new test file can mock fs and assert the error-class-vs-log-level matrix. 12 unit cases in pilot-agent-fs-errors.test.ts cover ENOENT, EACCES, EIO, EROFS, ENOSPC, missing errno, empty file, and the happy path. Mock pattern follows backend/src/__tests__/filesystem.test.ts. * fix(pilot): address code-review on the fs-error branch Three findings from the review pass: - Em dash in a test description (Directive 18). Rewritten as "does not throw, so the in-memory token stays usable for the current session". - persistToken still had an existsSync + mkdirSync pair around the token-write. mkdirSync({ recursive: true }) is idempotent on existing directories, so the existsSync was redundant and added a TOCTOU window where the directory could be removed between the probe and the write. Dropped the existsSync; the test that previously primed mockExistsSync now asserts mockExistsSync is NOT called, locking the TOCTOU removal. - The two new exports used the @internal JSDoc tag, but this repo's existing pattern for "public-by-convention-for-tests" helpers (e.g. RegistryService.ts:481) is plain prose "Exposed for unit tests." Switched to that style. No behavior change beyond the TOCTOU removal.	2026-05-08 03:48:35 -04:00
Anso	3d9489648e	fix(pilot): harden outbound reverse-tunnel against resource exhaustion (#979) ... * fix(pilot): cap tunnel frame size, concurrent streams, and stream idle time Pilot tunnels carry every HTTP, WS, and Mesh-TCP byte for a remote node through a single multiplexed WebSocket. A buggy or compromised peer that sent oversized frames, opened streams in a tight loop, or left streams parked indefinitely could exhaust gateway memory. Three protocol-level limits applied symmetrically on both ends: - MAX_FRAME_SIZE_BYTES (8 MB): set as the ws maxPayload on the gateway-side WebSocketServer and the agent-side WebSocket client, plus a defense-in-depth length check in decodeBinaryFrame and decodeJsonFrame. - MAX_STREAMS_PER_TUNNEL (1024): bridge refuses new loopback HTTP / upgrade / TCP allocations with 503 once at the cap; the agent rejects new incoming http_req / ws_open / tcp_open with the appropriate error frame. - STREAM_IDLE_TIMEOUT_MS (10 min): every stream gets a per-stream timer refreshed on each inbound or outbound activity. Expiry tears down the local half and notifies the peer. The constants are colocated in pilot/protocol.ts so any future agent build picks them up via the protocol module. * fix(pilot): rate-limit pilot enrollment endpoints to 10 per minute Pilot enrollment mints a JWT and writes a pilot_enrollments row, both privileged operations that should not share the global API budget (200/min). Add a dedicated express-rate-limit instance keyed by user or IP at 10/min in production (100/min in dev so the local enrollment test loop is not throttled). The limiter is applied directly on POST /api/nodes/:id/pilot/enroll. On POST /api/nodes the limiter's skip function reads the parsed body and exempts proxy-mode creates; only requests that resolve to mode=pilot_agent count against the enrollment budget. * fix(pilot): cap concurrent pilot tunnels system-wide The PilotTunnelManager held an unbounded Map of bridges. A reconnect storm, runaway enrollment, or operator misconfiguration could grow the map without limit, even though every tunnel still carries a valid JWT. Cap at 256 concurrent tunnels per primary instance: - Soft warning at 128 (logged once per crossing). - Hard refusal at 256: registerTunnel throws PilotTunnelCapacityError and the upgrade handler closes the WebSocket with 1013 (Try Again Later) so the agent backs off rather than tight-looping. A node that already has a registered tunnel does not consume a new slot when it reconnects; the existing bridge is closed first. * fix(pilot): release backpressure as soon as the tunnel buffer drains Previously the bridge paused HTTP request bodies when the tunnel WebSocket's bufferedAmount climbed above 4 MB but never resumed them explicitly; the next data event re-checked the threshold, and TCP streams only saw a 'drain' fan-out on the 30 s ping cycle. Slow-consumer peers held buffered bytes for tens of seconds longer than needed. Replace both with an on-demand drain check: when at least one stream is paused, sample bufferedAmount every 100 ms; once it drops below the high-water mark, resume every paused request and emit 'drain' to every accepted TCP stream, then stop the timer. Dormant when no stream is paused, so steady-state cost is zero. * fix(pilot): trust internal CAs via SENCHO_PILOT_CA_FILE Self-hosted deployments often terminate TLS with an internal CA. The only previous escape hatch was NODE_TLS_REJECT_UNAUTHORIZED=0, which disables verification across every outbound connection in the agent process and is the wrong shape of fix. Add SENCHO_PILOT_CA_FILE: when set, the agent reads the file as a PEM bundle and passes it to ws as the `ca` option for the tunnel WebSocket. rejectUnauthorized remains true. Failure to read the file exits with a clear error so the operator does not silently fall back to the default trust store. There is no flag to disable TLS verification entirely; that would defeat the credential trust model. * fix(pilot): gate frame-rate-adjacent logs behind developer_mode The agent's malformed-frame warning fires per inbound frame and could flood logs under attack or against a buggy primary. The bridge swallowed parse errors silently, leaving operators blind to protocol drift, and the manager had no signal at all on tunnel registration. Route per-frame and per-tunnel diagnostic logs through the existing isDebugEnabled() helper (same pattern used by middleware/auth, RBAC, and websocket/logs). Production stays quiet by default; the toggle is the existing developer_mode setting in global_settings — no new env var, no new dependency. * feat(pilot): expose per-tunnel metrics via /api/system/pilot-tunnels Operator support had no signal beyond raw logs to answer "is this tunnel flapping?" or "is one bad node hiding behind the aggregate?". Add an in-process counter set covering tunnels_total, tunnels_replaced, tunnels_rejected_capacity, enroll_acks, frame_decode_errors, plus a per-node array carrying the connectedAt and bufferedAmount so a single tunnel sitting on a stuck buffer remains visible. Counters live in services/PilotMetrics.ts; the gateway has no shared in-process metrics facility today, so this is a per-feature pattern documented as such for future consolidation. Counters are strictly process-local — no telemetry, no export, no phone-home — consistent with Sencho's privacy posture. Surfaced read-only via GET /api/system/pilot-tunnels behind admin auth, mirroring the existing cache-stats endpoint. * fix(pilot): tighten reconnect backoff and log handling Three small follow-ups to the hardening pass: - Sanitize the primary URL on the agent's connect log so a malicious SENCHO_PRIMARY_URL with embedded control characters cannot inject fake log lines. - Move the reconnect-backoff reset from the 'open' callback to the 'hello' frame handler. A peer that always rejects the handshake (incompatible version, consumed enrollment token) used to reset the backoff on every TCP-level connect and tight-loop reconnects; now the reset waits for a clean protocol round-trip. - Document the StreamIdAllocator wrap behavior so future readers can see the relationship between the 2^31 wrap and the MAX_STREAMS_PER_TUNNEL cap without re-deriving it. * test(pilot): add coverage for enrollment, rate limiter, and tunnel caps Adds two test files exercising the hardening pass surfaces that were previously uncovered: - pilot-enrollment.test.ts: end-to-end through POST /api/nodes (pilot mode), POST /api/nodes/:id/pilot/enroll, the SHA256 token-hash persistence, replay protection, expired enrollments, and the rate-limit header wiring (enrollment limiter on pilot paths, global limiter elsewhere). - pilot-bridge-limits.test.ts: oversize-frame rejection at both binary and JSON decoders, and the per-tunnel concurrent stream cap as observed via openTcpStream returning null and the loopback HTTP server returning 503 once the bridge is at capacity. Bridge cap test fills the slot map with TCP stream handles rather than real HTTP requests so the OS socket pool stays out of the picture. * test(pilot): cover manager metrics snapshot and capacity-error shape Adds direct coverage for: - PilotTunnelCapacityError exposing the limit so the upgrade handler can format a useful close-frame reason. - PilotMetrics.snapshot returning a defensive copy (callers must not mutate the live counter set). - getMetricsSnapshot returning the open count, per-node breakdown, and counter set in a stable shape, with tunnels_total bumping on a successful registerTunnel. The manager test seeds a real pilot-mode node row first because updateNode throws on missing rows; this models the production path where a node is created before its enrollment is consumed. * docs(pilot): document tunnel limits, custom CA, and new failure modes Refresh the Pilot Agent feature doc to cover the hardening surfaces: - New 'Self-signed primary TLS certs' section walking through the SENCHO_PILOT_CA_FILE env var with an example docker run command. - New 'Resource limits' section listing the per-tunnel and system-wide ceilings so operators know what the wire enforces. - Four new troubleshooting entries: WebSocket close 1013 (system cap), loopback 503 (stream cap), close 1002 with protocol error (frame size / malformed), and HTTP 429 on enrollment. Also expand .env.example with a new pilot-agent block covering SENCHO_MODE, SENCHO_PRIMARY_URL, SENCHO_ENROLL_TOKEN, and SENCHO_PILOT_CA_FILE so operators do not have to read code or the feature doc to discover the agent-side config surface. * fix(pilot): address code-review findings on the hardening pass Critical: - Bridge: TCP backpressure now starts the drain timer and tracks streams awaiting drain, so a TcpStream caller waiting on 'drain' no longer hangs when no HTTP request is in flight. - Bridge: every direct streams.delete call now goes through the removeStream helper so per-stream idle timers are cleared consistently and pausedReqs / tcpAwaitingDrain stay aligned. - Bridge close(): resume any paused IncomingMessage before clearing the map so a parser does not stay stuck across teardown. High: - Protocol: decodeJsonFrame now compares Buffer.byteLength(raw, 'utf8') against the cap; raw.length (UTF-16 code units) let multi-byte payloads sneak ~3x the byte budget through. - Agent: the optional CA bundle is read once at construction and cached on the instance, so a missing or rotated SENCHO_PILOT_CA_FILE no longer process-exits on every reconnect attempt. Medium / Low: - Bridge limits test: assert mockWs.sent.length to confirm slot allocations actually serialized a tcp_open frame and that a rejected (cap+1) attempt did not consume a stream id. - Manager: defer the tunnels_replaced increment until after the cap check passes, so a rejected reconnect does not double-count as both replacement and capacity rejection. - Manager: clarify the protocol comment about MAX_FRAME_SIZE_BYTES enforcement layering (ws maxPayload is authoritative; decoder check is for tests and defense-in-depth). - Limiter: defensive `if (!req.body) return false` so a future refactor that delays body parsing cannot silently skip the enrollment limiter. Deferred (documented as follow-ups, not in this branch): - M2: narrowing public surface of PilotTunnelManager.getBridge to a MeshTunnelHandle interface (cross-cutting refactor). - H4: end-to-end replay test driving the upgrade handler twice with the same enrollment JWT (needs WS test harness).	2026-05-07 21:28:35 -04:00
Anso	7663f4cd8b	feat(fleet): sencho mesh in traffic and routing tab (#858) ... * feat(fleet): sencho mesh in traffic and routing tab Lights up Sencho Mesh: cross-node container forwarding rendered as if the container next to you were on localhost. Builds on the dormant TCP frame plumbing from the prior PR (pilot tunnel TCP frames + sencho-mesh sidecar package) and exposes the Admiral-only orchestrator surface. Backend - New mesh_stacks table (per-node opt-ins) + nodes.mesh_enabled column via DatabaseService.migrateMeshTables. - MeshService singleton: sidecar lifecycle via Dockerode, opt-in/out with cascading override regeneration, request-based resolver from sidecar control WS, cross-node TCP forwarding via PilotTunnelManager (same-node fast path included), in-memory 1000-event activity ring buffer with durable mirror to audit_log for state-change events, per-node and per-route diagnostics, and the Test upstream probe. - MeshComposeOverride: pure YAML generator that injects extra_hosts using host-gateway. The user's docker-compose.yml is never mutated; overrides live under DATA_DIR/mesh/overrides. - ComposeService deploy/update splice the override file when the stack is opted in; non-mesh stacks behave identically to today. - Pilot agent resolveMeshTarget consults the local mesh_stacks table (defense in depth) and resolves Compose containers via Dockerode. - /api/mesh router with 13 Admiral-gated endpoints covering status, enable/disable, stack opt-in/out, alias listing, per-route diagnostic, Test upstream probe, per-node diagnostic, sidecar restart, activity log paginated and SSE. - meshControl WS slot at /api/mesh/control validates the mesh_sidecar JWT minted by MeshService; dispatched as upgrade slot 2 (canonical order preserved). Frontend - New Traffic Routing tab in FleetView, gated by isAdmiral and wrapped in AdmiralGate. Tab uses the cyan brand glyph and italic-serif state typography from the audit. - RoutingTab masthead with mesh activity drawer, per-node card grid with TogglePill, alias rows with five-state pill taxonomy (healthy / degraded / unreachable / tunnel-down / not-authorized), inline Test buttons. - Four sheets: opt-in picker with port-collision inline error, per-route detail with diagnostic + filtered activity, per-node diagnostics with active streams + resolver cache + restart action, fleet-wide activity log with filters. - meshRouteState helper centralizes pill-state mapping; pure-function tests cover all five states. Docs - User docs at /docs/features/sencho-mesh.mdx covering opt-in, troubleshooting, security model (4 guarantees + 4 explicit non-guarantees), and V1 limitations. - Internal architecture and runbook pages. - websocket-dispatch internal doc updated with the new slot. * fix(mesh): validate stack name before path use; fix test DB lifecycle Two surgical fixes against the prior PR. Path-injection (CodeQL js/path-injection): MeshService.optInStack, optOutStack, ensureStackOverride, and removeStackOverride now validate stackName via isValidStackName from utils/validation, reject malicious names at the API boundary, and additionally check isPathWithinBase on the resolved override file path for defense in depth. The dataflow from req.params.stackName to fs.writeFile no longer reaches an unsanitized path expression. Test DB lifecycle: mesh-service.test.ts used per-test setupTestDb / cleanupTestDb, which deletes the temp dir while DatabaseService still holds an open SQLite handle. On Linux CI this raises SQLITE_READONLY_DBMOVED on the next prepare() because the inode has been unlinked. Switched to file-scoped beforeAll/afterAll matching agents-routes.test.ts, with a per-test beforeEach that truncates mesh_stacks plus non-default nodes and resets the MeshService singleton in-memory state. Adds a new test case asserting the path-traversal rejection. * fix(compose): use discovered compose filename instead of hardcoded docker-compose.yml composeArgs() hardcoded `-f docker-compose.yml` for every deploy. Sencho writes its canonical compose file as `compose.yaml`, so any stack created via the UI failed to deploy with `open ...docker-compose.yml: no such file or directory`. When no mesh override applies, drop the explicit `-f` so docker compose's built-in discovery resolves the actual filename. When an override exists, look up the real base filename via FileSystemService.getComposeFilename() and pass both files explicitly. Also hoist the MeshService import to module top now that the dependency is known to be acyclic, and revert the matching unit-test assertion.	2026-05-01 01:50:53 -04:00
Anso	6893ece898	feat(pilot): add tcp tunnel frames + mesh sidecar package (#857) ... Lays the dormant data-plane foundation for Sencho Mesh. The pilot tunnel gains TCP forwarding frames (tcp_open / tcp_open_ack / tcp_close JSON plus a 0x04 TcpData binary type) and a TcpStream surface on the bridge so a future MeshService can ride the existing WSS tunnel for cross-node container traffic. The agent rejects every tcp_open with mesh_not_enabled until a follow-up PR wires the Dockerode resolver gated by a mesh_stacks opt-in table; ships dormant. A new top-level mesh-sidecar/ package provides the per-node container that will host the L4 forwarder + control WS in production. Built as a small Node 22 alpine image and published in lockstep with the main sencho image via a parallel docker-publish workflow job. Tests cover protocol roundtrips on both packages and the sidecar forwarder end-to-end including resolve, splice, close, and stats.	2026-05-01 00:28:18 -04:00
Anso	4e5ba17710	refactor(backend): sanitize user input before logging to close CRLF injection (#807) ... * refactor(backend): sanitize user input before logging to close CRLF injection Adds a small sanitizeForLog helper that strips CR, LF, tab, and ASCII control characters (0x00-0x1F, 0x7F) from a value before it is embedded in a console.log/warn/error/debug call. Wraps every call site where a user-controlled value (req.params, req.body, req.query, or a value derived from them) flows into a log message. Closes the bulk of the open CodeQL alerts in this family: - 96 js/log-injection - 28 js/tainted-format-string The helper is in backend/src/utils/safeLog.ts. Routes still pre-validate input at the request boundary; this is the second line of defense and gives static analyzers a sanitizer they can trace through. JSON responses, Docker filter labels, and other non-log call sites are intentionally left unwrapped. * refactor(backend): printf-style format strings for tainted-log call sites CodeQL's js/tainted-format-string rule flags template literals in the first arg of console.X when any interpolated value is user-controlled, regardless of whether each value is sanitized inline. The canonical mitigation is to use a static format string and pass values as positional args. Converts the 28 flagged template literals to printf-style ("%s") format strings, with sanitizeForLog applied to each positional arg. Also fills in the log-injection wraps on 9 sites where a user-controlled value was missed in the first sweep (agents, fleet, gitSources, imageUpdates, GitSourceService). No behavior change at runtime. Node's util.format substitutes %s tokens identically to template-literal interpolation. * fix(backend): wrap nodeId/snapshotId in fleet restore debug log CodeQL flagged the unwrapped numeric args even though they cannot contain control chars in practice. Apply the sanitizer for taint-flow recognition.	2026-04-27 10:47:23 -04:00
Anso	8e7a567f69	feat: pilot agent outbound-mode for remote nodes (#667) ... * feat: pilot agent outbound-mode for remote nodes Adds a second mode for managing remote nodes: the agent dials an outbound WebSocket tunnel to the primary, so the remote host no longer needs an inbound port, a reachable URL, or its own TLS certificate. Works behind NAT, residential routers, and corporate firewalls. The primary multiplexes HTTP and WebSocket requests over a single tunnel via a hybrid JSON + binary frame protocol, bridged through a per-tunnel loopback server so existing proxy and upgrade handlers route pilot-mode nodes identically to proxy-mode ones. Enrollment uses a single-use 15-minute pilot_enroll JWT exchanged for a long-lived pilot_tunnel credential on first connect. Proxy mode continues to work unchanged and both modes are supported side-by-side. * test(e2e): switch to proxy mode before asserting api_url field Remote nodes default to Pilot Agent mode, which hides the api_url input. The SSRF-validation tests need proxy mode, so the helper now selects Distributed API Proxy after picking Remote type before asserting the field is visible. * fix(e2e): wire Combobox id prop so node-mode selector resolves The Combobox trigger button had no id, leaving its Label orphaned and making getByRole name-based lookups fail. Adding id to the primitive, passing id="node-mode" from NodeManager, and updating the E2E helper to use #node-mode fixes both the a11y regression and the CI timeout.	2026-04-17 20:31:43 -04:00