cli

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

type AuthRunner struct {
	OpenAdmin func(context.Context, string) (sessionstore.IdentityAdmin, func(), error)
	WriteFile func(string, []byte, os.FileMode) error
}

type BugreportRunner struct {
	Collect       func(ctx context.Context, serial, outputPath string) error
	CollectIOS    func(ctx context.Context, udid, outputPath string) error
	ResolveSerial func(context.Context) (string, error)
}

type CheckSyntaxRunner struct {
	Checker Checker
	Getwd   func() (string, error)
}

type Checker interface {
	Check(context.Context, Source) error
}

type CryptoRandom struct{}

type DBRunner struct {
	ApplySchema func(context.Context, string) error
}

type DeviceSession struct {
	Driver device.Driver
	// OutputDirectory receives screenshots and other run artifacts.
	OutputDirectory string
	// BaseDirectory resolves flow resources such as runScript files.
	BaseDirectory string
	// Clock is optional; a nil clock uses the wall clock. Tests supply their
	// own so a flow's waits do not take real time.
	Clock engine.Clock
	// ExecutionID is optional; a blank one is derived from the run's own start.
	ExecutionID string
	// Shard is which share of the run this session executes. It is what the
	// reserved FLOWBATON_SHARD_* and FLOWBATON_DEVICE_UDID variables are built
	// from, so a flow can report where it ran.
	Shard Shard
}

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

type DriverSetupRunner struct {
	Build func(ctx context.Context, platform string) error
}

type ExploreDeps struct {
	Driver device.Driver
	Models explore.ModelSet
	Config explore.Config
	Stdout io.Writer
}

type ExploreInvoker interface {
	Explore(ctx context.Context, options ExploreToolOptions) (ExploreToolResult, error)
}

type ExploreRunner struct {
	// NewModels builds the tiered model set from the environment. Nil means
	// this build carries no model wiring, and the command refuses after flag
	// validation.
	NewModels func(getenv func(string) string) (explore.ModelSet, error)
	// NewCrew assembles the role implementations. Nil refuses like NewModels.
	NewCrew func(deps ExploreDeps) (explore.Crew, error)
	// NewDriver is injected by tests; nil constructs the real platform driver
	// through the same path the test session uses.
	NewDriver func(ctx context.Context, options TestOptions, udid string, port int) (device.Driver, error)
	// Clock is optional; nil uses the wall clock. The default session name
	// and output directory read it.
	Clock engine.Clock
	// Getenv is optional; nil reads the process environment.
	Getenv func(string) string
	// Environ is optional; nil reads the process environment. It feeds the
	// same diagnostic-port fallback `hierarchy` uses.
	Environ func() []string
}

type ExploreToolOptions struct {
	AppID      string
	Platform   string
	Device     string
	DriverPort int
	MaxTests   int
	MaxSteps   int
	OutputDir  string
}

type ExploreToolResult struct {
	Report string   `json:"report"`
	Flows  []string `json:"flows"`
}

type GenerateCompletionRunner struct{}

type HierarchyRunner struct {
	Fetch func(ctx context.Context, platform, udid string, appIDs []string, target string) (device.TreeNode, error)
}

type ImageChecker struct{}

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

type ListDevicesRunner struct {
	IOS         func(context.Context) ([]ios.Device, error)
	IOSPhysical func(context.Context) ([]iosdevice.Device, error)
	Android     func(context.Context) ([]android.Device, error)
}

type MCPRunner struct {
	Checker     Checker
	ListDevices ListDevicesRunner
	Hierarchy   HierarchyRunner
	Query       QueryRunner
	// RunFlow executes run_flow calls through the same pipeline as the test
	// subcommand. Its zero value builds real device sessions.
	RunFlow TestRunner
	// Screenshot captures one frame from a device. Its zero value opens the
	// real driver, in the same way the hierarchy diagnostic does.
	Screenshot ScreenshotRunner
	// StartDevice boots simulators and launches emulators through the same
	// orchestration as the start-device subcommand. Its zero value reaches
	// simctl and the Android tooling.
	StartDevice StartDeviceRunner
	// Explore serves the explore tool. Nil adapts the real ExploreRunner,
	// which refuses until its crew wiring is assembled.
	Explore ExploreInvoker
	// BaseDir confines inline flow links exposed through MCP. Run fills it from
	// --base-dir (or the current working directory).
	BaseDir string
}

type ParserChecker struct {
	Preflight Preflight
}

type Preflight interface {
	Check(context.Context, Source, model.Flow) error
}

type QueryRunner struct {
	Fetch func(ctx context.Context, platform, udid, appID, expression string) ([]device.TreeNode, error)
}

type RecordRunner struct {
	NewSession SessionFactory
}

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

type ScreenshotRunner struct {
	Fetch func(ctx context.Context, platform, udid string) ([]byte, error)
}

type ServeBootstrap struct {
	OpenStore      func(context.Context, string) (serveRuntimeStore, error)
	BuildDriver    func(context.Context, serveDevice) (device.Driver, error)
	LoadTLS        func(string, string, string) (*tls.Config, error)
	LoadPrivateKey func(string, string) (string, ed25519.PrivateKey, error)
	RunServer      func(context.Context, server.RuntimeConfig) error
	Executable     func() (string, error)
	ProcessID      func() int
}

type ServeOptions struct {
	Address           string
	DatabaseURL       string
	TLSCertificate    string
	TLSPrivateKey     string
	ClientCA          string
	SigningKey        string
	SigningKeyID      string
	NodeID            string
	PublicAddress     string
	Inventory         string
	WorkerConcurrency int
	WorkerPoll        time.Duration
	WorkerClaim       time.Duration
	WorkerTimeout     time.Duration
	NodeHeartbeat     time.Duration
}

type ServeRunner struct {
	Serve func(context.Context, ServeOptions) error
}

type SessionFactory func(context.Context, Shard, TestOptions) (TestSession, error)

type Shard struct {
	// Index is 0-based; the human-facing number is Index+1.
	Index int
	// Roots are the flow paths this shard runs, in the plan's own order.
	Roots []string
	// Device is the udid this shard runs on. It is blank for an unsharded run
	// with no --device, so the driver keeps saying which flag is missing.
	Device string
	// OutputDirectory is where this shard's artifacts go. The runner fills it
	// in after planning; planning itself has no opinion about the filesystem.
	OutputDirectory string
	// DriverPort is the loopback port this shard's driver talks to. Shard 1
	// keeps the contract's port; later shards get one each, because two shards
	// on one port drive the same runner.
	DriverPort int
}

type Source struct {
	Name    string
	BaseDir string
	// ConfineTo, when non-empty, requires every linked flow to remain beneath
	// this directory after symlink evaluation. The CLI leaves it empty because
	// an operator-selected flow may intentionally link elsewhere; MCP sets it to
	// --base-dir because inline content is untrusted client input.
	ConfineTo string
	Data      []byte
}

type StartDeviceRunner struct {
	// Boot boots an existing iOS simulator by udid (default: simctl boot).
	Boot func(ctx context.Context, platform, udid string) error
	// ListAVDs enumerates installed Android AVD names (default: emulator -list-avds).
	ListAVDs func(ctx context.Context) ([]string, error)
	// LaunchAVD launches an Android AVD by name (default: emulator -avd <name>).
	LaunchAVD func(ctx context.Context, avd, locale string) error
	// CreateSim creates a new iOS simulator and returns its udid (default: simctl create).
	CreateSim func(ctx context.Context, options deviceCreateOptions) (string, error)
	// CreateAVD creates a new Android AVD and returns its name (default: avdmanager create).
	CreateAVD func(ctx context.Context, options deviceCreateOptions) (string, error)
	// WaitReady blocks until the started target is usable (default: simctl
	// bootstatus or adb's sys.boot_completed property).
	WaitReady func(ctx context.Context, platform, target string) error
	// ReadyTimeout bounds readiness independently from a long-lived parent.
	ReadyTimeout time.Duration
	// ConfigureLocale applies the requested locale after an iOS simulator is
	// booted. Android receives its locale as an emulator launch property.
	ConfigureLocale func(ctx context.Context, platform, target, locale string) error
}

type TestOptions struct {
	Roots []string

	ConfigPath  string
	Env         map[string]string
	IncludeTags []string
	ExcludeTags []string

	Format        string
	TestSuiteName string
	Output        string

	DebugOutput        string
	TestOutputDir      string
	FlattenDebugOutput bool
	Continuous         bool
	Headless           bool
	ReinstallDriver    bool
	ScreenSize         string
	APIURL             string
	APIKey             string
	Platform           string
	Devices            []string
	ShardSplit         int
	ShardAll           int

	// RecordTo is where `record` wants the video. It is NOT parsed from a
	// command line: the `test` command has no such flag. RecordRunner sets it.
	RecordTo string

	// SequencedRoots and ContinueOnFailure come from the workspace's
	// executionOrder, not from argv. They decide whether a failed flow ends
	// the suite; see engine.Dependencies for the rule.
	SequencedRoots    int
	ContinueOnFailure bool
	// contains filtered or unexported fields
}

type TestRunner struct {
	// NewSession acquires one shard's device and executes its flows. It is
	// injected because no production session can be built without a device; a
	// nil factory falls back to the real one.
	NewSession SessionFactory
	Loader     capability.FlowLoader
	// Clock is optional; nil uses the wall clock. It fixes the run's own notion
	// of now, which both the default output directory and the report timestamp
	// read, so two identical runs render identical bytes.
	Clock engine.Clock
	// Environ is optional; nil reads the process environment. It supplies the
	// shell's FLOWBATON_ variables, per specs/01-core-engine.md:101.
	Environ func() []string
	// AllocatePort is optional; nil asks the operating system for an ephemeral
	// port. Injected so a test can pin the ports a sharded run picks.
	AllocatePort func() (int, error)
	// PollInterval is how often continuous mode re-stamps its watch set; zero
	// uses defaultPollInterval. Injected so a test does not wait on it.
	PollInterval time.Duration
	// RecordTo is set by RecordRunner, never by argv. See TestOptions.RecordTo.
	RecordTo string
}

type TestSession interface {
	Execute(context.Context, *engine.Program, TestOptions) ([]engine.FlowResult, error)
}

type UnsupportedRecordingController struct{}

type UsageError struct {
	Message string
}