Files
pipelines/internal/server/chat_export.go
T
alan 1de74f76bb Chat info: Session section with native id, resume command and export
The chat information sheet gains a Session section: the harness's native
session id (copy), harness, directory, a verified resume command (copy)
and Export conversation (Markdown), Export JSON and, for Claude Code,
Export native session (the JSONL transcript).

Server: chat_sessions rows carry resume_command and native_export; new
chat_export command builds Markdown/JSON from the same paged history
chat_messages serves (bounded at 8 MiB), refuses non-operator sessions.
App: exports go through the artifact file bridge (web download, share
sheet on phones).
2026-11-03 10:59:41 +00:00

227 lines
6.8 KiB
Go

package server
import (
"context"
"errors"
"strings"
"time"
"git.a-wan.net/alan/pipelines/internal/claude"
"git.a-wan.net/alan/pipelines/internal/codex"
"git.a-wan.net/alan/pipelines/internal/protocol"
)
// chatExportLimit bounds an exported transcript. Older pages stop being read
// once the newest history already fills it, and the file says so.
const chatExportLimit = 8 << 20
// chatExportPageLimit bounds how many history pages one export reads.
const chatExportPageLimit = 500
// chatNativeExporter is a harness that can hand back its own session file
// cheaply (Claude Code's JSONL transcript).
type chatNativeExporter interface {
NativeExport(ctx context.Context, sessionID string) (protocol.ChatExportFile, error)
}
// NativeExport routes to the session's harness; only harnesses with a cheap
// native file implement it.
func (m *chatManager) NativeExport(ctx context.Context, sessionID string) (protocol.ChatExportFile, error) {
adapter, err := m.brokerFor(ctx, sessionID)
if err != nil {
return protocol.ChatExportFile{}, err
}
exporter, ok := adapter.(chatNativeExporter)
if !ok {
return protocol.ChatExportFile{}, errors.New("this chat's harness has no native session export")
}
return exporter.NativeExport(ctx, sessionID)
}
// chatBackendName is the harness's display name.
func chatBackendName(backend string) string {
switch backend {
case claude.Backend:
return "Claude Code"
case codex.Backend:
return "Codex"
case "", "opencode":
return "OpenCode"
default:
return backend
}
}
// chatResumeCommand is the terminal command that continues a session with the
// harness's own CLI in its directory. Each form was checked against the CLI's
// --help: `claude --resume <id>` (Claude Code 2.1), `codex resume <id>` (Codex
// CLI 0.164) and `opencode --session <id>` (OpenCode 2.0).
func chatResumeCommand(backend, sessionID, directory string) string {
if !validChatSessionID(sessionID) {
return ""
}
var command string
switch backend {
case claude.Backend:
command = "claude --resume " + sessionID
case codex.Backend:
command = "codex resume " + sessionID
case "", "opencode":
command = "opencode --session " + sessionID
default:
return ""
}
if strings.TrimSpace(directory) == "" {
return command
}
return "cd " + shellQuote(directory) + " && " + command
}
// chatNativeExportAvailable says chat_export format=native is offered.
func chatNativeExportAvailable(backend string) bool { return backend == claude.Backend }
// withChatHandoff fills the session's resume command and native export flag.
func withChatHandoff(session protocol.ChatSession) protocol.ChatSession {
session.ResumeCommand = chatResumeCommand(session.Backend, session.ID, session.Directory)
session.NativeExport = chatNativeExportAvailable(session.Backend)
return session
}
// shellQuote leaves a plain path as it is and single-quotes anything else.
func shellQuote(value string) string {
plain := value != ""
for _, r := range value {
if !(r >= 'a' && r <= 'z' || r >= 'A' && r <= 'Z' || r >= '0' && r <= '9' || strings.ContainsRune("/._-+,:@%=", r)) {
plain = false
break
}
}
if plain {
return value
}
return "'" + strings.ReplaceAll(value, "'", `'\''`) + "'"
}
// handleChatExport answers chat_export for one recorded operator session.
func handleChatExport(ctx context.Context, request protocol.Message, broker chatBroker, registry operatorRegistry, write func(protocol.Message) error) {
fail := func(message string) {
_ = write(protocol.Message{Type: protocol.Error, ID: request.ID, Error: message})
}
if broker == nil {
fail("chat is not configured on this server")
return
}
if registry == nil {
fail("operator session registry is not configured on this server")
return
}
body := request.ChatExport
if body == nil || !validChatSessionID(body.SessionID) {
fail("a valid chat session id is required")
return
}
format := strings.TrimSpace(body.Format)
if format == "" {
format = protocol.ChatExportMarkdown
}
switch format {
case protocol.ChatExportMarkdown, protocol.ChatExportJSON, protocol.ChatExportNative:
default:
fail("chat export format must be markdown, json or native")
return
}
row, found, err := registry.OperatorSession(ctx, body.SessionID)
if err != nil {
fail(err.Error())
return
}
if !found {
fail("session " + body.SessionID + " is not an operator chat session")
return
}
session := withChatHandoff(chatSessionFromOperator(row))
var file protocol.ChatExportFile
if format == protocol.ChatExportNative {
if !session.NativeExport {
fail(chatBackendName(session.Backend) + " has no native session export")
return
}
exporter, ok := broker.(chatNativeExporter)
if !ok {
fail("native session export is not available on this server")
return
}
file, err = exporter.NativeExport(ctx, body.SessionID)
if err != nil {
fail(err.Error())
return
}
} else {
messages, truncated, err := chatExportHistory(ctx, broker, body.SessionID)
if err != nil {
fail(err.Error())
return
}
transcript := chatExportTranscript{Session: session, Messages: messages, Truncated: truncated, ExportedAt: time.Now().UTC()}
file, err = transcript.file(format)
if err != nil {
fail(err.Error())
return
}
}
file.SessionID = body.SessionID
file.Format = format
_ = write(protocol.Message{Type: protocol.ChatExport, ID: request.ID, ChatExportFile: &file})
}
// chatExportHistory reads the session's whole history, newest page first as
// chat_messages serves it, and returns it oldest first. It stops reading older
// pages once the bound is reached and reports that older turns were left out.
func chatExportHistory(ctx context.Context, broker chatBroker, sessionID string) ([]protocol.ChatMessage, bool, error) {
var pages [][]protocol.ChatMessage
seen := map[string]bool{}
size := 0
cursor := ""
for page := 0; page < chatExportPageLimit; page++ {
history, err := broker.Messages(ctx, sessionID, 100, cursor)
if err != nil {
return nil, false, err
}
kept := make([]protocol.ChatMessage, 0, len(history.Messages))
for _, message := range history.Messages {
if message.ID != "" && seen[message.ID] {
continue
}
seen[message.ID] = true
kept = append(kept, message)
size += chatMessageSize(message)
}
pages = append(pages, kept)
next := history.NextCursor
if next == "" || next == cursor {
return flattenChatPages(pages), false, nil
}
if size >= chatExportLimit {
return flattenChatPages(pages), true, nil
}
cursor = next
}
return flattenChatPages(pages), true, nil
}
func flattenChatPages(pages [][]protocol.ChatMessage) []protocol.ChatMessage {
out := []protocol.ChatMessage{}
for index := len(pages) - 1; index >= 0; index-- {
out = append(out, pages[index]...)
}
return out
}
func chatMessageSize(message protocol.ChatMessage) int {
size := 0
for _, part := range message.Parts {
size += len(part.Text) + len(part.Name) + 64
}
return size
}