stack

type Action struct {
	Verb string // create, remove, start, connect, disconnect
	Type string // container, network, volume
	Name string
	ID   string // existing resource, for remove, start and disconnect
	// Peer is the container a connect or disconnect action moves in or out of the network Name;
	// Alias is the name it is reachable by on that network.
	Peer  string
	Alias string
}

type Attachment struct {
	Container string
	Alias     string
	Networks  []string
}

type ContainerSpec struct {
	Name  string
	Image string
	Cmd   []string
	User  string
	// OwnedVolumes are volumes the container writes as User: the engine creates volumes owned by
	// root and agents do not run as root, so they are handed over once the container exists.
	OwnedVolumes []string
	Env          []string
	Mounts       []MountSpec
	Tmpfs        map[string]string
	Network      string
	WorkingDir   string
	Harness      string
	NanoCPUs     int64
	Memory       int64
	Healthcheck  []string
	// PidsLimit caps processes and threads; MemorySwap equals Memory when a memory limit is set, so
	// swap does not double it.
	PidsLimit  int64
	MemorySwap int64
	// Agents run under an init process that reaps children and forwards signals.
	Init bool
	// Hardened sidecars get a read-only root filesystem. Agents need a writable one.
	ReadonlyRootfs bool
	Identity       engine.Identity `json:"-"`
}

type Desired struct {
	Networks    []NetworkSpec
	Volumes     []VolumeSpec
	Containers  []ContainerSpec
	Attachments []Attachment
	Control     string
	Proxy       string // empty when the project has no agents
	// PrepImage runs the short-lived prep containers (git, volume ownership).
	PrepImage string
}

type DotenvError struct {
	Line   int    // 0 when the parser does not say
	Reason string // a message of egzo's, or empty
}

type ExistsError struct {
	Name     string
	Template string
}

type Inputs struct {
	// Image is the all-in-one egzo image that runs every sidecar role.
	Image string
	// Tokens maps each instance to the token that identifies it to the proxy and control.
	Tokens map[string]string
	// User is the "uid:gid" agents run as, so what they write on the host is the invoking user's.
	// Empty leaves it to the image (Podman maps users itself).
	User string
	// HarnessPrefix is the start of a harness image's name, ending in "egzo-harness-".
	HarnessPrefix string
	// Prompts maps each agent that has a prompt file to its text (see ReadPrompts).
	Prompts map[string]string
	// Instances are the names of the instances that exist: the sidecars are attached to their networks.
	Instances []string
	// Placeholders maps each instance to the variables it gets and their placeholder texts (not secrets).
	Placeholders map[string]map[string]string
	// SignIns maps each instance to the variables that carry the stand-ins of its sign-ins (not secrets: they only work
	// through the proxy), for the harness to write where its client keeps its tokens.
	SignIns map[string]map[string]string
}

type Instance struct {
	Name         string
	ID           string // see NewInstanceID
	Template     string // the key of the template, from the service label
	Actor        string
	Container    string
	State        string
	Created      time.Time
	TemplateHash string
}

type InstanceIdentity struct {
	// ID is the instance's own id (see NewInstanceID).
	ID           string
	Template     string
	Actor        string
	TemplateHash string
}

type LockedError struct {
	Project string
	Holder  string
	Expires time.Time
}

type LogProbe struct {
	// Driver and Options are what the engine gave the container (the effective configuration, the daemon's own
	// options included).
	Driver  string
	Options map[string]string
	// Readable is whether the log could be read back at all. When it could not, ReadError says why.
	Readable  bool
	ReadError string
	// Separated is whether standard output and standard error came back apart.
	Separated bool
	// Followed is whether a line written while we were already following arrived while the container was still
	// running, which is what a client that follows needs.
	Followed bool
}

type MountSpec struct {
	Bind     bool
	Source   string
	Target   string
	ReadOnly bool
}

type NetworkSpec struct {
	Name     string
	Internal bool
	Identity engine.Identity `json:"-"`
}

type NotUpError struct{ Sidecar, State string }

type Observed struct {
	Resources []Resource
	// Ignored is what carries the project's label but labels egzo never writes (engine.IdentityOf): it is not the project's, and
	// nothing is done to it. Each says what and why.
	Ignored []string
}

type Options struct {
	DryRun   bool
	Recreate bool
	Image    string
	// HarnessPrefix overrides where harness images are pulled from (EGZO_HARNESS_PREFIX).
	HarnessPrefix string
	// Warnings is where what went wrong without failing `up` is written (a base clone that could not be made).
	Warnings io.Writer
}

type PassError struct{ Message string }

type PrepEnv struct {
	Image string
	User  string
}

type PrepSpec struct {
	Image    string
	Cmd      []string
	User     string // "" runs as the image's user (root)
	CapAdd   []string
	Env      []string
	Mounts   []MountSpec
	Network  string // "" has no network at all
	Identity engine.Identity
	Timeout  time.Duration
}

type Published struct {
	Version int
	Project string
	Dir     string
	// Image is the all-in-one egzo image: the prep containers use it.
	Image string
	// User is the "uid:gid" instances run as: the user who ran `up`.
	User      string
	Templates map[string]Template
}

type Report struct {
	Status   string
	Activity string
	Open     int  // requests the agent has fetched and not resolved
	Waiting  bool // it has asked a question nobody has answered
}

type Resource struct {
	Type       string // container, network or volume
	ID         string
	Name       string
	State      string   // containers only
	Health     string   // containers only
	Networks   []string // containers only: names of the networks it is attached to
	Service    string
	Kind       string
	ConfigHash string
	ProjectDir string
	// Workspace is the workspace a volume belongs to.
	Workspace string
	// Instance, Actor and TemplateHash come from the labels of what belongs to an instance.
	Instance     string
	Actor        string
	TemplateHash string
	InstanceID   string    // on the container and the network of an instance
	Created      time.Time // containers only
}

type Row struct {
	Name     string    `json:"name"`
	ID       string    `json:"id,omitempty"` // an instance's id; a sidecar has none
	Service  string    `json:"service"`
	Kind     string    `json:"kind"`
	State    string    `json:"state"`
	Health   string    `json:"health"`
	Activity string    `json:"activity"`
	Open     int       `json:"open"`
	Waiting  bool      `json:"waiting"`
	Status   string    `json:"status"`
	Actor    string    `json:"actor"`
	Created  time.Time `json:"created"`
	Stale    bool      `json:"stale"`
}

type ShortSecretKeyError struct{ Bytes int }

type Snapshot struct {
	CreatedBy    string            `yaml:"created-by"`
	SpecVersion  string            `yaml:"spec-version"`
	ConfigHashes map[string]string `yaml:"config-hashes"`
	Config       *config.Resolved  `yaml:"config"`
}

type SpawnRequest struct {
	Template string
	// Name is the instance's name; empty gives `<template>-<n>`.
	Name string
	// Actor is who asks: "operator" for the CLI, "user:<id>" or "service:<name>" for another tool.
	Actor string
	// NoFetch makes the worktrees from the base clones as they are, without fetching first.
	NoFetch bool
	// Reuse continues with a worktree or a branch an earlier instance of the name left, instead of refusing it.
	Reuse bool
}

type Spawned struct {
	Name      string
	ID        string
	Template  string
	Container string
	Actor     string
	// TemplateHash is the hash of the template the instance was made from.
	TemplateHash string
}

type Template struct {
	Agent      config.ResolvedAgent
	Profile    *config.ResolvedProfile
	Workspaces map[string]config.ResolvedWorkspace // the declared workspaces its mounts name
	// PromptText is the text of the agent's prompt file, read when `up` ran: an instance needs nothing on the host.
	PromptText string
	// Image is the harness image, resolved when `up` ran, or the image it built.
	Image string
	// Placeholders maps each variable the agent gets to its placeholder text. A placeholder is not a
	// secret. The text is made once and never changes, so the hash leaves it out: what decides whether
	// an instance is stale is the profile's service, which names the variable and the secret.
	Placeholders map[string]string `json:",omitempty"`
	// Hash fingerprints all of the above. An instance carries the hash of the template it was spawned
	// from; when the template's hash moves, the instance is stale.
	Hash string
}

type VolumeSpec struct {
	Name     string
	Identity engine.Identity `json:"-"`
}

type WorkspaceRow struct {
	Name      string   `json:"name"`
	Kind      string   `json:"kind"`   // directory or git
	Volume    string   `json:"volume"` // the directory's volume, or the base clone's
	State     string   `json:"state"`  // a directory: exists or missing; a git workspace: cloned or not cloned
	Worktrees []string `json:"worktrees"`
}

type Worktree struct {
	Workspace string
	Instance  string
	Volume    string // the worktree's volume
	Base      string // the base's volume
	URL       string
	Branch    string
}

type WorktreeOptions struct {
	NoFetch bool
	Reuse   bool
}