Files
Bedrock/internal/platform/canvas_ai_explicit_apply.go
T
codex-bot d6ee8942f1
Foundry Go checks / check (push) Successful in 2m40s
Foundry Go checks / check (pull_request) Successful in 2m36s
Implement Canvas V2 subgraphs, assets and asynchronous AI execution
2026-11-06 18:36:00 +08:00

195 lines
5.9 KiB
Go

package platform
import (
"database/sql"
"encoding/json"
"net/http"
"unicode/utf8"
)
func (s *service) applyCanvasAIOutput(w http.ResponseWriter, r *http.Request, project, account string) error {
if r.Method != http.MethodPost {
reject(w, 405, "method_not_allowed")
return nil
}
key, id := canvasIdempotencyKey(r), r.PathValue("run")
if !uuidSlugPattern.MatchString(key) || !uuidSlugPattern.MatchString(id) {
reject(w, 400, "invalid_ai_request")
return nil
}
expected, ok := expectedVersion(w, r)
if !ok {
return nil
}
var input struct {
NodeID string `json:"node_id"`
OutputID string `json:"output_id"`
}
if !decode(w, r, &input) {
return nil
}
if !canvasID.MatchString(input.NodeID) || !uuidSlugPattern.MatchString(input.OutputID) {
reject(w, 400, "invalid_ai_request")
return nil
}
hash := payloadDigest(input)
workspace, board := r.PathValue("workspace"), r.PathValue("material")
tx, err := s.db.BeginTx(r.Context(), nil)
if err != nil {
return err
}
defer tx.Rollback()
_, role, err := lockMaterial(r.Context(), tx, project, workspace, board, account)
if err != nil {
return err
}
if role == "viewer" {
reject(w, 403, "forbidden")
return nil
}
var runStatus string
err = tx.QueryRowContext(r.Context(), `SELECT status FROM canvas_ai_runs WHERE project=$1 AND workspace_id=$2 AND board_id=$3 AND id=$4 FOR UPDATE`, project, workspace, board, id).Scan(&runStatus)
if err != nil {
return err
}
var previousHash string
var previous json.RawMessage
err = tx.QueryRowContext(r.Context(), `SELECT payload_hash,response_body FROM canvas_ai_mutations WHERE project=$1 AND workspace_id=$2 AND run_id=$3 AND account_id=$4 AND action='apply' AND idempotency_key=$5`, project, workspace, id, account, key).Scan(&previousHash, &previous)
if err == nil {
if hash != previousHash {
reject(w, 409, "idempotency_conflict")
return nil
}
var saved struct {
Version int64 `json:"canvas_version"`
}
_ = json.Unmarshal(previous, &saved)
setVersion(w, saved.Version)
reply(w, 200, previous)
return nil
}
if err != sql.ErrNoRows {
return err
}
var stepID, targetBoard, node, status string
var outputRaw, frozenRaw json.RawMessage
var applied sql.NullInt64
err = tx.QueryRowContext(r.Context(), `SELECT id,board_id::text,node_id,status,output,frozen_input,applied_version FROM canvas_ai_steps WHERE project=$1 AND workspace_id=$2 AND run_id=$3 AND output->>'output_id'=$4 FOR UPDATE`, project, workspace, id, input.OutputID).Scan(&stepID, &targetBoard, &node, &status, &outputRaw, &frozenRaw, &applied)
if err != nil {
return err
}
if node != input.NodeID || status != "conflict" || applied.Valid || runStatus == "cancelled" {
reject(w, 409, "output_not_applicable")
return nil
}
_, role, err = lockMaterial(r.Context(), tx, project, workspace, targetBoard, account)
if err != nil {
return err
}
if role == "viewer" {
reject(w, 403, "forbidden")
return nil
}
snapshot, err := loadCanvas(r, tx, project, workspace, targetBoard)
if err != nil {
return err
}
if snapshot.Version != expected {
reject(w, 412, "version_conflict")
return nil
}
var output struct {
Kind string `json:"kind"`
Text string `json:"text"`
AssetID string `json:"assetId"`
Src string `json:"src"`
}
if err = json.Unmarshal(outputRaw, &output); err != nil {
return err
}
var frozen canvasAIStepPlan
if err = json.Unmarshal(frozenRaw, &frozen); err != nil {
return err
}
patch := response{}
switch output.Kind {
case "text":
if !canvasChoice(frozen.Kind, "text", "script", "plain-text") || !utf8.ValidString(output.Text) || utf8.RuneCountInString(output.Text) > 100000 {
reject(w, 422, "model_incompatible")
return nil
}
patch["text"] = output.Text
case "image":
if !canvasChoice(frozen.Kind, "image", "plain-image") || !uuidSlugPattern.MatchString(output.AssetID) || output.Src != s.assetURL(project, workspace, output.AssetID) {
reject(w, 422, "model_incompatible")
return nil
}
readable, err := assetReadable(r, tx, project, workspace, output.AssetID, account)
if err != nil {
return err
}
if !readable {
reject(w, 404, "not_found")
return nil
}
patch["src"] = output.Src
patch["assetId"] = output.AssetID
default:
reject(w, 422, "model_incompatible")
return nil
}
var doc map[string]any
if err = json.Unmarshal(snapshot.Document, &doc); err != nil {
return err
}
var target map[string]any
for _, v := range doc["nodes"].([]any) {
n := v.(map[string]any)
if n["id"] == node {
target = n["data"].(map[string]any)
}
}
if target == nil {
reject(w, 404, "not_found")
return nil
}
if target["kind"] != frozen.Kind {
reject(w, 409, "ownership_conflict")
return nil
}
for key, value := range patch {
target[key] = value
}
encoded, _ := json.Marshal(doc)
normalized, ok := normalizeCanvas(encoded)
if !ok {
reject(w, 413, "canvas_too_large")
return nil
}
snapshot.Document = normalized
snapshot.Version++
if err = s.saveCanvas(r, tx, project, workspace, snapshot); err != nil {
return err
}
_, err = tx.ExecContext(r.Context(), `UPDATE canvas_ai_steps SET applied_version=$5 WHERE project=$1 AND workspace_id=$2 AND run_id=$3 AND id=$4`, project, workspace, id, stepID, snapshot.Version)
if err != nil {
return err
}
result := response{"run_id": id, "step_id": stepID, "board_id": targetBoard, "node_id": node, "output_id": input.OutputID, "canvas_version": snapshot.Version, "patch": patch}
if err = appendAIEvent(r.Context(), tx, project, workspace, id, "step.applied", result); err != nil {
return err
}
encoded, _ = json.Marshal(result)
_, err = tx.ExecContext(r.Context(), `INSERT INTO canvas_ai_mutations(project,workspace_id,run_id,account_id,action,idempotency_key,payload_hash,response_body) VALUES($1,$2,$3,$4,'apply',$5,$6,$7)`, project, workspace, id, account, key, hash, encoded)
if err != nil {
return err
}
if err = tx.Commit(); err != nil {
return err
}
setVersion(w, snapshot.Version)
reply(w, 200, result)
return nil
}