service

type BurpBackend struct {
	// contains filtered or unexported fields
}

type CollyBackend struct {
	// contains filtered or unexported fields
}

type CrawlFlow struct {
	ID             string        // Short sectool ID
	SessionID      string        // Parent session ID
	URL            string        // Full URL visited
	Host           string        // Hostname (extracted from URL)
	Path           string        // Path with query string (extracted from URL)
	Method         string        // HTTP method
	FoundOn        string        // Parent URL where discovered
	Depth          int           // Crawl depth from seed
	StatusCode     int           // HTTP response status
	ContentType    string        // Response content type
	ResponseLength int           // Response body length in bytes
	Request        []byte        // Wire-format bytes from httputil.DumpRequestOut
	Response       []byte        // Wire-format bytes from httputil.DumpResponse
	Truncated      bool          // True if response exceeded max_response_body_bytes
	Duration       time.Duration // Request/response round-trip time
	DiscoveredAt   time.Time     // When this flow was captured
}

type CrawlListOptions struct {
	Host        string            // Glob pattern for host
	PathPattern string            // Glob pattern for path
	StatusCodes *StatusCodeFilter // Filter by status codes (supports ranges like 2XX)
	Methods     []string          // Filter by HTTP methods
	ExcludeHost string            // Exclude hosts matching glob
	ExcludePath string            // Exclude paths matching glob
	Since       string            // Only flows after this flow_id, or "last" for new flows
	Limit       int               // Max results (0 = no limit)
	Offset      int               // Skip first N results

	// Search regexes for header/body content matching.
	// Applied during filtering so the since=last cursor only advances
	// to the last flow that matches all filters including search.
	SearchHeaderRe *regexp.Regexp
	SearchBodyRe   *regexp.Regexp
}

type CrawlOptions struct {
	Label           string            // Optional unique label for the session
	Seeds           []CrawlSeed       // Initial seeds (URLs and/or flow IDs)
	ExplicitDomains []string          // User-specified via --domain
	AllowedPaths    []string          // Glob patterns (default: all)
	DisallowedPaths []string          // Glob patterns (default from config)
	MaxDepth        int               // 0 = unlimited
	MaxRequests     int               // 0 = unlimited
	Delay           time.Duration     // Default: 200ms
	RandomDelay     time.Duration     // Additional random jitter
	Parallelism     int               // Default: 2
	IgnoreRobotsTxt bool              // Default: false
	SubmitForms     bool              // Default: false
	ExtractForms    *bool             // Default: true (from config)
	Headers         map[string]string // Custom headers
}

type CrawlSeed struct {
	URL    string // Direct URL seed
	FlowID string // Or proxy flow ID - extracts URL and ALL headers
}

type CrawlSessionInfo struct {
	ID        string    // Short sectool ID
	Label     string    // Optional user-provided label
	CreatedAt time.Time // When the session was created
	State     string    // "running", "stopped", "completed", "error"
}

type CrawlStatus struct {
	State           string        // "running", "stopped", "completed", "error"
	URLsQueued      int           // URLs waiting to be visited
	URLsVisited     int           // URLs successfully visited
	URLsErrored     int           // URLs that resulted in errors
	FormsDiscovered int           // Forms found during crawl
	Duration        time.Duration // Time since session started
	LastActivity    time.Time     // When last request was made
	ErrorMessage    string        // Error details if State is "error"
}

type CrawlerBackend interface {
	// CreateSession starts a new crawl session. Returns immediately; crawling is async.
	// Returns error if max concurrent sessions reached or no valid seeds/domains.
	CreateSession(ctx context.Context, opts CrawlOptions) (*CrawlSessionInfo, error)

	// AddSeeds adds URLs to an existing session (can be called while running).
	// sessionID can be the ID or label. Returns error if session is not running.
	AddSeeds(ctx context.Context, sessionID string, seeds []CrawlSeed) error

	// GetStatus returns session progress metrics.
	// sessionID can be the ID or label. Returns ErrNotFound if session doesn't exist.
	GetStatus(ctx context.Context, sessionID string) (*CrawlStatus, error)

	// ListFlows returns flows matching filters.
	// sessionID can be the ID or label.
	ListFlows(ctx context.Context, sessionID string, opts CrawlListOptions) ([]CrawlFlow, error)

	// ListForms returns forms discovered in a session.
	// sessionID can be the ID or label.
	ListForms(ctx context.Context, sessionID string, limit int) ([]protocol.CrawlForm, error)

	// ListErrors returns errors encountered in a session.
	// sessionID can be the ID or label.
	ListErrors(ctx context.Context, sessionID string, limit int) ([]protocol.CrawlError, error)

	// GetFlow returns a flow by ID. Returns ErrNotFound if flow doesn't exist.
	GetFlow(ctx context.Context, flowID string) (*CrawlFlow, error)

	// StopSession immediately stops a running crawl. In-flight requests are abandoned.
	// sessionID can be the ID or label.
	StopSession(ctx context.Context, sessionID string) error

	// ListSessions returns all sessions (active and completed), most recent first.
	// limit=0 means no limit.
	ListSessions(ctx context.Context, limit int) ([]CrawlSessionInfo, error)

	// Close cleans up all sessions (called on service shutdown).
	Close() error
}

type HttpBackend interface {
	// Close shuts down the HttpBackend.
	Close() error

	// GetProxyHistory retrieves proxy HTTP history entries oldest-first.
	// afterFlowID == "" starts from the beginning.
	GetProxyHistory(ctx context.Context, count int, afterFlowID string) ([]ProxyEntry, error)

	// GetProxyHistoryMeta retrieves lightweight metadata for proxy history entries oldest-first.
	// afterFlowID == "" starts from the beginning.
	GetProxyHistoryMeta(ctx context.Context, count int, afterFlowID string) ([]ProxyEntryMeta, error)

	// GetProxyEntry returns a single entry by flow_id.
	// Returns ErrNotFound if no entry exists for the flow_id.
	GetProxyEntry(ctx context.Context, flowID string) (*ProxyEntry, error)

	// GetProxyChildren returns the child flows of parentFlowID in emission order
	// (stream children, session inner flows). Empty on backends without nested
	// flows (Burp).
	GetProxyChildren(ctx context.Context, parentFlowID string) ([]ProxyEntry, error)

	// DeleteProxyEntries removes proxy history entries by flow_id and returns the number actually deleted.
	// Unknown flow_ids are silently ignored. Returns ErrNotSupported on backends without delete (Burp).
	DeleteProxyEntries(ctx context.Context, flowIDs []string) (int, error)

	// SendRequest sends an HTTP request and returns the response.
	// The request is raw HTTP bytes. Response is returned as headers and body.
	SendRequest(ctx context.Context, name string, req SendRequestInput) (*SendRequestResult, error)

	// ListRules returns all enabled find/replace rules managed by sectool.
	// websocket=true returns WebSocket rules, false returns HTTP rules.
	ListRules(ctx context.Context, websocket bool) ([]protocol.RuleEntry, error)

	// AddRule creates a new find/replace rule.
	// WebSocket vs HTTP is inferred from rule.Type (ws:* types are WebSocket).
	// RuleID is ignored on input and assigned by the backend.
	AddRule(ctx context.Context, rule protocol.RuleEntry) (*protocol.RuleEntry, error)

	// DeleteRule removes a rule by ID or label.
	// Searches both HTTP and WebSocket rules automatically.
	DeleteRule(ctx context.Context, idOrLabel string) error

	// Sidecars returns the connected sidecar registry, or nil on backends that
	// host no sidecars (Burp).
	Sidecars() SidecarRegistry
}

type InteractshBackend struct {
	// contains filtered or unexported fields
}

type MCPServerFlags struct {
	ConfigPath    string
	BurpMCPURL    string
	MCPPort       int
	ProxyPort     int    // 0 = not set via CLI
	RequireBurp   bool   // --burp flag: require Burp, error if unavailable
	WorkflowMode  string // "", "none", "multi", "explore", "test-report"
	Notes         bool   // enable notes/findings tools (experimental)
	SidecarSocket string // override for the sidecar IPC socket (path or host:port)
}

type NativeProxyBackend struct {
	// contains filtered or unexported fields
}

type OastBackend interface {
	// CreateSession registers with the OAST provider and starts background polling.
	// Returns session with short ID and domain.
	// If label is non-empty, it must be unique across all sessions.
	// If redirectTarget is non-empty, HTTP requests to the session domain receive a 307 redirect.
	CreateSession(ctx context.Context, label, redirectTarget string) (*OastSessionInfo, error)

	// SupportsRedirect reports whether this backend supports redirect responses.
	SupportsRedirect() bool

	// PollSession returns events for a session.
	// idOrDomain accepts either the short ID or the full domain.
	// since filters events: empty returns all, "last" returns since last poll, or an event ID.
	// eventType filters by protocol: empty returns all, otherwise one of dns, http, smtp, ftp, ldap, smb, responder.
	// wait specifies how long to block waiting for events (0 = return immediately).
	// limit caps the number of events returned (0 = no limit). When used with "since last",
	// the last position is updated to the last returned event (for pagination).
	PollSession(ctx context.Context, idOrDomain string, since string, eventType string, wait time.Duration, limit int) (*OastPollResultInfo, error)

	// GetEvent retrieves a single event by ID, searching across all sessions.
	// Returns the full event details without truncation.
	GetEvent(ctx context.Context, eventID string) (*OastEventInfo, error)

	// ListSessions returns all active sessions.
	ListSessions(ctx context.Context) ([]OastSessionInfo, error)

	// DeleteSession stops polling and deregisters from the OAST provider.
	// idOrDomain accepts either the short ID or the full domain.
	DeleteSession(ctx context.Context, idOrDomain string) error

	// Close cleans up all sessions (called on service shutdown).
	// Should attempt deregistration with a short timeout.
	Close() error
}

type OastEventInfo struct {
	ID        string                 // Short sectool ID
	Time      time.Time              // When the interaction occurred
	Type      string                 // "dns", "http", "smtp"
	SourceIP  string                 // Remote address of the interaction
	Subdomain string                 // Full subdomain that was accessed
	Details   map[string]interface{} // Protocol-specific details
}

type OastPollResultInfo struct {
	Events       []OastEventInfo // Events matching the filter
	DroppedCount int             // Number of events dropped due to buffer limit
}

type OastSessionInfo struct {
	ID             string    // Short sectool ID (e.g., "a1b2c3")
	Domain         string    // Full Interactsh domain (e.g., "xyz123.alpha.oastsrv.net")
	Label          string    // Optional user-provided label for easier reference
	RedirectTarget string    // URL to 307 redirect HTTP requests to (empty = no redirect)
	CreatedAt      time.Time // When the session was created
}

type PathQueryOpts struct {
	Method      string   // replace HTTP method
	Path        string   // replace entire path (without query)
	Query       string   // replace entire query string
	SetQuery    []string // add or replace query params ("key=value")
	RemoveQuery []string // remove query params by key
}

type ProxyEntry struct {
	FlowID    string    `json:"flow_id"`
	Timestamp time.Time `json:"-"` // capture-start for native; first observation for Burp
	Request   string    `json:"request"`
	Response  string    `json:"response"`
	// InterimResponses holds wire-formatted 1xx responses that preceded Response.
	InterimResponses []string `json:"interim_responses,omitempty"`
	Notes            string   `json:"notes"`
	Protocol         string   `json:"protocol"`                 // "http/1.1" or "http/2" (empty defaults to http/1.1)
	Adapter          string   `json:"adapter,omitempty"`        // emitting adapter name
	ParentFlowID     string   `json:"parent_flow_id,omitempty"` // parent flow when nested
	Scheme           string   `json:"scheme,omitempty"`         // "http" or "https" (empty = infer from host)
	Port             int      `json:"port,omitempty"`           // original port (0 = infer from scheme)
	// Annotations carries sidecar-authored flow metadata.
	Annotations       map[string]any `json:"annotations,omitempty"`
	InvokedBy         string         `json:"invoked_by,omitempty"`
	SidecarInstanceID string         `json:"sidecar_instance_id,omitempty"`
	// Placeholder marks an unparseable Burp entry that preserves offset contiguity; skipped for display.
	Placeholder bool `json:"-"`
}

type ProxyEntryMeta struct {
	FlowID       string
	Timestamp    time.Time // capture-start for native; first observation for Burp
	Method       string
	Host         string
	Path         string // includes query string
	Status       int
	RespLen      int
	Protocol     string
	Adapter      string // emitting adapter name
	ParentFlowID string // parent flow when nested (stream child, session inner flow)
	Scheme       string // "http" or "https" (empty = infer from host)
	Port         int    // original port (0 = infer from scheme)
	ContentType  string
	// Annotations carries sidecar-authored flow metadata.
	Annotations       map[string]any
	InvokedBy         string
	SidecarInstanceID string
	// Placeholder marks an unparseable Burp entry that preserves offset contiguity; skipped for display.
	Placeholder bool
}

type ProxyListRequest struct {
	Host         string `json:"host,omitempty"`
	Path         string `json:"path,omitempty"`
	Method       string `json:"method,omitempty"`
	Status       string `json:"status,omitempty"`
	SearchHeader string `json:"search_header,omitempty"`
	SearchBody   string `json:"search_body,omitempty"`
	Since        string `json:"since,omitempty"`
	ExcludeHost  string `json:"exclude_host,omitempty"`
	ExcludePath  string `json:"exclude_path,omitempty"`
	Adapter      string `json:"adapter,omitempty"`
	ProtocolTag  string `json:"protocol_tag,omitempty"`
	ParentFlowID string `json:"parent_flow_id,omitempty"`
	Limit        int    `json:"limit,omitempty"`
	Offset       int    `json:"offset,omitempty"`
	Source       string `json:"source,omitempty"`
}

type RequestSender func(ctx context.Context, req SendRequestInput, start time.Time) (*SendRequestResult, error)

type ResponderBackend interface {
	// AddResponder registers a custom response for a specific origin and path.
	// ResponderID is assigned by the backend and returned in the result.
	AddResponder(ctx context.Context, input protocol.ResponderEntry) (*protocol.ResponderEntry, error)

	// DeleteResponder removes a responder by ID or label.
	DeleteResponder(ctx context.Context, idOrLabel string) error

	// ListResponders returns all registered responders.
	ListResponders(ctx context.Context) ([]protocol.ResponderEntry, error)
}

type SendRequestInput struct {
	RawRequest      []byte
	Target          types.Target
	FollowRedirects bool
	Force           bool // Skip validation for protocol-level tests

	// Protocol from the original history entry ("http/1.1" or "http/2")
	// Empty defaults to HTTP/1.1
	Protocol string
}

type SendRequestResult struct {
	Headers         []byte
	Body            []byte
	Duration        time.Duration
	ModifiedRequest []byte // post-rule request bytes; nil if no rules applied
}

type Server struct {
	// contains filtered or unexported fields
}

type SidecarRegistry interface {
	// HasAdapter reports whether a healthy sidecar is registered under name.
	HasAdapter(name string) bool
	// AdapterTools returns each healthy adapter's MCP tools keyed by adapter name,
	// as a single consistent snapshot.
	AdapterTools() map[string][]wire.MCPTool
	// InvokeTool delegates a sidecar-registered tool call to its owning adapter.
	InvokeTool(ctx context.Context, name string, args json.RawMessage) (wire.InvokeToolResult, *wire.Error)
	// SidecarSend routes a replay or origination to the named adapter.
	SidecarSend(ctx context.Context, adapter string, p wire.SidecarSendParams) (wire.SidecarSendResult, *wire.Error)
	// SetToolsChangedHook registers a callback invoked when the connected adapter set changes.
	SetToolsChangedHook(fn func())
}

type StatusCodeFilter struct {
	// contains filtered or unexported fields
}