package server import ( "bytes" "context" "fmt" "io" "os" "path/filepath" "strconv" "strings" "git.a-wan.net/alan/pipelines/internal/protocol" "github.com/yuin/goldmark" "github.com/yuin/goldmark/extension" ) const reportLimit = 2 << 20 // renderReport is deterministic and deliberately structural: no factual or // completion validation is implied. Raw HTML is disabled by Goldmark's default // renderer; the document has no scripts, stylesheets or remote dependencies. func renderReport(format string, output map[string]any) (string, []byte, error) { if err := protocol.ValidateOutputFormat(format); err != nil { return "", nil, err } var markdown string for _, key := range []string{"markdown", "report", "result", "summary", "message"} { if text, ok := output[key].(string); ok && strings.TrimSpace(text) != "" { markdown = text break } } if strings.TrimSpace(markdown) == "" { return "", nil, fmt.Errorf("requested report requires nonempty textual output (markdown, report, result, summary or message)") } if len(markdown) > reportLimit { return "", nil, fmt.Errorf("report source exceeds size limit") } if format == "markdown" { return "report.md", []byte(markdown), nil } var body bytes.Buffer if err := goldmark.New(goldmark.WithExtensions(extension.GFM)).Convert([]byte(markdown), &body); err != nil { return "", nil, err } // No external resources are fetched even if markdown includes image links. doc := "\nRun report
" + body.String() + "
\n" if len(doc) > reportLimit { return "", nil, fmt.Errorf("rendered report exceeds size limit") } return "report.html", []byte(doc), nil } // finalizeDeliverable runs before the successful terminal store transition. // Fixed names and os.Root keep writes confined even if a stage left symlinks. // Existing files (including model-created reports) are never overwritten. func (r *runner) finalizeDeliverable(ctx context.Context, id int64, sequence int, output map[string]any) error { detail, err := r.store.GetRun(ctx, id) if err != nil { return err } if detail.OutputFormat == "" { return nil } if detail.Status != protocol.RunStatusQueued && detail.Status != protocol.RunStatusRunning { return nil // never create evidence for an already-settled/canceled run } if sequence <= 0 { return fmt.Errorf("requested report has no completed visit") } name, body, err := renderReport(detail.OutputFormat, output) if err != nil { return err } var visit *protocol.RunStep for i := range detail.Steps { if detail.Steps[i].Sequence == sequence { visit = &detail.Steps[i] break } } if visit == nil || visit.Status != "completed" { return fmt.Errorf("requested report has no completed terminal visit") } var inventoried int64 for _, file := range visit.Artifacts { inventoried += file.SizeBytes } if len(visit.Artifacts) >= maxArtifactFiles || inventoried+int64(len(body)) > maxArtifactTotalBytes { return fmt.Errorf("requested report exceeds artifact inventory bounds") } root, err := os.OpenRoot(r.artifactsRoot) if err != nil { return err } defer root.Close() run := strconv.FormatInt(id, 10) public := filepath.Join(run, "public") // Refuse symlinked directories, rather than using another visit's files. for _, dir := range []string{run, public} { info, err := root.Lstat(dir) if os.IsNotExist(err) { err = root.Mkdir(dir, 0755) if err != nil { return err } continue } if err != nil { return err } if !info.IsDir() || info.Mode()&os.ModeSymlink != 0 { return fmt.Errorf("report directory is not a normal directory") } } target := filepath.Join(public, name) file, err := root.OpenFile(target, os.O_CREATE|os.O_EXCL|os.O_WRONLY, 0644) if err != nil { return fmt.Errorf("create requested report: %w", err) } written, writeErr := file.Write(body) if writeErr == nil && written != len(body) { writeErr = io.ErrShortWrite } if writeErr == nil { writeErr = file.Sync() } closeErr := file.Close() if writeErr != nil { return writeErr } if closeErr != nil { return closeErr } info, err := root.Lstat(target) if err != nil { return err } if !info.Mode().IsRegular() || info.Size() <= 0 || info.Size() > reportLimit { return fmt.Errorf("requested report is missing, empty, not a normal file or oversized") } check, err := root.Open(target) if err != nil { return err } actual, err := io.ReadAll(io.LimitReader(check, reportLimit+1)) check.Close() if err != nil { return err } if !bytes.Equal(actual, body) { return fmt.Errorf("requested report changed during verification") } contentType := "text/markdown; charset=utf-8" if detail.OutputFormat == "html" { contentType = "text/html; charset=utf-8" } return r.store.RecordDeliverable(ctx, id, sequence, protocol.StageArtifact{Name: "public/" + name, SizeBytes: info.Size(), ContentType: contentType, URL: artifactURL(id, sequence, "public/"+name)}) }