1f75e4797e
Add an opt-in way to broker chat from an operator-supplied OpenCode service instead of the instance the server spawns for itself, and a way to adopt a session that already exists on that endpoint so it appears in chat_sessions and can be continued from the app. - Endpoint selection: the `-opencode-endpoint` server flag (defaulting to `PIPELINES_OPENCODE_ENDPOINT`) opts in; precedence is explicit flag > explicit environment > the endpoint recorded on a previous run, with the spawned instance as the default. opencode.OpenEndpoint validates the reference once (http(s), host, no userinfo/query/fragment/path), detects the backend from its own /api/info (v2) or /global/health (v1) contract, and requires a streamable text/event-stream event path. It owns no process (Close is a no-op) and never calls startServe; every failure names the endpoint and disables chat rather than silently falling back. An authenticated endpoint takes an optional password only through the private file PIPELINES_OPENCODE_ENDPOINT_PASSWORD_FILE, with PIPELINES_OPENCODE_ENDPOINT_USERNAME overriding the detected default. - Persistence: the validated choice is recorded in an additive single-row server_settings table so a restart with no flag/environment reuses it; an unreachable recorded endpoint disables chat with a clear message and no fallback. - chat_adopt: a new protocol request (ChatAdoptRequest) with handleChatAdopt in internal/server/chat.go. It refuses a nil broker/registry/payload and a blank or foreign-shaped id before any endpoint call, reads the endpoint via the shared Chat.Session (which reuses Sessions/decodeChatSessions), records through the existing RecordOperatorSession with the endpoint's directory and title verbatim, and echoes the adopted session plus its registry row like chat_create. A missing id is refused naming the id and records nothing; an endpoint record with an empty directory is refused rather than substituting the server's working directory or home. - CLI: `pipelines chat-adopt <session-id> [--json]` (usage, notes, help inventory, dispatch) with docs/cli.md updated under Chat sessions. - Autostart preserves the endpoint variables (and the password-file reference, never an inline secret) via serviceEnvironmentKeys. Checks before committing: - Package location: the change is user-facing chat behaviour, so the packaged authoring skill reference internal/author/skill/references/operations.md is updated in the same change (Brokered OpenCode chat section) with a dated verification-evidence entry and the not-deployed state. No new reference file is added, so internal/author/install.go's managed inventory is unchanged. - Packaged templates: this repository packages no template set for this behaviour and none references the chat endpoint, so no template needs updating. - Verification: `go build ./...`, `go vet` on the touched packages, `gofmt -l` clean and `go test ./...` all pass. The unit tests cover the endpoint validation/precedence, the adopt happy path and refusals, the recorded endpoint round-trip, the protocol round-trip and the CLI dispatch. The live scratch-server check against the operator's real endpoint was not run in this change. Nothing unrelated is staged; docs left stale (README and other shared documents) are not edited here and are for a single folding writer.
222 lines
9.0 KiB
Go
222 lines
9.0 KiB
Go
package protocol
|
|
|
|
import (
|
|
"encoding/json"
|
|
"reflect"
|
|
"strings"
|
|
"testing"
|
|
)
|
|
|
|
// chatSamples covers every new chat type with a populated value, plus a text and
|
|
// a tool chat_event, so a round-trip loss in any field fails the test.
|
|
func chatSamples() []struct {
|
|
name string
|
|
value any
|
|
} {
|
|
return []struct {
|
|
name string
|
|
value any
|
|
}{
|
|
{"session", ChatSession{
|
|
ID: "ses_1", Title: "demo", Agent: "build", Model: "deepseek-v4.1-flash",
|
|
Directory: "/work", ParentID: "ses_0", Tag: ChatSessionTagOperator, CreatedAt: 1792112366711, UpdatedAt: 1792112367999,
|
|
}},
|
|
{"session_busy", ChatSession{ID: "ses_2", Title: "held", Busy: true}},
|
|
{"create", ChatCreateRequest{Title: "demo", Directory: "/work"}},
|
|
{"adopt", ChatAdoptRequest{SessionID: "ses_1"}},
|
|
{"query", ChatQuery{SessionID: "ses_1", Limit: 50}},
|
|
{"prompt", ChatPromptRequest{SessionID: "ses_1", Text: "hello", Model: "m", Agent: "build", Files: []string{"file:///tmp/a.png"}}},
|
|
{"message", ChatMessage{
|
|
ID: "msg_1", SessionID: "ses_1", Role: ChatRoleAssistant, Model: "m", Agent: "build", CreatedAt: 1792112366711,
|
|
Parts: []ChatPart{
|
|
{Type: ChatPartText, ID: "p1", Text: "done"},
|
|
{Type: ChatPartReasoning, ID: "p2", Text: "thinking"},
|
|
{Type: ChatPartTool, ID: "call_1", Name: "shell", Executed: true,
|
|
State: &ChatToolState{
|
|
Status: ChatToolCompleted,
|
|
Input: json.RawMessage(`{"command":"ls"}`),
|
|
Content: []ChatToolContent{{Type: "text", Text: "app-debug.apk"}, {Type: "file", URI: "file:///tmp/x.png", Mime: "image/png", Name: "x.png"}},
|
|
Metadata: map[string]any{"exit": "0"},
|
|
},
|
|
Time: &ChatTime{Created: 1, Ran: 2, Completed: 3},
|
|
},
|
|
{Type: ChatPartTool, ID: "call_2", Name: "edit",
|
|
State: &ChatToolState{Status: ChatToolError, Input: json.RawMessage(`{}`), Error: &ChatError{Type: "tool", Message: "boom"}},
|
|
},
|
|
},
|
|
}},
|
|
{"event_text", ChatEventFrame{
|
|
SessionID: "ses_1", MessageID: "msg_1", Kind: ChatEventText, Delta: "hel",
|
|
Part: &ChatPart{Type: ChatPartText, ID: "p1"},
|
|
}},
|
|
{"event_tool", ChatEventFrame{
|
|
SessionID: "ses_1", MessageID: "msg_1", Kind: ChatEventTool,
|
|
Part: &ChatPart{Type: ChatPartTool, ID: "call_1", Name: "shell", Executed: true,
|
|
State: &ChatToolState{Status: ChatToolRunning, Input: json.RawMessage(`{"command":"ls"}`)},
|
|
},
|
|
}},
|
|
{"event_step", ChatEventFrame{SessionID: "ses_1", Kind: ChatEventStep, Step: &ChatStep{Status: ChatStepEnded, Index: 2}}},
|
|
{"event_usage", ChatEventFrame{SessionID: "ses_1", Kind: ChatEventUsage, Usage: &ChatUsage{InputTokens: 12, OutputTokens: 34, Cost: 0.001}}},
|
|
{"permission", ChatPermissionFrame{
|
|
SessionID: "ses_1", RequestID: "per_1", Action: "bash",
|
|
Resources: []string{"rm -rf /tmp"}, Save: []string{"bash:rm -rf /tmp"},
|
|
Metadata: map[string]any{"command": "rm -rf /tmp"},
|
|
Source: &ChatPermissionSource{Type: "tool", MessageID: "msg_1", ID: "call_1"},
|
|
Message: "wants to run a command",
|
|
}},
|
|
{"reply", ChatReplyRequest{SessionID: "ses_1", RequestID: "req_1", Decision: ChatDecisionOnce, Message: "ok"}},
|
|
}
|
|
}
|
|
|
|
func TestChatTypesGoldenRoundTrip(t *testing.T) {
|
|
for _, sample := range chatSamples() {
|
|
encoded, err := json.Marshal(sample.value)
|
|
if err != nil {
|
|
t.Fatalf("%s: marshal: %v", sample.name, err)
|
|
}
|
|
target := reflect.New(reflect.TypeOf(sample.value))
|
|
if err := json.Unmarshal(encoded, target.Interface()); err != nil {
|
|
t.Fatalf("%s: unmarshal: %v", sample.name, err)
|
|
}
|
|
decoded := target.Elem().Interface()
|
|
if !reflect.DeepEqual(decoded, sample.value) {
|
|
t.Fatalf("%s: fields lost\n got %+v\nwant %+v", sample.name, decoded, sample.value)
|
|
}
|
|
again, err := json.Marshal(decoded)
|
|
if err != nil {
|
|
t.Fatalf("%s: re-marshal: %v", sample.name, err)
|
|
}
|
|
if string(again) != string(encoded) {
|
|
t.Fatalf("%s: wire shape not stable\n got %s\nwant %s", sample.name, again, encoded)
|
|
}
|
|
}
|
|
}
|
|
|
|
// TestChatEventGoldenJSON pins the exact wire shape of a pushed frame so a JSON
|
|
// tag change cannot silently alter what the phone parses.
|
|
func TestChatEventGoldenJSON(t *testing.T) {
|
|
event := ChatEventFrame{
|
|
SessionID: "ses_1", MessageID: "msg_1", Kind: ChatEventTool,
|
|
Part: &ChatPart{Type: ChatPartTool, ID: "call_1", Name: "shell", Executed: true,
|
|
State: &ChatToolState{
|
|
Status: ChatToolStreaming,
|
|
Input: json.RawMessage(`"{\"command\":\"ls\""`),
|
|
Content: nil,
|
|
},
|
|
Time: &ChatTime{Created: 10, Ran: 11, Completed: 12},
|
|
},
|
|
}
|
|
encoded, err := json.Marshal(event)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
want := `{"session_id":"ses_1","message_id":"msg_1","kind":"tool","part":{"type":"tool","id":"call_1","name":"shell","executed":true,"state":{"status":"streaming","input":"{\"command\":\"ls\""},"time":{"created":10,"ran":11,"completed":12}}}`
|
|
if string(encoded) != want {
|
|
t.Fatalf("golden mismatch\n got %s\nwant %s", encoded, want)
|
|
}
|
|
var decoded ChatEventFrame
|
|
if err := json.Unmarshal([]byte(want), &decoded); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if !reflect.DeepEqual(decoded, event) {
|
|
t.Fatalf("golden did not decode back: %+v", decoded)
|
|
}
|
|
}
|
|
|
|
// TestChatPermissionGoldenJSON pins the exact wire shape of the pushed
|
|
// chat_permission frame so a JSON tag change cannot silently alter what the
|
|
// phone parses.
|
|
func TestChatPermissionGoldenJSON(t *testing.T) {
|
|
frame := ChatPermissionFrame{
|
|
SessionID: "ses_1", RequestID: "per_1", Action: "bash",
|
|
Resources: []string{"rm -rf /tmp"},
|
|
Source: &ChatPermissionSource{Type: "tool", MessageID: "msg_1", ID: "call_1"},
|
|
}
|
|
encoded, err := json.Marshal(frame)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
want := `{"session_id":"ses_1","request_id":"per_1","action":"bash","resources":["rm -rf /tmp"],"source":{"type":"tool","message_id":"msg_1","id":"call_1"}}`
|
|
if string(encoded) != want {
|
|
t.Fatalf("golden mismatch\n got %s\nwant %s", encoded, want)
|
|
}
|
|
var decoded ChatPermissionFrame
|
|
if err := json.Unmarshal([]byte(want), &decoded); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if !reflect.DeepEqual(decoded, frame) {
|
|
t.Fatalf("golden did not decode back: %+v", decoded)
|
|
}
|
|
}
|
|
|
|
func TestChatEnvelopeRoundTrip(t *testing.T) {
|
|
session := ChatSession{ID: "ses_1", Title: "demo"}
|
|
message := Message{
|
|
Type: ChatSessions, ID: "r1",
|
|
ChatSessions: []ChatSession{session},
|
|
ChatSession: &session,
|
|
ChatCreate: &ChatCreateRequest{Title: "new"},
|
|
ChatAdopt: &ChatAdoptRequest{SessionID: "ses_1"},
|
|
ChatQuery: &ChatQuery{SessionID: "ses_1", Limit: 10},
|
|
ChatPrompt: &ChatPromptRequest{SessionID: "ses_1", Text: "hi"},
|
|
ChatMessages: []ChatMessage{{ID: "msg_1", SessionID: "ses_1", Role: ChatRoleUser, Parts: []ChatPart{{Type: ChatPartText, Text: "hi"}}}},
|
|
ChatEvent: &ChatEventFrame{SessionID: "ses_1", Kind: ChatEventText, Delta: "hi"},
|
|
ChatPermission: &ChatPermissionFrame{
|
|
SessionID: "ses_1", RequestID: "per_1", Action: "bash", Resources: []string{"rm -rf /"},
|
|
},
|
|
ChatReply: &ChatReplyRequest{SessionID: "ses_1", RequestID: "req_1", Decision: ChatDecisionReject},
|
|
ChatDirectories: []string{"/home/operator", "/work/project"},
|
|
}
|
|
encoded, err := json.Marshal(message)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
var decoded Message
|
|
if err := json.Unmarshal(encoded, &decoded); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if decoded.Type != ChatSessions || decoded.ID != "r1" {
|
|
t.Fatalf("envelope lost: %+v", decoded)
|
|
}
|
|
if !reflect.DeepEqual(decoded.ChatSessions, message.ChatSessions) ||
|
|
!reflect.DeepEqual(decoded.ChatSession, message.ChatSession) ||
|
|
!reflect.DeepEqual(decoded.ChatCreate, message.ChatCreate) ||
|
|
!reflect.DeepEqual(decoded.ChatAdopt, message.ChatAdopt) ||
|
|
!reflect.DeepEqual(decoded.ChatQuery, message.ChatQuery) ||
|
|
!reflect.DeepEqual(decoded.ChatPrompt, message.ChatPrompt) ||
|
|
!reflect.DeepEqual(decoded.ChatMessages, message.ChatMessages) ||
|
|
!reflect.DeepEqual(decoded.ChatEvent, message.ChatEvent) ||
|
|
!reflect.DeepEqual(decoded.ChatPermission, message.ChatPermission) ||
|
|
!reflect.DeepEqual(decoded.ChatReply, message.ChatReply) ||
|
|
!reflect.DeepEqual(decoded.ChatDirectories, message.ChatDirectories) {
|
|
t.Fatalf("chat payloads lost: %+v", decoded)
|
|
}
|
|
}
|
|
|
|
func TestChatFieldsOmittedWhenUnused(t *testing.T) {
|
|
minimal, err := json.Marshal(Message{Type: List, ID: "r1"})
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
for _, absent := range []string{"chat_sessions", "chat_session", "chat_create", "chat_adopt", "chat_query", "chat_prompt", "chat_messages", "chat_event", "chat_permission", "chat_reply", "chat_directories"} {
|
|
if strings.Contains(string(minimal), absent) {
|
|
t.Fatalf("absent %q must be omitted: %s", absent, minimal)
|
|
}
|
|
}
|
|
}
|
|
|
|
// TestChatOperatorTagVocabulary pins that the stored tag and the display label
|
|
// are one mapping (a wire tag plus a derived label), not a second vocabulary.
|
|
func TestChatOperatorTagVocabulary(t *testing.T) {
|
|
if ChatSessionTagOperator != "operator" || ChatSessionTagOperatorDisplay != "Operator" {
|
|
t.Fatalf("operator tag vocabulary = %q/%q, want operator/Operator", ChatSessionTagOperator, ChatSessionTagOperatorDisplay)
|
|
}
|
|
encoded, err := json.Marshal(ChatSession{ID: "ses_1", Tag: ChatSessionTagOperator})
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if !strings.Contains(string(encoded), `"tag":"operator"`) {
|
|
t.Fatalf("operator tag not on the wire: %s", encoded)
|
|
}
|
|
}
|