api

type ConnectInfo struct {
	// Active is whether this instance has a connection secret at all.
	Active bool `json:"active"`
	// Connected is whether the relay socket is actually up right now, which
	// is a different question: a stored secret with a relay that cannot be
	// reached is configured but not working, and collapsing the two is what
	// made the old relay card unable to say which was wrong.
	Connected bool `json:"connected"`
	// PasswordSet mirrors GET /api/auth, so the page can warn - before
	// anything is generated - that the phrase it is about to hand out
	// reaches every instance in the group, and that this one is unprotected.
	PasswordSet bool `json:"passwordSet"`
	// RelayURL is which relay this instance dials: the compiled-in default,
	// or an override somebody set to point at their own.
	RelayURL string `json:"relayUrl"`
	// SelfHosted is whether that is an override rather than the default -
	// the one bit of the address a person actually needs to see.
	SelfHosted bool `json:"selfHosted"`
}

type DeploymentInfo struct {
	// Deployment is "container" (cmd/knightloader, the default) or
	// "desktop" (the Wails build) — see buildinfo.Deployment.
	Deployment string `json:"deployment"`
	// CanQuit and CanRestart report whether this process actually has a way
	// to act on the two routes below at all — false wherever RequestExit was
	// never wired. Both read the same field today because the mechanism is
	// identical either way (see RequestExit's own doc comment); they are two
	// fields rather than one so a build that ever wants to offer only one of
	// the two can say so without changing the response shape.
	CanQuit    bool `json:"canQuit"`
	CanRestart bool `json:"canRestart"`
	// Note is plain English from the server about what quit and restart
	// actually do in THIS build — the same "a fact about this build, not a
	// translation key" convention Feature.Reason already uses (routes_
	// features.go), for the same reason: what matters here (does something
	// outside this process bring it back) is true or false about the
	// deployment, not about the button, and 38 locale files should not have
	// to gain a key every time that sentence is reworded.
	Note string `json:"note"`
}

type Diagnostics struct {
	GeneratedAt time.Time `json:"generatedAt"`
	Version     string    `json:"version"`
	// Deployment is "container" or "desktop" (internal/buildinfo) - the same
	// fact 10D's quit/restart route reports, worth repeating here because a
	// bug report attached from a browser gives no other way to tell which
	// binary produced it.
	Deployment string `json:"deployment"`
	GoVersion  string `json:"goVersion"`
	OS         string `json:"os"`
	Arch       string `json:"arch"`
	Goroutines int    `json:"goroutines"`

	// Settings is what GET /api/settings sends, with one further redaction
	// on top: Settings.Redacted() covers the router and proxy passwords (see
	// its own doc comment, internal/settings/settings_network.go) but was
	// never meant to cover ArchivePasswords - that field is ordinary,
	// visible config on the Archives settings page, where a user is editing
	// their own passwords and needs to see them. This bundle is a different
	// exposure: a file meant to be attached to a PUBLIC bug report, where
	// the same values have no business appearing. Cleared here rather than
	// by changing Settings.Redacted() itself, which would incorrectly blank
	// the Archives page too. ArchivePasswordCount below keeps the one
	// diagnostically useful fact (is anything configured at all) without
	// the values themselves.
	Settings             settings.Settings `json:"settings"`
	ArchivePasswordCount int               `json:"archivePasswordCount"`

	// LogLines is the ring's own recent tail, oldest first - see
	// internal/logring for what feeds it and why capturing it costs no
	// changes anywhere else in the tree.
	LogLines []string `json:"logLines"`
	// LogCapacity is how many lines the ring keeps at most, so the page can
	// say "showing the last N" without a second copy of that number.
	LogCapacity int `json:"logCapacity"`
}

type Feature struct {
	// ID is stable and is what the interface looks a label up by. The label is
	// deliberately not here: a server string cannot be translated by the browser,
	// and this instance does not know which of the 42 locales is looking at it.
	ID string `json:"id"`

	Verdict FeatureVerdict `json:"verdict"`

	// Page is the settings sub-page this module is configured on, empty when it
	// has none. It is what lets a page with nothing shipped behind it explain
	// itself out of this table rather than inventing its own excuse.
	Page string `json:"page"`

	// Enabled is computed from live state on every request. See the file comment.
	Enabled bool `json:"enabled"`

	Switch FeatureSwitch `json:"switch"`

	// Parked is whether a SwitchParked module has a value waiting to come back.
	//
	// It is the difference between "somebody switched this off" and "this was
	// never set up", and without it the two are the same row. That collapse is a
	// deadlock on a fresh install: the page that configures the module disables
	// its field because the module reads off, and the switch refuses to turn on
	// because nothing is configured, so there is no way in from either end.
	Parked bool `json:"parked"`

	// Reason is why the verdict is what it is, or why there is no switch. It is
	// English prose from the server for the same reason a Go error is: it is a
	// fact about this build, and inventing a translation key per build fact means
	// 42 files change every time a subsystem lands.
	Reason string `json:"reason,omitempty"`

	// Detail is one line of live state — the folder being watched, the port, how
	// many rules there are — so the row says something even when the switch does
	// not apply.
	Detail string `json:"detail,omitempty"`
}

type FeaturePage struct {
	ID string `json:"id"`
	// Modules are the module ids configured on this page, so the page can render
	// the registry's reason for what is missing instead of writing its own.
	Modules []string `json:"modules"`
}

type FeatureState struct {
	Modules []Feature     `json:"modules"`
	Pages   []FeaturePage `json:"pages"`
}

type FeatureSwitch string

type FeatureVerdict string

type HelpIndex struct {
	Version    string `json:"version"`
	Deployment string `json:"deployment"`
	// About is one paragraph of orientation for somebody who has never seen
	// this API before: how it is guarded, and what "open" below means.
	About string `json:"about"`
	// Vocabulary is why every route name here is KnightLoader's own, never
	// JDownloader's Deprecated API or My.JDownloader's remote namespaces.
	// This is the field section 8's Wave 11 amendment asks for by name, so a
	// future contributor reads a decision here instead of an absence and
	// does not go half-build a compatibility shim that buys nothing.
	Vocabulary string `json:"vocabulary"`
	// RemoteAccess is why there is no hosted relay and no pairing route, and
	// points at what this build offers instead: GET /api/remote-access and
	// POST /api/tokens.
	RemoteAccess string `json:"remoteAccess"`
	// Routes is the full table, sorted by path then method, the same slice
	// TestOnlyTheseRoutesAreOpen and TestEveryRouteDescribesItself already
	// hold every route in this build to.
	Routes []Route `json:"routes"`
}

type QRMatrix struct {
	Size int `json:"size"`
	// Bits is one string per row, '1' for a dark module and '0' for a light
	// one: a fixed-width string per row rather than size squared individual
	// booleans, because the JSON is a quarter the size and there is nothing
	// to interpret beyond "index into this string".
	Bits []string `json:"bits"`
}

type ReachableAddress struct {
	// Label names where this address came from: "this connection" for the
	// one the request itself arrived on, "known" for one remembered or typed
	// in by hand (see rememberDomain below), otherwise the interface's own
	// IP.
	Label string `json:"label"`
	URL   string `json:"url"`
	// Loopback is true for 127.0.0.1/localhost/::1: reachable only from this
	// same machine, never a phone on the LAN, and never what the QR code
	// should encode.
	Loopback bool `json:"loopback"`
	// Domain is true when URL's host is a real hostname rather than a bare
	// IP - a domain behind a reverse proxy or VPN is what actually lets
	// pairing and the QR code work from outside this LAN, so it outranks a
	// LAN IP the moment one is known (see preferredAddress below), and the
	// Access tab uses this to tell a remembered domain apart from a plain
	// interface IP in the same list.
	Domain bool `json:"domain"`
}

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

type RemoteAccessInfo struct {
	// Deployment is "container" or "desktop" (buildinfo.Deployment). The
	// desktop build never opens a TCP port at all, see main's own comment on
	// AssetServer, so everything below is reported empty/false for it rather
	// than guessed at from request fields that mean nothing there.
	Deployment string `json:"deployment"`
	// PasswordSet mirrors GET /api/auth's own "enabled", repeated here so
	// the page has the one fact its warning banner turns on without a second
	// request racing this one.
	PasswordSet bool `json:"passwordSet"`
	// Addresses is every address this build can confirm or infer this
	// instance answers on, the one the request itself arrived on always
	// first (see remoteAddresses' own comment).
	Addresses []ReachableAddress `json:"addresses"`
	// Exposed is the loud warning's own condition: no password, and EITHER
	// this very request just proved this instance is reachable from
	// somewhere other than this machine itself (see requestIsNonLoopback),
	// OR the listener itself is bound wider than loopback on a machine that
	// has a real non-loopback interface to be reached on
	// (buildinfo.ListensWidely - see its own doc comment). The second half
	// exists because the first half alone can never be true for the one
	// person best placed to act on the warning: an admin looking at their
	// own Access page from 127.0.0.1 never generates a non-loopback
	// request, no matter how exposed the instance actually is - reproduced
	// live before this fix: a LAN-reachable, password-less instance showed
	// the warning to a visitor from another machine and never to the admin
	// sitting at the box itself.
	Exposed bool `json:"exposed"`
	// QR renders the primary address (Addresses[0] when there is one) as a
	// scannable code, nil when there is nothing to encode.
	QR *QRMatrix `json:"qr,omitempty"`
}

type Route struct {
	// Method is the HTTP method, exactly as net/http's pattern syntax wants it,
	// or AnyMethod.
	Method string `json:"method"`
	// Path is the pattern, wildcards included ("/api/tasks/{id}").
	Path string `json:"path"`
	// Summary is one line saying what the route does, in the language the rest of
	// the app is written in. It is what the index shows.
	Summary string `json:"summary"`
	// Open is a route reachable without a session on a password-protected
	// instance. It is false unless there is a reason, and the reason belongs in
	// the summary: these are the only doors in the building that are not locked.
	Open bool `json:"open"`
	// contains filtered or unexported fields
}