service

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

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

type CrawlError struct {
	FlowID string // May be empty if request never sent
	URL    string // URL that caused the error
	Error  string // Error message
	Status int    // HTTP status if available
}

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 CrawlStopResponse struct {
	Stopped bool `json:"stopped"`
}

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) ([]DiscoveredForm, error)

	// ListErrors returns errors encountered in a session.
	// sessionID can be the ID or label.
	ListErrors(ctx context.Context, sessionID string, limit int) ([]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 DiscoveredForm struct {
	ID        string      // Short sectool ID
	SessionID string      // Parent session ID
	URL       string      // Page containing the form
	Action    string      // Form action URL (resolved to absolute)
	Method    string      // GET/POST
	Inputs    []FormInput // Form fields
	HasCSRF   bool        // Detected CSRF token field
}

type ExportResult struct {
	BundleID   string   // Bundle identifier (equals flow_id)
	BundlePath string   // Full path to bundle directory
	Files      []string // List of created files
}

type FormInput struct {
	Name     string // Field name attribute
	Type     string // text, password, hidden, select, textarea, etc.
	Value    string // Default/current value
	Required bool   // Has required attribute
}

type HealthMetricProvider func() string

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

	// GetProxyHistory retrieves proxy HTTP history entries.
	// Returns up to count entries starting from offset.
	GetProxyHistory(ctx context.Context, count int, offset uint32) ([]ProxyEntry, error)

	// GetProxyHistoryMeta retrieves lightweight metadata for proxy history entries.
	// Returns up to count entries starting from offset.
	GetProxyHistoryMeta(ctx context.Context, count int, offset uint32) ([]ProxyEntryMeta, 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 match/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 match/replace rule.
	// WebSocket vs HTTP is inferred from rule.Type (ws:* types are WebSocket).
	// Returns the created rule with assigned ID.
	AddRule(ctx context.Context, rule ProxyRuleInput) (*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
}

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", "explore", "test-report"
	Notes        bool   // enable notes/findings tools (experimental)
}

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.
	CreateSession(ctx context.Context, label string) (*OastSessionInfo, error)

	// 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 from a session.
	// Returns the full event details without truncation.
	GetEvent(ctx context.Context, idOrDomain string, 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 OastDeleteResponse struct{}

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.oast.fun")
	Label     string    // Optional user-provided label for easier reference
	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 {
	Request  string `json:"request"`  // Raw HTTP request
	Response string `json:"response"` // Raw HTTP response
	Notes    string `json:"notes"`    // User annotations
	Protocol string `json:"protocol"` // "http/1.1" or "h2" (empty defaults to http/1.1)
}

type ProxyEntryMeta struct {
	Method      string
	Host        string
	Path        string // includes query string
	Status      int
	RespLen     int
	Protocol    string
	ContentType string
}

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"`
	Limit        int    `json:"limit,omitempty"`
	Offset       int    `json:"offset,omitempty"`
	Source       string `json:"source,omitempty"`
}

type ProxyRuleInput struct {
	Label   string // Optional label for easier reference
	Type    string // Required on add
	IsRegex *bool
	Match   string
	Replace string
}

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

type RuleDeleteResponse struct{}

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

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

type SendRequestResult struct {
	Headers  []byte
	Body     []byte
	Duration time.Duration
}

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

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

type Target = proxy.Target