package opencode import ( "bytes" "context" "encoding/json" "errors" "fmt" "io" "strings" "time" "git.a-wan.net/alan/pipelines/internal/protocol" ) // MaxSessionExport bounds the native session readback used for the stage session // export. A larger session is read as a bounded prefix and reported truncated, // never presented as the whole session. const MaxSessionExport = 8 << 20 var ErrEmptySessionExport = errors.New("session recorded but native export contains no messages") var errTransientExport = errors.New("native session export temporarily unavailable") var errSessionIdentity = errors.New("native export session identity mismatch") // nativeExportResult is one bounded native export readback. envelope is capped // at the caller's limit; truncated explicitly distinguishes a size-limited // prefix from complete JSON. type nativeExportResult struct { envelope []byte truncated bool } // exportNative reads the existing V2 endpoint directly (CLI stdout silently // cuts large exports at 256 KiB), retaining the top-level export CLI for V1. // It never starts a backend, resumes a session, pairs, or mutates stored data. func exportNative(ctx context.Context, executable, directory, backend, id string, limit int, connections ...*Connection) (nativeExportResult, error) { if !sessionID.MatchString(id) { return nativeExportResult{}, fmt.Errorf("invalid session ID") } if backend == "v2" { var c *Connection if len(connections) > 0 { c = connections[0] } else { var err error c, err = sessionExportConnection(directory) if err != nil { return nativeExportResult{}, err } } if c == nil || c.URL == "" || c.Backend != "v2" { return nativeExportResult{}, fmt.Errorf("session export requires the existing V2 endpoint") } body, err := c.HistoryNative(ctx, "/api/experimental/session/"+id+"/export?sanitize=false") if err != nil { if c.LastHTTPStatus == 429 || c.LastHTTPStatus == 503 { err = errors.Join(errTransientExport, err) } return nativeExportResult{}, err } defer body.Close() data, err := io.ReadAll(io.LimitReader(body, int64(limit)+1)) if err != nil { return nativeExportResult{}, fmt.Errorf("session export response interrupted") } if len(data) > limit { return nativeExportResult{envelope: data[:limit], truncated: true}, nil } return nativeExportResult{envelope: data}, nil } args := []string{"export", id} cmd := CommandContext(ctx, executable, args...) cmd.Dir = directory stdout := &boundedOutput{limit: limit} stderr := &boundedOutput{limit: 8 << 10} cmd.Stdout = stdout cmd.Stderr = stderr if err := cmd.Run(); err != nil { // Only known temporary transport/store failures are retried. Do not // expose stderr: it may contain session text or credentials. text := strings.ToLower(string(stderr.Bytes())) for _, temporary := range []string{"temporarily unavailable", "connection refused", "database is locked", "server is busy"} { if strings.Contains(text, temporary) { err = errors.Join(errTransientExport, err) break } } return nativeExportResult{envelope: stdout.Bytes(), truncated: stdout.overflow}, err } return nativeExportResult{envelope: stdout.Bytes(), truncated: stdout.overflow}, nil } // validNativeExport is the exact-ID and messages-array validation // Connection.Messages and ExportSession share: the envelope must parse, carry an // info.id equal to wantID and a JSON messages array. An empty array is valid // readback syntax, not complete evidence; consumers must label it empty. func validNativeExport(data []byte, wantID string) (json.RawMessage, bool) { var envelope struct { Info struct { ID string `json:"id"` } `json:"info"` Messages json.RawMessage `json:"messages"` Data json.RawMessage `json:"data"` } if json.Unmarshal(data, &envelope) != nil { return nil, false } // The HTTP/CLI readback can wrap a payload in data. Only unwrap an // otherwise absent envelope, never use data to override a mismatched ID. if envelope.Info.ID == "" && len(envelope.Messages) == 0 && len(envelope.Data) > 0 { if json.Unmarshal(envelope.Data, &envelope) != nil { return nil, false } } if envelope.Info.ID != wantID || len(envelope.Messages) == 0 { return nil, false } messages := bytes.TrimSpace(envelope.Messages) if len(messages) > 0 && messages[0] == '{' { var wrapped struct { Data json.RawMessage `json:"data"` } if json.Unmarshal(messages, &wrapped) != nil { return nil, false } messages = bytes.TrimSpace(wrapped.Data) } if len(messages) == 0 || messages[0] != '[' { return nil, false } var records []json.RawMessage if json.Unmarshal(messages, &records) != nil { return nil, false } return messages, true } // ExportedPart is one decoded content element of an exported session. Raw keeps // the part's original JSON so an unrecognised type is rendered rather than // silently dropped; State carries a tool call's status, input, result and error. type ExportedPart struct { Type string ID string Text string Name string State *protocol.ChatToolState Time *protocol.ChatTime Raw json.RawMessage } // ExportedMessage is one decoded turn. Every role is kept, not only // user/assistant, so the export is the session the harness stored. type ExportedMessage struct { Raw json.RawMessage ID string Role string Model string Agent string CreatedAt int64 Parts []ExportedPart } // ExportedSession is one bounded native session readback for the stage session // export. Truncated is true when the source exceeded MaxSessionExport; Messages // then covers the complete turns decoded before the cut. type ExportedSession struct { Attempts int ID string Backend string Messages []ExportedMessage Truncated bool } // ExportSession reads the session's native export read-only and decodes it into // ExportedSession. It reuses the shared export invocation and exact-ID check, // decodes the v1/v2 message and part shapes through chatMessageRecords and, when // the source exceeded MaxSessionExport, streams the complete turns decoded from // the bounded prefix and reports Truncated instead of failing. It performs no // writes, no resumption and no idleness wait. Empty readbacks and explicitly // temporary failures get at most three attempts within the caller's deadline; // wrong identity and permanent failures never retry. // An optional existing connection pins V2 readback to the caller's exact // endpoint/auth context. Otherwise only configured endpoint/private local // service state is read; there is no CLI/service-start fallback. func ExportSession(ctx context.Context, executable, directory, backend, id string, connections ...*Connection) (ExportedSession, error) { if !sessionID.MatchString(id) { return ExportedSession{}, fmt.Errorf("invalid session ID") } for attempt := 0; attempt < 3; attempt++ { session, err := exportSessionOnce(ctx, executable, directory, backend, id, connections...) session.Attempts = attempt + 1 if err == nil { return session, nil } if ctx.Err() != nil { return session, ctx.Err() } if attempt == 2 || (!errors.Is(err, ErrEmptySessionExport) && !errors.Is(err, errTransientExport)) { return session, err } // Bounded recovery, not a causal claim about why readback was empty. timer := time.NewTimer(time.Duration(attempt+1) * 200 * time.Millisecond) select { case <-ctx.Done(): timer.Stop() return session, ctx.Err() case <-timer.C: } } panic("unreachable") } func exportSessionOnce(ctx context.Context, executable, directory, backend, id string, connections ...*Connection) (ExportedSession, error) { session := ExportedSession{ID: id, Backend: backend} exported, err := exportNative(ctx, executable, directory, backend, id, MaxSessionExport, connections...) if err != nil { return session, fmt.Errorf("native session export failed: %w", err) } if exported.truncated { records, _, err := decodeExportPrefix(exported.envelope, id) if err != nil { return session, err } session.Messages, session.Truncated = exportedMessages(records), true // Even a cut inside the first turn is partial evidence, never settling. return session, nil } messages, ok := validNativeExport(exported.envelope, id) if !ok { // Incomplete JSON is a possible interrupted read; valid but wrong // identity/schema is permanent and must never be retried as settling. var syntax *json.SyntaxError var envelope struct { Info struct { ID string `json:"id"` } `json:"info"` Data json.RawMessage `json:"data"` } if err := json.Unmarshal(exported.envelope, &envelope); err != nil { identity := exportPrefixIdentity(exported.envelope) if identity != "" && identity != id { return session, errSessionIdentity } if backend != "v2" && len(exported.envelope) != 262144 && identity == id && errors.As(err, &syntax) && strings.Contains(syntax.Error(), "unexpected end") { return session, errTransientExport } return session, fmt.Errorf("native export returned invalid session evidence") } if envelope.Info.ID == "" && len(envelope.Data) > 0 { _ = json.Unmarshal(envelope.Data, &envelope) } if envelope.Info.ID != "" && envelope.Info.ID != id { return session, errSessionIdentity } return session, fmt.Errorf("native export returned unsupported or missing session evidence") } records, err := chatMessageRecords(messages) if err != nil { return session, err } session.Messages = exportedMessages(records) if len(session.Messages) == 0 { return session, ErrEmptySessionExport } return session, nil } // exportPrefixIdentity reads only complete metadata preceding an interrupted // messages array. A known wrong session is permanent even when JSON is cut. func exportPrefixIdentity(data []byte) string { decoder := json.NewDecoder(bytes.NewReader(data)) if token, err := decoder.Token(); err != nil || token != json.Delim('{') { return "" } for decoder.More() { token, err := decoder.Token() if err != nil { return "" } if token == "info" { var info struct { ID string `json:"id"` } if decoder.Decode(&info) == nil { return info.ID } return "" } var skip json.RawMessage if decoder.Decode(&skip) != nil { return "" } } return "" } // exportedMessages maps decoded native turns onto ExportedMessage, preserving // every role and each part's raw JSON for unknown types. func exportedMessages(records []nativeChatMessage) []ExportedMessage { messages := make([]ExportedMessage, 0, len(records)) for _, record := range records { message := ExportedMessage{ Raw: record.Raw, ID: record.messageID(), Role: record.role(), Model: record.modelID(), Agent: record.agent(), CreatedAt: record.createdAt(), } for _, part := range record.contentParts() { message.Parts = append(message.Parts, ExportedPart{ Type: part.Type, ID: part.ID, Text: part.Text, Name: part.Name, State: part.State, Time: part.Time, Raw: part.Raw, }) } // A v2 user turn carries its prompt text as a message-level string rather // than a content array, so surface it as the turn's single text part. if len(message.Parts) == 0 && message.Role == protocol.ChatRoleUser && record.Text != "" { message.Parts = append(message.Parts, ExportedPart{Type: protocol.ChatPartText, Text: record.Text}) } var fields map[string]json.RawMessage _ = json.Unmarshal(record.Raw, &fields) var files []json.RawMessage _ = json.Unmarshal(fields["files"], &files) for _, file := range files { message.Parts = append(message.Parts, ExportedPart{Type: "file", Raw: file}) } // Non-chat events (system, selection, compaction, etc.) must retain // their real payload even when they have no text/content array. if len(message.Parts) == 0 { message.Parts = append(message.Parts, ExportedPart{Type: record.role(), Raw: record.Raw}) } messages = append(messages, message) } return messages } // decodeExportPrefix streams the messages of a bounded export prefix. Complete // turns decoded before the cut are returned with truncated=true; a mismatched // info.id is an error so an unrelated session is never exported. func decodeExportPrefix(data []byte, wantID string) ([]nativeChatMessage, bool, error) { decoder := json.NewDecoder(bytes.NewReader(data)) return decodeExportPrefixObject(decoder, wantID) } func decodeExportPrefixObject(decoder *json.Decoder, wantID string) ([]nativeChatMessage, bool, error) { open, err := decoder.Token() if err != nil { return nil, false, fmt.Errorf("native export returned invalid session evidence") } if delim, ok := open.(json.Delim); !ok || delim != '{' { return nil, false, fmt.Errorf("native export returned invalid session evidence") } var messages []nativeChatMessage sawMessages := false sawIdentity := false partial := func() ([]nativeChatMessage, bool, error) { if !sawIdentity { return nil, false, fmt.Errorf("native export prefix has no verified session identity") } return messages, true, nil } for decoder.More() { keyToken, err := decoder.Token() if err != nil { return partial() } key, _ := keyToken.(string) switch key { case "data": if sawIdentity || sawMessages { return nil, false, fmt.Errorf("ambiguous native export envelope") } return decodeExportPrefixObject(decoder, wantID) case "info": var info struct { ID string `json:"id"` } if err := decoder.Decode(&info); err != nil { return partial() } if info.ID != wantID { return nil, false, fmt.Errorf("native export session id mismatch") } sawIdentity = true case "messages": sawMessages = true open, err := decoder.Token() if err != nil { return partial() } if delim, ok := open.(json.Delim); !ok || delim != '[' { return nil, false, fmt.Errorf("native export returned invalid session evidence") } for decoder.More() { var message nativeChatMessage if err := decoder.Decode(&message); err != nil { return partial() } messages = append(messages, message) } if _, err := decoder.Token(); err != nil { return partial() } default: var skip json.RawMessage if err := decoder.Decode(&skip); err != nil { return partial() } } } if !sawMessages { return nil, false, fmt.Errorf("native export returned no session messages") } if !sawIdentity { return nil, false, fmt.Errorf("native export prefix has no verified session identity") } if _, err := decoder.Token(); err != nil { return partial() } return messages, false, nil }