connect

type AccessError struct {
	Client      string        // client id/name
	Path        string        // config path attempted
	Outcome     AccessOutcome // accessDenied (could also wrap malformed)
	Remediation string        // actionable fix text
	Err         error         // underlying OS cause
}

type AccessOutcome = string

type ClientDef struct {
	ID        string // Unique identifier, e.g. "claude-code"
	Name      string // Human-readable name, e.g. "Claude Code"
	Format    string // File format: "json" or "toml"
	ServerKey string // Top-level key for server entries: "mcpServers" or "servers"
	Supported bool   // Whether this client can be connected (directly or via a bridge)
	Reason    string // Explanation when Supported is false
	Note      string // Optional caveat shown for supported clients (e.g. bridge requirement)
	Bridge    bool   // Connects via a stdio bridge; Connect can create the config when absent
	Icon      string // Icon identifier for frontend use
}

type ClientStatus struct {
	ID         string `json:"id"`
	Name       string `json:"name"`
	ConfigPath string `json:"config_path"`
	Exists     bool   `json:"exists"`           // config file exists on disk
	Connected  bool   `json:"connected"`        // mcpproxy entry present in config
	Supported  bool   `json:"supported"`        // client can be connected (directly or via a bridge)
	Reason     string `json:"reason,omitempty"` // why not supported
	Note       string `json:"note,omitempty"`   // caveat for supported clients (e.g. bridge requirement)
	Bridge     bool   `json:"bridge,omitempty"` // connects via a stdio bridge; connectable even without an existing config
	Icon       string `json:"icon"`
	ServerName string `json:"server_name,omitempty"` // name under which mcpproxy is registered

	// AccessState classifies the per-client content access (Spec 075, additive).
	// Empty/"unknown" in the content-read-free overall status; resolved to
	// "accessible"/"absent"/"malformed" (and "denied" in US2) by on-demand reads.
	AccessState string `json:"access_state"`
	// CheckedPaths lists every config location the existence check consults,
	// highest precedence first. For most clients this is just ConfigPath; for
	// OpenCode it names both opencode.jsonc and opencode.json (#922), so a
	// "no config found" UI can say exactly which files were looked for.
	CheckedPaths []string `json:"checked_paths,omitempty"`
	// Remediation carries actionable fix text, populated only when access is denied.
	Remediation string `json:"remediation,omitempty"`
}

type ConnectPreview struct {
	Client         string                 `json:"client"`
	ConfigPath     string                 `json:"config_path"`
	Format         string                 `json:"format"`           // "json" | "toml"
	ServerKey      string                 `json:"server_key"`       // mcpServers / servers / mcp_servers / mcp
	ServerName     string                 `json:"server_name"`      // key written into the config ("mcpproxy")
	Entry          map[string]interface{} `json:"entry"`            // exact entry (masked) that will be written
	EntryText      string                 `json:"entry_text"`       // entry rendered in the client's format (masked)
	EntryExists    bool                   `json:"entry_exists"`     // an entry with this name already exists (overwrite/force case)
	ContainsAPIKey bool                   `json:"contains_api_key"` // the written URL embeds an apikey credential
	Bridge         bool                   `json:"bridge,omitempty"` // connects via a stdio bridge (config created if absent)
	// AccessState classifies the on-demand config read used to determine
	// EntryExists (Spec 075): accessible|absent|malformed. A denied read never
	// reaches here — it is returned as a typed *AccessError (403 + remediation).
	AccessState string `json:"access_state"`

	// ExistingEntrySummary describes the entry this connect would REPLACE, and
	// is populated only when EntryExists (Spec 091 FR-003). It is built by
	// construction from non-secret projections — see EntrySummary — so no
	// arbitrary value from the user's config can ride out in a preview. It is
	// display-only: drift detection uses PreconditionToken, never this.
	ExistingEntrySummary *EntrySummary `json:"existing_entry_summary,omitempty"`

	// PreconditionToken is the opaque, keyed digest of the raw pre-write state
	// this preview describes plus the exact entry that would be written (Spec
	// 091 FR-005). A caller echoes it on the subsequent write; the core
	// recomputes and refuses with a discriminated conflict when anything has
	// drifted — externally (the file or the target entry changed) or
	// proxy-side (credential rotation, auth toggle, address change).
	PreconditionToken string `json:"precondition_token"`

	// ConnectRefusal carries, verbatim, the reason a connect would refuse for
	// this client regardless of user intent — today only a non-create-capable
	// client (OpenCode) whose config is absent. It is produced by the SAME guard
	// the write runs, so the form can hide the Connect control and show the
	// reason instead of letting the user discover it by clicking (Spec 091
	// FR-003). Empty means connectable.
	ConnectRefusal string `json:"connect_refusal,omitempty"`
}

type ConnectResult struct {
	Success    bool   `json:"success"`
	Client     string `json:"client"`
	ConfigPath string `json:"config_path"`
	BackupPath string `json:"backup_path,omitempty"`
	ServerName string `json:"server_name"`
	Action     string `json:"action"` // "created", "updated", "already_exists", "removed", "not_found"
	Message    string `json:"message"`
}

type EntrySummary struct {
	// EntryName is the key the entry actually lives under, which may differ
	// from the requested server_name when the write adopts an equivalent entry.
	EntryName   string   `json:"entry_name"`
	Type        string   `json:"type,omitempty"`
	Endpoint    string   `json:"endpoint,omitempty"`
	Command     string   `json:"command,omitempty"`
	HeaderNames []string `json:"header_names"`
	EnvNames    []string `json:"env_names"`
}

type PreconditionState struct {
	// ClientID scopes the token to one client's connect flow.
	ClientID string
	// ConfigPath is which file is being written.
	ConfigPath string
	// Requested is the entry name the caller asked for — the key the write
	// creates when nothing is adopted. It is NOT implied by ResolvedEntryName:
	// that one is empty for every absent target, so without this a preview for
	// one name validated a write under any other.
	Requested string
	// FileExists distinguishes create from update (a file appearing or
	// vanishing between preview and write).
	FileExists bool
	// ResolvedEntryName is the key the write would replace, AFTER the same
	// equivalent-entry adoption the write performs. Empty when none resolved.
	ResolvedEntryName string
	// RawResolvedEntry is that entry's value; nil when there is none. It
	// includes values the sanitized summary deliberately hides, so a credential
	// rotation inside the existing entry drifts.
	RawResolvedEntry json.RawMessage
	// PendingEntry is the entry the proxy would write right now, so proxy-side
	// drift (API-key rotation, require_mcp_auth toggle, listen-address change)
	// invalidates the preview too — otherwise a credential could be embedded
	// without the FR-004 notice ever having been shown.
	PendingEntry json.RawMessage
}

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