mirror of
https://github.com/router-for-me/CLIProxyAPI.git
synced 2026-11-17 07:08:01 +08:00
Existing request interceptors wrap the full request body in a JSON RPC envelope with Base64 encoding and skip subsequent duplex WebSocket business frames, causing ~3.33x memory and CPU amplification when rewriting small fields such as Codex `<timezone>` and `<current_date>` in large contexts. - Add schema v8 raw request body patch methods (`request.patch_body_before` and `request.patch_body_after`) and capabilities (`request_interceptor_patch_body_before/after`, `request_body_patcher_before/after`) that pass raw `Body []byte` directly across the C ABI without JSON/Base64 request wrapping - Add `RequestBodyEdit`, `RequestBodyPatchResponse`, and `RequestBodyPatcher` in `sdk/pluginapi` with single-pass host splicing, bounds/overlap validation, `json.Valid` verification, no-op original body reuse, and sequential multi-plugin chaining - Eliminate redundant full-body slice clones in handler/conductor request interceptor application paths - Run before-auth and after-auth request interceptors on subsequent duplex WebSocket `response.create`, `response.append`, and `response.steer` messages Closes: #7072
902 lines
29 KiB
Go
902 lines
29 KiB
Go
package pluginhost
|
|
|
|
import (
|
|
"bytes"
|
|
"context"
|
|
"encoding/json"
|
|
"fmt"
|
|
"io"
|
|
"net/http"
|
|
"net/url"
|
|
"reflect"
|
|
"sort"
|
|
"strings"
|
|
|
|
coreauth "github.com/router-for-me/CLIProxyAPI/v8/sdk/cliproxy/auth"
|
|
coreexecutor "github.com/router-for-me/CLIProxyAPI/v8/sdk/cliproxy/executor"
|
|
"github.com/router-for-me/CLIProxyAPI/v8/sdk/pluginabi"
|
|
"github.com/router-for-me/CLIProxyAPI/v8/sdk/pluginapi"
|
|
log "github.com/sirupsen/logrus"
|
|
)
|
|
|
|
func (h *Host) callRequestInterceptor(ctx context.Context, record capabilityRecord, method string, call func(context.Context, pluginapi.RequestInterceptRequest) (pluginapi.RequestInterceptResponse, error), req pluginapi.RequestInterceptRequest) (out pluginapi.RequestInterceptResponse, ok bool) {
|
|
if h == nil || call == nil || h.isPluginFused(record.id) || !h.recordCurrent(record) {
|
|
return pluginapi.RequestInterceptResponse{}, false
|
|
}
|
|
defer func() {
|
|
if recovered := recover(); recovered != nil {
|
|
h.fusePlugin(record.id, method, recovered)
|
|
out = pluginapi.RequestInterceptResponse{}
|
|
ok = false
|
|
}
|
|
}()
|
|
resp, errIntercept := call(ctx, req)
|
|
if errIntercept != nil {
|
|
log.Warnf("pluginhost: request interceptor %s failed: %v", record.id, errIntercept)
|
|
return pluginapi.RequestInterceptResponse{}, false
|
|
}
|
|
return resp, true
|
|
}
|
|
|
|
func (h *Host) callRequestBodyPatcher(ctx context.Context, record capabilityRecord, method string, patcher pluginapi.RequestBodyPatcher, body []byte) (out pluginapi.RequestBodyPatchResponse, ok bool) {
|
|
if h == nil || patcher == nil || h.isPluginFused(record.id) || !h.recordCurrent(record) {
|
|
return pluginapi.RequestBodyPatchResponse{}, false
|
|
}
|
|
defer func() {
|
|
if recovered := recover(); recovered != nil {
|
|
h.fusePlugin(record.id, method, recovered)
|
|
out = pluginapi.RequestBodyPatchResponse{}
|
|
ok = false
|
|
}
|
|
}()
|
|
resp, errPatch := patcher.PatchRequestBody(ctx, body)
|
|
if errPatch != nil {
|
|
log.Warnf("pluginhost: request body patcher %s failed: %v", record.id, errPatch)
|
|
return pluginapi.RequestBodyPatchResponse{}, false
|
|
}
|
|
return resp, true
|
|
}
|
|
|
|
func (h *Host) callResponseInterceptor(ctx context.Context, record capabilityRecord, interceptor pluginapi.ResponseInterceptor, req pluginapi.ResponseInterceptRequest) (out pluginapi.ResponseInterceptResponse, ok bool) {
|
|
if h == nil || interceptor == nil || h.isPluginFused(record.id) || !h.recordCurrent(record) {
|
|
return pluginapi.ResponseInterceptResponse{}, false
|
|
}
|
|
defer func() {
|
|
if recovered := recover(); recovered != nil {
|
|
h.fusePlugin(record.id, "ResponseInterceptor.InterceptResponse", recovered)
|
|
out = pluginapi.ResponseInterceptResponse{}
|
|
ok = false
|
|
}
|
|
}()
|
|
resp, errIntercept := interceptor.InterceptResponse(ctx, req)
|
|
if errIntercept != nil {
|
|
log.Warnf("pluginhost: response interceptor %s failed: %v", record.id, errIntercept)
|
|
return pluginapi.ResponseInterceptResponse{}, false
|
|
}
|
|
return resp, true
|
|
}
|
|
|
|
func (h *Host) callStreamChunkInterceptor(ctx context.Context, record capabilityRecord, interceptor pluginapi.StreamChunkInterceptor, req pluginapi.StreamChunkInterceptRequest) (out pluginapi.StreamChunkInterceptResponse, ok bool) {
|
|
if h == nil || interceptor == nil || h.isPluginFused(record.id) || !h.recordCurrent(record) {
|
|
return pluginapi.StreamChunkInterceptResponse{}, false
|
|
}
|
|
defer func() {
|
|
if recovered := recover(); recovered != nil {
|
|
h.fusePlugin(record.id, "StreamChunkInterceptor.InterceptStreamChunk", recovered)
|
|
out = pluginapi.StreamChunkInterceptResponse{}
|
|
ok = false
|
|
}
|
|
}()
|
|
resp, errIntercept := interceptor.InterceptStreamChunk(ctx, req)
|
|
if errIntercept != nil {
|
|
log.Warnf("pluginhost: stream chunk interceptor %s failed: %v", record.id, errIntercept)
|
|
return pluginapi.StreamChunkInterceptResponse{}, false
|
|
}
|
|
return resp, true
|
|
}
|
|
|
|
func (h *Host) callWebSocketResponseObserver(ctx context.Context, record capabilityRecord, observer pluginapi.WebSocketResponseObserver, event pluginapi.WebSocketResponseEvent) {
|
|
if h == nil || observer == nil || h.isPluginFused(record.id) || !h.recordCurrent(record) {
|
|
return
|
|
}
|
|
defer func() {
|
|
if recovered := recover(); recovered != nil {
|
|
h.fusePlugin(record.id, "WebSocketResponseObserver.ObserveWebSocketResponseEvent", recovered)
|
|
}
|
|
}()
|
|
if errObserve := observer.ObserveWebSocketResponseEvent(ctx, event); errObserve != nil {
|
|
log.Warnf("pluginhost: websocket response observer %s failed: %v", record.id, errObserve)
|
|
}
|
|
}
|
|
|
|
func (h *Host) InterceptRequestBeforeAuth(ctx context.Context, req pluginapi.RequestInterceptRequest) pluginapi.RequestInterceptResponse {
|
|
return h.InterceptRequestBeforeAuthExcept(ctx, req, "")
|
|
}
|
|
|
|
func (h *Host) InterceptRequestBeforeAuthExcept(ctx context.Context, req pluginapi.RequestInterceptRequest, skipPluginID string) pluginapi.RequestInterceptResponse {
|
|
return h.interceptRequest(ctx, req, true, "RequestInterceptor.InterceptRequestBeforeAuth", func(interceptor pluginapi.RequestInterceptor, ctx context.Context, req pluginapi.RequestInterceptRequest) (pluginapi.RequestInterceptResponse, error) {
|
|
return interceptor.InterceptRequestBeforeAuth(ctx, req)
|
|
}, skipPluginID)
|
|
}
|
|
|
|
func (h *Host) InterceptRequestAfterAuth(ctx context.Context, req pluginapi.RequestInterceptRequest) pluginapi.RequestInterceptResponse {
|
|
return h.InterceptRequestAfterAuthExcept(ctx, req, "")
|
|
}
|
|
|
|
func (h *Host) InterceptRequestAfterAuthExcept(ctx context.Context, req pluginapi.RequestInterceptRequest, skipPluginID string) pluginapi.RequestInterceptResponse {
|
|
return h.interceptRequest(ctx, req, false, "RequestInterceptor.InterceptRequestAfterAuth", func(interceptor pluginapi.RequestInterceptor, ctx context.Context, req pluginapi.RequestInterceptRequest) (pluginapi.RequestInterceptResponse, error) {
|
|
return interceptor.InterceptRequestAfterAuth(ctx, req)
|
|
}, skipPluginID)
|
|
}
|
|
|
|
func (h *Host) interceptRequest(ctx context.Context, req pluginapi.RequestInterceptRequest, beforeAuth bool, method string, invoke func(pluginapi.RequestInterceptor, context.Context, pluginapi.RequestInterceptRequest) (pluginapi.RequestInterceptResponse, error), skipPluginID string) pluginapi.RequestInterceptResponse {
|
|
current := pluginapi.RequestInterceptResponse{
|
|
Headers: cloneHeader(req.Headers),
|
|
}
|
|
skipPluginID = strings.TrimSpace(skipPluginID)
|
|
currentBase := req.Body
|
|
bodyModified := false
|
|
patchMethod := "RequestBodyPatcher.PatchRequestBodyAfterAuth"
|
|
if beforeAuth {
|
|
patchMethod = "RequestBodyPatcher.PatchRequestBodyBeforeAuth"
|
|
}
|
|
|
|
for _, record := range h.activeRecords() {
|
|
if h.isPluginFused(record.id) || record.id == skipPluginID {
|
|
continue
|
|
}
|
|
patcher := requestRecordBodyPatcher(record, beforeAuth)
|
|
interceptor := record.plugin.Capabilities.RequestInterceptor
|
|
if patcher == nil && interceptor == nil {
|
|
continue
|
|
}
|
|
if patcher != nil {
|
|
if len(currentBase) > 0 {
|
|
patchInput := requestPatcherInputBody(patcher, currentBase)
|
|
if patchResp, ok := h.callRequestBodyPatcher(ctx, record, patchMethod, patcher, patchInput); ok && len(patchResp.Edits) > 0 {
|
|
patched, modified, errPatch := applyRequestBodyEdits(currentBase, patchResp.Edits)
|
|
if errPatch != nil {
|
|
log.Warnf("pluginhost: request body patcher %s returned invalid edits: %v", record.id, errPatch)
|
|
} else if modified {
|
|
currentBase = patched
|
|
bodyModified = true
|
|
}
|
|
}
|
|
}
|
|
// When a plugin opts into raw body patching for this phase without also requesting
|
|
// metadata-only request interception (omit_body), skip the legacy full-body RPC call.
|
|
if interceptor == nil || !requestInterceptorOmitsBody(record, beforeAuth) {
|
|
continue
|
|
}
|
|
}
|
|
nextReq := req
|
|
nextReq.Headers = cloneHeader(current.Headers)
|
|
if requestInterceptorOmitsBody(record, beforeAuth) {
|
|
nextReq.Body = nil
|
|
} else if len(currentBase) > 0 {
|
|
nextReq.Body = requestInterceptorInputBody(interceptor, currentBase)
|
|
} else {
|
|
nextReq.Body = nil
|
|
}
|
|
nextReq.Metadata = cloneInterceptorMetadata(req.Metadata)
|
|
if nextReq.CallerScope == "" {
|
|
if scope, ok := nextReq.Metadata[coreexecutor.CallerScopeMetadataKey].(string); ok {
|
|
nextReq.CallerScope = strings.TrimSpace(scope)
|
|
}
|
|
} else if _, ok := nextReq.Metadata[coreexecutor.CallerScopeMetadataKey]; !ok {
|
|
if nextReq.Metadata == nil {
|
|
nextReq.Metadata = make(map[string]any, 1)
|
|
}
|
|
nextReq.Metadata[coreexecutor.CallerScopeMetadataKey] = strings.TrimSpace(nextReq.CallerScope)
|
|
}
|
|
if current.Path != "" {
|
|
if nextReq.Metadata == nil {
|
|
nextReq.Metadata = make(map[string]any, 1)
|
|
}
|
|
nextReq.Metadata[coreexecutor.RequestPathMetadataKey] = current.Path
|
|
}
|
|
if resp, ok := h.callRequestInterceptor(ctx, record, method, func(callCtx context.Context, callReq pluginapi.RequestInterceptRequest) (pluginapi.RequestInterceptResponse, error) {
|
|
return invoke(interceptor, callCtx, callReq)
|
|
}, nextReq); ok {
|
|
current.Headers = mergeHeaders(current.Headers, resp.Headers, resp.ClearHeaders)
|
|
if len(resp.ClearHeaders) > 0 {
|
|
current.ClearHeaders = append(current.ClearHeaders, resp.ClearHeaders...)
|
|
}
|
|
if len(resp.Body) > 0 {
|
|
currentBase = requestInterceptorOutputBody(interceptor, resp.Body)
|
|
bodyModified = true
|
|
} else if edits := requestInterceptResponseEdits(resp); len(edits) > 0 && len(currentBase) > 0 {
|
|
patched, modified, errPatch := applyRequestBodyEdits(currentBase, edits)
|
|
if errPatch != nil {
|
|
log.Warnf("pluginhost: request interceptor %s returned invalid edits: %v", record.id, errPatch)
|
|
} else if modified {
|
|
currentBase = patched
|
|
bodyModified = true
|
|
}
|
|
}
|
|
if strings.TrimSpace(resp.Path) != "" {
|
|
current.Path = strings.TrimSpace(resp.Path)
|
|
}
|
|
if resp.Terminate {
|
|
current.Terminate = true
|
|
current.StatusCode = resp.StatusCode
|
|
current.ResponseHeaders = cloneHeader(resp.ResponseHeaders)
|
|
current.ResponseBody = bytes.Clone(resp.ResponseBody)
|
|
break
|
|
}
|
|
}
|
|
}
|
|
if len(current.ClearHeaders) > 0 && len(current.Headers) > 0 {
|
|
filtered := current.ClearHeaders[:0]
|
|
for _, key := range current.ClearHeaders {
|
|
if current.Headers.Values(key) == nil {
|
|
filtered = append(filtered, key)
|
|
}
|
|
}
|
|
if len(filtered) == 0 {
|
|
current.ClearHeaders = nil
|
|
} else {
|
|
current.ClearHeaders = filtered
|
|
}
|
|
}
|
|
if bodyModified {
|
|
current.Body = currentBase
|
|
}
|
|
return current
|
|
}
|
|
|
|
// CompleteRequest schedules terminal notifications without blocking response delivery.
|
|
func (h *Host) CompleteRequest(ctx context.Context, completion pluginapi.RequestCompletion) {
|
|
h.CompleteRequestExcept(ctx, completion, "")
|
|
}
|
|
|
|
func (h *Host) HasWebSocketResponseObservers() bool {
|
|
if h == nil {
|
|
return false
|
|
}
|
|
for _, record := range h.activeRecords() {
|
|
if h.isPluginFused(record.id) {
|
|
continue
|
|
}
|
|
if record.plugin.Capabilities.WebSocketResponseObserver != nil {
|
|
return true
|
|
}
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (h *Host) ObserveWebSocketResponseEvent(ctx context.Context, event pluginapi.WebSocketResponseEvent) {
|
|
h.ObserveWebSocketResponseEventExcept(ctx, event, "")
|
|
}
|
|
|
|
func (h *Host) ObserveWebSocketResponseEventExcept(ctx context.Context, event pluginapi.WebSocketResponseEvent, skipPluginID string) {
|
|
if h == nil {
|
|
return
|
|
}
|
|
if ctx == nil {
|
|
ctx = context.Background()
|
|
} else {
|
|
ctx = context.WithoutCancel(ctx)
|
|
}
|
|
skipPluginID = strings.TrimSpace(skipPluginID)
|
|
for _, record := range h.activeRecords() {
|
|
observer := record.plugin.Capabilities.WebSocketResponseObserver
|
|
if h.isPluginFused(record.id) || observer == nil || record.id == skipPluginID || !h.recordCurrent(record) {
|
|
continue
|
|
}
|
|
next := event
|
|
next.Payload = bytes.Clone(event.Payload)
|
|
next.Metadata = cloneInterceptorMetadata(event.Metadata)
|
|
h.callWebSocketResponseObserver(ctx, record, observer, next)
|
|
}
|
|
}
|
|
|
|
// CompleteRequestExcept notifies lifecycle plugins except the plugin that initiated a nested host execution.
|
|
func (h *Host) CompleteRequestExcept(ctx context.Context, completion pluginapi.RequestCompletion, skipPluginID string) {
|
|
if h == nil {
|
|
return
|
|
}
|
|
if ctx == nil {
|
|
ctx = context.Background()
|
|
} else {
|
|
ctx = context.WithoutCancel(ctx)
|
|
}
|
|
skipPluginID = strings.TrimSpace(skipPluginID)
|
|
for _, record := range h.activeRecords() {
|
|
plugin := record.plugin.Capabilities.RequestLifecyclePlugin
|
|
if h.isPluginFused(record.id) || plugin == nil || record.id == skipPluginID || !h.recordCurrent(record) {
|
|
continue
|
|
}
|
|
next := completion
|
|
next.Metadata = cloneInterceptorMetadata(completion.Metadata)
|
|
go func(record capabilityRecord, plugin pluginapi.RequestLifecyclePlugin, completion pluginapi.RequestCompletion) {
|
|
defer func() {
|
|
if recovered := recover(); recovered != nil {
|
|
h.fusePlugin(record.id, "RequestLifecyclePlugin.HandleRequestComplete", recovered)
|
|
}
|
|
}()
|
|
if errComplete := plugin.HandleRequestComplete(ctx, completion); errComplete != nil {
|
|
log.Warnf("pluginhost: request lifecycle plugin %s failed: %v", record.id, errComplete)
|
|
}
|
|
}(record, plugin, next)
|
|
}
|
|
}
|
|
|
|
func (h *Host) InterceptResponse(ctx context.Context, req pluginapi.ResponseInterceptRequest) pluginapi.ResponseInterceptResponse {
|
|
return h.InterceptResponseExcept(ctx, req, "")
|
|
}
|
|
|
|
func (h *Host) InterceptResponseExcept(ctx context.Context, req pluginapi.ResponseInterceptRequest, skipPluginID string) pluginapi.ResponseInterceptResponse {
|
|
current := pluginapi.ResponseInterceptResponse{
|
|
Headers: cloneHeader(req.ResponseHeaders),
|
|
Body: bytes.Clone(req.Body),
|
|
}
|
|
skipPluginID = strings.TrimSpace(skipPluginID)
|
|
for _, record := range h.activeRecords() {
|
|
interceptor := record.plugin.Capabilities.ResponseInterceptor
|
|
if h.isPluginFused(record.id) || interceptor == nil || record.id == skipPluginID {
|
|
continue
|
|
}
|
|
nextReq := req
|
|
nextReq.RequestHeaders = cloneHeader(req.RequestHeaders)
|
|
nextReq.ResponseHeaders = cloneHeader(current.Headers)
|
|
nextReq.OriginalRequest = bytes.Clone(req.OriginalRequest)
|
|
nextReq.RequestBody = bytes.Clone(req.RequestBody)
|
|
nextReq.Body = bytes.Clone(current.Body)
|
|
nextReq.Metadata = cloneInterceptorMetadata(req.Metadata)
|
|
if resp, ok := h.callResponseInterceptor(ctx, record, interceptor, nextReq); ok {
|
|
current.Headers = mergeHeaders(current.Headers, resp.Headers, resp.ClearHeaders)
|
|
if len(resp.Body) > 0 {
|
|
current.Body = bytes.Clone(resp.Body)
|
|
}
|
|
}
|
|
}
|
|
return current
|
|
}
|
|
|
|
func (h *Host) InterceptStreamChunk(ctx context.Context, req pluginapi.StreamChunkInterceptRequest) pluginapi.StreamChunkInterceptResponse {
|
|
return h.InterceptStreamChunkExcept(ctx, req, "")
|
|
}
|
|
|
|
func (h *Host) InterceptStreamChunkExcept(ctx context.Context, req pluginapi.StreamChunkInterceptRequest, skipPluginID string) pluginapi.StreamChunkInterceptResponse {
|
|
current := pluginapi.StreamChunkInterceptResponse{
|
|
Headers: cloneHeader(req.ResponseHeaders),
|
|
Body: bytes.Clone(req.Body),
|
|
}
|
|
skipPluginID = strings.TrimSpace(skipPluginID)
|
|
for _, record := range h.activeRecords() {
|
|
interceptor := record.plugin.Capabilities.StreamChunkInterceptor
|
|
if h.isPluginFused(record.id) || interceptor == nil || current.DropChunk || record.id == skipPluginID {
|
|
continue
|
|
}
|
|
nextReq := req
|
|
nextReq.RequestHeaders = cloneHeader(req.RequestHeaders)
|
|
nextReq.ResponseHeaders = cloneHeader(current.Headers)
|
|
// Schema v3+ omits request bodies on payload chunks to avoid re-sending multi-MB
|
|
// prompts across cgo/JSON for every frame. Legacy plugins still receive them.
|
|
if req.ChunkIndex != pluginapi.StreamChunkHeaderInitIndex && streamChunkOmitsRequestBodies(record.plugin.SchemaVersion) {
|
|
nextReq.OriginalRequest = nil
|
|
nextReq.RequestBody = nil
|
|
} else {
|
|
nextReq.OriginalRequest = bytes.Clone(req.OriginalRequest)
|
|
nextReq.RequestBody = bytes.Clone(req.RequestBody)
|
|
}
|
|
nextReq.Body = bytes.Clone(current.Body)
|
|
// Schema v5+ omits HistoryChunks on payload chunks to avoid cloning and re-encoding
|
|
// recent chunk windows across cgo/JSON for every frame. Legacy plugins still receive them.
|
|
if req.ChunkIndex != pluginapi.StreamChunkHeaderInitIndex && streamChunkOmitsHistory(record.plugin.SchemaVersion) {
|
|
nextReq.HistoryChunks = nil
|
|
} else {
|
|
nextReq.HistoryChunks = cloneByteSlices(req.HistoryChunks)
|
|
}
|
|
nextReq.Metadata = cloneInterceptorMetadata(req.Metadata)
|
|
if resp, ok := h.callStreamChunkInterceptor(ctx, record, interceptor, nextReq); ok {
|
|
current.Headers = mergeHeaders(current.Headers, resp.Headers, resp.ClearHeaders)
|
|
if len(resp.Body) > 0 {
|
|
current.Body = bytes.Clone(resp.Body)
|
|
}
|
|
if resp.DropChunk {
|
|
current.DropChunk = true
|
|
}
|
|
}
|
|
}
|
|
return current
|
|
}
|
|
|
|
func (h *Host) HasStreamInterceptors() bool {
|
|
if h == nil {
|
|
return false
|
|
}
|
|
for _, record := range h.activeRecords() {
|
|
if h.isPluginFused(record.id) {
|
|
continue
|
|
}
|
|
if record.plugin.Capabilities.StreamChunkInterceptor != nil {
|
|
return true
|
|
}
|
|
}
|
|
return false
|
|
}
|
|
|
|
// StreamChunkPayloadIncludesRequestBody reports whether any active stream chunk
|
|
// interceptor still requires OriginalRequest/RequestBody on payload chunks
|
|
// (schema_version < SchemaVersionStreamChunkOmitRequestBody).
|
|
func (h *Host) StreamChunkPayloadIncludesRequestBody() bool {
|
|
if h == nil {
|
|
return false
|
|
}
|
|
for _, record := range h.activeRecords() {
|
|
if h.isPluginFused(record.id) || record.plugin.Capabilities.StreamChunkInterceptor == nil {
|
|
continue
|
|
}
|
|
if !streamChunkOmitsRequestBodies(record.plugin.SchemaVersion) {
|
|
return true
|
|
}
|
|
}
|
|
return false
|
|
}
|
|
|
|
func streamChunkOmitsRequestBodies(schemaVersion uint32) bool {
|
|
return schemaVersion >= pluginabi.SchemaVersionStreamChunkOmitRequestBody
|
|
}
|
|
|
|
// StreamChunkPayloadIncludesHistory reports whether any active stream chunk
|
|
// interceptor still requires HistoryChunks on payload chunks
|
|
// (schema_version < SchemaVersionStreamChunkOmitHistory).
|
|
func (h *Host) StreamChunkPayloadIncludesHistory() bool {
|
|
if h == nil {
|
|
return false
|
|
}
|
|
for _, record := range h.activeRecords() {
|
|
if h.isPluginFused(record.id) || record.plugin.Capabilities.StreamChunkInterceptor == nil {
|
|
continue
|
|
}
|
|
if !streamChunkOmitsHistory(record.plugin.SchemaVersion) {
|
|
return true
|
|
}
|
|
}
|
|
return false
|
|
}
|
|
|
|
func requestInterceptorOmitsBody(record capabilityRecord, beforeAuth bool) bool {
|
|
if record.plugin.SchemaVersion < pluginabi.SchemaVersionRequestInterceptorOmitBody {
|
|
return false
|
|
}
|
|
caps := record.plugin.Capabilities
|
|
if caps.RequestInterceptor == nil {
|
|
return false
|
|
}
|
|
return requestInterceptorWantsOmitBody(caps, beforeAuth)
|
|
}
|
|
|
|
func streamChunkOmitsHistory(schemaVersion uint32) bool {
|
|
return schemaVersion >= pluginabi.SchemaVersionStreamChunkOmitHistory
|
|
}
|
|
|
|
func (h *Host) HasRequestInterceptors() bool {
|
|
if h == nil {
|
|
return false
|
|
}
|
|
for _, record := range h.activeRecords() {
|
|
if h.isPluginFused(record.id) {
|
|
continue
|
|
}
|
|
if recordHasRequestInterceptor(record) {
|
|
return true
|
|
}
|
|
}
|
|
return false
|
|
}
|
|
|
|
func recordHasRequestInterceptor(record capabilityRecord) bool {
|
|
caps := record.plugin.Capabilities
|
|
if caps.RequestInterceptor != nil {
|
|
return true
|
|
}
|
|
return requestRecordBodyPatcher(record, true) != nil || requestRecordBodyPatcher(record, false) != nil
|
|
}
|
|
|
|
type funcBodyPatcher func(context.Context, []byte) (pluginapi.RequestBodyPatchResponse, error)
|
|
|
|
func (f funcBodyPatcher) PatchRequestBody(ctx context.Context, body []byte) (pluginapi.RequestBodyPatchResponse, error) {
|
|
return f(ctx, body)
|
|
}
|
|
|
|
func requestRecordBodyPatcher(record capabilityRecord, beforeAuth bool) pluginapi.RequestBodyPatcher {
|
|
if record.plugin.SchemaVersion < pluginabi.SchemaVersionRequestInterceptorBodyPatch {
|
|
return nil
|
|
}
|
|
caps := record.plugin.Capabilities
|
|
if beforeAuth {
|
|
if caps.RequestBodyPatcherBefore != nil {
|
|
return caps.RequestBodyPatcherBefore
|
|
}
|
|
if caps.RequestInterceptorPatchBodyBefore && caps.RequestInterceptor != nil {
|
|
if p, ok := caps.RequestInterceptor.(interface {
|
|
PatchRequestBodyBeforeAuth(context.Context, []byte) (pluginapi.RequestBodyPatchResponse, error)
|
|
}); ok && p != nil {
|
|
return funcBodyPatcher(p.PatchRequestBodyBeforeAuth)
|
|
}
|
|
if p, ok := caps.RequestInterceptor.(pluginapi.RequestBodyPatcher); ok && p != nil {
|
|
return p
|
|
}
|
|
}
|
|
return nil
|
|
}
|
|
if caps.RequestBodyPatcherAfter != nil {
|
|
return caps.RequestBodyPatcherAfter
|
|
}
|
|
if caps.RequestInterceptorPatchBodyAfter && caps.RequestInterceptor != nil {
|
|
if p, ok := caps.RequestInterceptor.(interface {
|
|
PatchRequestBodyAfterAuth(context.Context, []byte) (pluginapi.RequestBodyPatchResponse, error)
|
|
}); ok && p != nil {
|
|
return funcBodyPatcher(p.PatchRequestBodyAfterAuth)
|
|
}
|
|
if p, ok := caps.RequestInterceptor.(pluginapi.RequestBodyPatcher); ok && p != nil {
|
|
return p
|
|
}
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func requestPatcherInputBody(patcher pluginapi.RequestBodyPatcher, body []byte) []byte {
|
|
if _, isRPC := patcher.(rpcRequestBodyPatcher); isRPC {
|
|
return body
|
|
}
|
|
return bytes.Clone(body)
|
|
}
|
|
|
|
func requestInterceptorInputBody(interceptor pluginapi.RequestInterceptor, body []byte) []byte {
|
|
if _, isRPC := interceptor.(*rpcPluginAdapter); isRPC {
|
|
return body
|
|
}
|
|
return bytes.Clone(body)
|
|
}
|
|
|
|
func requestInterceptorOutputBody(interceptor pluginapi.RequestInterceptor, body []byte) []byte {
|
|
if _, isRPC := interceptor.(*rpcPluginAdapter); isRPC {
|
|
return body
|
|
}
|
|
return bytes.Clone(body)
|
|
}
|
|
|
|
func requestInterceptResponseEdits(resp pluginapi.RequestInterceptResponse) []pluginapi.RequestBodyEdit {
|
|
if len(resp.BodyEdits) > 0 {
|
|
return resp.BodyEdits
|
|
}
|
|
return resp.Edits
|
|
}
|
|
|
|
func requestBodyEditReplacementLen(edit pluginapi.RequestBodyEdit) int {
|
|
if len(edit.ReplacementBytes) > 0 {
|
|
return len(edit.ReplacementBytes)
|
|
}
|
|
return len(edit.Replacement)
|
|
}
|
|
|
|
func appendRequestBodyEditReplacement(dst []byte, edit pluginapi.RequestBodyEdit) []byte {
|
|
if len(edit.ReplacementBytes) > 0 {
|
|
return append(dst, edit.ReplacementBytes...)
|
|
}
|
|
return append(dst, edit.Replacement...)
|
|
}
|
|
|
|
func applyRequestBodyEdits(base []byte, edits []pluginapi.RequestBodyEdit) ([]byte, bool, error) {
|
|
if len(edits) == 0 {
|
|
return base, false, nil
|
|
}
|
|
type indexedEdit struct {
|
|
edit pluginapi.RequestBodyEdit
|
|
}
|
|
sorted := make([]indexedEdit, len(edits))
|
|
for i, edit := range edits {
|
|
sorted[i] = indexedEdit{edit: edit}
|
|
}
|
|
if len(sorted) > 1 {
|
|
sort.SliceStable(sorted, func(i, j int) bool {
|
|
if sorted[i].edit.Start != sorted[j].edit.Start {
|
|
return sorted[i].edit.Start < sorted[j].edit.Start
|
|
}
|
|
return sorted[i].edit.End < sorted[j].edit.End
|
|
})
|
|
}
|
|
baseLen := len(base)
|
|
outLen := baseLen
|
|
prevEnd := 0
|
|
anyChange := false
|
|
for i, item := range sorted {
|
|
e := item.edit
|
|
if e.Start < 0 || e.End < e.Start || e.End > baseLen {
|
|
return base, false, fmt.Errorf("edit[%d] range [%d:%d] out of bounds for body length %d", i, e.Start, e.End, baseLen)
|
|
}
|
|
if i > 0 && e.Start < prevEnd {
|
|
return base, false, fmt.Errorf("edit[%d] range [%d:%d] overlaps previous end %d", i, e.Start, e.End, prevEnd)
|
|
}
|
|
replLen := requestBodyEditReplacementLen(e)
|
|
if e.Start != e.End || replLen > 0 {
|
|
if len(e.ReplacementBytes) > 0 {
|
|
if !bytes.Equal(base[e.Start:e.End], e.ReplacementBytes) {
|
|
anyChange = true
|
|
}
|
|
} else if string(base[e.Start:e.End]) != e.Replacement {
|
|
anyChange = true
|
|
}
|
|
}
|
|
outLen += replLen - (e.End - e.Start)
|
|
prevEnd = e.End
|
|
}
|
|
if !anyChange {
|
|
return base, false, nil
|
|
}
|
|
out := make([]byte, 0, outLen)
|
|
cursor := 0
|
|
for _, item := range sorted {
|
|
e := item.edit
|
|
if e.Start > cursor {
|
|
out = append(out, base[cursor:e.Start]...)
|
|
}
|
|
out = appendRequestBodyEditReplacement(out, e)
|
|
cursor = e.End
|
|
}
|
|
if cursor < baseLen {
|
|
out = append(out, base[cursor:]...)
|
|
}
|
|
if !json.Valid(out) {
|
|
return base, false, fmt.Errorf("patched request body is not valid JSON")
|
|
}
|
|
return out, true, nil
|
|
}
|
|
|
|
func readAndRestoreRequestBody(r *http.Request) ([]byte, error) {
|
|
if r == nil || r.Body == nil {
|
|
return nil, nil
|
|
}
|
|
origBody := r.Body
|
|
body, errReadAll := io.ReadAll(origBody)
|
|
if errReadAll != nil {
|
|
r.Body = struct {
|
|
io.Reader
|
|
io.Closer
|
|
}{
|
|
Reader: io.MultiReader(bytes.NewReader(body), origBody),
|
|
Closer: origBody,
|
|
}
|
|
return nil, errReadAll
|
|
}
|
|
r.Body = io.NopCloser(bytes.NewReader(body))
|
|
return body, nil
|
|
}
|
|
|
|
func authID(auth *coreauth.Auth) string {
|
|
if auth == nil {
|
|
return ""
|
|
}
|
|
return auth.ID
|
|
}
|
|
|
|
func authProvider(auth *coreauth.Auth) string {
|
|
if auth == nil {
|
|
return ""
|
|
}
|
|
return auth.Provider
|
|
}
|
|
|
|
func authMetadata(auth *coreauth.Auth) map[string]any {
|
|
if auth == nil {
|
|
return nil
|
|
}
|
|
return auth.Metadata
|
|
}
|
|
|
|
func cloneHeader(in http.Header) http.Header {
|
|
if len(in) == 0 {
|
|
return nil
|
|
}
|
|
out := make(http.Header, len(in))
|
|
for key, values := range in {
|
|
out[key] = append([]string(nil), values...)
|
|
}
|
|
return out
|
|
}
|
|
|
|
func mergeHeaders(current, updates http.Header, clear []string) http.Header {
|
|
out := cloneHeader(current)
|
|
if out == nil {
|
|
out = make(http.Header)
|
|
}
|
|
for _, key := range clear {
|
|
out.Del(key)
|
|
}
|
|
for key, values := range updates {
|
|
out.Del(key)
|
|
for _, value := range values {
|
|
out.Add(key, value)
|
|
}
|
|
}
|
|
return out
|
|
}
|
|
|
|
func cloneByteSlices(in [][]byte) [][]byte {
|
|
if len(in) == 0 {
|
|
return nil
|
|
}
|
|
out := make([][]byte, 0, len(in))
|
|
for _, item := range in {
|
|
out = append(out, bytes.Clone(item))
|
|
}
|
|
return out
|
|
}
|
|
|
|
func cloneValues(in url.Values) url.Values {
|
|
if len(in) == 0 {
|
|
return nil
|
|
}
|
|
out := make(url.Values, len(in))
|
|
for key, values := range in {
|
|
out[key] = append([]string(nil), values...)
|
|
}
|
|
return out
|
|
}
|
|
|
|
func cloneAnyMap(in map[string]any) map[string]any {
|
|
if len(in) == 0 {
|
|
return nil
|
|
}
|
|
out := make(map[string]any, len(in))
|
|
for key, value := range in {
|
|
out[key] = value
|
|
}
|
|
return out
|
|
}
|
|
|
|
func cloneInterceptorMetadata(in map[string]any) map[string]any {
|
|
if len(in) == 0 {
|
|
return nil
|
|
}
|
|
visited := make(map[metadataCloneVisit]reflect.Value)
|
|
out := make(map[string]any, len(in))
|
|
for key, value := range in {
|
|
out[key] = cloneInterceptorMetadataAny(reflect.ValueOf(value), visited)
|
|
}
|
|
return out
|
|
}
|
|
|
|
type metadataCloneVisit struct {
|
|
typ reflect.Type
|
|
ptr uintptr
|
|
}
|
|
|
|
func cloneInterceptorMetadataAny(value reflect.Value, visited map[metadataCloneVisit]reflect.Value) any {
|
|
cloned := cloneInterceptorMetadataReflectValue(value, visited)
|
|
if !cloned.IsValid() {
|
|
return nil
|
|
}
|
|
return cloned.Interface()
|
|
}
|
|
|
|
func cloneInterceptorMetadataReflectValue(value reflect.Value, visited map[metadataCloneVisit]reflect.Value) reflect.Value {
|
|
if !value.IsValid() {
|
|
return reflect.Value{}
|
|
}
|
|
|
|
switch value.Kind() {
|
|
case reflect.Interface:
|
|
if value.IsNil() {
|
|
return reflect.Zero(value.Type())
|
|
}
|
|
return cloneInterceptorMetadataReflectValue(value.Elem(), visited)
|
|
case reflect.Pointer:
|
|
if value.IsNil() {
|
|
return reflect.Zero(value.Type())
|
|
}
|
|
visit := metadataCloneVisit{typ: value.Type(), ptr: value.Pointer()}
|
|
if existing, okExisting := visited[visit]; okExisting {
|
|
return existing
|
|
}
|
|
out := reflect.New(value.Type().Elem())
|
|
visited[visit] = out
|
|
clonedElem := cloneInterceptorMetadataReflectValue(value.Elem(), visited)
|
|
if clonedElem.IsValid() {
|
|
outElem := out.Elem()
|
|
if clonedElem.Type().AssignableTo(outElem.Type()) {
|
|
outElem.Set(clonedElem)
|
|
} else if clonedElem.Type().ConvertibleTo(outElem.Type()) {
|
|
outElem.Set(clonedElem.Convert(outElem.Type()))
|
|
}
|
|
}
|
|
return out
|
|
case reflect.Map:
|
|
if value.IsNil() {
|
|
return reflect.Zero(value.Type())
|
|
}
|
|
visit := metadataCloneVisit{typ: value.Type(), ptr: value.Pointer()}
|
|
if existing, okExisting := visited[visit]; okExisting {
|
|
return existing
|
|
}
|
|
out := reflect.MakeMapWithSize(value.Type(), value.Len())
|
|
visited[visit] = out
|
|
iter := value.MapRange()
|
|
for iter.Next() {
|
|
keyValue := adaptClonedValue(iter.Key(), cloneInterceptorMetadataReflectValue(iter.Key(), visited))
|
|
valValue := adaptClonedValue(iter.Value(), cloneInterceptorMetadataReflectValue(iter.Value(), visited))
|
|
out.SetMapIndex(keyValue, valValue)
|
|
}
|
|
return out
|
|
case reflect.Slice:
|
|
if value.IsNil() {
|
|
return reflect.Zero(value.Type())
|
|
}
|
|
if value.Type().Elem().Kind() == reflect.Uint8 {
|
|
out := reflect.MakeSlice(value.Type(), value.Len(), value.Len())
|
|
reflect.Copy(out, value)
|
|
return out
|
|
}
|
|
visit := metadataCloneVisit{typ: value.Type(), ptr: value.Pointer()}
|
|
if existing, okExisting := visited[visit]; okExisting {
|
|
return existing
|
|
}
|
|
out := reflect.MakeSlice(value.Type(), value.Len(), value.Len())
|
|
visited[visit] = out
|
|
for i := 0; i < value.Len(); i++ {
|
|
clonedItem := cloneInterceptorMetadataReflectValue(value.Index(i), visited)
|
|
if !clonedItem.IsValid() {
|
|
continue
|
|
}
|
|
out.Index(i).Set(adaptClonedValue(value.Index(i), clonedItem))
|
|
}
|
|
return out
|
|
case reflect.Array:
|
|
out := reflect.New(value.Type()).Elem()
|
|
for i := 0; i < value.Len(); i++ {
|
|
clonedItem := cloneInterceptorMetadataReflectValue(value.Index(i), visited)
|
|
if !clonedItem.IsValid() {
|
|
continue
|
|
}
|
|
out.Index(i).Set(adaptClonedValue(value.Index(i), clonedItem))
|
|
}
|
|
return out
|
|
case reflect.Struct:
|
|
out := reflect.New(value.Type()).Elem()
|
|
// Preserve unexported fields and deep-clone exported fields on a best-effort basis.
|
|
out.Set(value)
|
|
for i := 0; i < value.NumField(); i++ {
|
|
field := value.Field(i)
|
|
if !out.Field(i).CanSet() {
|
|
continue
|
|
}
|
|
fieldClone := cloneInterceptorMetadataReflectValue(field, visited)
|
|
if !fieldClone.IsValid() {
|
|
continue
|
|
}
|
|
out.Field(i).Set(adaptClonedValue(field, fieldClone))
|
|
}
|
|
return out
|
|
default:
|
|
return value
|
|
}
|
|
}
|
|
|
|
func adaptClonedValue(original, cloned reflect.Value) reflect.Value {
|
|
if !cloned.IsValid() {
|
|
return original
|
|
}
|
|
if cloned.Type().AssignableTo(original.Type()) {
|
|
return cloned
|
|
}
|
|
if cloned.Type().ConvertibleTo(original.Type()) {
|
|
return cloned.Convert(original.Type())
|
|
}
|
|
return original
|
|
}
|
|
|
|
func cloneStringMap(in map[string]string) map[string]string {
|
|
if len(in) == 0 {
|
|
return nil
|
|
}
|
|
out := make(map[string]string, len(in))
|
|
for key, value := range in {
|
|
out[key] = value
|
|
}
|
|
return out
|
|
}
|