config

type AIAdapterConfig struct {
	// Disabled disables prompt injection for this agent entirely.
	Disabled bool `kdl:"disabled"`
	// FlagName overrides the CLI flag used for flag-based injection.
	// Ignored by stdin-based adapters. Example: "--system-prompt".
	FlagName string `kdl:"flag-name"`
	// StdinDelayMs overrides the delay (in milliseconds) before
	// injecting initial stdin. Ignored by flag-based adapters.
	StdinDelayMs int `kdl:"stdin-delay-ms"`
}

type AIConfig struct {
	// Skill is a skill/persona name to use (e.g., "code-review", "debugging")
	Skill string `kdl:"skill"`
	// Env are environment variables to set for AI commands
	Env map[string]string `kdl:"env"`
	// Context is a brief project description injected at the top of the system
	// prompt, before the agnt tools list. Use it to tell the AI what the project
	// is, which ports/URLs to use, and any other startup context.
	// Example: "React + FastAPI app. Dev server: port 3000, API: port 8080."
	Context string `kdl:"context"`
	// SystemPrompt is a full system prompt that replaces the default
	SystemPrompt string `kdl:"system-prompt"`
	// AppendSystemPrompt is appended to the default system prompt
	AppendSystemPrompt string `kdl:"append-system-prompt"`
	// Adapters is the map of per-adapter injection overrides, keyed by
	// lowercase agent name (e.g. "claude", "aider"). Empty / missing
	// entries inherit the adapter's default behavior.
	//
	// See internal/agentadapter for the set of built-in adapters and
	// docs/agent-adapters.md for a guide to adding a new one.
	Adapters map[string]*AIAdapterConfig `kdl:"adapters"`
	// HelpersCheatSheet controls whether the compact __devtool.*
	// helpers cheat sheet is appended to the default system prompt.
	// nil (the default) means "enabled"; set to an explicit false to
	// omit the cheat sheet — useful when the agent is already primed
	// via skill/prompt overrides and the extra ~40 lines are noise.
	HelpersCheatSheet *bool `kdl:"helpers-cheat-sheet"`
}

type AgntConfig struct {
	// Project metadata (optional, for documentation/info only)
	Project *AgntProjectMeta `kdl:"project"`

	// Scripts to manage
	Scripts map[string]*ScriptConfig `kdl:"scripts"`

	// Proxies to manage
	Proxies map[string]*ProxyConfig `kdl:"proxies"`

	// AI configuration for run and ai commands
	AI *AIConfig `kdl:"ai"`

	// Hooks configuration
	Hooks *HooksConfig `kdl:"hooks"`

	// Toast notification settings
	Toast *ToastConfig `kdl:"toast"`

	// Alerts configuration for process output monitoring
	Alerts *AlertsConfig `kdl:"alerts"`

	// Channel configuration for MCP push-based event forwarding
	Channel *ChannelConfig `kdl:"channel"`

	// Session lifecycle configuration (daemon-side cleanup policies)
	Session *SessionConfig `kdl:"session"`

	// HookRules configures the `agnt hook check-bash` / `check-prompt`
	// interceptors. Parsed here so the hookrules package can pull a
	// single AgntConfig via LoadAgntConfig rather than re-parsing KDL.
	HookRules *HookRulesConfig `kdl:"hook-rules"`

	// Setup configures the first-run auto-setup flow for `agnt run`.
	Setup *SetupConfig `kdl:"setup"`
}

type AgntProjectMeta struct {
	Type         string `kdl:"type"`
	Name         string `kdl:"name"`
	PortConflict string `kdl:"port-conflict"`
}

type AlertPatternConfig struct {
	// Pattern is a regular expression to match against output lines.
	Pattern string `kdl:"pattern"`

	// Severity is "error", "warning", or "info".
	Severity string `kdl:"severity"`
}

type AlertsConfig struct {
	// Enabled controls whether alerts are active. Default: true.
	Enabled *bool `kdl:"enabled"`

	// Patterns defines custom alert patterns keyed by ID.
	Patterns map[string]*AlertPatternConfig `kdl:"patterns"`

	// Disable is a list of built-in pattern IDs to disable.
	Disable []string `kdl:"disable"`

	// BatchWindow is the batching window in seconds before delivering alerts.
	// Default: 3.
	BatchWindow int `kdl:"batch-window"`

	// DedupeWindow is the deduplication window in seconds.
	// Duplicate alerts within this window are suppressed. Default: 60.
	DedupeWindow int `kdl:"dedupe-window"`

	// AutoForward configures automatic forwarding of browser/proxy errors to the AI agent.
	AutoForward *AutoForwardConfig `kdl:"auto-forward"`

	// Push configures which push channels are active for alert delivery.
	Push *PushConfig `kdl:"push"`

	// Preset names a predefined push channel configuration (e.g., "claude-code", "universal").
	// When set, it expands into a PushConfig. An explicit Push block takes precedence.
	Preset string `kdl:"preset"`

	// IncidentPipeline enables the new incident pipeline (Phase A dual-path rollout).
	// When false (default): existing AlertHub MCPAlertSink/OverlayAlertSink path is
	// active; incident.Bus runs in parallel for observability only (no pings sent).
	// When true: MCPAlertSink + OverlayAlertSink are suppressed; incident.Bus Pinger
	// emits instead. StreamSink is unaffected in both modes.
	// KDL: alerts { incident-pipeline true }
	IncidentPipeline bool `kdl:"incident-pipeline"`

	// OutageHold configures the transport-signal-driven outage gate that holds
	// transport / browser-JS errors during dev-server restarts that the
	// process-state classifier cannot detect (e.g. dotnet watch keeps the
	// supervisor process Running while the embedded HTTP/WS server bounces).
	OutageHold *OutageHoldConfig `kdl:"outage-hold"`
}

type AutoForwardConfig struct {
	// Enabled controls whether browser/proxy errors are auto-forwarded. Default: true.
	Enabled *bool `kdl:"enabled"`

	// Sources specifies which error sources to forward. Default: ["browser", "http"].
	Sources []string `kdl:"sources"`

	// Debounce is the minimum seconds between forwarded errors. Default: 10.
	Debounce int `kdl:"debounce"`

	// Severity is the minimum severity to forward: "error" or "warning". Default: "error".
	Severity string `kdl:"severity"`
}

type ChannelConfig struct {
	// Enabled controls whether the channel is active. Default: false.
	Enabled *bool `kdl:"enabled"`

	// Events is an allowlist of event types to forward.
	// Empty/omitted means all types. Valid values: "error", "diagnostic", "interaction".
	Events []string `kdl:"events"`

	// Severity is the minimum event severity to forward.
	// Valid values: "trace", "debug", "info", "warning", "error".
	// Default: "warning".
	Severity string `kdl:"severity"`

	// DedupeWindow is the per-event deduplication window in milliseconds.
	// 0 disables deduplication. Default: 2000.
	DedupeWindow int `kdl:"dedupe-window"`

	// ReplyTool controls whether the channel-reply MCP tool is registered.
	// Default: true.
	ReplyTool *bool `kdl:"reply-tool"`
}

type CommandConfig struct {
	// Command is the executable name.
	Command string `json:"command"`
	// Args are the default arguments.
	Args []string `json:"args"`
	// Description is a human-readable description.
	Description string `json:"description,omitempty"`
	// Timeout is the command timeout in seconds.
	Timeout int `json:"timeout,omitempty"`
	// Persistent indicates this is a long-running process.
	Persistent bool `json:"persistent,omitempty"`
	// Env holds environment variables to set.
	Env map[string]string `json:"env,omitempty"`
}

type Config struct {
	// Version is the config file version.
	Version string `json:"version"`

	// Settings are global server settings.
	Settings Settings `json:"settings"`

	// Languages holds language-specific configurations.
	Languages map[string]LanguageConfig `json:"languages"`
}

type DependsOnList []ScriptDependency

type HealthPatterns struct {
	Error   string // Regex that indicates an error
	Healthy string // Regex that clears the error state
}

type HookBashPattern struct {
	Pattern     string `kdl:"pattern"`
	Action      string `kdl:"action"`
	Replacement string `kdl:"replacement"`
	Reason      string `kdl:"reason"`
}

type HookPromptPattern struct {
	Pattern  string `kdl:"pattern"`
	Reminder string `kdl:"reminder"`
}

type HookRulesConfig struct {
	// BypassEnv overrides the default AGNT_HOOK_BYPASS env-var name.
	BypassEnv string `kdl:"bypass-env"`

	// BashPatterns is a map from rule name to bash pattern rule. The
	// rule name is used only for diagnostics (rules list output) and
	// does not affect matching order relative to builtins.
	BashPatterns map[string]*HookBashPattern `kdl:"bash-patterns"`

	// PromptPatterns is a map from rule name to prompt pattern rule.
	PromptPatterns map[string]*HookPromptPattern `kdl:"prompt-patterns"`
}

type HooksConfig struct {
	// OnResponse controls what happens when Claude responds
	OnResponse *ResponseHookConfig `kdl:"on-response"`
}

type KDLCommand struct {
	Command    string            `kdl:"cmd"`
	Args       []string          `kdl:"args"`
	Timeout    int               `kdl:"timeout"`
	Persistent bool              `kdl:"persistent"`
	Env        map[string]string `kdl:"env"`
}

type KDLConfig struct {
	Version   string       `kdl:"version"`
	Settings  KDLSettings  `kdl:"settings"`
	Languages KDLLanguages `kdl:"languages"`
}

type KDLLanguage struct {
	Markers              []string               `kdl:"markers"`
	Priority             int                    `kdl:"priority"`
	PackageManagerDetect bool                   `kdl:"package-manager-detect"`
	Commands             map[string]*KDLCommand `kdl:"commands"`
}

type KDLLanguages struct {
	Go     *KDLLanguage `kdl:"go"`
	Node   *KDLLanguage `kdl:"node"`
	Python *KDLLanguage `kdl:"python"`
}

type KDLProjectConfig struct {
	Language       string                 `kdl:"language"`
	PackageManager string                 `kdl:"package-manager"`
	Commands       map[string]*KDLCommand `kdl:"commands"`
}

type KDLSettings struct {
	DefaultTimeout  int `kdl:"default-timeout"`
	MaxOutputBuffer int `kdl:"max-output-buffer"`
	GracefulTimeout int `kdl:"graceful-timeout"`
}

type LanguageConfig struct {
	// Markers are files that identify this project type.
	Markers []string `json:"markers"`
	// Priority determines detection order (higher = first).
	Priority int `json:"priority"`
	// Commands are the available commands for this language.
	Commands map[string]CommandConfig `json:"commands"`
	// PackageManagerDetect enables automatic package manager detection (Node.js).
	PackageManagerDetect bool `json:"package_manager_detect,omitempty"`
}

type OutageHoldConfig struct {
	// Enabled controls whether the hold buffer is active. Default: true.
	Enabled *bool `kdl:"enabled"`

	// WindowMs is how long a held event waits before being force-emitted
	// when no recovery signal arrives. Default: 3000.
	WindowMs int `kdl:"window-ms"`

	// TransportErrThreshold is how many transport errors must occur within
	// TransportErrWindowMs before the proxy enters synthetic outage. Default: 1.
	TransportErrThreshold int `kdl:"transport-err-threshold"`

	// TransportErrWindowMs is the sliding window for the threshold check.
	// Default: 1000.
	TransportErrWindowMs int `kdl:"transport-err-window-ms"`

	// RecoveryDebounceMs is the minimum time after entering outage before
	// recovery signals are honoured. Guards against single-request races
	// where a 2xx arrives interleaved with a refused connection. Default: 500.
	RecoveryDebounceMs int `kdl:"recovery-debounce-ms"`

	// JSCascadePatterns is the case-insensitive substring list used to
	// classify a browser-JS error as transport-cascade. Cascade entries are
	// dropped on recovery; non-cascade entries are emitted. Default: the
	// standard set covering "Failed to fetch", "NetworkError", "WebSocket",
	// "ERR_CONNECTION_REFUSED", "ERR_NETWORK_CHANGED",
	// "ERR_INTERNET_DISCONNECTED", "net::ERR_", "Load failed".
	JSCascadePatterns []string `kdl:"js-cascade-patterns"`
}

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

type ProjectConfig struct {
	// Language overrides the detected language.
	Language string `json:"language,omitempty"`
	// PackageManager overrides the detected package manager.
	PackageManager string `json:"package_manager,omitempty"`
	// Commands override default commands.
	Commands map[string]CommandConfig `json:"commands,omitempty"`
}

type ProxyConfig struct {
	// Autostart starts the proxy when session opens
	Autostart bool `kdl:"autostart"`
	// MaxLogSize is the max number of log entries to keep
	MaxLogSize int `kdl:"max-log-size"`

	// Script links this proxy to a script for URL detection from output
	Script string `kdl:"script"`
	// URLPattern filters which detected URLs should trigger this proxy.
	// Regex pattern matched against detected URLs. Use to select specific ports
	// when a script outputs multiple URLs (e.g., ":34115" to match Wails backend).
	URLPattern string `kdl:"url-pattern"`

	// URL is the full target URL (e.g., "http://localhost:3000")
	URL string `kdl:"url"`
	// Target is the backend URL (deprecated, use URL instead)
	Target string `kdl:"target"`
	// Port is the target port - shorthand for http://localhost:PORT
	Port int `kdl:"port"`
	// FallbackPort is used when script URL detection fails
	FallbackPort int `kdl:"fallback-port"`
	// Host is the target host (default: localhost)
	Host string `kdl:"host"`

	// Bind is the address the proxy listens on
	// "127.0.0.1" (default) or "0.0.0.0" (all interfaces)
	Bind string `kdl:"bind"`

	// ListenPort is the explicit port the proxy binds to. When zero or
	// unset, the hash-based stable allocator in
	// proxy.DefaultPortForURL picks a port in the 10000-60000 range.
	//
	// When set, the proxy MUST bind to Bind:ListenPort or fail — the
	// daemon does not silently fall back to an auto-assigned port, and
	// the runtime Start() path honors StrictListenPort so a bind
	// conflict surfaces as a visible error event instead of getting
	// papered over with a random port. Intended for CORS origin
	// registration, shareable dev URLs that must not drift across
	// sessions, and reverse proxies to external hostnames that pin to
	// a specific listen port.
	ListenPort int `kdl:"listen-port"`

	// SkipTLSVerify disables TLS certificate verification on the
	// upstream (target) connection. Defaults to false — certs are
	// verified. Set to true to proxy to targets with self-signed,
	// expired, or otherwise untrusted certificates (common in local
	// dev environments with wildcard self-signed certs). The listen
	// side of the proxy is unaffected; this only controls the client
	// TLS config used when dialing the upstream URL.
	SkipTLSVerify bool `kdl:"skip-tls-verify"`

	// AllowExternal permits binding to non-localhost addresses
	// (0.0.0.0, ::). Required opt-in when Bind is set to a
	// non-localhost value; otherwise proxym.Create rejects the
	// bind to prevent accidental network exposure. Only surfaced
	// via the MCP tool path (PROXY START JSON extension); .agnt.kdl
	// autostart proxies must set `allow-external` explicitly for
	// the same gate to open.
	AllowExternal bool `kdl:"allow-external"`

	// PublicURL is the externally-visible URL for tunnel services
	// (e.g. "https://abc123.trycloudflare.com"). Informs the URL
	// rewriter so Location headers and absolute links are
	// rewritten to the public host instead of the bound listen
	// addr. Mirrors proxy.ProxyConfig.PublicURL; surfaced via MCP
	// tool JSON (`public_url`) and KDL (`public-url`).
	PublicURL string `kdl:"public-url"`

	// Websocket enables WebSocket proxying
	Websocket bool `kdl:"websocket"`

	// WaitFor lists script ids that must reach Running Healthy (or
	// Running With Errors) before this proxy begins forwarding
	// requests. While any entry is pending, the proxy binds and is
	// visible to `proxy list`, but every incoming request receives a
	// 503 with the `agnt_proxy_not_ready` sentinel body. When every
	// listed script signals ready (URL detected, port bound, or
	// ready-signal fired), the proxy flips to ready atomically.
	//
	// The proxy is a readiness gate, not a build gate. Per
	// .claude/rules/daemon-lifecycle.md, a process that is bound and
	// producing output (including compile errors) counts as "running"
	// — the readiness signal fires as soon as the port is listening,
	// regardless of whether the child is in a clean or errored state.
	//
	// Every entry must resolve to a declared script in the same
	// `scripts {}` block; unknown names fail config parsing. Proxy →
	// proxy dependencies are not supported.
	WaitFor []string `kdl:"wait-for"`
}

type PushConfig struct {
	// MCPNotifications controls delivery via MCP session.Log().
	// Works natively in Claude Desktop; may be dropped by other clients.
	// Defaults to true when unset.
	MCPNotifications *bool `kdl:"mcp-notifications"`

	// PTYInjection controls delivery via stdin typing into the PTY.
	// Universal channel that works in all clients (Claude Code, OpenCode, etc).
	// Defaults to true when unset.
	PTYInjection *bool `kdl:"pty-injection"`
}

type ResponseHookConfig struct {
	// Toast shows a toast notification in the browser
	Toast bool `kdl:"toast"`
	// Indicator updates the bug indicator
	Indicator bool `kdl:"indicator"`
	// Sound plays a notification sound
	Sound bool `kdl:"sound"`
}

type ScriptConfig struct {
	// Run is a shell command string (executed via platform shell)
	// On Unix: sh -c "..."
	// On Windows: cmd.exe /c "..."
	// Override with Shell field
	Run string `kdl:"run"`
	// Command is the executable name (used with Args)
	Command string `kdl:"command"`
	// Args are command arguments (used with Command)
	Args []string `kdl:"args"`
	// Shell overrides the shell used for "run" commands.
	// Examples: "bash", "powershell", "cmd.exe", "sh"
	// If empty, uses platform default (sh on Unix, cmd.exe on Windows)
	Shell string `kdl:"shell"`
	// ShellArgs overrides the shell arguments. Default: ["-c"] for sh/bash, ["/c"] for cmd.exe
	ShellArgs []string `kdl:"shell-args"`
	// Autostart starts the script when session opens
	Autostart bool `kdl:"autostart"`
	// URLMatchers are patterns for URL detection in output
	URLMatchers []string `kdl:"url-matchers"`
	// Env are environment variables for the script
	Env map[string]string `kdl:"env"`
	// Cwd is the working directory for the script
	Cwd string `kdl:"cwd"`
	// DependsOn lists scripts that must be ready before this script starts.
	DependsOn DependsOnList `kdl:"depends-on"`
	// Ports lists the ports this script uses. Used for pre-flight orphan cleanup
	// and EADDRINUSE recovery. Multiple ports supported (e.g., API + WebSocket).
	Ports []int `kdl:"ports"`
	// AutoRestart enables automatic restart when the process exits.
	// Default: false — user restarts manually from the overlay.
	AutoRestart bool `kdl:"auto-restart"`
	// Hooks defines optional shell commands run at process lifecycle transitions.
	Hooks *ScriptLifecycleHooks `kdl:"hooks"`
}

type ScriptDependency struct {
	// Name is the name of the script this depends on.
	Name string
	// Timeout is how long to wait for the dependency to become ready.
	// Zero means wait indefinitely (until the autostart context is cancelled
	// or the dependency's ready signal arrives). A positive value enforces
	// a hard upper bound on the wait — only set when the user explicitly
	// configures `timeout=N` in .agnt.kdl.
	Timeout time.Duration
}

type ScriptLifecycleHooks struct {
	// OnStart fires after the process transitions to Running state.
	OnStart string `kdl:"on-start"`
	// OnStop fires after a clean process exit (user-initiated or expected).
	OnStop string `kdl:"on-stop"`
	// OnCrash fires after an unexpected exit (non-zero code, not user-initiated).
	OnCrash string `kdl:"on-crash"`
	// OnRestart fires before each auto-restart attempt.
	OnRestart string `kdl:"on-restart"`
}

type SessionConfig struct {
	// OrphanPGIDScan controls whether daemon startup scans /proc for
	// orphaned POSIX process groups (pgid leader dead, members still
	// running) and kills them. Defaults to true.
	//
	// This handles the case where the daemon crashed or was restarted
	// mid-session: the SessionRegistry is lost so slice-A session-pgid
	// tracking cannot fire on cleanup. The startup scan is the crash-
	// recovery fallback.
	//
	// Set to false to disable if the scan is interfering with other
	// long-running session leaders on the system (e.g. a tmux session
	// daemon that shares a pgid layout the scan cannot distinguish).
	OrphanPGIDScan *bool `kdl:"orphan-pgid-scan"`
}

type Settings struct {
	// DefaultTimeout is the default process timeout.
	DefaultTimeout time.Duration `json:"default_timeout"`
	// MaxOutputBuffer is the per-stream output buffer size.
	MaxOutputBuffer int `json:"max_output_buffer"`
	// GracefulTimeout is the graceful shutdown timeout.
	GracefulTimeout time.Duration `json:"graceful_timeout"`
}

type SetupConfig struct {
	// RenudgeTTLDays is the number of days to suppress the setup nudge
	// after a negative outcome. Defaults to 7 when unset or non-positive.
	RenudgeTTLDays *int `kdl:"renudge-ttl-days"`
}

type ToastConfig struct {
	// Duration in milliseconds (default 4000)
	Duration int `kdl:"duration"`
	// Position: "top-right", "top-left", "bottom-right", "bottom-left"
	Position string `kdl:"position"`
	// MaxVisible is the max number of visible toasts (default 3)
	MaxVisible int `kdl:"max-visible"`
}