codex

type Config ¶

type Config struct {
	Name              string
	Version           string
	CWD               string
	AppServerEndpoint string
	ClientEndpoint    string
	MCPBridgeSocket   string
	IntercomBin       string
	BrokerSocket      string
	BrokerBin         string
	New               bool
	AdoptThreadID     string
	ForkThreadID      string
	ReplaceBinding    bool
	ExecutionPolicy   ExecutionPolicy
	Logger            *slog.Logger

	QueueSize       int
	StartupTimeout  time.Duration
	ControlTimeout  time.Duration
	ReverseTimeout  time.Duration
	ActivityTimeout time.Duration
	StatePath       string
	LockPath        string
	OnReady         func(ReadyInfo) error
	OnStopping      func() error
	// contains filtered or unexported fields
}

type ExecutionPolicy ¶ added in v0.2.2

type ExecutionPolicy string

ExecutionPolicy is the launch-scoped command execution boundary for a managed Codex service. It is deliberately not persisted in ManagedState; omitting --yolo on a later launch returns the thread to workspace-write.

const (
	ExecutionWorkspaceWrite   ExecutionPolicy = "workspace-write"
	ExecutionDangerFullAccess ExecutionPolicy = "danger-full-access"
)

func (p ExecutionPolicy) IsYolo() bool

type ManagedState ¶

type ManagedState struct {
	SchemaVersion       int           `json:"schemaVersion"`
	Peer                string        `json:"peer"`
	ThreadID            string        `json:"threadId"`
	CWD                 string        `json:"cwd"`
	CodexHome           string        `json:"codexHome"`
	ServerUserAgent     string        `json:"serverUserAgent"`
	CodexVersion        string        `json:"codexVersion"`
	ToolContractVersion int           `json:"toolContractVersion"`
	ToolTransport       ToolTransport `json:"toolTransport"`
	Materialized        bool          `json:"materialized"`
}

ManagedState binds an Intercom peer to the Codex thread it exclusively manages. Conversation data remains in CODEX_HOME; this record contains only binding identity, compatibility metadata, and last-validated runtime diagnostics.

func (s ManagedState) Validate() error

type ReadyInfo ¶

type ReadyInfo struct {
	Name            string
	CWD             string
	ThreadID        string
	ClientEndpoint  string
	CodexVersion    string
	ExecutionPolicy ExecutionPolicy
}

ReadyInfo describes the live managed thread after the broker and optional TUI proxy are ready. OnReady runs synchronously before Run enters its main service loop.

type StateStore ¶

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

StateStore owns the non-blocking lifetime lock for one peer and provides atomic state reads and writes.

func AcquireStateStore(statePath, lockPath string) (*StateStore, error)

func (s *StateStore) Close() error

func (s *StateStore) Load() (*ManagedState, error)

func (s *StateStore) Remove() error

func (s *StateStore) Save(state ManagedState) error

type ThreadLock ¶ added in v0.2.2

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

ThreadLock is a non-blocking process-lifetime advisory lock. It coordinates Intercom controllers; ordinary Codex processes do not honor it.

func AcquireThreadLock(lockPath string) (*ThreadLock, error)

func (l *ThreadLock) Close() error

type ToolTransport ¶ added in v0.2.2

type ToolTransport string

ToolTransport identifies how a managed Codex thread reaches Intercom's tools. Threads created by Intercom persist app-server dynamic tools in their rollout. Adopted and forked interactive threads receive an ephemeral MCP bridge configuration on every cold resume.

const (
	ToolTransportDynamic   ToolTransport = "dynamic"
	ToolTransportMCPBridge ToolTransport = "mcpBridge"
)