claude

type ByteWalker struct {
	Data []byte
}

type CombinedFinder struct {
	Finders []InstanceFinder
}

type CommChecker func(pid int) bool

type CommandRunner interface {
	Run(ctx context.Context, name string, args ...string) ([]byte, error)
}

type ContainerChecker interface {
	IsContainerized(pid int) bool
}

type ContainerInfo struct {
	ID     string
	Name   string
	Labels map[string]string
}

type CwdResolver interface {
	ResolveCwd(pid int) (string, error)
}

type DirWalker interface {
	WalkJSONL(root string, fn func(line []byte) error) error
}

type DockerClient interface {
	ListContainers(ctx context.Context) ([]ContainerInfo, error)
	Exec(ctx context.Context, containerID string, cmd []string) (int, io.Reader, error)
	ContainerStats(ctx context.Context, containerID string) (*MemoryInfo, error)
	Close() error
}

type DockerFinder struct {
	Client   DockerClient
	CacheTTL time.Duration // TTL for container data cache; defaults to 2s
	// contains filtered or unexported fields
}

type FileSessionResolver struct {
	HomeDir string
}

type FileWriter interface {
	MkdirAll(path string, perm os.FileMode) error
	WriteFile(name string, data []byte, perm os.FileMode) error
	ReadFile(name string) ([]byte, error)
}

type HostFinder struct {
	Runner           CommandRunner
	HomeDir          string           // override for testing; empty uses os.UserHomeDir result passed externally
	CwdResolver      CwdResolver      // nil defaults to ProcCwdResolver
	ContainerChecker ContainerChecker // nil defaults to ProcContainerChecker
	SessionResolver  SessionResolver  // nil defaults to FileSessionResolver{HomeDir: h.HomeDir}
	CommChecker      CommChecker      // nil defaults to verifyProcComm
	PPIDResolver     PPIDResolver     // nil defaults to ProcPPIDResolver
}

type Instance struct {
	Label           string      // e.g. "Host (PID 7046)" or `Container "dev-myapp" (abc123)`
	Source          string      // "host" or "container"
	Walker          DirWalker   // how to read its JSONL data
	Root            string      // JSONL root path (or virtual path for containers)
	Memory          *MemoryInfo // memory usage (containers only)
	ContainerID     string      // full Docker container ID (containers only)
	PID             int         // host PID of the claude process (0 for containers)
	Cwd             string      // working directory of the Claude process
	FilePath        string      // resolved JSONL path for fsnotify (host instances only)
	ProxyConfigured bool        // true if the instance is configured to use the daemon's HTTPS proxy
	DaemonConnected bool        // true if the instance has recently communicated with the daemon
}

type InstanceFinder interface {
	FindInstances(ctx context.Context) ([]Instance, error)
}

type InstanceState int

type InstanceUsage struct {
	Instance Instance
	Summary  *UsageSummary
	State    InstanceState
}

type MemoryInfo struct {
	Usage uint64 // current memory usage in bytes
	Limit uint64 // memory limit in bytes (0 = unlimited)
}

type ModelUsage struct {
	InputTokens  int
	OutputTokens int
	CacheCreate  int
	CacheRead    int
}

type OSCommandRunner struct{}

type OSDirWalker struct{}

type OSFileWriter struct{}

type OSProcessLister struct {
	Runner CommandRunner
}

type OSTmuxClient struct {
	Runner CommandRunner
}

type PPIDResolver interface {
	ResolvePPID(pid int) int
}

type ProcContainerChecker struct{}

type ProcCwdResolver struct{}

type ProcPPIDResolver struct{}

type ProcessInfo struct {
	PID  int
	PPID int
	Comm string
	Args string // full command line (may be empty)
}

type ProcessLister interface {
	ListProcesses(ctx context.Context) ([]ProcessInfo, error)
}

type SessionResolver interface {
	ResolveSessionID(pid int) (string, error)
}

type TmuxClient interface {
	ListPanes(ctx context.Context) ([]TmuxPane, error)
}

type TmuxPane struct {
	PID          int
	SessionName  string
	WindowIndex  int
	PaneIndex    int
	Cwd          string        // pane working directory
	Devcontainer bool          // true when claude runs inside a devcontainer in this pane
	ContainerID  string        // matched container ID (only set when Devcontainer is true)
	ClaudePID    int           // PID of the actual claude process (0 if unknown)
	State        InstanceState // busy/ready/unknown
}

type UsageSummary struct {
	Models map[string]*ModelUsage
}