console

type Approver = kconsole.Approver

type Beller = kconsole.Beller

type Decision = kconsole.Decision

type IO = kconsole.IO

type Key = kconsole.Key

type KeySource = kconsole.KeySource

type LineSource = kconsole.LineSource

type Options struct {
	Profile string
	// AllowUnmask lets clients ask for unmasked output (--allow-unmask).
	AllowUnmask bool
	// ShowResults starts with the clear results on (--show-results);
	// Ctrl-O switches them while the console runs.
	ShowResults bool
	Cwd         string
	IO          IO
	// Now defaults to time.Now.
	Now func() time.Time
	// StateDir defaults to config.StateDir().
	StateDir string
	// PIIDir, when set (PIIDirEnv), is the directory of the PII rule sets
	// (pii/<set>.toml) instead of the profile's: lox up's copy of the
	// profile is read-only, and the console writes its first rule set and
	// every rule it adds. A set it lacks is first copied from the
	// profile's directory.
	PIIDir string
	// Version is the console version reported to clients.
	Version string
	// TTY is the console's terminal device (nil when unknown): its owner
	// must be the console's account in a separated setup.
	TTY *os.File
	// Hub is the lockhub the console is decided on (--hub, --hub-key-file,
	// --instance, as lox up passes them): required. The human decides in
	// lockhub, query.run answers pending with a ticket.
	Hub kconsole.HubOptions
	// AllowedUIDs (--allowed-uids) may connect besides the members of the
	// client group, as allowed_uids of the system setup: an agent in a
	// container of its own whose uid has no account in the console's.
	// Set only by whoever starts the console, never by a client.
	AllowedUIDs []int
}

type Outcome = kconsole.Outcome

type Result = kconsole.Result

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

type ServerConfig struct {
	// Policy is the approved policy the server enforces.
	Policy config.Policy
	// RulesPath is the file of the profile's PII rule set:
	// <project>/.locksql/pii/<set>.toml, or pii/<set>.toml in the user
	// config directory outside a project.
	RulesPath string
	// StateDir and ApprovedKey locate the approved policy file.
	StateDir    string
	ApprovedKey string
	Session     engine.Session
	// DBUser is the database account in use (it may have been asked for).
	DBUser    string
	Databases []string
	Audit     *audit.Log
	IO        IO
	// Approver takes every human decision: the hub's asynchronous
	// approver, which keeps the console's own decisions (policy changes,
	// :unmask) on this terminal. nil means Hub's around typed approvals.
	Approver Approver
	// Fingerprint is true when Approver is the fingerprint approver
	// (level 2): a typed answer alone then never widens anything.
	Fingerprint bool
	// Boundary names the desktop boundary for the status screen ("" in
	// the session shape).
	Boundary string
	Now      func() time.Time
	// AllowUnmask starts with unmasked output allowed: clients may ask for
	// it, and each such query is decided in lockhub. Without it an
	// unmask plan is refused before anything else. :unmask switches it
	// while the console runs.
	AllowUnmask bool
	// ShowResults starts with the clear results on: the result of each
	// masked run printed in the console, in clear; the client still gets
	// it masked. Ctrl-O switches them while the console runs. Ignored on
	// the desktop (Boundary set): levels 1 and 2 keep the results masked.
	ShowResults bool
	Version     string
	// LoadPolicy re-reads the current policy from the config files. Nil
	// disables CheckPolicy.
	LoadPolicy func() (config.Policy, error)
	// Reconnect opens a new session after a lost connection, under p, the
	// profile in force at that time. Nil means a lost connection ends the
	// console.
	Reconnect func(ctx context.Context, p config.Profile) (engine.Session, error)
	// RefuseProduction re-applies the start-up refusals of a production
	// profile (an X11 session, core dumps that could not be disabled) when
	// the policy in force becomes production: an error ends the session.
	// nil: none.
	RefuseProduction func() error
	// Quantum levels the response time of query.run (ResponseQuantum in
	// the real console, 0 to disable).
	Quantum time.Duration
	// PeerAllowed decides which clients are served, from the kernel's
	// credentials of the peer. Nil serves the console's own account only.
	PeerAllowed func(ipc.Cred) bool
	// Health is reported in status for locksql doctor.
	Health *ipc.Health
	// Refused is the fingerprint of a loosening the human refused at start,
	// not announced again until the files change.
	Refused string
	// Hub is the lockhub the requests are decided on (required).
	Hub *kconsole.Hub
}

type Sized = kconsole.Sized

type StatusLine = kconsole.StatusLine

type Terminal = kconsole.Terminal