Skip to content
Open
Show file tree
Hide file tree
Changes from all commits
Commits
File filter

Filter by extension

Filter by extension

Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
20 changes: 14 additions & 6 deletions internal/runner/daemon.go
Original file line number Diff line number Diff line change
Expand Up @@ -582,18 +582,26 @@ func (d *Daemon) executeTask(ctx context.Context, task domain.RunnerTask) {
completeCtx, cancel := context.WithTimeout(context.Background(), 30*time.Second)
defer cancel()
req := CompleteRequest{Status: result.status, Result: result.result, Error: result.errMsg, Artifacts: artifacts, Outputs: result.outputs}
if result.status == domain.RunnerTaskFailed || result.status == domain.RunnerTaskSuccess {
exit := result.exitCode
req.ExitCode = &exit
}
req.ExitCode = reportedExitCode(result)
if err := d.client.Complete(completeCtx, task.ID, req); err != nil {
log.Printf("task %s complete report: %v", task.ID, err)
}
log.Printf("task %s finished (%s)", task.ID, result.status)
}

func (d *Daemon) executeRunCleanup(ctx context.Context, task domain.RunnerTask) execResult {
if err := d.client.StartTask(ctx, task.ID); err != nil {
// reportedExitCode is the exit status the control plane should show. A task that
// never spawned its executor has none: reporting the zero value made every
// pre-flight failure read "… (exit 0)" next to the real error, which sent
// operators looking for a crashed process instead of a missing CLI or model.
func reportedExitCode(result execResult) *int {
if result.status == domain.RunnerTaskSuccess || (result.status == domain.RunnerTaskFailed && result.ran) {
code := result.exitCode
return &code
}
return nil
}

func (d *Daemon) executeRunCleanup(ctx context.Context, task domain.RunnerTask) execResult { if err := d.client.StartTask(ctx, task.ID); err != nil {
return execResult{status: domain.RunnerTaskFailed, errMsg: fmt.Sprintf("start cleanup: %v", err)}
}
root, err := filepath.Abs(d.cfg.DefaultWorkspaceRoot)
Expand Down
23 changes: 20 additions & 3 deletions internal/runner/exec.go
Original file line number Diff line number Diff line change
Expand Up @@ -98,6 +98,7 @@ func (d *Daemon) executeSandboxProcess(ctx context.Context, task domain.RunnerTa
return result
}
result.exitCode = exitCode(completed.err)
result.ran = processRan(completed.err)
if completed.err != nil {
result.status = domain.RunnerTaskFailed
result.errMsg = completed.err.Error()
Expand Down Expand Up @@ -258,9 +259,13 @@ func (b *eventBatcher) taskResult(rawFallback string) string {
type execResult struct {
status string
exitCode int
result string
errMsg string
outputs *domain.RunnerTaskOutputs
// ran reports that the executor actually spawned. A pre-flight failure
// (missing CLI, unusable credentials, missing image) never produced a
// process, so it has no exit status to report.
ran bool
result string
errMsg string
outputs *domain.RunnerTaskOutputs
}

// executeProcess spawns the Agent CLI in its own process group so a cancel
Expand Down Expand Up @@ -372,6 +377,7 @@ func (d *Daemon) executeProcess(ctx context.Context, task domain.RunnerTask, arg
return result
}
result.exitCode = code
result.ran = processRan(err)
if err != nil {
result.status = domain.RunnerTaskFailed
result.errMsg = err.Error()
Expand Down Expand Up @@ -444,6 +450,17 @@ func isBenignStreamClose(err error) bool {
return strings.Contains(msg, "file already closed") || strings.Contains(msg, "use of closed file")
}

// processRan reports whether err came from a process that actually ran: nil for
// a clean exit, *exec.ExitError for a non-zero one. Anything else (exec not
// found, permission denied, an aborted start) never produced an exit status.
func processRan(err error) bool {
if err == nil {
return true
}
var exitErr *exec.ExitError
return asExitError(err, &exitErr)
}

func exitCode(err error) int {
if err == nil {
return 0
Expand Down
44 changes: 44 additions & 0 deletions internal/runner/exit_code_report_test.go
Original file line number Diff line number Diff line change
@@ -0,0 +1,44 @@
package runner

import (
"errors"
"os/exec"
"testing"

"agentflow/internal/domain"
)

// A failure before the executor spawned — a missing CLI, unusable credentials,
// an absent model — has no exit status. Reporting the zero value made every
// such error read "… (exit 0)" in the run log, which points the investigation
// at a process that never existed.
func TestReportedExitCodeSkipsPreflightFailures(t *testing.T) {
preflight := execResult{status: domain.RunnerTaskFailed, errMsg: "Pi 需要指定模型"}
if got := reportedExitCode(preflight); got != nil {
t.Fatalf("pre-flight failure reported exit %d, want no exit code", *got)
}
crashed := execResult{status: domain.RunnerTaskFailed, exitCode: 127, ran: true}
if got := reportedExitCode(crashed); got == nil || *got != 127 {
t.Fatalf("executor that ran exit code = %v, want 127", got)
}
succeeded := execResult{status: domain.RunnerTaskSuccess, exitCode: 0, ran: true}
if got := reportedExitCode(succeeded); got == nil || *got != 0 {
t.Fatalf("successful task exit code = %v, want 0", got)
}
}

func TestProcessRan(t *testing.T) {
if !processRan(nil) {
t.Fatal("a clean exit ran")
}
exitErr := exec.Command("false").Run()
if !processRan(exitErr) {
t.Fatal("a non-zero exit still ran")
}
if code := exitCode(exitErr); code != 1 {
t.Fatalf("exitCode = %d, want 1", code)
}
if processRan(errors.New("exec: \"pi\": executable file not found in $PATH")) {
t.Fatal("a spawn failure never ran")
}
}