dispatch

type ActionInvocationInput struct {
	Session *SessionInvocationInput `json:"session,omitempty"`
	// Inputs are the values collected for the action's declared inputs, keyed
	// by input name. They are validated against the catalog's declaration on
	// every invocation, so a name the action does not declare is refused.
	Inputs map[string]string `json:"inputs,omitempty"`
	Rerun  bool              `json:"rerun,omitempty"`
}

type ActionLister interface {
	Get(string) (actions.Action, bool)
}

type ActionRunView struct {
	CommandID            int64             `json:"commandId"`
	Status               string            `json:"status"`
	Result               *ExecutionOutcome `json:"result,omitempty"`
	Error                string            `json:"error,omitempty"`
	ConfirmationRequired bool              `json:"confirmationRequired,omitempty"`
}

type ClipboardExecutionOutcome struct {
	Text string `json:"text"`
}

type ClipboardExecutor struct{}

type CreateSessionRequest struct {
	Repository string  `json:"repository,omitempty"`
	Workspace  string  `json:"workspace,omitempty"`
	Name       string  `json:"name"`
	Prompt     string  `json:"prompt"`
	Agent      string  `json:"agent,omitempty"`
	ItemIDs    []int64 `json:"itemIds,omitempty"`
}

type DecodedActionItem struct {
	ID      string
	Kind    string
	Payload []byte
}

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

type ExecEnvironment interface {
	Environ(ctx context.Context) []string
}

type ExecutionLog struct {
	Stdout string `json:"stdout,omitempty"`
	Stderr string `json:"stderr,omitempty"`
}

type ExecutionOutcome struct {
	Session   *SessionExecutionOutcome   `json:"session,omitempty"`
	Message   *MessageExecutionOutcome   `json:"message,omitempty"`
	Clipboard *ClipboardExecutionOutcome `json:"clipboard,omitempty"`
}

type ExecutionResult struct {
	// Attempted is internal execution state, not frontend data. It separates a
	// side effect that returned an error after dispatch from validation/config
	// failures before dispatch.
	Attempted bool              `json:"-"`
	Outcome   *ExecutionOutcome `json:"outcome,omitempty"`
	Log       ExecutionLog      `json:"log"`
}

type Executor interface {
	Execute(context.Context, actions.Action, OutputData, ActionInvocationInput) (ExecutionResult, error)
}

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

type FlowLister interface {
	List() []flow.Flow
}

type InboxItemLocator interface {
	IDByExternalID(ctx context.Context, profileID, sourceKind, sourceScope, externalID string) (int64, error)
}

type ItemSessionLinker interface {
	Link(ctx context.Context, sessionID string, ref models.ItemRef) error
}

type LaunchNodeActionConfig struct {
	actions.LaunchSessionConfig
	NameTemplate string
}

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

type LaunchSessionRequest struct {
	Name            string
	Prompt          string
	Agent           string
	Repo            string
	CollisionSuffix string
	// Origins are the inbox items the session is being created for. An empty
	// slice means the session has no inbox item behind it.
	Origins []models.ItemRef
}

type LaunchWorkspaceSessionRequest struct {
	Workspace string
	Name      string
	Prompt    string
	Origins   []models.ItemRef
}

type MessageExecutionOutcome struct {
	Topic  string `json:"topic"`
	Sender string `json:"sender"`
}

type MessageService interface {
	Publish(context.Context, messaging.Message, []string) (messaging.PublishResult, error)
}

type NotificationGate interface {
	NotificationPolicy() NotificationPolicy
}

type NotificationPolicy struct {
	// Allowed is the kill switch. False means no flow may notify, whatever
	// its nodes say.
	Allowed bool
	// Sound is the app-level sound preference. A node can silence itself,
	// but it cannot make a notification audible once this is off.
	Sound bool
	// InApp routes this delivery inside Hive instead of to an OS banner. The
	// gate resolves it from the user's delivery preference and, for the
	// automatic mode, the window's current focus — so this package needs no
	// vocabulary for either.
	InApp bool
}

type NotifyActionConfig struct {
	Title    string
	Body     string
	Severity string
	Sound    bool
	// Cooldown is the node's resolved per-item delivery floor:
	// flow.NotifyCooldownDefault when the node declares none, 0 when it
	// explicitly disabled the cooldown.
	Cooldown time.Duration
}

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

type OutputCommandStore interface {
	ClaimNextAutomatic(context.Context, int64, string) (stores.OutputCommand, bool, error)
	Confirm(context.Context, string, string, []byte, models.ItemRef, string) (stores.OutputCommand, bool, error)
	Rerun(context.Context, string, string, []byte, models.ItemRef, string) (stores.OutputCommand, error)
	Get(context.Context, int64) (stores.OutputCommand, error)
	Complete(context.Context, int64, string, string) error
	Fail(context.Context, int64, string, string) error
	Requeue(context.Context, int64, string, string, time.Duration) error
	Cancel(context.Context, int64, string, string) error
}

type OutputData struct {
	Key       string
	Payload   map[string]any
	Raw       json.RawMessage
	Inputs    map[string]string
	Session   *SessionTarget
	Window    *WindowTarget
	CreatedAt int64
	CommandID int64
	IsRerun   bool
	Origin    models.ItemRef
	// contains filtered or unexported fields
}

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

type RemoteGenerator func(repo, itemURL string) string

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

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

type RunLogSink interface {
	AppendLog(ctx context.Context, commandID, attempt int64, lines []stores.NewActionRunLogLine) error
}

type SessionCreateFailure struct {
	// Reason is the wrapped error, a chain like
	// "clone repository: git clone: exec git: exit status 1".
	Reason string `json:"reason"`
	// Step is the last thing creation reported: "Cloning repository...",
	// "Executing rules...".
	Step string `json:"step"`
	// Output is the tail of the attempt's progress output, hook output included.
	Output string `json:"output"`
	// CloneStrategy is "full" or "worktree".
	CloneStrategy string `json:"cloneStrategy"`
	// Destination is the checkout hive resolved for the attempt.
	Destination string `json:"destination"`
	// LeftoverCheckout reports that Destination survived the failure, which is
	// what makes it a directory to go and delete. A refused clone names a
	// destination git already removed.
	LeftoverCheckout bool      `json:"leftoverCheckout"`
	At               time.Time `json:"at"`
}

type SessionCreator interface {
	CreateFromRequest(context.Context, sessionsvc.LaunchRequest) (session.Session, error)
}

type SessionDraft struct {
	Repository string  `json:"repository,omitempty"`
	Workspace  string  `json:"workspace,omitempty"`
	Name       string  `json:"name"`
	Prompt     string  `json:"prompt"`
	Agent      string  `json:"agent,omitempty"`
	ItemIDs    []int64 `json:"itemIds,omitempty"`
	// nil on a draft that is not a retry, which is also what "no attempt is
	// waiting" looks like to a caller.
	Failure *SessionCreateFailure `json:"failure,omitempty"`
}

type SessionDraftItem struct {
	Title   string
	URL     string
	Payload []byte
}

type SessionExecutionOutcome struct {
	ID   string `json:"id"`
	Name string `json:"name"`
	// Slug names the tmux session; Path is the checkout a post hook runs in.
	Slug string `json:"slug,omitempty"`
	Path string `json:"path,omitempty"`
	// Remote is the session's stored remote; it differs from the request when
	// launch resolution kept a checkout's spelling.
	Remote string `json:"remote,omitempty"`
}

type SessionInvocationInput struct {
	Name       string `json:"name"`
	Repository string `json:"repository,omitempty"`
	Workspace  string `json:"workspace,omitempty"`
	Agent      string `json:"agent,omitempty"`
}

type SessionLaunchOptions struct {
	Repositories             []SessionLaunchRepository `json:"repositories"`
	DefaultRepository        string                    `json:"defaultRepository"`
	Workspaces               []SessionLaunchWorkspace  `json:"workspaces"`
	Agents                   []string                  `json:"agents"`
	DefaultAgent             string                    `json:"defaultAgent"`
	PromptFileThresholdBytes int                       `json:"promptFileThresholdBytes"`
}

type SessionLaunchRepository struct {
	Name       string `json:"name"`
	Repository string `json:"repository"`
}

type SessionLaunchWorkspace struct {
	Dir            string `json:"dir"`
	Name           string `json:"name"`
	SupportsPrompt bool   `json:"supportsPrompt"`
}

type SessionLauncher interface {
	LaunchSession(ctx context.Context, req LaunchSessionRequest) (SessionExecutionOutcome, error)
}

type SessionPromptData struct {
	Title  string
	Kind   string
	Repo   string
	Num    int
	Author string
	Body   string
	URL    string
	Labels []string
	State  string
}

type SessionTarget struct {
	ID     string
	Name   string
	Slug   string
	Repo   string
	Path   string
	Branch string
	// WebURL is the repository's web page, resolved through the forge that
	// serves the remote. It is empty for a remote with no host.
	WebURL string
}

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

type SystemNotification struct {
	Title    string
	Body     string
	Severity string
	Sound    bool
	// InApp asks the delivery adapter to surface this inside Hive rather than
	// as an OS banner. Copied from the policy; see NotificationPolicy.InApp.
	InApp bool
	// Data rides along to the native notification and comes back when the
	// user clicks it, which is how a banner knows which item to reveal.
	Data map[string]any
}

type SystemNotifier interface {
	Notify(ctx context.Context, n SystemNotification) error
}

type TerminalTarget struct {
	Slug string `json:"slug"`
	// WindowID is set when the invocation came from a window row. It is what
	// separates a window invocation from a session one, and it is the tmux
	// window id, so it addresses the window across renames.
	WindowID string `json:"windowId,omitempty"`
}

type WindowTarget struct {
	ID string
}

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

type WorkspaceSessionLauncher interface {
	LaunchWorkspaceSession(ctx context.Context, req LaunchWorkspaceSessionRequest) (SessionExecutionOutcome, error)
}