Files
tutti/packages/agent/daemon/runtime/process_transport_replay_recv.go
agent-radar 2ed3415fb7
Publish Claude Code Binaries / Stage and publish binaries (push) Canceled after 0s
Publish Tutti App Runtime / Build darwin-arm64 (push) Canceled after 0s
Publish Tutti App Runtime / Build darwin-amd64 (push) Canceled after 0s
Publish Tutti App Runtime / Build linux-amd64 (push) Canceled after 0s
Publish Tutti App Runtime / Build windows-amd64 (push) Canceled after 0s
Sync Tutti Agent Skills / sync (push) Canceled after 0s
Windows Agent Adapters / Test Windows agent adapters (push) Canceled after 0s
Windows Daemon Adapters / Test Windows daemon adapters (push) Canceled after 0s
Publish Tutti App Runtime / Publish runtime catalog (push) Canceled after 0s
源码快照 @ 2026-09-01 (source-only, 剔除非源码素材)
2026-09-01 20:17:27 +08:00

199 lines
4.9 KiB
Go

package agentruntime
import (
"context"
"errors"
"io"
"time"
)
func (c *replayProcessConnection) Recv() (ProcessFrame, error) {
return c.recvContext(context.Background())
}
func (c *replayProcessConnection) RecvContext(ctx context.Context) (ProcessFrame, error) {
return c.recvContext(ctx)
}
func (c *replayProcessConnection) recvContext(ctx context.Context) (ProcessFrame, error) {
c.recvMu.Lock()
defer c.recvMu.Unlock()
for {
c.mu.Lock()
if c.isClosedLocked() {
c.mu.Unlock()
return ProcessFrame{}, io.EOF
}
if len(c.pendingSyntheticStdout) > 0 {
stdout := c.pendingSyntheticStdout[0]
c.pendingSyntheticStdout = c.pendingSyntheticStdout[1:]
connectionID := c.connectionID
c.mu.Unlock()
return ProcessFrame{
Stdout: stdout,
ConnectionID: connectionID,
Synthetic: true,
}, nil
}
if c.cursor >= len(c.chunks) {
if c.holdOpen {
changed := c.changed
c.mu.Unlock()
select {
case <-ctx.Done():
return ProcessFrame{}, ctx.Err()
case <-changed:
}
continue
}
c.mu.Unlock()
return ProcessFrame{}, io.EOF
}
chunk := c.chunks[c.cursor]
if chunk.Kind == "outbound" {
if method, responseID, ok := processCassetteJSONRPCRequest(chunk); ok &&
responseID != "" && c.descriptor.IsOptionalProbeMethod(method) {
if !c.skippingOptionalProbeRun {
changed := c.changed
c.mu.Unlock()
timer := time.NewTimer(50 * time.Millisecond)
select {
case <-ctx.Done():
stopReplayPlaybackTimer(timer)
return ProcessFrame{}, ctx.Err()
case <-c.closed:
stopReplayPlaybackTimer(timer)
return ProcessFrame{}, io.EOF
case <-changed:
stopReplayPlaybackTimer(timer)
continue
case <-timer.C:
}
c.mu.Lock()
if c.cursor >= len(c.chunks) ||
c.chunks[c.cursor].ChunkSeq != chunk.ChunkSeq {
c.mu.Unlock()
continue
}
}
c.playback.advanceTo(chunk.ElapsedMS)
c.skippedRPCs[responseID] = struct{}{}
c.skippingOptionalProbeRun = true
c.cursor++
c.signalChangedLocked()
c.mu.Unlock()
continue
}
changed := c.changed
c.mu.Unlock()
select {
case <-ctx.Done():
return ProcessFrame{}, ctx.Err()
case <-changed:
}
continue
}
// Inbound delivery may park on checkpoint pause. Optional-probe absorb
// queues synthetic stdout and signals c.changed; interrupt those waits so
// Recv can drain the synthetic response without waiting for the fence.
chunkSeq := chunk.ChunkSeq
elapsedMS := chunk.ElapsedMS
for {
if len(c.pendingSyntheticStdout) > 0 {
c.mu.Unlock()
break
}
if c.cursor >= len(c.chunks) || c.chunks[c.cursor].ChunkSeq != chunkSeq {
c.mu.Unlock()
break
}
connChanged := c.changed
c.mu.Unlock()
if err := c.playback.waitUntil(ctx, elapsedMS, c.closed, connChanged); err != nil {
if errors.Is(err, errReplayRecvInterrupted) {
c.mu.Lock()
continue
}
if errors.Is(err, context.Canceled) && c.isClosed() {
return ProcessFrame{}, io.EOF
}
return ProcessFrame{}, err
}
c.mu.Lock()
if len(c.pendingSyntheticStdout) > 0 {
c.mu.Unlock()
break
}
if c.cursor >= len(c.chunks) || c.chunks[c.cursor].ChunkSeq != chunkSeq {
c.mu.Unlock()
break
}
connChanged = c.changed
c.mu.Unlock()
endRelease, err := c.playback.controller.beginInboundRelease(ctx, c.closed, connChanged)
if err != nil {
if errors.Is(err, errReplayRecvInterrupted) {
c.mu.Lock()
continue
}
if errors.Is(err, context.Canceled) && c.isClosed() {
return ProcessFrame{}, io.EOF
}
return ProcessFrame{}, err
}
c.mu.Lock()
if c.isClosedLocked() {
c.mu.Unlock()
endRelease()
return ProcessFrame{}, io.EOF
}
if len(c.pendingSyntheticStdout) > 0 ||
c.cursor >= len(c.chunks) ||
c.chunks[c.cursor].ChunkSeq != chunkSeq {
c.mu.Unlock()
endRelease()
break
}
frame, err := decodeProcessCassetteFrame(chunk)
if err != nil {
c.mu.Unlock()
endRelease()
return ProcessFrame{}, err
}
frame.Stdout = mapProcessCassetteFrameJSON(
frame.Stdout,
c.recordedCWD,
c.replayCWD,
c.replayHome,
c.descriptor,
c.identityValues,
)
frame.Stderr = mapProcessCassetteFrameJSON(
frame.Stderr,
c.recordedCWD,
c.replayCWD,
c.replayHome,
c.descriptor,
c.identityValues,
)
frame.Stdout = suppressSkippedProcessCassetteResponses(frame.Stdout, c.skippedRPCs)
frame.Stdout = mapProcessCassetteResponseIDs(frame.Stdout, c.responseIDs)
frame.ConnectionID = chunk.ConnectionID
frame.ChunkSeq = chunk.ChunkSeq
c.cursor++
c.signalChangedLocked()
c.mu.Unlock()
endRelease()
if len(frame.Stdout) == 0 && len(frame.Stderr) == 0 &&
frame.ExitCode == nil && frame.Message == "" {
break
}
c.mu.Lock()
c.skippingOptionalProbeRun = false
c.mu.Unlock()
return frame, nil
}
continue
}
}