setup

type AckBoost struct {
	Off     bool   `json:"off,omitempty"`
	Content string `json:"content,omitempty"`
}

type Agent struct {
	// PersonID is the agent's Person id in AccountID. Admission takes the
	// agent's id from the profile's verified identity at run time; this is
	// what that identity is checked against.
	PersonID int64 `json:"person_id"`
	// Kind is KindAgent or KindBotUser.
	Kind string `json:"kind"`
	// IdentityID is the bot user's account-independent identity, the value
	// --expect-identity pins. Zero for an Agent person, which has none.
	IdentityID int64 `json:"identity_id,omitempty"`
}

type Changes struct {
	// Trust is the trust mode, "" to keep the file's.
	Trust admission.TrustMode
	// Allow replaces the allowlist when non-empty: the people trusted as
	// operators besides the operator. It implies allowlist mode unless the
	// same run asks for project mode, which admits the project's members as
	// participants beside them.
	Allow []int64
	// AllowAssignments turns the allowlist's assignment opt-in on or off.
	// Nil keeps the file's, except in a run that passes Allow, which
	// restates the opt-in with the list it covers: off unless set here.
	// SetOperator drops a kept one that is left covering nobody.
	AllowAssignments *bool

	// AllowAgents adds agents allowed to wake this one by @mentioning it;
	// DisallowAgents removes them. The list is kept across runs, like the
	// served projects.
	AllowAgents    []int64
	DisallowAgents []int64
	// AgentThreadCap and AgentDailyCap set the agent loop caps; nil keeps
	// the file's. Zero restores the default.
	AgentThreadCap *int
	AgentDailyCap  *int

	// AllowInPing lets people reach the agent in one Ping alone, as
	// participants there; DisallowInPing takes them out. Kept across runs,
	// like the allowed agents.
	AllowInPing    []PingPerson
	DisallowInPing []PingPerson

	// Serve are the project (bucket) ids to serve. A project already served
	// keeps its class and watch_completions.
	Serve []int64
	// Classes sets a served project's class; an empty class clears it.
	Classes map[int64]string
	// WatchCompletions turns watch_completions on (true) or off (false) for
	// a served project.
	WatchCompletions map[int64]bool
	// Remove stops serving projects.
	Remove []int64

	// AckBoost sets how the connector acknowledges a request; nil keeps the
	// file's.
	AckBoost *AckBoost
}

type Check struct {
	Name    string `json:"name"`
	Status  string `json:"status"`
	Message string `json:"message"`
	Hint    string `json:"hint,omitempty"`
}

type Duration time.Duration

type File struct {
	Version int `json:"version"`

	// Profile is the CLI profile holding the agent's credential.
	Profile string `json:"profile"`
	// AccountID is the account the agent belongs to.
	AccountID string `json:"account_id"`
	// Agent is who the profile's credential proved to be when setup ran.
	Agent Agent `json:"agent"`

	// Trust and Projects are admission's, in admission's own types, so the
	// two cannot drift. Projects is the list of Basecamp projects this agent
	// serves, keyed by project id.
	Trust    admission.Trust             `json:"trust"`
	Projects map[int64]admission.Project `json:"projects"`
	// Pings lets people reach the agent in one Ping alone, as participants
	// there (--allow-in-ping), keyed by the Ping's id. Absent when it lets
	// nobody in, so a file that uses none still opens in a CLI that predates
	// the key.
	Pings map[int64]admission.PingTrust `json:"pings,omitempty"`
	// AckBoost is how the connector acknowledges a request someone made of
	// the agent (--ack-boost, --no-ack-boost). Absent means the default, a
	// DefaultAckContent boost, and setup writes it only when it is not, so a
	// file that keeps the default still opens in a CLI that predates the
	// key.
	AckBoost *AckBoost `json:"ack_boost,omitempty"`

	// The Legacy fields are the settings of a connector that ran its own
	// workers: which driver and coding agent, how many at once, for how
	// long, and dangerous mode. The connector no longer starts workers
	// (the person's own session does the work), so nothing reads these.
	// They are fields for the same reason LegacyWorktrees is: Parse refuses
	// an unknown key, and a connect.json written before has them. Parse
	// zeroes them, and omitempty keeps them out of anything written from
	// here.
	LegacyDriver      string `json:"driver,omitempty"`
	LegacyWorker      string `json:"worker,omitempty"`
	LegacyConcurrency int    `json:"concurrency,omitempty"`
	LegacyDeadline    string `json:"deadline,omitempty"`
	LegacyDangerous   bool   `json:"dangerous,omitempty"`

	// LegacyWorktrees is the --worktrees setting of a connector that gave
	// each task a git worktree of its own. Worktrees are gone: a task runs
	// where the connector was started, and nothing here reads this. It is
	// still a field
	// because Parse refuses an unknown key, and a connect.json written
	// before they went has "worktrees" in it — accepting it is what lets
	// that file still open. Parse zeroes it, and omitempty keeps it out of
	// everything written from here, so the next `connect setup` writes the
	// key away for good.
	LegacyWorktrees bool `json:"worktrees,omitempty"`
}

type Person struct {
	ID             int64
	Name           string
	PersonableType string
	Client         bool
}

type Ping struct {
	ID     int64
	People []Person
}

type PingPerson struct {
	Ping   int64
	Person int64
}

type Reader interface {
	// Me is the person the credential authenticates as.
	Me(ctx context.Context) (Person, error)
	// Person reads someone else in the account.
	Person(ctx context.Context, id int64) (Person, error)
	// MintStreamTicket mints a stream ticket and throws it away. The ticket
	// is a bearer credential: an implementation must neither return, log nor
	// keep it.
	MintStreamTicket(ctx context.Context) error
	// Project reads a project.
	Project(ctx context.Context, id int64) error
	// ProjectPeople reads a project's people.
	ProjectPeople(ctx context.Context, id int64) error
	// Ping reads a Ping the reader is in.
	Ping(ctx context.Context, id int64) (Ping, error)
}

type Report struct {
	Path          string
	Profile       string
	AccountID     string
	AgentPersonID int64
	AgentKind     string
	OperatorID    int64
	TrustMode     string
	// Projects is how many Basecamp projects the file serves.
	Projects int
	Written  bool
	// contains filtered or unexported fields
}

type SDKReader struct {
	Client *basecamp.AccountClient
}

type Trust struct {
	// Operator is the operator. When OperatorProfile is set, it is the person
	// that profile's own credential read back, which proves who they are.
	Operator        Person
	OperatorProfile string
	// OperatorIsOwner says Operator is the person the agent works for, as
	// Basecamp named them in the agent's own profile. Basecamp's word proves
	// who they are, as a profile's own credential does, so they are not read
	// again: a new agent may share no project with them yet.
	OperatorIsOwner bool
	// Allowlist is every allowlisted Person id the file will hold.
	Allowlist []int64
	// Agents is every agent the file will allow to mention this one. Each
	// must read back as an Agent person: the reverse of the allowlist.
	Agents []int64
	// Recorded is the trust connect.json already holds for this same agent
	// and account. It is taken as the owner's own record — the file is
	// private to them, and setup verified it if setup wrote it — so a person
	// in it who cannot be re-read now is a warning, not a refusal. A read
	// that answers still decides. The zero value records nobody.
	Recorded admission.Trust
}