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 httpapi
import (
"context"
"encoding/json"
"fmt"
"os"
"path/filepath"
"slices"
"strings"
"time"
"agentflow/internal/config"
"agentflow/internal/domain"
"agentflow/internal/runtime"
)
const (
// Monitor and PowerShell run shell commands on the control plane like Bash.
nativeDisallowedTools = "Bash,PowerShell,Monitor,Write,Edit,MultiEdit,NotebookEdit,WebFetch,WebSearch,Task,KillShell,CronCreate,CronList,CronDelete"
// Match CodeBuddy's interactive unlimited value (Number.MAX_SAFE_INTEGER).
// Omitting --max-turns falls back to the CLI's finite headless default.
nativeAssistantUnlimitedTurns = "9007199254740991"
nativeTerminalMaxRetries = 2
agentToolSessionMCPServerID = "agentflow_session"
// The session gateway lists upstream TAPD/工蜂 tools before it
// answers tools/list, which can exceed CodeBuddy's ~2s headless MCP wait.
// The tools pinned with defer_loading=false below would then be absent
// from the first model request and, being non-deferred, unreachable via
// ToolSearch/DeferExecuteTool. Use CodeBuddy's interactive 30s wait.
agentToolSessionMCPStartupWait = 30 * time.Second
)
type agentToolFiles struct {
Dir string
MCPConfig string
Settings string
}
func (f agentToolFiles) Cleanup() {
if f.Dir == "" {
return
}
_ = os.Remove(f.MCPConfig)
_ = os.Remove(f.Settings)
_ = os.Remove(f.Dir)
}
func agentToolMCPURL(token string) string {
return config.Current().AgentToolGateway + "/internal/agent-tools/" + strings.TrimSpace(token) + "/mcp"
}
// writeAgentToolFiles writes the host-side CodeBuddy session config used by
// assistant, clarification and report commands. The per-tool defer_loading
// extension belongs to CodeBuddy; it must not enter the shared runtime MCP
// configuration consumed by other providers.
func writeAgentToolFiles(parentDir, token string) (agentToolFiles, error) {
parentDir = strings.TrimSpace(parentDir)
if parentDir == "" {
return agentToolFiles{}, fmt.Errorf("empty agent tool config directory")
}
dir, err := os.MkdirTemp(parentDir, "mcp-")
if err != nil {
if err := os.MkdirAll(parentDir, 0o700); err != nil {
return agentToolFiles{}, err
}
dir, err = os.MkdirTemp(parentDir, "mcp-")
if err != nil {
return agentToolFiles{}, err
}
}
if err := os.Chmod(dir, 0o700); err != nil {
_ = os.RemoveAll(dir)
return agentToolFiles{}, err
}
files := agentToolFiles{
Dir: dir,
MCPConfig: filepath.Join(dir, "mcp.json"),
Settings: filepath.Join(dir, "settings.json"),
}
config, err := json.Marshal(map[string]any{
"mcpServers": map[string]any{
agentToolSessionMCPServerID: map[string]any{
"type": "http",
"url": agentToolMCPURL(token),
// Submission and draft schema lookup must not depend on ToolSearch.
// Business tools keep CodeBuddy's normal deferred loading.
"tools": map[string]any{
"workbench_tool_schema": map[string]bool{"defer_loading": false},
submitAssistantReplyTool: map[string]bool{"defer_loading": false},
submitClarificationTool: map[string]bool{"defer_loading": false},
submitNotificationReportTool: map[string]bool{"defer_loading": false},
},
},
},
})
if err != nil {
files.Cleanup()
return agentToolFiles{}, err
}
if err := os.WriteFile(files.MCPConfig, config, 0o600); err != nil {
files.Cleanup()
return agentToolFiles{}, err
}
settings, err := json.Marshal(nativeToolSettings())
if err != nil {
files.Cleanup()
return agentToolFiles{}, err
}
if err := os.WriteFile(files.Settings, settings, 0o600); err != nil {
files.Cleanup()
return agentToolFiles{}, err
}
return files, nil
}
func nativeToolSettings() map[string]any {
return map[string]any{
"permissions": map[string]any{
"deny": strings.Split(nativeDisallowedTools, ","),
},
}
}
func applyNativeToolSafety(argv []string, mode AgentToolMode) []string {
_ = mode
// --tools is a built-in allowlist. CodeBuddy also applies it to MCP tools,
// so listing Read/Grep/Glob or mcp__* globs hides submit_* and TAPD/工蜂.
argv = dropNativeArg(argv, "--tools")
if !slices.Contains(argv, "--disallowedTools") {
argv = appendNativeArgs(argv, "--disallowedTools", nativeDisallowedTools)
}
if !slices.Contains(argv, "--strict-mcp-config") {
argv = appendNativeArgs(argv, "--strict-mcp-config")
}
return argv
}
// Provider commands terminate options with -- before the positional prompt.
// Flags added by control-plane callers must stay before that delimiter.
func appendNativeArgs(argv []string, args ...string) []string {
for i, arg := range argv {
if arg == "--" {
out := append([]string(nil), argv[:i]...)
out = append(out, args...)
return append(out, argv[i:]...)
}
}
return append(argv, args...)
}
func dropNativeArg(argv []string, flag string) []string {
out := make([]string, 0, len(argv))
skip := false
for _, arg := range argv {
if skip {
skip = false
continue
}
if arg == flag {
skip = true
continue
}
if strings.HasPrefix(arg, flag+"=") {
continue
}
out = append(out, arg)
}
return out
}
func replaceArgValue(argv []string, flag, value string) []string {
out := make([]string, 0, len(argv)+2)
replaced := false
skip := false
for i := 0; i < len(argv); i++ {
if skip {
skip = false
continue
}
if argv[i] == flag {
out = append(out, flag, value)
skip = true
replaced = true
continue
}
out = append(out, argv[i])
}
if !replaced {
out = appendNativeArgs(out, flag, value)
}
return out
}
func argvFlagValue(argv []string, flag string) (string, bool) {
for i, arg := range argv {
if arg == flag && i+1 < len(argv) {
return argv[i+1], true
}
}
return "", false
}
func nativeCommandContainsSecret(command runtime.CommandSpec, files agentToolFiles, token string) bool {
blob, _ := os.ReadFile(files.MCPConfig)
text := string(blob)
if strings.Contains(text, "Authorization") || strings.Contains(strings.ToLower(text), "bearer ") {
return true
}
joined := strings.Join(command.Argv, " ")
if token != "" && strings.Contains(joined, token) {
return true
}
return false
}
func startAgentToolSession(ctx context.Context, user domain.User, projectID string, mode AgentToolMode, exec assistantExecMode, issueID string, servers []domain.MCPServerDefinition, cancel context.CancelFunc, parent string) (*AgentToolSession, agentToolFiles, error) {
session := &AgentToolSession{
ControlScope: assistantControlScopeFrom(ctx),
UserID: user.ID,
ProjectID: projectID,
Mode: mode,
IssueID: issueID,
ctx: ctx,
MCPServers: servers,
User: user,
ExecMode: exec,
Final: make(chan AgentTerminalResult, 1),
CancelModel: cancel,
}
if err := agentToolSessions.create(session); err != nil {
return nil, agentToolFiles{}, err
}
files, err := writeAgentToolFiles(parent, session.Token)
if err != nil {
session.Close()
return nil, agentToolFiles{}, err
}
return session, files, nil
}
func redactAgentToolPath(path string) string {
const prefix = "/internal/agent-tools/"
if !strings.HasPrefix(path, prefix) {
return path
}
rest := path[len(prefix):]
if i := strings.IndexByte(rest, '/'); i >= 0 {
return prefix + "[redacted]" + rest[i:]
}
return prefix + "[redacted]"
}
func nativeShouldRetryTerminal(ctx context.Context, err error) bool {
if ctx != nil && ctx.Err() != nil {
return false
}
if err == nil {
return true
}
msg := strings.ToLower(err.Error())
switch {
case strings.Contains(msg, "api key"), strings.Contains(msg, "凭据"), strings.Contains(msg, "未找到"), strings.Contains(msg, "unauthorized"), strings.Contains(msg, "401"):
return false
default:
return true
}
}