domain

type AuditEntry struct {
	Timestamp  time.Time `json:"timestamp"`
	Step       string    `json:"step"`
	Action     string    `json:"action"` // "executed", "skipped", "verified", "verify_failed", "invalidated", "failed"
	Machine    string    `json:"machine"`
	DurationMs int64     `json:"durationMs,omitempty"`
	Message    string    `json:"message,omitempty"`
	Error      string    `json:"error,omitempty"`
}

type CommandHook struct {
	Command    string `yaml:"command,omitempty"`
	AllowCache *bool  `yaml:"allow_cache,omitempty"`
}

type ComposeConfig struct {
	Autostart []string     `yaml:"autostart"`       // services started on create (proxy is always implicit if enabled)
	Image     string       `yaml:"image"`           // base Docker image for app containers (e.g., "node:20")
	Proxy     *ProxyConfig `yaml:"proxy,omitempty"` // reverse proxy configuration
}

type ComputeAccess interface {
	// WriteFile writes content to a path relative to the compute root.
	WriteFile(ctx context.Context, relPath string, data []byte, mode os.FileMode) error

	// ReadFile reads content from a path relative to the compute root.
	ReadFile(ctx context.Context, relPath string) ([]byte, error)

	// Exec runs a command in the compute root directory.
	// Stderr streams to the configured writer. Stdout is captured and returned silently.
	Exec(ctx context.Context, command string, env []string) (stdout string, err error)

	// VerboseExec runs a command and tees stdout to stderr for real-time visibility.
	// Use for user-defined hooks and build commands where output should always be visible.
	VerboseExec(ctx context.Context, command string, env []string) (stdout string, err error)

	// Root returns the compute root path (local path or remote working dir).
	Root() string
}

type ComputeAccessInfo struct {
	Type            string            `json:"type"`                      // "local" or "ssh"
	Path            string            `json:"path,omitempty"`            // local worktree path or remote root
	Host            string            `json:"host,omitempty"`            // VM hostname (ssh)
	User            string            `json:"user,omitempty"`            // SSH user
	ManagedWorktree bool              `json:"managedWorktree,omitempty"` // true = created by previewctl
	Metadata        map[string]string `json:"metadata,omitempty"`        // hook-provided metadata (e.g., "vm_zone", "gcp_project")
}

type ComputeHooks struct {
	Create  string     `yaml:"create"`
	Destroy string     `yaml:"destroy"`
	Outputs []string   `yaml:"outputs,omitempty"`
	SSH     *SSHConfig `yaml:"ssh,omitempty"`
}

type ComputePort interface {
	// Create sets up compute resources for an environment.
	// branch is the target branch to use/create.
	// baseBranch is the branch to create from (empty = use branch as-is).
	Create(ctx context.Context, envName string, branch string, baseBranch string) (*ComputeResources, error)

	// Start starts per-environment services (infra containers, etc).
	Start(ctx context.Context, envName string, ports PortMap) error

	// Stop stops services without destroying data or resources.
	Stop(ctx context.Context, envName string) error

	// Destroy tears down all compute resources.
	Destroy(ctx context.Context, envName string) error

	// IsRunning checks if environment compute resources are active.
	IsRunning(ctx context.Context, envName string) (bool, error)

	// DetectBranch returns the current git branch for a worktree path.
	DetectBranch(ctx context.Context, worktreePath string) (string, error)
}

type ComputeResources struct {
	WorktreePath string `json:"worktreePath,omitempty"` // local mode
	VMId         string `json:"vmId,omitempty"`         // preview/sandbox mode
	ExternalIP   string `json:"externalIp,omitempty"`   // preview/sandbox mode
}

type CoreResetOpts struct {
	// NoPropagate skips regenerating remote manifest/env/compose files and
	// restarting dependent services after a successful reset. State is still
	// updated with fresh provisioner outputs. Use this when you want to batch
	// several resets and run a single SyncRemote at the end.
	NoPropagate bool
}

type DestroyOptions struct {
	// Force continues past destroy-hook failures and always removes the
	// environment from the state store. Useful when the create lifecycle
	// failed and left state in an inconsistent shape that hooks can't handle.
	Force bool
}

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

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

type EnvironmentDetail struct {
	Entry        *EnvironmentEntry `json:"entry"`
	InfraRunning bool              `json:"infraRunning"`
}

type EnvironmentEntry struct {
	Name               string                       `json:"name"`
	Mode               EnvironmentMode              `json:"mode"`
	Branch             string                       `json:"branch"`
	Status             EnvironmentStatus            `json:"status"`
	CreatedAt          time.Time                    `json:"createdAt"`
	UpdatedAt          time.Time                    `json:"updatedAt"`
	Ports              PortMap                      `json:"ports"`
	ProvisionerOutputs map[string]map[string]string `json:"provisionerOutputs"`
	Compute            *ComputeAccessInfo           `json:"compute,omitempty"`
	Env                map[string]string            `json:"env,omitempty"`             // persistent key-value store for hooks
	EnabledServices    []string                     `json:"enabledServices,omitempty"` // services currently enabled (seeded from autostart, updated by service start/stop)
	Steps              map[string]*StepRecord       `json:"steps,omitempty"`
	AuditLog           []AuditEntry                 `json:"auditLog,omitempty"`
}

type EnvironmentMode string

type EnvironmentStatus string

type InfraService struct {
	Name   string
	Image  string
	Port   int
	EnvVar string // e.g., "REDIS_PORT" (extracted from ${REDIS_PORT:-6379} patterns)
}

type InfrastructureConfig struct {
	ComposeFile string `yaml:"compose_file"`
}

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

type ManagerDeps struct {
	Compute     ComputePort
	Networking  NetworkingPort
	State       StatePort
	Progress    ProgressReporter
	Config      *ProjectConfig
	ProjectRoot string
	NoCache     bool
}

type Manifest struct {
	Version            int                          `json:"version"`
	EnvName            string                       `json:"env_name"`
	ProjectName        string                       `json:"project_name"`
	Branch             string                       `json:"branch"`
	Mode               string                       `json:"mode"`
	Ports              PortMap                      `json:"ports"`
	ProvisionerOutputs map[string]map[string]string `json:"provisioner_outputs,omitempty"`
	Services           map[string]ManifestService   `json:"services,omitempty"`
	Infrastructure     *ManifestInfrastructure      `json:"infrastructure,omitempty"`
	EnabledServices    []string                     `json:"enabled_services,omitempty"`
}

type ManifestInfrastructure struct {
	ComposeFile string `json:"compose_file"`
}

type ManifestService struct {
	Path    string            `json:"path"`
	EnvFile string            `json:"env_file"`
	Env     map[string]string `json:"env,omitempty"`
}

type NetworkingPort interface {
	// AllocatePorts returns deterministic port assignments for all services and infrastructure.
	AllocatePorts(envName string) (PortMap, error)

	// GetServiceURL returns the URL to reach a named service in the environment.
	GetServiceURL(envName string, service string) (string, error)
}

type NoopReporter struct{}

type PortMap map[string]int

type ProgressReporter interface {
	OnStep(event StepEvent)
	// StderrWriter returns a writer for hook stderr output.
	// The reporter may indent or buffer this output for display.
	StderrWriter() io.Writer
}

type ProjectConfig struct {
	Version        int                      `yaml:"version"`
	Name           string                   `yaml:"name"`
	Provisioner    ProvisionerConfig        `yaml:"provisioner"`
	Infrastructure *InfrastructureConfig    `yaml:"infrastructure,omitempty"`
	Services       map[string]ServiceConfig `yaml:"services"`
	Runner         *RunnerConfig            `yaml:"runner,omitempty"`

	// Mode is the deployment mode (e.g., "local"). Set at load time, not from YAML.
	Mode string `yaml:"-"`

	// InfraServices is populated by parsing the compose file referenced in
	// Infrastructure.ComposeFile. It is not read from YAML directly.
	InfraServices map[string]InfraService `yaml:"-"`
}

type ProvisionerConfig struct {
	Before   string                              `yaml:"before,omitempty"`
	After    string                              `yaml:"after,omitempty"`
	Compute  *ComputeHooks                       `yaml:"compute,omitempty"`
	Services map[string]ProvisionerServiceConfig `yaml:"services,omitempty"`
}

type ProvisionerServiceConfig struct {
	Outputs []string `yaml:"outputs,omitempty"`
	Init    string   `yaml:"init,omitempty"`
	Seed    string   `yaml:"seed,omitempty"`
	Reset   string   `yaml:"reset,omitempty"`
	Destroy string   `yaml:"destroy,omitempty"`
}

type ProxyConfig struct {
	Enabled *bool  `yaml:"enabled,omitempty"` // defaults to true if omitted
	Domain  string `yaml:"domain"`            // e.g., "preview.airgoods.com"
	Type    string `yaml:"type,omitempty"`    // "nginx" (default). Future: "traefik", "caddy"
}

type ReconcileReport struct {
	Results []ReconcileResult
	Healed  int
	Failed  int
	OK      int
	Skipped int
	NotRun  int
}

type ReconcileResult struct {
	Step       string
	Action     string // "ok", "healed", "failed", "skipped", "not_run"
	Message    string
	DurationMs int64
}

type RunnerConfig struct {
	Before CommandHook `yaml:"before,omitempty"`
	// Build, when set, runs once during build_services in place of the
	// per-service Build loop. Intended for monorepo tools (turborepo, nx,
	// lerna) where one bulk command builds everything more efficiently
	// than N filtered invocations.
	Build   CommandHook    `yaml:"build,omitempty"`
	Deploy  CommandHook    `yaml:"deploy,omitempty"`
	Destroy CommandHook    `yaml:"destroy,omitempty"`
	After   CommandHook    `yaml:"after,omitempty"`
	Compose *ComposeConfig `yaml:"compose,omitempty"`
}

type SSHComputeAccessOpts struct {
	Host         string // SSH host (direct mode) or logical hostname (proxy mode)
	User         string
	Root         string
	ProxyCommand string // when set, uses -o ProxyCommand=... instead of relying on SSH config
	IdentityFile string // path to SSH private key (optional)
}

type SSHConfig struct {
	// ProxyCommand is the SSH ProxyCommand used to tunnel into the VM.
	// Example: "gcloud compute start-iap-tunnel {{store.VM_NAME}} %p --listen-on-stdin --zone={{store.GCP_ZONE}} --project={{store.GCP_PROJECT}}"
	ProxyCommand string `yaml:"proxy_command"`
	// User is the SSH username. Example: "{{store.SSH_USER}}"
	User string `yaml:"user"`
	// UserCommand is a shell command that resolves the SSH username dynamically.
	// Useful when different users (CI vs human) SSH into the same VM.
	// Example: "gcloud compute os-login describe-profile --format='value(posixAccounts[0].username)'"
	// Takes precedence over User when set.
	UserCommand string `yaml:"user_command"`
	// IdentityFile is the path to the SSH private key. Supports ~ expansion.
	// Example: "~/.ssh/google_compute_engine"
	IdentityFile string `yaml:"identity_file"`
	// Root is the remote working directory. Defaults to "/app".
	Root string `yaml:"root,omitempty"`
}

type ServiceConfig struct {
	Path      string            `yaml:"path"`
	Port      int               `yaml:"port,omitempty"` // fixed port — skips the port allocator when set
	Command   string            `yaml:"command,omitempty"`
	DependsOn []string          `yaml:"depends_on,omitempty"`
	Env       map[string]string `yaml:"env,omitempty"`
	EnvFile   string            `yaml:"env_file,omitempty"` // relative to path, defaults to ".env.local"
	Build     string            `yaml:"build,omitempty"`    // build command (run on host before container starts)
	Start     string            `yaml:"start,omitempty"`    // start command (run inside container). Required for compose generation.
	Proxy     []ServiceProxy    `yaml:"proxy,omitempty"`    // optional reverse proxy rules for nginx
}

type ServiceProxy struct {
	Path       string             `yaml:"path"`                  // source path the browser sends, e.g., "/api" or "/iapi"
	TargetPath string             `yaml:"target_path,omitempty"` // path rewritten to on the target service. Defaults to Path if omitted.
	To         ServiceProxyTarget `yaml:"to"`
}

type ServiceProxyTarget struct {
	Service string `yaml:"service"` // target service name, resolved to its port at generation time
}

type State struct {
	Version      int                          `json:"version"`
	Environments map[string]*EnvironmentEntry `json:"environments"`
}

type StatePort interface {
	// Load returns the full state.
	Load(ctx context.Context) (*State, error)

	// Save persists the full state.
	Save(ctx context.Context, state *State) error

	// GetEnvironment returns a single environment entry, or nil if not found.
	GetEnvironment(ctx context.Context, name string) (*EnvironmentEntry, error)

	// SetEnvironment creates or updates an environment entry.
	SetEnvironment(ctx context.Context, name string, entry *EnvironmentEntry) error

	// RemoveEnvironment deletes an environment entry.
	RemoveEnvironment(ctx context.Context, name string) error
}

type StepEvent struct {
	Step    string // e.g. "allocate_ports", "create_worktree", "create_database"
	Status  StepStatus
	Message string // human-readable detail
	Error   error  // non-nil when Status == StepFailed
}

type StepOpts struct {
	Name        string
	StartMsg    string
	CompleteMsg *string
	Fn          func() error
	Verify      VerifyFunc            // nil = pure, skip on checkpoint alone
	Outputs     func() map[string]any // capture outputs after success
	AllowCache  *bool                 // nil = true; false = always execute
}

type StepRecord struct {
	Name       string           `json:"name"`
	Status     StepRecordStatus `json:"status"`
	StartedAt  time.Time        `json:"startedAt"`
	FinishedAt time.Time        `json:"finishedAt"`
	DurationMs int64            `json:"durationMs"`
	Machine    string           `json:"machine"`
	Error      string           `json:"error,omitempty"`
	Outputs    map[string]any   `json:"outputs,omitempty"`
}

type StepRecordStatus string

type StepStatus string

type TemplateContext struct {
	ServicePorts       PortMap
	InfraPorts         PortMap
	ProvisionerOutputs map[string]map[string]string
	CurrentService     string            // set per-service during rendering, enables {{self.port}}
	EnvName            string            // environment name, enables {{env.name}}
	Store              map[string]string // persistent key-value store, enables {{store.KEY}}
	ProxyDomain        string            // proxy domain (e.g., "preview.airgoods.com"), enables {{proxy.*}}
}

type VMInfo struct {
	ID         string
	ExternalIP string
	Status     string
}

type VMSpec struct {
	MachineType string
	DiskSizeGB  int
	Image       string
	Region      string
}

type ValidationError struct {
	Errors []string
}

type VerifyFunc func(ctx context.Context) error