Files

84 lines
2.5 KiB
Go

package claude
import (
"context"
"encoding/json"
"os"
"time"
"git.a-wan.net/alan/pipelines/internal/claudehost"
"git.a-wan.net/alan/pipelines/internal/protocol"
)
// Automations reports only the last native Stop-hook snapshot. It never starts
// or resumes Claude, sends a prompt, or attaches a delivery reader.
func (c *Chat) Automations(ctx context.Context, sessionID string) (protocol.ChatAutomationInfo, error) {
info := protocol.ChatAutomationInfo{SessionID: sessionID, Provider: Backend, Status: protocol.ChatAutomationUnavailable,
Reason: "Claude Code has not reported a native Stop snapshot for this session"}
if sessionID == "" {
return info, nil
}
if ctx == nil {
ctx = context.Background()
}
var snapshot *claudehost.AutomationSnapshot
var socket string
direct := false
s := c.session(sessionID)
if s != nil {
s.mu.Lock()
p := s.proc
cached := s.automations
cachedProcess := s.automationProcess
s.mu.Unlock()
if p == nil || cachedProcess != p || processExited(p) {
cached = nil
}
if p != nil && p.link != nil {
socket = p.link.record.Socket
} else if p != nil {
direct = true
snapshot = cached
}
}
if socket == "" && !direct && c.hostDir != "" {
path := claudehost.PathsFor(c.hostDir, sessionID).Record
if data, err := os.ReadFile(path); err == nil {
var record claudehost.Record
if json.Unmarshal(data, &record) == nil && record.SessionID == sessionID && record.Socket != "" {
socket = record.Socket
}
}
}
if socket != "" {
statusCtx, cancel := context.WithTimeout(ctx, 3*time.Second)
status, err := claudehost.ReadStatus(statusCtx, socket)
cancel()
if err == nil && status != nil && !status.Exited && status.SessionID == sessionID {
snapshot = status.Automations
}
}
if snapshot == nil || snapshot.SessionID != sessionID || snapshot.ObservedAtMS <= 0 {
return info, nil
}
count := len(snapshot.IDs)
info.Status, info.ActiveCount, info.ObservedAtMS = protocol.ChatAutomationSupported, &count, snapshot.ObservedAtMS
info.Reason = "last native Claude Code Stop snapshot; not a live query"
return info, nil
}
// Native future wakeups are live work even while no model turn is running.
// A replacement process cannot inherit its predecessor's in-memory timers.
// The caller holds s.mu.
func (s *session) hasAutomationsLocked() bool {
return s.proc != nil && s.automationProcess == s.proc &&
s.automations != nil && len(s.automations.IDs) > 0
}
func processExited(p *process) bool {
p.mu.Lock()
defer p.mu.Unlock()
return p.exited
}