server

type ClaudeCodeInfo struct {
	Installed *string
	Floor     string
	Verified  string
	Status    string
}

type ClaudeThemeInfo struct {
	Family string `json:"family"`
}

type Config struct {
	Store       *store.Store
	Logger      zerolog.Logger
	UIToken     string
	IngestToken string
	// WebDist, non-empty, serves the dashboard from disk instead of the embedded copy.
	WebDist         string
	DaemonVersion   string
	ClaudeCode      ClaudeCodeInfo
	IngestQueueSize int
	TmuxSocket      string
	// HTTPClient is shared by every feature with outbound HTTP calls (usage, issue,
	// update); nil defaults to http.DefaultClient, resolved once by New (like TmuxClient
	// and Attach below) since all three features need the same default.
	HTTPClient *http.Client
	// TmuxClient overrides the tmux client sessionLauncher/shellRegistry use; nil constructs tmux.New(cfg.TmuxSocket).
	TmuxClient paneSpawner
	// Attach overrides how a terminal socket attaches to a tmux target; nil uses termbridge.Attach.
	Attach attachFunc
	// ShellScroll overrides the shell socket's copy-mode driver (kb:anchor/terminal.shell-ws); nil
	// uses the real tmux client (the same one TmuxClient's override does not affect —
	// production always wants real tmux copy-mode commands regardless of a paneSpawner
	// test double).
	ShellScroll shellScroller
	// Locator resolves a dropped file's path (kb:anchor/sessions.locate); nil answers 500, never a panic.
	Locator *locate.Locator
	// InterruptChecker is handed to the session manager's interrupt sweep
	// (session.Config.InterruptChecker); nil disables it. cmd/musterd wires the Claude Code
	// transcript reader, so internal/server stays free of transcript knowledge.
	InterruptChecker session.InterruptChecker
	Launch           LaunchConfig
	Usage            UsageConfig
	Theme            ThemeConfig
	Issue            IssueConfig
	Update           UpdateConfig
	RepoRefresh      RepoRefreshConfig
}

type IssueConfig struct {
	// Repo is the GitHub repo issues are filed against.
	Repo string
	// APIURL is the GitHub API's base URL. main always passes the flag's non-empty
	// default, so this is the only place that URL is defined — no fallback constant
	// duplicates it here. Empty disables both new endpoints entirely: they 404
	// not_found (kb:anchor/issue.captures / kb:anchor/issue.create).
	APIURL string
	// TokenFile, when non-empty, reads the bearer token from this file's trimmed
	// contents instead of running `gh auth token` — a test seam that makes it
	// structurally impossible for a test using it to execute the real gh.
	TokenFile string
}

type LaunchConfig struct {
	// ClaudeBin is the `claude` binary to spawn (default "claude").
	ClaudeBin string
	// HookScript/StatusLineScript are the absolute paths to the generated command-hook
	// wrapper scripts (internal/claudecode.WriteWrapperScripts) — every event, including
	// SessionStart, is registered against HookScript.
	HookScript       string
	StatusLineScript string
	// LegacyScripts lists prior wrapper paths MergeSettings must still recognise and
	// drop from an already-instrumented directory.
	LegacyScripts []string
	// BrowseRoot is the folder browser's root (kb:anchor/browse.get): GET /api/browse's
	// no-param default and the "Up" ceiling. Empty means the daemon user's home
	// directory.
	BrowseRoot string
	// ProjectsDir is Claude Code's transcript store (claudecode.ProjectsDir's default, or
	// -claude-projects-dir): the resume-from-list branch's and GET /api/past-sessions'
	// one read root, read-only.
	ProjectsDir string
}

type PrefsInfo struct {
	View         string `json:"view"`
	Density      string `json:"density"`
	UsageModel   string `json:"usageModel"`
	RailSort     string `json:"railSort"`
	Theme        string `json:"theme"`
	UpdateCheck  bool   `json:"updateCheck"`
	RailDensity  string `json:"railDensity"`
	RailActivity string `json:"railActivity"`
}

type RepoRefreshConfig struct {
	// Poll is the poll interval (-repo-poll). <= 0 runs no timer: the poll then runs once at
	// start and on a nudge only (kb:adr/lifecycle-branch-refreshed-by-repo-poll).
	Poll time.Duration
}

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

type Snapshot struct {
	Sessions    []sessionWire   `json:"sessions"`
	Usage       UsageInfo       `json:"usage"`
	Prefs       PrefsInfo       `json:"prefs"`
	ClaudeTheme ClaudeThemeInfo `json:"claudeTheme"`
	// Update (kb:anchor/ws.update): always present, even on a daemon with updates disabled
	// entirely.
	Update UpdateInfo `json:"update"`
	// ShellsBusy (kb:anchor/ws.shell-activity): session ids whose shell is busy right now,
	// always present as [] when none — never null — so a reconnecting client re-syncs
	// without waiting for a shellActivity transition.
	ShellsBusy []int64 `json:"shellsBusy"`
	// Groups and Ungrouped (kb:anchor/ws.groups): the rail's sections, always present — Groups
	// as [] when there are none.
	Groups    []groupWire   `json:"groups"`
	Ungrouped ungroupedWire `json:"ungrouped"`
}

type ThemeConfig struct {
	// Poll is the poll interval. <= 0 disables polling entirely: snapshot.claudeTheme.family
	// stays "unknown" forever.
	Poll time.Duration
	// ConfigFile is Claude Code's global config file to poll
	// (claudecode.DefaultConfigPath() in production) — a test seam like UsageConfig.TokenFile.
	ConfigFile string
}

type UpdateApplyInfo struct {
	Phase   string  `json:"phase"`
	Version *string `json:"version"`
	Error   *string `json:"error"`
}

type UpdateConfig struct {
	// BaseURL is the GitHub Releases base URL; "" disables checking and apply entirely.
	BaseURL string
	// CheckInterval is how often the daemon re-checks for a newer release.
	CheckInterval time.Duration
	// PublicKey is the minisign public key file's raw bytes verification trusts
	// (overrides the embedded selfupdate.PublicKey() — a test seam; production always
	// passes the embedded key).
	PublicKey []byte
	// Install is the startup install classification (selfupdate.Classify), computed
	// once in cmd/musterd from the resolved executable path. installer/unmanaged are
	// re-derived at the start of every check by the Reclassify closure below, from
	// exePath/home/the write probe, not from this field; Install only decides whether
	// that re-derivation runs (dev/homebrew stay fixed for the daemon's life).
	Install selfupdate.Install
	// ExePath is the resolved (os.Executable + filepath.EvalSymlinks) real path of the
	// running binary — where an apply installs the new one and what swap detection stats.
	ExePath string
	// Reclassify re-derives installer/unmanaged (kb:adr/update-install-rechecked-on-every-check),
	// built in cmd/musterd from the same exePath/home/access inputs that produced Install.
	// Nil (every test daemon that doesn't exercise reclassification) means installer/
	// unmanaged never change after startup.
	Reclassify func() selfupdate.Install
}

type UpdateInfo struct {
	Running   string          `json:"running"`
	Install   string          `json:"install"`
	Remedy    *string         `json:"remedy"`
	CanCheck  bool            `json:"canCheck"`
	Available *string         `json:"available"`
	CheckedAt *string         `json:"checkedAt"`
	Installed *string         `json:"installed"`
	Apply     UpdateApplyInfo `json:"apply"`
}

type UsageBucket struct {
	UsedPct  float64 `json:"usedPct"`
	ResetsAt string  `json:"resetsAt"`
}

type UsageConfig struct {
	// Poll is the poll interval. <= 0 disables polling entirely: POST /api/usage/refresh
	// then 404s (kb:anchor/usage.refresh).
	Poll time.Duration
	// APIURL is the per-model usage endpoint's base URL. main always passes the flag's
	// non-empty default, so this is the *only* place that URL is defined — there is
	// deliberately no fallback constant here duplicating it. Empty disables the poller
	// entirely (same fail-safe shape as Poll <= 0).
	APIURL string
	// TokenFile, when non-empty, reads the Claude Code OAuth token from this file
	// instead of the macOS Keychain — a test seam that makes it structurally impossible
	// for a test using it to fall through to the real Keychain.
	TokenFile string
	// KeychainUser is the account name `security` looks the Keychain item up under
	// (main passes os/user.Current()'s value) — used only when TokenFile is empty.
	KeychainUser string
}

type UsageInfo struct {
	FiveHour          *UsageBucket       `json:"fiveHour"`
	SevenDay          *UsageBucket       `json:"sevenDay"`
	SampledAt         *string            `json:"sampledAt"`
	Source            string             `json:"source"`
	ModelScoped       []UsageModelWindow `json:"modelScoped"`
	ModelScopedAt     *string            `json:"modelScopedAt"`
	ModelScopedError  *string            `json:"modelScopedError"`
	ModelScopedSource string             `json:"modelScopedSource"`
}

type UsageModelWindow struct {
	DisplayName string  `json:"displayName"`
	UsedPct     float64 `json:"usedPct"`
	ResetsAt    string  `json:"resetsAt"`
}