Skip to content

Self-hosted workflows for coding-agent delivery. Orchestrate CodeBuddy, Codex and Claude Code with scripts and human approval gates. Includes Local workflows for coding assistants.

4.6 KB
Raw Blame
package runner

import (
	"agentflow/internal/domain"
	"agentflow/internal/managedcli"
	"agentflow/internal/runtime"
	"context"
	"encoding/json"
	"fmt"
	"path/filepath"
	"regexp"
	"strings"
	"sync"
	"time"
)

var conversationKeyPattern = regexp.MustCompile(`^[a-f0-9]{64}$`)

func (d *Daemon) conversationProcess(ctx context.Context, request domain.RunnerWorkspaceRequest) domain.RunnerWorkspaceResponse {
	var req runtime.ConversationProcessRequest
	if err := json.Unmarshal(request.Conversation, &req); err != nil || !conversationKeyPattern.MatchString(req.SessionKey) {
		return domain.RunnerWorkspaceResponse{Status: 400, Error: "invalid conversation process request"}
	}
	root := filepath.Join(d.cfg.DefaultWorkspaceRoot, ".conversations", req.SessionKey)
	if req.Transient {
		if request.RunID != "" {
			return domain.RunnerWorkspaceResponse{Status: 400, Error: "transient processes cannot use a run workspace"}
		}
		root = filepath.Join(d.cfg.DefaultWorkspaceRoot, ".conversations", ".transient", req.SessionKey)
	}
	workspace := ""
	if request.RunID != "" {
		var err error
		workspace, err = d.runnerWorkspaceRoot(request)
		if err != nil {
			return runnerWorkspaceError(err)
		}
		if request.Sandbox == nil || !domain.ConversationSandboxDriver(request.Sandbox.Profile.Driver) {
			return domain.RunnerWorkspaceResponse{Status: 400, Error: "对话工作区只支持 Docker 或 native 沙箱"}
		}
	}
	d.conversationMu.Lock()
	forward := d.conversationForward
	d.conversationMu.Unlock()
	if forward == nil {
		return runnerWorkspaceError(fmt.Errorf("conversation control channel unavailable"))
	}
	var factory runtime.ConversationSandboxFactory
	if request.RunID == "" {
		factory = func(envCtx context.Context, _ string) (runtime.Sandbox, func(), error) {
			var lease *managedcli.ClaimLease
			var err error
			var inventory managedcli.Inventory
			if d.cfg.ManagedCLIRoot != "" {
				lease, err = managedcli.BeginClaim(envCtx, d.cfg.ManagedCLIRoot)
				if err == nil {
					inventory, err = managedcli.ReadInventory(d.cfg.ManagedCLIRoot)
				}
				if err != nil {
					_ = lease.Close()
					return nil, nil, err
				}
			}
			release := func() { _ = lease.Close() }
			provider := req.Command.Provider
			binary := strings.TrimSpace(d.cfg.ExtraBinaries[provider])
			if binary == "" {
				binary, _ = inventory.BinaryFor(provider)
			}
			if binary == "" {
				binary, _ = providerBinaryPath(d.currentRuntimes(), provider)
			}
			if binary == "" {
				binary, _ = lookupCLI(defaultProviderBinary(provider))
			}
			if binary == "" {
				release()
				return nil, nil, fmt.Errorf("执行机器未安装 CLI %s", provider)
			}
			req.Command.Argv[0] = binary
			return nil, release, nil
		}
	} else {
		factory = func(envCtx context.Context, nativeRoot string) (runtime.Sandbox, func(), error) {
			gate := d.requestGate(request)
			if err := lockConversationWorkspace(envCtx, gate); err != nil {
				return nil, nil, err
			}
			task, err := d.workspaceSandboxTask(workspace, request)
			if err != nil {
				gate.Unlock()
				return nil, nil, err
			}
			sb, release, err := d.acquireTaskSandbox(envCtx, task)
			if err != nil {
				gate.Unlock()
				return nil, nil, err
			}
			if err = runtime.ConfigureConversationSandbox(envCtx, sb, nativeRoot); err == nil {
				var execution runtime.Sandbox
				execution, err = d.workspaceExecutionSandbox(envCtx, sb, request)
				if err == nil {
					_, err = runtime.EnsureWorkspacePreparation(envCtx, execution, *request.Workflow, request.Repositories, nil)
				}
			}
			if err != nil {
				release()
				gate.Unlock()
				return nil, nil, err
			}
			// A running conversation excludes recreation/checkpoints (writers),
			// while its own delivery task may share the sandbox as a reader.
			gate.Unlock()
			gate.RLock()
			finish := onceRelease(release, gate.RUnlock)
			return sb, finish, nil
		}
	}
	result, err := d.conversationProcesses.Handle(ctx, root, workspace, request.Sandbox, req, forward, factory)
	if err != nil {
		return runnerWorkspaceError(err)
	}
	return runnerWorkspacePayload(result)
}

// A cancelled background export may have been queued when the API preempted
// it. Wait for that gate here, before any CLI is created; never replay start.
func lockConversationWorkspace(ctx context.Context, gate *sync.RWMutex) error {
	deadline := time.NewTimer(2 * time.Second)
	defer deadline.Stop()
	ticker := time.NewTicker(25 * time.Millisecond)
	defer ticker.Stop()
	for {
		if err := ctx.Err(); err != nil {
			return err
		}
		if gate.TryLock() {
			return nil
		}
		select {
		case <-ctx.Done():
			return ctx.Err()
		case <-deadline.C:
			return newWorkspaceBusyError("workspace is in use")
		case <-ticker.C:
		}
	}
}