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.
JavaScript agent-orchestrationagentic-workflowai-agentsai-codingclaude-codecode-reviewcodebuddycodexcoding-agentscursordeveloper-toolshuman-on-the-loopllmmcpmulti-agentsdlcself-hostedsopworkflow-automationworkflow-engine
package runtime
import (
"context"
"strings"
"agentflow/internal/domain"
)
// SandboxRequirements describes the host state and runtime features a provider
// needs before a Run sandbox is created.
type SandboxRequirements struct {
// ConversationRoot is the private, persistent native CLI state directory.
ConversationRoot string
CLIStates []CLIStateRequirement
PrivateHome bool
BunFS bool
// RunnerLoginRelay allows Docker Codex account login to reach the host refresh listener.
RunnerLoginRelay bool `json:",omitempty"`
}
type CLIStateRequirement struct {
Directory string
Files []string
}
type providerMaterializeContext struct {
Workspace string
AgentID string
AgentRel string
RuntimeRel string
ConfigRoot string
AgentRoot string
Content []byte
SkillPaths []string
MCPServers []domain.MCPServerDefinition
Assets domain.AgentAssetBundle
Compiled *compiledConfig
}
type providerInvocation struct {
Executor domain.ExecutorDefinition
Compiled compiledConfig
Prompt string
PromptFile string
Driver string
Options InvocationOptions
}
// Provider owns all behavior that varies by executor kind. The runtime remains
// responsible for shared materialization, process execution and workspace safety.
type Provider interface {
Kind() string
Materialize(*providerMaterializeContext) error
Prepare(providerInvocation) (CommandSpec, error)
Protocol(domain.ExecutorDefinition, EventSink) *protocolAdapter
SandboxRequirements() SandboxRequirements
RunBuiltin(context.Context, domain.AgentDefinition, string, EventSink) (string, bool, error)
StartObservation(context.Context, compiledConfig, EventSink) context.CancelFunc
// SystemHooks returns provider-owned hooks that must be merged ahead of the
// role's hooks and rendered as one effective provider configuration.
SystemHooks() []domain.AgentHook
}
type baseProvider struct {
kind string
parser protocolParser
adapter string
}
func (p baseProvider) Kind() string { return p.kind }
func (baseProvider) Materialize(*providerMaterializeContext) error { return nil }
func (p baseProvider) Prepare(in providerInvocation) (CommandSpec, error) {
return CommandSpec{Argv: append(buildProviderArgs(in), positionalPrompt(in)), Provider: p.Kind(), PrivateHome: p.SandboxRequirements().PrivateHome}, nil
}
func buildProviderArgs(in providerInvocation) []string {
argv := append([]string{in.Executor.Binary}, in.Executor.Args...)
argv = append(argv, in.Compiled.Args...)
if in.Executor.Model != "" && !hasArg(argv, "--model") {
argv = append(argv, "--model", in.Executor.Model)
}
return argv
}
// appendEffortArgs injects the native --effort flag used by Claude Code and
// CodeBuddy. Codex maps the same setting onto a -c config override in its own
// Prepare, so this helper is intentionally Claude/CodeBuddy-only.
func appendEffortArgs(argv []string, effort string) []string {
effort = strings.TrimSpace(effort)
if effort == "" || hasArg(argv, "--effort") {
return argv
}
return append(argv, "--effort", effort)
}
// maxArgvPromptBytes stays under Linux MAX_ARG_STRLEN (~128KiB per argument).
// Ordinary node task books stay on argv so existing SOP behavior is unchanged.
const maxArgvPromptBytes = 96 << 10
// PromptFitsArgv reports whether a prompt leaves headroom under the platform's
// single-argument limit.
func PromptFitsArgv(bytes int) bool {
return bytes <= maxArgvPromptBytes
}
func positionalPrompt(in providerInvocation) string {
if rel := strings.TrimSpace(in.PromptFile); rel != "" && len(in.Prompt) > maxArgvPromptBytes {
return "执行系统提示中的「本次节点任务书」(完整正文也在 `" + rel + "`)。不要等待更多输入。"
}
return in.Prompt
}
// PromptOnStdin moves an oversized trailing positional prompt to stdin.
//
// Linux rejects any single argv string above MAX_ARG_STRLEN (128KiB) with
// E2BIG, so the CLI never starts ("fork/exec ...: argument list too long").
// Chat prompts embed the whole conversation on a fresh native session and
// have no prompt file to point at. CodeBuddy and Claude Code in print mode
// read the prompt from stdin when no positional prompt is given; stdin is
// forwarded by local, Docker and remote conversation execution.
//
// Only a command ending in "--", prompt is rewritten. The "--" terminator
// stays so flags appended later by callers remain before it. Short prompts
// keep the existing argv form.
func PromptOnStdin(command CommandSpec, prompt string) CommandSpec {
n := len(command.Argv)
if PromptFitsArgv(len(prompt)) || command.Stdin != nil || n < 3 || command.Argv[n-1] != prompt || command.Argv[n-2] != "--" {
return command
}
command.Argv = append([]string(nil), command.Argv[:n-1]...)
command.Stdin = strings.NewReader(prompt)
return command
}
func (p baseProvider) Protocol(ex domain.ExecutorDefinition, sink EventSink) *protocolAdapter {
return makeProtocolAdapter(ex, sink, p.parser, p.adapter)
}
func (baseProvider) SandboxRequirements() SandboxRequirements { return SandboxRequirements{} }
func (baseProvider) RunBuiltin(context.Context, domain.AgentDefinition, string, EventSink) (string, bool, error) {
return "", false, nil
}
func (baseProvider) StartObservation(context.Context, compiledConfig, EventSink) context.CancelFunc {
return func() {}
}
func (baseProvider) SystemHooks() []domain.AgentHook { return nil }
var providers = map[string]Provider{
"claude-code": claudeProvider{},
"codebuddy": codeBuddyProvider{},
"codex": codexProvider{},
"mock": mockProvider{},
}
func init() {
for _, kind := range AgentCLIKinds {
providers[kind] = newAgentCLIProvider(kind)
}
}
func providerForKind(kind string) Provider {
if provider := providers[strings.TrimSpace(kind)]; provider != nil {
return provider
}
return baseProvider{kind: kind, parser: protocolGeneric, adapter: "generic-json-v1"}
}
func MergeSandboxRequirements(values ...SandboxRequirements) SandboxRequirements {
var merged SandboxRequirements
seen := map[string]bool{}
for _, value := range values {
merged.BunFS = merged.BunFS || value.BunFS
merged.RunnerLoginRelay = merged.RunnerLoginRelay || value.RunnerLoginRelay
states := append([]CLIStateRequirement(nil), value.CLIStates...)
for _, state := range states {
if state.Directory == "" || seen[state.Directory] {
continue
}
seen[state.Directory] = true
merged.CLIStates = append(merged.CLIStates, state)
}
}
return merged
}
func ProviderRequirements(kind string) SandboxRequirements {
return providerForKind(kind).SandboxRequirements()
}
// PrepareProviderCommand exposes the same provider flag and credential-binding
// policy to control-plane call sites that do not run a workflow node.
func PrepareProviderCommand(executor domain.ExecutorDefinition, prompt, driver string, options InvocationOptions) (CommandSpec, error) {
if executor.Model == "default" {
executor.Model = ""
}
return providerForKind(executor.Kind).Prepare(providerInvocation{
Executor: executor,
Prompt: prompt,
Driver: driver,
Options: options,
})
}