136 lines
3.2 KiB
Go
136 lines
3.2 KiB
Go
package claude
|
|
|
|
import (
|
|
"context"
|
|
"encoding/json"
|
|
"fmt"
|
|
"os"
|
|
"time"
|
|
|
|
"git.a-wan.net/alan/pipelines/internal/claudehost"
|
|
)
|
|
|
|
// retainedSessionReadback may reattach an existing verified live host after a
|
|
// transient startup failure. It never spawns/resumes a CLI or sends a prompt.
|
|
// Unavailable live work is unknown, not an authoritative empty task/turn set.
|
|
func (c *Chat) retainedSessionReadback(ctx context.Context, id string) (*session, error) {
|
|
for {
|
|
if err := ctx.Err(); err != nil {
|
|
return nil, err
|
|
}
|
|
c.mu.Lock()
|
|
closed := c.closed
|
|
c.mu.Unlock()
|
|
if closed {
|
|
return nil, context.Canceled
|
|
}
|
|
s := c.session(id)
|
|
if s != nil {
|
|
s.mu.Lock()
|
|
attached := s.proc != nil
|
|
waiting := s.starting
|
|
s.mu.Unlock()
|
|
if attached {
|
|
return s, s.awaitReadbackReady(ctx)
|
|
}
|
|
if waiting != nil {
|
|
select {
|
|
case <-waiting:
|
|
continue
|
|
case <-ctx.Done():
|
|
return nil, ctx.Err()
|
|
}
|
|
}
|
|
}
|
|
var retained *claudehost.Record
|
|
if c.hostDir != "" {
|
|
path := claudehost.PathsFor(c.hostDir, id).Record
|
|
data, err := os.ReadFile(path)
|
|
if err != nil && !os.IsNotExist(err) {
|
|
return nil, fmt.Errorf("read Claude Code host reference: %w", err)
|
|
}
|
|
if err == nil {
|
|
var record claudehost.Record
|
|
if json.Unmarshal(data, &record) != nil || record.SessionID != id || record.Socket == "" {
|
|
return nil, fmt.Errorf("invalid retained Claude Code host reference for %s", id)
|
|
}
|
|
if hostReferenceLive(record) {
|
|
retained = &record
|
|
}
|
|
}
|
|
if retained == nil {
|
|
// A hosted session without a live retained owner has no work
|
|
// to reattach; do not reuse stale cached turn/task liveness.
|
|
return nil, nil
|
|
}
|
|
} else {
|
|
// Direct-mode callers retain their existing in-memory behavior.
|
|
return s, nil
|
|
}
|
|
if s == nil {
|
|
s = c.sessionFor(id, retained.Directory)
|
|
}
|
|
s.mu.Lock()
|
|
if s.proc != nil || s.starting != nil {
|
|
s.mu.Unlock()
|
|
continue
|
|
}
|
|
wait := make(chan struct{})
|
|
s.starting = wait
|
|
s.mu.Unlock()
|
|
p, conn, plan := c.connectHostContext(ctx, *retained)
|
|
c.mu.Lock()
|
|
closed = c.closed
|
|
c.mu.Unlock()
|
|
if p != nil && (ctx.Err() != nil || closed) {
|
|
_ = conn.Close()
|
|
p = nil
|
|
}
|
|
s.mu.Lock()
|
|
if p != nil {
|
|
s.proc = p
|
|
s.adoptLocked(p)
|
|
}
|
|
s.starting = nil
|
|
close(wait)
|
|
s.mu.Unlock()
|
|
if p == nil {
|
|
if err := ctx.Err(); err != nil {
|
|
return nil, err
|
|
}
|
|
if closed {
|
|
return nil, context.Canceled
|
|
}
|
|
return nil, fmt.Errorf("Claude Code host for %s is unavailable; retained work was not stopped", id)
|
|
}
|
|
go p.readHost(conn, plan)
|
|
return s, s.awaitReadbackReady(ctx)
|
|
}
|
|
}
|
|
|
|
// A replay deadline must propagate as unknown to startup recovery. Otherwise an
|
|
// empty cache can incorrectly settle/delete the durable live-session journal.
|
|
func (s *session) awaitReadbackReady(ctx context.Context) error {
|
|
if err := ctx.Err(); err != nil {
|
|
return err
|
|
}
|
|
s.mu.Lock()
|
|
p := s.proc
|
|
s.mu.Unlock()
|
|
if p == nil {
|
|
return nil
|
|
}
|
|
timer := time.NewTimer(10 * time.Second)
|
|
defer timer.Stop()
|
|
select {
|
|
case <-p.ready:
|
|
return nil
|
|
case <-p.done:
|
|
return fmt.Errorf("Claude Code host disconnected before replay completed")
|
|
case <-ctx.Done():
|
|
return ctx.Err()
|
|
case <-timer.C:
|
|
return fmt.Errorf("Claude Code host replay timeout: %w", context.DeadlineExceeded)
|
|
}
|
|
}
|