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 (
"agentflow/internal/domain"
"agentflow/internal/engine"
"agentflow/internal/repo"
"agentflow/internal/runtime"
"context"
"encoding/json"
"errors"
"fmt"
"github.com/gin-gonic/gin"
"net/http"
"strings"
"time"
)
func (h *runsHandlers) workspaceEditActor(c *gin.Context) (domain.Run, int64, bool) {
run, ok := h.repo.RunState(c.Param("id"))
if !ok {
c.JSON(404, gin.H{"error": "运行不存在"})
return run, 0, false
}
userID, status, message := h.workspaceEditAccess(c.Request, run)
if status != 0 {
c.JSON(status, gin.H{"error": message})
return run, 0, false
}
return run, userID, true
}
func (h *runsHandlers) workspaceEditAccess(r *http.Request, run domain.Run) (int64, int, string) {
user, ok := h.requestUser(r, true)
if !ok {
return 0, http.StatusUnauthorized, "请先登录"
}
// Conversation tools inherit project access from their authenticated entry
// point; the separate task-panel editor policy does not apply to them.
if run.ID == "" || (mainBotWorkspaceRun(r.Context()) != run.ID && !h.workspaceEditAllowed(r, run, user.ID)) {
return 0, http.StatusForbidden, "无权编辑该任务工作区"
}
if engine.WorkspaceRunID(run) != run.ID {
return 0, http.StatusConflict, "子 SOP 共享父任务工作区,请从父任务操作"
}
// Parent/child workspace ownership needs a separate coordinated lease.
for _, node := range run.Nodes {
if node != nil && node.ChildRunID != "" {
return 0, http.StatusConflict, "请进入子 SOP 运行后再编辑对应工作区"
}
}
return user.ID, 0, ""
}
func (h *runsHandlers) workspaceTakeover(c *gin.Context) {
run, user, ok := h.workspaceEditActor(c)
if !ok {
return
}
// Kept for older clients. People edit at any time, so this pauses nothing.
if err := h.repo.AcquireWorkspaceEditor(run.ID, user); err != nil {
c.JSON(409, gin.H{"error": err.Error()})
return
}
c.JSON(200, gin.H{"editorId": user, "expiresAt": time.Now().UTC().Add(15 * time.Minute)})
}
func (h *runsHandlers) workspaceRelease(c *gin.Context) {
run, user, ok := h.workspaceEditActor(c)
if !ok {
return
}
if err := h.repo.ReleaseWorkspaceEditor(run.ID, user, func(locked domain.Run) error { return h.closeWorkspaceTerminals(c.Request.Context(), locked, user) }); err != nil {
c.JSON(409, gin.H{"error": err.Error()})
return
}
c.JSON(200, gin.H{"ok": true})
}
func (h *runsHandlers) workspaceWrite(c *gin.Context) {
run, user, ok := h.workspaceEditActor(c)
if !ok {
return
}
c.Request.Body = http.MaxBytesReader(c.Writer, c.Request.Body, 2<<20)
var req struct {
Path string `json:"path"`
Content string `json:"content"`
ExpectedSHA string `json:"expectedSha256"`
}
if !decode(c, &req) {
return
}
var sha string
runnerID := h.engine.RunExecutionRunner(run)
err := h.withWorkspaceWriter(c, run.ID, user, func(locked domain.Run) error {
if runnerID != "" {
if h.runnerControls == nil {
return fmt.Errorf("执行端未连接")
}
ctx, cancel := context.WithTimeout(c.Request.Context(), 10*time.Second)
defer cancel()
response, err := h.runnerControls.requestWorkspace(ctx, runnerID, domain.RunnerWorkspaceRequest{RunID: runnerWorkspaceRunID(locked), RunStatus: locked.Status, WorkspaceLayout: run.ExecutionContext.RunnerWorkspaceLayout, RunKind: mainBotWorkspaceMode(c, locked), ConcurrentEdit: humanWorkspaceEdit(c, locked), Operation: domain.RunnerWorkspaceOperationWrite, Path: req.Path, Content: req.Content, ExpectedSHA256: req.ExpectedSHA, TerminalOwner: user})
if err != nil {
return fmt.Errorf("执行端写入失败:%w", err)
}
if response.Error != "" {
return fmt.Errorf("%s", response.Error)
}
var result struct {
SHA string `json:"sha256"`
}
if err = json.Unmarshal(response.Payload, &result); err != nil {
return err
}
sha = result.SHA
return nil
}
root, reason := h.engine.LocalRunWorkspace(locked)
if reason != "" {
return fmt.Errorf("%s", reason)
}
var err error
sha, err = runtime.WriteWorkspaceFile(root, req.Path, req.Content, req.ExpectedSHA)
return err
})
if err != nil {
c.JSON(409, gin.H{"error": err.Error()})
return
}
if h.engine != nil {
h.engine.AppendRunEvent(run.ID, "workspace.changed", "工作区文件已修改,之前的检查仅供历史参考")
}
c.JSON(200, gin.H{"sha256": sha})
}
// workspaceEditAllowed reports whether userID may edit run's task workspace
// from the task panel: platform admins, the project owner, anyone on an
// unowned project without members, and non-viewer project members.
func (h *runsHandlers) workspaceEditAllowed(r *http.Request, run domain.Run, userID int64) bool {
if run.IsPersonalWorkspace() {
return userID > 0 && userID == run.ExecutionContext.ResponsibleUserID
}
if h.isPlatformAdmin(r) {
return true
}
project, ok := h.repo.Project(run.ExecutionContext.ProjectID)
if !ok {
return false
}
if project.OwnerID == userID || project.OwnerID == 0 && len(project.Members) == 0 {
return true
}
for _, member := range project.Members {
if member.UserID == userID && !strings.EqualFold(member.Role, "viewer") {
return true
}
}
return false
}
func (h *runsHandlers) workspaceWritable(c *gin.Context, run domain.Run) bool {
// Read-only probe: never write HTTP errors here (browse handlers still return the payload).
if run.ID == "" || engine.WorkspaceRunID(run) != run.ID {
return false
}
user, ok := h.requestUser(c.Request, true)
if !ok {
return false
}
if mainBotWorkspaceRun(c.Request.Context()) == run.ID {
return run.LiveWorkspace() || (run.Status == "waiting" && run.PauseRequested && !run.CancelRequested) || domain.TerminalRunStatus(run.Status)
}
return run.HumanEditable() && h.workspaceEditAllowed(c.Request, run, user.ID)
}
func (h *runsHandlers) workspaceTerminal(c *gin.Context) {
run, user, ok := h.workspaceEditActor(c)
if !ok {
return
}
c.Request.Body = http.MaxBytesReader(c.Writer, c.Request.Body, 64<<10)
var req domain.WorkspaceTerminalRequest
if !decode(c, &req) {
return
}
runnerID := h.engine.RunExecutionRunner(run)
remoteHost := h.engine.WorkspaceRemoteHost(run)
var trustedRequest domain.RunnerWorkspaceRequest
if runnerID != "" || remoteHost {
var err error
trustedRequest, err = h.engine.TrustedWorkspaceRequest(run.ID, domain.RunnerWorkspaceRequest{RunID: run.ID, Operation: domain.RunnerWorkspaceOperationTerminal, Terminal: &req, TerminalOwner: user})
if err != nil {
c.JSON(409, gin.H{"error": err.Error()})
return
}
}
var result any
launch := func() error {
var credentials runtime.TerminalGitCredentials
if runnerID == "" && !remoteHost && req.Operation == "open" {
credentials = h.engine.WorkspaceTerminalGitCredentials(c.Request.Context(), run, user)
}
return h.withWorkspaceWriter(c, run.ID, user, func(locked domain.Run) error {
req.ExpiresAt = locked.WorkspaceEditUntil
trustedRequest.RunID = runnerWorkspaceRunID(locked)
trustedRequest.RunStatus = locked.Status
trustedRequest.WorkspaceLayout = locked.ExecutionContext.RunnerWorkspaceLayout
trustedRequest.RunKind = mainBotWorkspaceMode(c, locked)
trustedRequest.ConcurrentEdit = humanWorkspaceEdit(c, locked)
if runnerID != "" {
if h.runnerControls == nil {
return fmt.Errorf("执行端未连接")
}
ctx, cancel := context.WithTimeout(c.Request.Context(), 5*time.Second)
defer cancel()
response, err := h.runnerControls.requestWorkspace(ctx, runnerID, trustedRequest)
if err != nil {
return err
}
if response.Error != "" {
// The runner refuses a busy open before creating a PTY, so a
// caller may retry it like any other workspace_busy answer.
if req.Operation == "open" && response.Code == domain.WorkspaceErrorBusy {
return fmt.Errorf("%w(%s)", repo.ErrWorkspaceInUse, response.Error)
}
return fmt.Errorf("%s", response.Error)
}
result = json.RawMessage(response.Payload)
return nil
}
if remoteHost {
response, err := h.engine.ForwardPreparedWorkspaceRequest(c.Request.Context(), locked, trustedRequest)
if err != nil {
return err
}
if response.Error != "" {
return fmt.Errorf("%s", response.Error)
}
result = json.RawMessage(response.Payload)
return nil
}
r, err := h.engine.HandlePreparedWorkspaceTerminal(c.Request.Context(), run, &h.terminals, fmt.Sprintf("%s:%d", run.ID, user), req, credentials)
result = r
return err
})
}
var err error
if req.Operation == "open" {
err = h.withPreparedWorkspace(c, run.ID, func(runtime.WorkspacePreparationStatus) error { return launch() })
} else {
err = launch()
}
if err != nil {
body := gin.H{"error": err.Error()}
if errors.Is(err, repo.ErrWorkspaceInUse) {
// The lease was refused before touching the PTY. Retrying this
// specific response cannot duplicate input or create a second shell.
body["code"] = "workspace_busy"
}
c.JSON(409, body)
return
}
if h.engine != nil && req.Operation == "input" && req.Data != "" {
h.engine.AppendRunEvent(run.ID, "workspace.changed", "工作区终端收到输入,之前的检查仅供历史参考")
}
c.JSON(200, result)
}
func (h *runsHandlers) closeWorkspaceTerminals(ctx context.Context, run domain.Run, user int64) error {
h.terminals.CloseScope(fmt.Sprintf("%s:%d", run.ID, user))
if runnerID := h.engine.RunExecutionRunner(run); runnerID != "" {
if h.runnerControls == nil {
return fmt.Errorf("执行端未连接,暂不能结束编辑")
}
ctx, cancel := context.WithTimeout(ctx, 5*time.Second)
defer cancel()
req := domain.WorkspaceTerminalRequest{Operation: "close-all"}
response, err := h.runnerControls.requestWorkspace(ctx, runnerID, domain.RunnerWorkspaceRequest{RunID: runnerWorkspaceRunID(run), RunStatus: run.Status, WorkspaceLayout: run.ExecutionContext.RunnerWorkspaceLayout, Operation: domain.RunnerWorkspaceOperationTerminal, Terminal: &req, TerminalOwner: user})
if err != nil {
return err
}
if response.Error != "" {
return fmt.Errorf("%s", response.Error)
}
}
return nil
}
func (h *runsHandlers) withWorkspaceWriter(c *gin.Context, runID string, user int64, fn func(domain.Run) error) error {
ctx := c.Request.Context()
token := engine.ConversationWorkspaceToken(ctx, runID)
if h.engine != nil && token == "" {
var err error
token, err = h.engine.BeginConversationWorkspaceUse(runID)
if err != nil {
return err
}
defer func() {
saveCtx, stop := context.WithTimeout(context.WithoutCancel(ctx), 30*time.Second)
defer stop()
_ = h.engine.EndConversationWorkspaceUse(saveCtx, runID, token)
}()
}
if h.engine != nil {
if err := h.engine.EnsureConversationWorkspace(ctx, runID, token); err != nil {
return err
}
}
if mainBotWorkspaceRun(ctx) == runID {
return h.repo.WithMainBotWorkspace(runID, user, fn)
}
return h.repo.WithWorkspaceEditor(runID, user, fn)
}
// humanWorkspaceEdit marks IDE requests on runs that may still have agents
// running, which the runner serves beside those tasks (sharing their gate)
// instead of waiting for their fence. Finished runs keep the exclusive fence.
func humanWorkspaceEdit(c *gin.Context, run domain.Run) bool {
return mainBotWorkspaceRun(c.Request.Context()) != run.ID && run.HumanEditable() && !domain.TerminalRunStatus(run.Status)
}
// mainBotWorkspaceMode tells the runner to apply the live-workspace rule to
// Main Bot (no SOP fence on its conversation workspace).
func mainBotWorkspaceMode(c *gin.Context, run domain.Run) string {
if mainBotWorkspaceRun(c.Request.Context()) == run.ID {
return run.Kind
}
return ""
}