vulnmap

type ActiveUser struct {
	Id       string `json:"id"`
	UserName string `json:"username,omitempty"`
	Orgs     []struct {
		Name  string `json:"name,omitempty"`
		Id    string `json:"id,omitempty"`
		Group struct {
			Name string `json:"name,omitempty"`
			Id   string `json:"id,omitempty"`
		} `json:"group,omitempty"`
	} `json:"orgs,omitempty"`
}

type AuthenticationFailedError struct {
	ManualAuthentication bool
}

type AuthenticationFunction func() (string, error)

type AuthenticationProvider interface {
	// Authenticate triggers the authentication. This may involve manual steps, like logging in using a browser
	Authenticate(ctx context.Context) (string, error)

	// ClearAuthentication removes all authentication information from the configuration
	ClearAuthentication(ctx context.Context) error

	// AuthURL returns the latest provided AuthenticationURL. This can be empty.
	AuthURL(ctx context.Context) string
	// SetAuthURL sets the latest provided Authentication URL. This is a temporary URL.
	SetAuthURL(url string)

	GetCheckAuthenticationFunction() AuthenticationFunction
}

type AuthenticationService interface {
	// Authenticate attempts to authenticate the user, and sends a notification to the client when successful
	Authenticate(ctx context.Context) (string, error)

	Provider() AuthenticationProvider

	// UpdateCredentials stores the token in the configuration, and sends a $/vulnmap.hasAuthenticated notification to the
	// client if sendNotification is true
	UpdateCredentials(newToken string, sendNotification bool)

	Logout(ctx context.Context)

	// IsAuthenticated returns true if the token is verified
	IsAuthenticated() (bool, error)

	// SetProvider sets the authentication provider
	SetProvider(provider AuthenticationProvider)
}

type CodeAction struct {
	// Title is a short, human-readable, title for this code action.
	Title string

	IsPreferred *bool

	// Edit is an optional WorkspaceEdit literal that can be executed by the client.
	Edit *WorkspaceEdit

	// DeferredEdit is a function that returns a WorkspaceEdit.
	// Used for heavy calculations that shouldn't be done ahead of time.
	// A CodeAction cannot have both Edit and DeferredEdit.
	DeferredEdit *func() *WorkspaceEdit

	// Command that will be executed after the Edit (if present).
	Command *CommandData

	// DeferredCommand is a function that returns a Command.
	// Used for heavy calculations that shouldn't be done ahead of time.
	// A CodeAction cannot have both Command and DeferredCommand.
	DeferredCommand *func() *CommandData

	// UUID is a unique identifier for this code action. This is used for deferred resolution of a command or edit.
	Uuid *uuid.UUID
}

type CodeIssueData struct {
	// Unique key identifying an issue in the whole result set
	Key                string             `json:"key"`
	Title              string             `json:"title"`
	Message            string             `json:"message"`
	Rule               string             `json:"rule"`
	RuleId             string             `json:"ruleId"`
	RepoDatasetSize    int                `json:"repoDatasetSize"`
	ExampleCommitFixes []ExampleCommitFix `json:"exampleCommitFixes"`
	CWE                []string           `json:"cwe"`
	Text               string             `json:"text"`
	Markers            []Marker           `json:"markers,omitempty"`
	Cols               CodePoint          `json:"cols"`
	Rows               CodePoint          `json:"rows"`
	IsSecurityType     bool               `json:"isSecurityType"`
	IsAutofixable      bool               `json:"isAutofixable"`
}

type CodePoint = [2]int

type Command interface {
	Command() CommandData
	Execute(ctx context.Context) (any, error)
}

type CommandData struct {
	/**
	 * Title of the command, like `save`.
	 */
	Title string
	/**
	 * The identifier of the actual command handler.
	 */
	CommandId string
	/**
	 * Arguments that the command handler should be
	 * invoked with.
	 */
	Arguments []any
}

type CommandName string

type CommandService interface {
	ExecuteCommandData(ctx context.Context, commandData CommandData, server lsp.Server) (any, error)
}

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

type CommitChangeLine struct {
	Line       string `json:"line"`
	LineNumber int    `json:"lineNumber"`
	LineChange string `json:"lineChange"`
}

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

type ExampleCommitFix struct {
	CommitURL string             `json:"commitURL"`
	Lines     []CommitChangeLine `json:"lines"`
}

type FakeAuthenticationProvider struct {
	ExpectedAuthURL string
	IsAuthenticated bool
	// contains filtered or unexported fields
}

type IaCIssueData struct {
	// Unique key identifying an issue in the whole result set
	Key string `json:"key"`
	// Title: title of the issue
	Title string `json:"title"`
	// PublicID: unique identifier for the issue; it is the same as the ScanIssue.ID
	PublicId string `json:"publicId"`
	// Documentation is a URL which is constructed from the PublicID (e.g. https://security.vulnmap.khulnasoft.com/rules/cloud/VULNMAP-CC-K8S-13)
	Documentation string `json:"documentation"`
	// LineNumber: line number of the issue in the file
	LineNumber int `json:"lineNumber"`
	// Issue: will contain the issue description
	Issue string `json:"issue"`
	// Impact: will contain the impact description
	Impact string `json:"impact"`
	// Resolve: will contain the resolution description (not to be confused with Remediation)
	Resolve string `json:"resolve"`
	// Path: path to the issue in the file
	Path []string `json:"path"`
	// References: List of reference URLs
	References []string `json:"references,omitempty"`
}

type InlineValue interface {
	Path() string
	Range() Range
	Text() string
	fmt.Stringer
}

type InlineValueProvider interface {
	// GetInlineValues returns inline values for a given path and range.
	// This should be a very fast operation.
	GetInlineValues(path string, myRange Range) ([]InlineValue, error)

	// ClearInlineValues clears inline values for a given path.
	ClearInlineValues(path string)
}

type Issue struct {
	// ID uniquely identifies the issue, it is intended to be human-readable
	ID        string
	Severity  Severity
	IssueType Type
	// Range identifies the location of this issue in its source of origin (e.g. line & character start & end)
	Range Range
	// Message is a human-readable description of the issue
	Message string
	// todo [jc] this contains a formatted longest message for hovers, this needs to be pushed up and rendered in presentation. [bd] shouldn't the content and formatting be decided by the product?
	FormattedMessage string
	// AffectedFilePath is the file path to the file where the issue was found
	AffectedFilePath string
	// Product is the Vulnmap product, e.g. Vulnmap Open Source
	Product product.Product // todo: can we avoid it, if it's part of a scanner interface already?
	// References deliver additional information
	References []Reference
	// IssueDescriptionURL contains a Uri to display more information
	IssueDescriptionURL *url.URL
	// CodeActions can contain workspace edits or commands to be executed
	CodeActions []CodeAction
	// CodelensCommands that can be executed via a codelens
	CodelensCommands []CommandData
	// The Ecosystem of the issue, e.g. npm, maven, nuget, etc.
	Ecosystem string
	// A slice of the CWEs of the issue, e.g. CWEs-79
	CWEs []string
	// A slice of the CVEs of the issue
	CVEs []string
	// AdditionalData contains data that can be passed by the product (e.g. for presentation)
	AdditionalData any
}

type Marker struct {
	Msg CodePoint        `json:"msg"`
	Pos []MarkerPosition `json:"pos"`
}

type MarkerPosition struct {
	Cols CodePoint `json:"cols"`
	Rows CodePoint `json:"rows"`
	File string    `json:"file"`
}

type MessageAction string

type MessageType int

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

type OssIssueData struct {
	Key               string      `json:"key"`
	Title             string      `json:"title"`
	Name              string      `json:"name"`
	LineNumber        int         `json:"lineNumber"`
	Description       string      `json:"description"`
	References        []Reference `json:"references,omitempty"`
	Version           string      `json:"version"`
	License           string      `json:"license,omitempty"`
	PackageManager    string      `json:"packageManager"`
	PackageName       string      `json:"packageName"`
	From              []string    `json:"from"`
	FixedIn           []string    `json:"fixedIn,omitempty"`
	UpgradePath       []any       `json:"upgradePath,omitempty"`
	IsUpgradable      bool        `json:"isUpgradable,omitempty"`
	CVSSv3            string      `json:"CVSSv3,omitempty"`
	CvssScore         float64     `json:"cvssScore,omitempty"`
	Exploit           string      `json:"exploit,omitempty"`
	IsPatchable       bool        `json:"isPatchable"`
	ProjectName       string      `json:"projectName"`
	DisplayTargetFile string      `json:"displayTargetFile"`
	Language          string      `json:"language"`
	Details           string      `json:"details"`
}

type PackageScanner interface {
	ScanPackages(ctx context.Context, config *config.Config, path string, content string)
}

type Position struct {
	/**
	 * Line position in a document (zero-based).
	 */
	Line int
	/**
	 * Character offset on a line in a document (zero-based).
	 */
	Character int
}

type ProductScanner interface {
	// Scan scans a workspace folder or file for issues, given its path. 'folderPath' provides a path to a workspace folder, if a file needs to be scanned.
	Scan(
		ctx context.Context,
		path string,
		folderPath string,
	) (issues []Issue, err error)

	IsEnabled() bool
	Product() product.Product
}

type Range struct {
	/**
	 * The range's start position.
	 */
	Start Position

	/**
	 * The range's end position.
	 */
	End Position
}

type Reference struct {
	Title string
	Url   *url.URL
}

type ScanData struct {
	Product           product.Product
	Issues            []Issue
	Err               error
	DurationMs        int64
	TimestampFinished time.Time
	Critical          int
	High              int
	Medium            int
	Low               int
	SeverityCount     map[product.Product]SeverityCount
}

type ScanNotifier interface {
	SendInProgress(folderPath string)
	SendSuccess(product product.Product, folderPath string, issues []Issue)
	SendSuccessForAllProducts(folderPath string, issues []Issue)
	SendError(product product.Product, folderPath string)
}

type ScanResultProcessor = func(scanData ScanData)

type Scanner interface {
	// Scan scans a workspace folder or file for issues, given its path. 'folderPath' provides a path to a workspace folder, if a file needs to be scanned.
	Scan(
		ctx context.Context,
		path string,
		processResults ScanResultProcessor,
		folderPath string,
	)
	Init() error
}

type Severity int8

type SeverityCount struct {
	Critical int
	High     int
	Medium   int
	Low      int
}

type ShowMessageRequest struct {
	Message string                                                 `json:"message"`
	Type    MessageType                                            `json:"type"`
	Actions *data_structure.OrderedMap[MessageAction, CommandData] `json:"actions"`
}

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

type TestScanner struct {
	Issues []Issue
	// contains filtered or unexported fields
}

type TextEdit struct {
	/**
	 * The range of the text document to be manipulated. To insert
	 * text into a document create a range where start === end.
	 */
	Range Range

	/**
	 * The string to be inserted. For delete operations use an
	 * empty string.
	 */
	NewText string
}

type Type int8

type WorkspaceEdit struct {
	/**
	 * Holds changes to existing resources.
	 */
	Changes map[string][]TextEdit
}