diff --git a/docs/cli.md b/docs/cli.md index f5f8bb95..262d168d 100644 --- a/docs/cli.md +++ b/docs/cli.md @@ -291,6 +291,40 @@ aggregates. See `internal/protocol/message.go` for JSON envelopes. Mutating RPCs have real effects; they are not previews. TUI-only animation, scrolling, and transient client logs are presentation, not separate server capabilities. +## Chat sessions + +The brokered OpenCode chat exposes the operator's own sessions, separate from the +sessions pipeline runs create. The protocol types are: + +- `chat_sessions` lists the operator's own sessions only, ordered + most-recently-used first. Each carries its `directory`, its `tag`, its `busy` + state (another connection currently holds it) and its recency. A session with + no recorded tag is never listed, and no pipeline stage session is ever listed: + stage sessions are still recorded in `run_steps`/`run_session_owners` + for the run that owns them. The list is fail-closed: with no registry and no + store it returns an empty list, never the endpoint's whole session list. +- `chat_create` takes a `title` (default "New chat") and a `directory` + (default `~`, the operator's home; `~`, an omitted or empty value and a `~/...` + value all resolve to the home directory). A relative or missing directory is + rejected before any OpenCode call. The created session is recorded with the + stored tag `operator` and returned as the response's `chat_session`. +- `chat_directories` returns the operator's home first, then the directories of + previous operator sessions most-recently-used first, deduplicated and bounded + (currently 8). It is a dedicated request so the create dialog can load the + choices without first listing sessions; `chat_sessions` stays a pure session + list. + +The stored tag is exactly `operator`; the display label `Operator` is derived from +it, so there is no second tag vocabulary. Chat uses the server's one OpenCode +transport, and every existing chat guarantee (retained-state bounds, the +permission/approval flow, interruption, one broker call per list) is unchanged. + +The operator-session registry, filter, directory defaulting and the list bound are +covered by the `pipeline`, `opencode` and `server` unit tests. The live end-to-end +check is opt-in (`PIPELINES_TEST_OPENCODE_CHAT_LIVE=1`); it runs against a scratch +store and never touches the deployed server. Android rendering of the tag is out +of scope for the server change; the wire carries `tag: "operator"`. + ## Scripted runs Every run records a short, single-line `title` saying what it was for. `pipelines diff --git a/internal/author/skill/references/operations.md b/internal/author/skill/references/operations.md index ee9b2747..6c5561c1 100644 --- a/internal/author/skill/references/operations.md +++ b/internal/author/skill/references/operations.md @@ -227,11 +227,9 @@ traversal, absolute paths, symlink escapes and unknown runs/steps. ## Brokered OpenCode chat The protocol declares the brokered `chat_*` surface (`chat_sessions`, -`chat_create`, `chat_prompt`, `chat_messages`, `chat_interrupt`, `chat_permission`, -`chat_reply`). The server dispatches `chat_sessions`, `chat_prompt`, -`chat_messages`, `chat_interrupt` and `chat_reply`, answers the declared -`chat_create` with an explicit protocol error because it is not yet brokered, and -pushes `chat_event` frames derived from OpenCode's global SSE firehose +`chat_create`, `chat_directories`, `chat_prompt`, `chat_messages`, +`chat_interrupt`, `chat_permission`, `chat_reply`). The server dispatches all of +them, and pushes `chat_event` frames derived from OpenCode's global SSE firehose (`/event` on the native serve, `/api/event` on the V2 API), with retained per-session/per-message state so a reconnecting client re-syncs instead of replaying deltas. @@ -248,16 +246,39 @@ events it does not surface before decoding their data, so an unrelated event whose `delta` has a different shape (`session.instructions.updated` carries an object) never fails the stream. -`chat_sessions` is brokered but restricted: OpenCode's `GET /api/session` lists -every session on the machine, so the server filters it to the sessions recorded -in `run_steps` as owned by this server (deduped by session id), fills any missing -directory from the owning run's workspace, and fails closed to an empty list when -no ownership source is configured rather than exposing the operator's whole -environment. A session another client currently holds (an in-server claim, -released when the stream ends or the client disconnects) or that this server -records as an active run is marked `busy` so the phone can show it read-only; a -second client's `chat_prompt` for a held session is rejected before any OpenCode -call. `chat_create` remains unbrokered. +`chat_sessions` lists the operator's own chat sessions, not the sessions pipeline +runs create. Operator sessions are recorded in the dedicated `operator_sessions` +table (`session_id` primary key, plus `directory`, `title`, `tag`, `created_at`, +`last_used_at`), separate from `run_steps`/`run_session_owners`, so an operator +chat is a first-class thing and a pipeline stage session — recorded as run +ownership, never in the operator registry — is never listed. The handler reads the +registry once (bounded to 128 rows, most-recently-used first), calls OpenCode's +session list once, and keeps only registry rows the endpoint still reports, so a +session with no recorded tag is never listed and a deleted upstream session does +not linger. It fills each session's `directory`, `tag` and `created_at`/ +`updated_at` from the registry and marks `busy` when another client currently +holds the session (an in-server claim, released when the stream ends or the client +disconnects); a second client's `chat_prompt` for a held session is rejected +before any OpenCode call. It is fail-closed: with no registry configured it +returns an empty list, never the endpoint's whole session list. The OpenCode +session list is read unscoped by directory (the V2 `GET /api/session` otherwise +defaults to the caller's directory), because an operator session may live in any +directory. + +`chat_create` creates one operator session and records it in the same registry +with the stored tag `operator` (the display label `Operator` is derived from it, +so there is no second tag vocabulary). It takes a `title` (default "New chat") and +a `directory` (default `~`): an omitted or empty value, `~`, and any `~/...` value +all resolve to `os.UserHomeDir`, never the server's working directory; a relative +path or a missing directory is rejected before any OpenCode call, and a session +created but not recordable is reported as an error naming its id. Create posts the +verified V2 shape `POST /api/session` `{"title":...,"location":{"directory":...}}`. +`chat_directories` returns the operator's home first, then the directories of +previous operator sessions most-recently-used first, deduplicated and bounded (8); +it is a dedicated request so the create dialog can load the choices without first +listing sessions and `chat_sessions` stays a pure, fail-closed session list. A +successful `chat_prompt` touches the session's `last_used_at` in one UPDATE, so it +moves to the front of the list; a non-operator session id touches no row. While a `chat_prompt` subscription is open the server also polls `GET /api/permission/request` on a fixed small interval (first poll immediately) and @@ -288,10 +309,15 @@ Verified against the installed OpenCode 2.0.20 on 2026-10-17: plus `session.step.*` and `session.usage.updated`; the V2 API server authenticates the fixed `opencode` basic-auth user. - The opt-in live end-to-end test (`PIPELINES_TEST_OPENCODE_CHAT_LIVE=1 go test - ./internal/server/... -run TestChatLiveEndToEnd`) opened an owned V2 endpoint, - listed the owned scratch session, streamed a completed turn as - `[step:started,text,step:streamed,step:ended]` (first delta `"pong"`), and - interrupted a running turn so the session left the V2 active set. + ./internal/server -run TestChatLiveEndToEnd -v`) opened an owned V2 endpoint, + created an operator session through `chat_create` in a chosen directory, listed + exactly that session through `chat_sessions` (with its directory and tag + `operator`), recorded a genuine pipeline stage session in + `run_steps`/`run_session_owners` and showed it never appeared in the list, and + streamed a completed turn as `[step:started,text,step:streamed,step:ended]` + (first delta `"pong"`). The operator-session registry, the filter, directory + defaulting and the recents bound are also covered by the `pipeline`, `opencode` + and `server` unit tests, which run without the live gate. - Not verified live: a genuine pending-approval round trip and any backend other than the installed 2.0.20. The permission wire shapes are unit-tested over an httptest fixture, not against a live pending request. diff --git a/internal/opencode/chat.go b/internal/opencode/chat.go index 6f985f00..f71a9dfe 100644 --- a/internal/opencode/chat.go +++ b/internal/opencode/chat.go @@ -115,20 +115,45 @@ func (c *Chat) Messages(ctx context.Context, id string, limit int) ([]protocol.C // Sessions lists the OpenCode sessions on the endpoint. On the V2 HTTP API that // is GET /api/session; the native v1 serve translation maps it to GET /session. -// It decodes the verified {"data":[...]} envelope (tolerating a bare array like -// chatMessageRecords), lifts the nested location.directory and -// time{created,updated} into protocol.ChatSession, drops records without a valid -// session id, and orders newest-updated first so the list is deterministic. The -// service's list is global; the caller is responsible for restricting it to the -// sessions this server owns. +// It reads the list unscoped by the connection's directory (see +// Connection.SessionList): the V2 list is otherwise restricted to the +// connection's own directory, while an operator session may live in any +// directory, and the caller is responsible for restricting the result to the +// operator's recorded sessions. It decodes the verified {"data":[...]} envelope +// (tolerating a bare array like chatMessageRecords), lifts the nested +// location.directory and time{created,updated} into protocol.ChatSession, drops +// records without a valid session id, and orders newest-updated first so the list +// is deterministic. func (c *Chat) Sessions(ctx context.Context) ([]protocol.ChatSession, error) { - data, err := c.call(ctx, "get", "/api/session", nil) + c.mu.Lock() + data, err := c.conn.SessionList(ctx) + c.mu.Unlock() if err != nil { return nil, err } return decodeChatSessions(data) } +// Create creates one OpenCode session in the given directory, mirroring the +// verified V2 shape POST /api/session {"title":...,"location":{"directory":...}}. +// It deliberately sends no model or permission override here: the endpoint's own +// defaults apply, exactly as the live check creates a session. The created +// session is returned with its directory lifted from location.directory. +func (c *Chat) Create(ctx context.Context, title, directory string) (protocol.ChatSession, error) { + body := struct { + Title string `json:"title"` + Location struct { + Directory string `json:"directory"` + } `json:"location"` + }{Title: title} + body.Location.Directory = directory + data, err := c.call(ctx, "post", "/api/session", body) + if err != nil { + return protocol.ChatSession{}, err + } + return decodeChatSession(data) +} + // Reply posts a permission decision, mirroring the documented endpoint. func (c *Chat) Reply(ctx context.Context, request protocol.ChatReplyRequest) error { if !sessionID.MatchString(request.SessionID) { @@ -629,6 +654,39 @@ func chatSessionRecords(data []byte) ([]nativeChatSession, error) { return records, nil } +// chatSessionRecord reads one created session, accepting the {"data":{...}} +// envelope the V2 API returns and tolerating a bare object. An unrecognised body +// is an error, never an empty session. +func chatSessionRecord(data []byte) (nativeChatSession, error) { + var response struct { + Data *nativeChatSession `json:"data"` + } + if err := json.Unmarshal(data, &response); err == nil && response.Data != nil { + return *response.Data, nil + } + var record nativeChatSession + if err := json.Unmarshal(data, &record); err != nil || record.ID == "" { + return nativeChatSession{}, fmt.Errorf("invalid OpenCode session response") + } + return record, nil +} + +// chatSessionFields lifts the nested location.directory and time{created,updated} +// of one native session record onto protocol.ChatSession. It is the single field +// mapping shared by the list decoder and Create, so the two cannot drift. +func chatSessionFields(record nativeChatSession) protocol.ChatSession { + return protocol.ChatSession{ + ID: record.ID, + Title: record.Title, + Agent: record.Agent, + Model: record.Model.ID, + Directory: record.Location.Directory, + ParentID: record.ParentID, + CreatedAt: record.Time.Created, + UpdatedAt: record.Time.Updated, + } +} + // decodeChatSessions maps the listed sessions onto protocol.ChatSession, dropping // every record whose id is not a valid OpenCode session id (an empty or foreign // id cannot be addressed) and ordering by UpdatedAt then id so the result is @@ -643,16 +701,7 @@ func decodeChatSessions(data []byte) ([]protocol.ChatSession, error) { if !sessionID.MatchString(record.ID) { continue } - sessions = append(sessions, protocol.ChatSession{ - ID: record.ID, - Title: record.Title, - Agent: record.Agent, - Model: record.Model.ID, - Directory: record.Location.Directory, - ParentID: record.ParentID, - CreatedAt: record.Time.Created, - UpdatedAt: record.Time.Updated, - }) + sessions = append(sessions, chatSessionFields(record)) } sort.SliceStable(sessions, func(i, j int) bool { if sessions[i].UpdatedAt != sessions[j].UpdatedAt { @@ -662,3 +711,16 @@ func decodeChatSessions(data []byte) ([]protocol.ChatSession, error) { }) return sessions, nil } + +// decodeChatSession maps one created session, rejecting an empty or foreign id +// (an unaddressable session is an error, never a silent success). +func decodeChatSession(data []byte) (protocol.ChatSession, error) { + record, err := chatSessionRecord(data) + if err != nil { + return protocol.ChatSession{}, err + } + if !sessionID.MatchString(record.ID) { + return protocol.ChatSession{}, fmt.Errorf("invalid OpenCode session response") + } + return chatSessionFields(record), nil +} diff --git a/internal/opencode/chat_test.go b/internal/opencode/chat_test.go index 53181de7..1efaa12d 100644 --- a/internal/opencode/chat_test.go +++ b/internal/opencode/chat_test.go @@ -502,15 +502,21 @@ func TestDecodeChatMessagesSkipsUnknownPartsAndRoles(t *testing.T) { // TestChatSessionsListsAndLiftsShape loads the verified V2 session list // (GET /api/session: {"data":[{id,...,location.directory,time{created,updated}, // parentID}]}) and asserts the adapter reads it exactly once, lifts the nested -// directory/time onto protocol.ChatSession, and orders newest-updated first. +// directory/time onto protocol.ChatSession, orders newest-updated first, and does +// not scope the list to the connection's own directory (so operator sessions in +// other directories are returned for the caller to filter). func TestChatSessionsListsAndLiftsShape(t *testing.T) { var reads atomic.Int32 + var scoped bool srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { if r.Method != http.MethodGet || r.URL.Path != "/api/session" { t.Errorf("unexpected request %s %s", r.Method, r.URL.Path) return } reads.Add(1) + if r.URL.Query().Get("directory") != "" { + scoped = true + } w.Header().Set("Content-Type", "application/json") _, _ = w.Write([]byte(`{"location":{"directory":"/work"},"data":[ {"id":"ses_old","title":"older","agent":"build","model":{"id":"m1"},"parentID":"ses_new","location":{"directory":"/proj"},"time":{"created":10,"updated":20}}, @@ -519,7 +525,7 @@ func TestChatSessionsListsAndLiftsShape(t *testing.T) { })) defer srv.Close() - chat := NewChat(&Connection{Backend: "v2", URL: srv.URL}) + chat := NewChat(&Connection{Backend: "v2", URL: srv.URL, Directory: "/repo"}) ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second) defer cancel() sessions, err := chat.Sessions(ctx) @@ -529,6 +535,9 @@ func TestChatSessionsListsAndLiftsShape(t *testing.T) { if reads.Load() != 1 { t.Fatalf("session endpoint read %d times, want 1", reads.Load()) } + if scoped { + t.Fatal("session list was scoped to the connection directory; it must list every directory") + } if len(sessions) != 2 { t.Fatalf("sessions = %+v, want 2", sessions) } @@ -631,6 +640,65 @@ func TestChatStreamRequiresEndpoint(t *testing.T) { } } +// TestChatCreatePostsSessionEndpoint pins the outbound create call: the adapter +// must POST exactly once to /api/session with the verified V2 body +// {"title":...,"location":{"directory":...}} (no invented mechanism, no model or +// permission override), read exactly that one path, and lift the nested +// location.directory from the {"data":{...}} response. +func TestChatCreatePostsSessionEndpoint(t *testing.T) { + type request struct{ method, path, body string } + var mu sync.Mutex + var requests []request + srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { + data, _ := io.ReadAll(r.Body) + mu.Lock() + requests = append(requests, request{method: r.Method, path: r.URL.Path, body: string(data)}) + mu.Unlock() + w.Header().Set("Content-Type", "application/json") + _, _ = w.Write([]byte(`{"data":{"id":"ses_new","title":"demo","location":{"directory":"/work/proj"},"time":{"created":11,"updated":22}}}`)) + })) + defer srv.Close() + + chat := NewChat(&Connection{Backend: "v2", URL: srv.URL}) + ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second) + defer cancel() + session, err := chat.Create(ctx, "demo", "/work/proj") + if err != nil { + t.Fatalf("create: %v", err) + } + mu.Lock() + got := append([]request(nil), requests...) + mu.Unlock() + if len(got) != 1 { + t.Fatalf("create requests = %d, want 1: %+v", len(got), got) + } + if got[0].method != http.MethodPost || got[0].path != "/api/session" { + t.Fatalf("create request = %+v", got[0]) + } + if got[0].body != `{"title":"demo","location":{"directory":"/work/proj"}}` { + t.Fatalf("create body = %q", got[0].body) + } + if session.ID != "ses_new" || session.Title != "demo" || session.Directory != "/work/proj" || session.CreatedAt != 11 || session.UpdatedAt != 22 { + t.Fatalf("created session = %+v", session) + } +} + +// TestChatCreateRejectsMalformedSession pins that a response without a valid +// session id is an error, not a silent empty success. +func TestChatCreateRejectsMalformedSession(t *testing.T) { + for _, raw := range []string{`{"data":{}}`, `{"data":{"id":""}}`, `{"data":{"id":"msg_not_a_session"}}`, `not json`} { + srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { + w.Header().Set("Content-Type", "application/json") + _, _ = w.Write([]byte(raw)) + })) + chat := NewChat(&Connection{Backend: "v2", URL: srv.URL}) + if _, err := chat.Create(context.Background(), "demo", "/work"); err == nil { + t.Fatalf("response %q must be an error, not empty success", raw) + } + srv.Close() + } +} + func TestNormalizeChatEventWithoutMessageID(t *testing.T) { for _, payload := range []string{ `{"type":"session.text.delta","data":{"sessionID":"ses_1","ordinal":0,"delta":"x"}}`, diff --git a/internal/opencode/connection.go b/internal/opencode/connection.go index 4e7794ad..2b63eae0 100644 --- a/internal/opencode/connection.go +++ b/internal/opencode/connection.go @@ -316,15 +316,24 @@ func (c *Connection) Close() { } func (c *Connection) Native(ctx context.Context, method, path string, body any) ([]byte, error) { + return c.nativeRequest(ctx, method, path, body, c.Directory) +} + +// nativeRequest is the shared Native request path. An empty directory omits the +// ?directory= query parameter; the V2 session list then returns sessions across +// every directory instead of only the connection's own. +func (c *Connection) nativeRequest(ctx context.Context, method, path string, body any, directory string) ([]byte, error) { c.LastHTTPStatus = 0 c.LastHTTPOperation = strings.ToUpper(method) + " " + path u, err := url.Parse(c.URL + path) if err != nil { return nil, err } - query := u.Query() - query.Set("directory", c.Directory) - u.RawQuery = query.Encode() + if directory != "" { + query := u.Query() + query.Set("directory", directory) + u.RawQuery = query.Encode() + } var data []byte if body != nil { data, err = json.Marshal(body) diff --git a/internal/opencode/native.go b/internal/opencode/native.go index 4b195d53..d3646fc4 100644 --- a/internal/opencode/native.go +++ b/internal/opencode/native.go @@ -63,6 +63,23 @@ func messageText(data []byte) (string, error) { return text, nil } +// SessionList reads the endpoint's whole OpenCode session list without the +// connection's directory scope, so the brokered chat handler can filter it to +// the operator's own sessions across every directory. The V2 HTTP API scopes +// GET /api/session to ?directory= when given; omitting it lists every session, +// which is required because an operator session may live in any directory. The +// native serve list is /session. It reuses the same authenticated request path +// (no second transport or endpoint); only the directory query is omitted. +func (c *Connection) SessionList(ctx context.Context) ([]byte, error) { + if c.Backend == "v1" { + return c.nativeRequest(ctx, "get", "/session", nil, "") + } + if c.URL == "" { + return nil, fmt.Errorf("native adapter requires the serve backend") + } + return c.nativeRequest(ctx, "get", "/api/session", nil, "") +} + // Call adapts the pipeline's existing V2 command contract to the native stable API. // Sessions still use the same account/database; only our loopback serve process is owned. // A connection whose backend already speaks the /api HTTP surface forwards the path diff --git a/internal/pipeline/operator_sessions.go b/internal/pipeline/operator_sessions.go new file mode 100644 index 00000000..52d99d39 --- /dev/null +++ b/internal/pipeline/operator_sessions.go @@ -0,0 +1,110 @@ +package pipeline + +import ( + "context" + "time" +) + +// operatorSessionListLimit bounds one OperatorSessions read so a long-lived +// database with unbounded operator-session history cannot make one chat_sessions +// request scan it all. Rows are read most-recently-used first, so the bound only +// ever drops the oldest sessions, never one the operator just used. It mirrors +// the bounded newest-first convention of sessionOwnerScanLimit. +const operatorSessionListLimit = 128 + +// OperatorSession is one recorded operator chat session: a chat the person +// created through chat_create, tagged with its kind and carrying the directory +// it lives in. CreatedAt is when the row was first recorded; UpdatedAt is the +// last-used epoch-millisecond timestamp that drives most-recently-used ordering. +type OperatorSession struct { + ID string + Directory string + Title string + Tag string + CreatedAt int64 + UpdatedAt int64 +} + +// initOperatorSessions creates the operator-session registry. It is a table of +// its own rather than a kind column on run_steps so a pipeline run's session +// ownership (run_session_owners, SessionOwner) is untouched and the two +// vocabularies cannot be confused. session_id is the primary key, so lookups and +// the upsert use the index; operator_sessions_recent serves the recency order. +func (s *Store) initOperatorSessions() error { + _, err := s.db.Exec(`CREATE TABLE IF NOT EXISTS operator_sessions ( +session_id TEXT PRIMARY KEY, directory TEXT NOT NULL, title TEXT NOT NULL DEFAULT '', +tag TEXT NOT NULL DEFAULT '', created_at INTEGER NOT NULL, last_used_at INTEGER NOT NULL); +CREATE INDEX IF NOT EXISTS operator_sessions_recent ON operator_sessions(last_used_at DESC);`) + return err +} + +// RecordOperatorSession upserts one operator chat session in a single statement: +// a new id is inserted with its created_at and last_used_at set to now, and a +// repeated id updates directory/title/tag and moves last_used_at to now while +// preserving the original created_at. CreatedAt is therefore stable across +// re-records. +func (s *Store) RecordOperatorSession(ctx context.Context, sessionID, directory, title, tag string) error { + now := time.Now().UnixMilli() + _, err := s.db.ExecContext(ctx, `INSERT INTO operator_sessions(session_id,directory,title,tag,created_at,last_used_at) +VALUES(?,?,?,?,?,?) +ON CONFLICT(session_id) DO UPDATE SET directory=excluded.directory,title=excluded.title,tag=excluded.tag,last_used_at=excluded.last_used_at`, + sessionID, directory, title, tag, now, now) + return err +} + +// TouchOperatorSession records that an operator session was just used, in one +// UPDATE. A session id that is not an operator session updates no row and is not +// an error: the statement is itself the presence check, so no second read is +// needed. +func (s *Store) TouchOperatorSession(ctx context.Context, sessionID string) error { + _, err := s.db.ExecContext(ctx, "UPDATE operator_sessions SET last_used_at=? WHERE session_id=?", time.Now().UnixMilli(), sessionID) + return err +} + +// OperatorSessions reports the operator's chat sessions, most-recently-used +// first (ties broken by session id for a deterministic order), capped at +// operatorSessionListLimit. Rows with no tag are omitted: a session with no +// recorded tag is not an operator session and must never be listed. It is one +// bounded statement; recency is never mutated here. +func (s *Store) OperatorSessions(ctx context.Context) ([]OperatorSession, error) { + rows, err := s.db.QueryContext(ctx, `SELECT session_id,directory,title,tag,created_at,last_used_at +FROM operator_sessions WHERE tag <> '' ORDER BY last_used_at DESC, session_id LIMIT ?`, operatorSessionListLimit) + if err != nil { + return nil, err + } + defer rows.Close() + sessions := []OperatorSession{} + for rows.Next() { + var session OperatorSession + if err := rows.Scan(&session.ID, &session.Directory, &session.Title, &session.Tag, &session.CreatedAt, &session.UpdatedAt); err != nil { + return nil, err + } + sessions = append(sessions, session) + } + return sessions, rows.Err() +} + +// OperatorDirectories reports the distinct directories of the operator's +// sessions, most-recently-used first, deduplicated in SQL and capped at limit. +// It is one bounded statement, newest use per directory wins the ordering, and +// it never mutates recency. A non-positive limit returns no directories. +func (s *Store) OperatorDirectories(ctx context.Context, limit int) ([]string, error) { + if limit <= 0 { + return nil, nil + } + rows, err := s.db.QueryContext(ctx, `SELECT directory FROM operator_sessions WHERE tag <> '' +GROUP BY directory ORDER BY MAX(last_used_at) DESC, directory LIMIT ?`, limit) + if err != nil { + return nil, err + } + defer rows.Close() + directories := []string{} + for rows.Next() { + var directory string + if err := rows.Scan(&directory); err != nil { + return nil, err + } + directories = append(directories, directory) + } + return directories, rows.Err() +} diff --git a/internal/pipeline/operator_sessions_test.go b/internal/pipeline/operator_sessions_test.go new file mode 100644 index 00000000..5f289539 --- /dev/null +++ b/internal/pipeline/operator_sessions_test.go @@ -0,0 +1,193 @@ +package pipeline + +import ( + "context" + "path/filepath" + "testing" + "time" +) + +// TestOperatorSessionsRecordListAndUpsert proves the operator-session registry +// contract: rows persist the id, directory, title and tag; the list is +// most-recently-used first; and a second RecordOperatorSession for the same id +// updates directory/title/tag/last_used_at while preserving the original +// created_at. +func TestOperatorSessionsRecordListAndUpsert(t *testing.T) { + ctx := context.Background() + store, err := Open(filepath.Join(t.TempDir(), "operator.db")) + if err != nil { + t.Fatal(err) + } + defer store.Close() + + if err := store.RecordOperatorSession(ctx, "ses_a", "/work/a", "A", "operator"); err != nil { + t.Fatal(err) + } + time.Sleep(3 * time.Millisecond) + if err := store.RecordOperatorSession(ctx, "ses_b", "/work/b", "B", "operator"); err != nil { + t.Fatal(err) + } + sessions, err := store.OperatorSessions(ctx) + if err != nil { + t.Fatal(err) + } + if len(sessions) != 2 { + t.Fatalf("sessions = %+v, want 2", sessions) + } + // Most-recently-used first: ses_b was recorded after ses_a. + if sessions[0].ID != "ses_b" || sessions[1].ID != "ses_a" { + t.Fatalf("not ordered most-recently-used first: %+v", sessions) + } + if sessions[1].Directory != "/work/a" || sessions[1].Title != "A" || sessions[1].Tag != "operator" || sessions[1].CreatedAt == 0 || sessions[1].UpdatedAt == 0 { + t.Fatalf("recorded row missing fields: %+v", sessions[1]) + } + originalCreated := sessions[1].CreatedAt + + time.Sleep(3 * time.Millisecond) + if err := store.RecordOperatorSession(ctx, "ses_a", "/work/a2", "A2", "operator"); err != nil { + t.Fatal(err) + } + sessions, err = store.OperatorSessions(ctx) + if err != nil { + t.Fatal(err) + } + if sessions[0].ID != "ses_a" { + t.Fatalf("upsert did not move the session to the front: %+v", sessions) + } + updated := sessions[0] + if updated.Directory != "/work/a2" || updated.Title != "A2" || updated.Tag != "operator" { + t.Fatalf("upsert did not update directory/title/tag: %+v", updated) + } + if updated.CreatedAt != originalCreated { + t.Fatalf("upsert changed created_at: got %d want %d", updated.CreatedAt, originalCreated) + } + if updated.UpdatedAt <= originalCreated { + t.Fatalf("upsert did not move last_used_at: %+v", updated) + } +} + +// TestOperatorSessionsIgnoresUntagged proves an untagged row is not an operator +// session: it is never listed and never contributes a directory choice. +func TestOperatorSessionsIgnoresUntagged(t *testing.T) { + ctx := context.Background() + store, err := Open(filepath.Join(t.TempDir(), "untagged.db")) + if err != nil { + t.Fatal(err) + } + defer store.Close() + if err := store.RecordOperatorSession(ctx, "ses_untagged", "/work/untagged", "no tag", ""); err != nil { + t.Fatal(err) + } + sessions, err := store.OperatorSessions(ctx) + if err != nil { + t.Fatal(err) + } + if len(sessions) != 0 { + t.Fatalf("untagged session was listed: %+v", sessions) + } + directories, err := store.OperatorDirectories(ctx, 8) + if err != nil { + t.Fatal(err) + } + if len(directories) != 0 { + t.Fatalf("untagged session contributed a directory: %+v", directories) + } +} + +// TestOperatorDirectoriesDedupeBoundAndOrder proves OperatorDirectories returns +// distinct directories most-recently-used first, deduplicated and bounded: more +// directories are seeded than the requested limit. +func TestOperatorDirectoriesDedupeBoundAndOrder(t *testing.T) { + ctx := context.Background() + store, err := Open(filepath.Join(t.TempDir(), "directories.db")) + if err != nil { + t.Fatal(err) + } + defer store.Close() + + record := func(id, directory string) { + t.Helper() + if err := store.RecordOperatorSession(ctx, id, directory, id, "operator"); err != nil { + t.Fatal(err) + } + } + record("ses_1", "/work/one") + record("ses_2", "/work/one") // duplicate directory for a newer session + record("ses_3", "/work/two") + record("ses_4", "/work/three") + record("ses_5", "/work/four") + // Set the recency explicitly so the ordering assertion is deterministic. + set := func(id string, at int64) { + t.Helper() + if _, err := store.db.ExecContext(ctx, "UPDATE operator_sessions SET last_used_at=? WHERE session_id=?", at, id); err != nil { + t.Fatal(err) + } + } + set("ses_1", 10) + set("ses_2", 50) // the duplicate dir's newest use wins the ordering + set("ses_3", 40) + set("ses_4", 30) + set("ses_5", 20) + + directories, err := store.OperatorDirectories(ctx, 2) + if err != nil { + t.Fatal(err) + } + if len(directories) != 2 { + t.Fatalf("directories = %+v, want the requested bound of 2", directories) + } + if directories[0] != "/work/one" || directories[1] != "/work/two" { + t.Fatalf("directories = %+v, want the two most recently used distinct dirs", directories) + } + all, err := store.OperatorDirectories(ctx, 8) + if err != nil { + t.Fatal(err) + } + if len(all) != 4 { + t.Fatalf("directories = %+v, want 4 deduplicated", all) + } + if all[0] != "/work/one" || all[1] != "/work/two" || all[2] != "/work/three" || all[3] != "/work/four" { + t.Fatalf("directories not MRU-ordered: %+v", all) + } +} + +// TestOperatorSessionsSurviveRestart proves a recorded operator session is read +// back after Close and re-Open of the same SQLite path, with its +// directory/tag/recency intact and no re-registration. +func TestOperatorSessionsSurviveRestart(t *testing.T) { + ctx := context.Background() + path := filepath.Join(t.TempDir(), "restart.db") + store, err := Open(path) + if err != nil { + t.Fatal(err) + } + if err := store.RecordOperatorSession(ctx, "ses_restart", "/work/restart", "Restart", "operator"); err != nil { + t.Fatal(err) + } + before, err := store.OperatorSessions(ctx) + if err != nil { + t.Fatal(err) + } + if err := store.Close(); err != nil { + t.Fatal(err) + } + + store, err = Open(path) + if err != nil { + t.Fatal(err) + } + defer store.Close() + after, err := store.OperatorSessions(ctx) + if err != nil { + t.Fatal(err) + } + if len(after) != 1 || len(before) != 1 { + t.Fatalf("sessions before/after restart = %+v / %+v", before, after) + } + if after[0] != before[0] { + t.Fatalf("session changed across restart:\n got %+v\nwant %+v", after[0], before[0]) + } + if after[0].Directory != "/work/restart" || after[0].Tag != "operator" || after[0].UpdatedAt == 0 { + t.Fatalf("restarted row missing fields: %+v", after[0]) + } +} diff --git a/internal/pipeline/store.go b/internal/pipeline/store.go index ea69fb39..0e309d68 100644 --- a/internal/pipeline/store.go +++ b/internal/pipeline/store.go @@ -46,6 +46,10 @@ CREATE TABLE IF NOT EXISTS submissions (id INTEGER PRIMARY KEY, name TEXT NOT NU db.Close() return nil, err } + if err := s.initOperatorSessions(); err != nil { + db.Close() + return nil, err + } return s, nil } diff --git a/internal/protocol/chat.go b/internal/protocol/chat.go index 33ce57e0..cc7a6611 100644 --- a/internal/protocol/chat.go +++ b/internal/protocol/chat.go @@ -22,6 +22,13 @@ const ( ChatMessages = "chat_messages" ChatInterrupt = "chat_interrupt" ChatReply = "chat_reply" + // ChatDirectories is the request/response type for the operator's directory + // choices: the home directory plus the directories of previous operator + // sessions, most recently used first, deduplicated and bounded. It is a + // dedicated request (not a field on chat_sessions) so the create dialog can + // load the choices without first listing sessions and chat_sessions stays a + // pure, fail-closed operator-session list. + ChatDirectories = "chat_directories" // ChatEvent and ChatPermission are the server-pushed frames; they are the // only types the server sends without a matching request. ChatEvent = "chat_event" @@ -69,6 +76,15 @@ const ( ChatDecisionReject = "reject" ) +// ChatSession.Tag values. The stored tag vocabulary is exactly +// ChatSessionTagOperator; the display label the app shows is +// ChatSessionTagOperatorDisplay, derived from the wire tag rather than carried +// as a second field so there is no duplicate mapping to drift. +const ( + ChatSessionTagOperator = "operator" + ChatSessionTagOperatorDisplay = "Operator" +) + // ChatMessage.Role values. const ( ChatRoleUser = "user" @@ -85,6 +101,10 @@ type ChatSession struct { Model string `json:"model,omitempty"` Directory string `json:"directory,omitempty"` ParentID string `json:"parent_id,omitempty"` + // Tag marks the session kind. The only stored value is "operator" (a chat + // the person created); pipeline stage sessions are never tagged and are never + // listed by chat_sessions. Additive/omitempty so older peers ignore it. + Tag string `json:"tag,omitempty"` CreatedAt int64 `json:"created_at,omitempty"` UpdatedAt int64 `json:"updated_at,omitempty"` // Busy marks a session another client currently holds (or one the server diff --git a/internal/protocol/chat_test.go b/internal/protocol/chat_test.go index 046a9ced..38f376cb 100644 --- a/internal/protocol/chat_test.go +++ b/internal/protocol/chat_test.go @@ -19,7 +19,7 @@ func chatSamples() []struct { }{ {"session", ChatSession{ ID: "ses_1", Title: "demo", Agent: "build", Model: "deepseek-v4.1-flash", - Directory: "/work", ParentID: "ses_0", CreatedAt: 1792112366711, UpdatedAt: 1792112367999, + 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"}}, @@ -162,7 +162,8 @@ func TestChatEnvelopeRoundTrip(t *testing.T) { ChatPermission: &ChatPermissionFrame{ SessionID: "ses_1", RequestID: "per_1", Action: "bash", Resources: []string{"rm -rf /"}, }, - ChatReply: &ChatReplyRequest{SessionID: "ses_1", RequestID: "req_1", Decision: ChatDecisionReject}, + ChatReply: &ChatReplyRequest{SessionID: "ses_1", RequestID: "req_1", Decision: ChatDecisionReject}, + ChatDirectories: []string{"/home/operator", "/work/project"}, } encoded, err := json.Marshal(message) if err != nil { @@ -183,7 +184,8 @@ func TestChatEnvelopeRoundTrip(t *testing.T) { !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.ChatReply, message.ChatReply) || + !reflect.DeepEqual(decoded.ChatDirectories, message.ChatDirectories) { t.Fatalf("chat payloads lost: %+v", decoded) } } @@ -193,9 +195,24 @@ func TestChatFieldsOmittedWhenUnused(t *testing.T) { if err != nil { t.Fatal(err) } - for _, absent := range []string{"chat_sessions", "chat_session", "chat_create", "chat_query", "chat_prompt", "chat_messages", "chat_event", "chat_permission", "chat_reply"} { + for _, absent := range []string{"chat_sessions", "chat_session", "chat_create", "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) + } +} diff --git a/internal/protocol/message.go b/internal/protocol/message.go index 4bca8408..2f177a0f 100644 --- a/internal/protocol/message.go +++ b/internal/protocol/message.go @@ -165,6 +165,11 @@ type Message struct { ChatEvent *ChatEventFrame `json:"chat_event,omitempty"` ChatPermission *ChatPermissionFrame `json:"chat_permission,omitempty"` ChatReply *ChatReplyRequest `json:"chat_reply,omitempty"` + // ChatDirectories carries the operator's directory choices on a + // chat_directories response (home first, then recent operator-session + // directories, deduplicated and bounded). Additive/omitempty so older peers + // ignore it. + ChatDirectories []string `json:"chat_directories,omitempty"` // RunEvent is the server-pushed run state delta (see runevents.go) and // RunIDs the optional subscribe scope, so a client asks for the runs it // displays. Both are optional so older peers ignore them. diff --git a/internal/server/chat.go b/internal/server/chat.go index fe53020c..dd67fd53 100644 --- a/internal/server/chat.go +++ b/internal/server/chat.go @@ -6,6 +6,8 @@ import ( "encoding/hex" "errors" "log" + "os" + "path/filepath" "strings" "sync" "time" @@ -27,14 +29,27 @@ type chatBroker interface { Interrupt(ctx context.Context, sessionID string) error Messages(ctx context.Context, sessionID string, limit int) ([]protocol.ChatMessage, error) // Sessions lists the endpoint's OpenCode sessions so the handler can - // restrict them to the ones this server owns. + // restrict them to the operator's own recorded sessions. Sessions(ctx context.Context) ([]protocol.ChatSession, error) + // Create creates one OpenCode session in the given directory and returns it. + Create(ctx context.Context, title, directory string) (protocol.ChatSession, error) // Permissions lists the session's pending OpenCode approval requests so the // handler can push chat_permission frames. Permissions(ctx context.Context, sessionID string) ([]protocol.ChatPermissionFrame, error) Reply(ctx context.Context, request protocol.ChatReplyRequest) error } +// operatorRegistry is the server-side operator-session seam. *pipeline.Store +// satisfies it. It is a table of its own, separate from the pipeline stage +// ownership (SessionOwner/run_session_owners) that settles a run: chat_sessions +// lists operator sessions only and never consults stage ownership. +type operatorRegistry interface { + RecordOperatorSession(ctx context.Context, sessionID, directory, title, tag string) error + TouchOperatorSession(ctx context.Context, sessionID string) error + OperatorSessions(ctx context.Context) ([]pipeline.OperatorSession, error) + OperatorDirectories(ctx context.Context, limit int) ([]string, error) +} + // chatPermissionPollInterval is the fixed interval between permission polls: one // GET per poll through the shared Connection bounds, never a busy loop. The first // poll runs immediately so a request pending when the prompt is sent is surfaced @@ -55,6 +70,12 @@ const chatRetainedLimit = opencode.MaxResponse // least-recently-updated turn is evicted once the cap is exceeded. const chatMaxTurns = 128 +// operatorDirectoryLimit bounds the chat_directories choices: the operator home +// plus recent operator-session directories, capped at this small fixed number so +// a long history is never returned. It matches the posture of the other small +// fixed list bounds. +const operatorDirectoryLimit = 8 + // chatClientToken returns an unguessable per-connection identity. It attributes // a session claim so two clients on the same server cannot silently write the // same conversation; a fresh token per connection means a reconnected client is @@ -433,10 +454,10 @@ func (h *chatHub) forgetPermission(sessionID, requestID string) { // the generic response). Frames are pushed after the ack, each through the // connection-scoped write function so the read loop and the stream goroutine // never interleave partial websocket writes. -func handleChat(ctx context.Context, request protocol.Message, broker chatBroker, hub *chatHub, owners func(context.Context) ([]pipeline.SessionOwner, error), clientID string, write func(protocol.Message) error) bool { +func handleChat(ctx context.Context, request protocol.Message, broker chatBroker, hub *chatHub, registry operatorRegistry, clientID string, write func(protocol.Message) error) bool { switch request.Type { case protocol.ChatPrompt: - handleChatPrompt(ctx, request, broker, hub, clientID, write) + handleChatPrompt(ctx, request, broker, hub, registry, clientID, write) return true case protocol.ChatMessages: handleChatMessages(ctx, request, broker, hub, write) @@ -448,90 +469,202 @@ func handleChat(ctx context.Context, request protocol.Message, broker chatBroker handleChatSimple(ctx, request, broker, hub, write) return true case protocol.ChatSessions: - handleChatSessions(ctx, request, broker, hub, owners, clientID, write) + handleChatSessions(ctx, request, broker, hub, registry, clientID, write) return true case protocol.ChatCreate: - // chat_create remains declared for the client but is not implemented yet. - // Answer explicitly so the client never mistakes the generic Pong for a - // chat reply, and the boundary stays visible instead of silently - // dropping. - _ = write(protocol.Message{Type: protocol.Error, ID: request.ID, Error: "creating a chat is not implemented yet"}) + handleChatCreate(ctx, request, broker, registry, write) + return true + case protocol.ChatDirectories: + handleChatDirectories(ctx, request, registry, write) return true } return false } -// handleChatSessions answers chat_sessions with the OpenCode sessions this -// server owns, marking any another client currently holds (or an active run) as -// Busy. FAIL-CLOSED: when no ownership source is configured the result is empty, -// never the whole endpoint list. broker.Sessions is called at most once per -// request. -func handleChatSessions(ctx context.Context, request protocol.Message, broker chatBroker, hub *chatHub, owners func(context.Context) ([]pipeline.SessionOwner, error), clientID string, write func(protocol.Message) error) { +// handleChatSessions answers chat_sessions with the operator's own sessions, +// marking any another client currently holds as Busy. The registry is the single +// source of truth for which sessions are listed and for their directory, tag, +// created/recency, so a pipeline stage session (recorded in run_steps, never in +// the operator registry) is always excluded and a session with no recorded tag +// is never listed. FAIL-CLOSED: when no registry is configured the result is +// empty, never the whole endpoint list. broker.Sessions is called at most once +// per request, and the registry once. +func handleChatSessions(ctx context.Context, request protocol.Message, broker chatBroker, hub *chatHub, registry operatorRegistry, clientID string, write func(protocol.Message) error) { if broker == nil { _ = write(protocol.Message{Type: protocol.Error, ID: request.ID, Error: "chat is not configured on this server"}) return } - owned, err := ownedSessionSet(ctx, owners) + response := protocol.Message{Type: protocol.ChatSessions, ID: request.ID} + // No registry (no store and no injection): list nothing rather than the whole + // OpenCode machine. + if registry == nil { + _ = write(response) + return + } + operatorSessions, err := registry.OperatorSessions(ctx) if err != nil { _ = write(protocol.Message{Type: protocol.Error, ID: request.ID, Error: err.Error()}) return } + // OperatorSessions is already most-recently-used first with a deterministic + // tie-break; keep that order and only include a registry session the broker + // still reports, so a session the operator deleted upstream is not listed. + registered := make(map[string]struct{}, len(operatorSessions)) + for _, session := range operatorSessions { + if session.ID != "" { + registered[session.ID] = struct{}{} + } + } sessions, err := broker.Sessions(ctx) if err != nil { _ = write(protocol.Message{Type: protocol.Error, ID: request.ID, Error: err.Error()}) return } - response := protocol.Message{Type: protocol.ChatSessions, ID: request.ID} + present := make(map[string]protocol.ChatSession, len(sessions)) for _, session := range sessions { - owner, ok := owned[session.ID] + if _, ok := registered[session.ID]; ok { + present[session.ID] = session + } + } + for _, operator := range operatorSessions { + session, ok := present[operator.ID] if !ok { continue } - if session.Directory == "" { - session.Directory = owner.Directory - } - if owner.Active || hub.busyForOther(session.ID, clientID) { - session.Busy = true + if operator.Title != "" { + session.Title = operator.Title } + session.Directory = operator.Directory + session.Tag = operator.Tag + session.CreatedAt = operator.CreatedAt + session.UpdatedAt = operator.UpdatedAt + session.Busy = hub.busyForOther(operator.ID, clientID) response.ChatSessions = append(response.ChatSessions, session) } _ = write(response) } -// ownedSessionSet reads the ownership source once and returns a set keyed by -// session id, deduped in favour of an active owner and a non-empty directory. -// A nil source (no store and no injection) yields an empty set: chat_sessions -// then lists nothing rather than the whole OpenCode machine. -func ownedSessionSet(ctx context.Context, owners func(context.Context) ([]pipeline.SessionOwner, error)) (map[string]pipeline.SessionOwner, error) { - set := map[string]pipeline.SessionOwner{} - if owners == nil { - return set, nil +// handleChatCreate creates one operator session in a resolved directory and +// records it in the operator registry: the OpenCode session id, the exact +// resolved directory, the title and the operator tag. A blank or omitted +// directory defaults to the operator's home, never the server's working +// directory. A registry write failure answers an error naming the created id, so +// an orphaned session is visible rather than silently reported as success. +func handleChatCreate(ctx context.Context, request protocol.Message, broker chatBroker, registry operatorRegistry, write func(protocol.Message) error) { + if broker == nil { + _ = write(protocol.Message{Type: protocol.Error, ID: request.ID, Error: "chat is not configured on this server"}) + return } - list, err := owners(ctx) + if registry == nil { + _ = write(protocol.Message{Type: protocol.Error, ID: request.ID, Error: "operator session registry is not configured on this server"}) + return + } + title := "" + directory := "" + if request.ChatCreate != nil { + title = strings.TrimSpace(request.ChatCreate.Title) + directory = strings.TrimSpace(request.ChatCreate.Directory) + } + if title == "" { + title = "New chat" + } + resolved, err := resolveChatDirectory(directory) if err != nil { - return nil, err + _ = write(protocol.Message{Type: protocol.Error, ID: request.ID, Error: err.Error()}) + return } - for _, owner := range list { - if owner.ID == "" { - continue - } - existing, ok := set[owner.ID] - if !ok { - set[owner.ID] = owner - continue - } - if owner.Active && !existing.Active { - existing.Active = true - } - if existing.Directory == "" { - existing.Directory = owner.Directory - } - set[owner.ID] = existing + session, err := broker.Create(ctx, title, resolved) + if err != nil { + _ = write(protocol.Message{Type: protocol.Error, ID: request.ID, Error: err.Error()}) + return } - return set, nil + if err := registry.RecordOperatorSession(ctx, session.ID, resolved, title, protocol.ChatSessionTagOperator); err != nil { + _ = write(protocol.Message{Type: protocol.Error, ID: request.ID, Error: "session " + session.ID + " was created but could not be recorded: " + err.Error()}) + return + } + session.Directory = resolved + session.Tag = protocol.ChatSessionTagOperator + response := protocol.Message{Type: protocol.ChatCreate, ID: request.ID, ChatSession: &session} + // The same registry row is echoed on the list field so a client can splice it + // into chat_sessions without a re-list. + response.ChatSessions = []protocol.ChatSession{session} + _ = write(response) } -func handleChatPrompt(ctx context.Context, request protocol.Message, broker chatBroker, hub *chatHub, clientID string, write func(protocol.Message) error) { +// handleChatDirectories answers chat_directories with the operator's home first, +// then the directories of previous operator sessions most-recently-used first, +// deduplicated against the home directory and capped at operatorDirectoryLimit. +func handleChatDirectories(ctx context.Context, request protocol.Message, registry operatorRegistry, write func(protocol.Message) error) { + if registry == nil { + _ = write(protocol.Message{Type: protocol.Error, ID: request.ID, Error: "operator session registry is not configured on this server"}) + return + } + home, err := OperatorHomeDirectory() + if err != nil { + _ = write(protocol.Message{Type: protocol.Error, ID: request.ID, Error: err.Error()}) + return + } + directories := []string{home} + seen := map[string]struct{}{home: {}} + recent, err := registry.OperatorDirectories(ctx, operatorDirectoryLimit) + if err != nil { + _ = write(protocol.Message{Type: protocol.Error, ID: request.ID, Error: err.Error()}) + return + } + for _, directory := range recent { + if len(directories) >= operatorDirectoryLimit { + break + } + if directory == "" { + continue + } + if _, ok := seen[directory]; ok { + continue + } + seen[directory] = struct{}{} + directories = append(directories, directory) + } + _ = write(protocol.Message{Type: protocol.ChatDirectories, ID: request.ID, ChatDirectories: directories}) +} + +// resolveChatDirectory resolves a chat_create directory to an absolute path: an +// omitted/empty value, "~" or a "~/..." value resolves to the operator's home +// (os.UserHomeDir) and never the server's working directory; any other value +// must be an absolute, existing directory, so a relative path cannot silently +// create a session relative to wherever the server was started. +func resolveChatDirectory(directory string) (string, error) { + directory = strings.TrimSpace(directory) + if directory == "" || directory == "~" || strings.HasPrefix(directory, "~/") { + return OperatorHomeDirectory() + } + if !filepath.IsAbs(directory) { + return "", errors.New("chat directory must be absolute or start with ~") + } + info, err := os.Stat(directory) + if err != nil { + return "", errors.New("chat directory " + directory + " is not available: " + err.Error()) + } + if !info.IsDir() { + return "", errors.New("chat directory " + directory + " is not a directory") + } + return directory, nil +} + +// OperatorHomeDirectory returns the operator's home directory, the default chat +// location. It is resolved through the standard library so it never falls back +// to the process working directory. +func OperatorHomeDirectory() (string, error) { + home, err := os.UserHomeDir() + if err != nil { + return "", errors.New("resolve operator home directory: " + err.Error()) + } + if home == "" { + return "", errors.New("operator home directory is empty") + } + return home, nil +} + +func handleChatPrompt(ctx context.Context, request protocol.Message, broker chatBroker, hub *chatHub, registry operatorRegistry, clientID string, write func(protocol.Message) error) { if broker == nil { _ = write(protocol.Message{Type: protocol.Error, ID: request.ID, Error: "chat is not configured on this server"}) return @@ -612,6 +745,14 @@ func handleChatPrompt(ctx context.Context, request protocol.Message, broker chat _ = write(protocol.Message{Type: protocol.Error, ID: request.ID, Error: err.Error()}) return } + // Recency is one UPDATE: it moves the operator session to the front of + // chat_sessions. A session id that is not an operator session updates no row + // and is not an error, so pipeline stage prompts are unaffected. + if registry != nil { + if err := registry.TouchOperatorSession(ctx, sessionID); err != nil { + log.Printf("touch operator session %s: %v", sessionID, err) + } + } // Acknowledge the accepted prompt with the echoed request id, then stream the // reply. The prompt is sent exactly once and never re-sent on resume. if err := write(protocol.Message{Type: protocol.ChatPrompt, ID: request.ID}); err != nil { diff --git a/internal/server/chat_live_test.go b/internal/server/chat_live_test.go index 8023b500..716ba7c2 100644 --- a/internal/server/chat_live_test.go +++ b/internal/server/chat_live_test.go @@ -5,6 +5,7 @@ import ( "encoding/json" "net/http/httptest" "os" + "path/filepath" "strings" "testing" "time" @@ -18,13 +19,14 @@ import ( ) // TestChatLiveEndToEnd drives the real brokered chat path against the installed -// OpenCode: it opens the server's single owned endpoint, creates a scratch -// session, and pushes chat_sessions, chat_messages, a completed chat_prompt and -// an interrupted chat_prompt through a real /connect websocket. It is opt-in -// (real inference) and never touches the deployed server, ntfy or any lane; it -// runs on an in-process handler and a t.TempDir workspace. The model defaults to -// the pipeline's own and is overridable with -// PIPELINES_TEST_OPENCODE_CHAT_MODEL=provider/model. +// OpenCode: it opens the server's single owned endpoint, creates an operator +// session through chat_create in a chosen directory, lists it through +// chat_sessions, prompts it, and reads its history through chat_messages — all on +// a scratch store and an in-process handler. Its key proof is that a genuine +// pipeline stage session (created as a raw OpenCode session and recorded in +// run_steps/run_session_owners exactly as a run does) never appears in +// chat_sessions. It is opt-in (real inference) and never touches the deployed +// server, ntfy or any lane; it runs on a t.TempDir workspace. func TestChatLiveEndToEnd(t *testing.T) { if os.Getenv("PIPELINES_TEST_OPENCODE_CHAT_LIVE") != "1" { t.Skip("set PIPELINES_TEST_OPENCODE_CHAT_LIVE=1 to run the live OpenCode chat end-to-end check") @@ -39,40 +41,13 @@ func TestChatLiveEndToEnd(t *testing.T) { defer conn.Close() t.Logf("owned OpenCode endpoint %s (backend %s)", conn.URL, conn.Backend) - provider, model := "opencode-go", "deepseek-v4.1-flash" - if override := os.Getenv("PIPELINES_TEST_OPENCODE_CHAT_MODEL"); override != "" { - if parts := strings.SplitN(override, "/", 2); len(parts) == 2 { - provider, model = parts[0], parts[1] - } - } - created, err := conn.Call(ctx, "post", "/api/session", map[string]any{ - "title": "pipelines chat live check", - "location": map[string]string{"directory": dir}, - "model": map[string]string{"providerID": provider, "id": model}, - "permissions": []map[string]string{{"action": "*", "resource": "*", "effect": "deny"}}, - }) + store, err := pipeline.Open(filepath.Join(t.TempDir(), "chat-live.db")) if err != nil { - t.Fatalf("create session: %v", err) + t.Fatal(err) } - var session struct { - Data struct { - ID string `json:"id"` - } `json:"data"` - } - if err := json.Unmarshal(created, &session); err != nil || session.Data.ID == "" { - t.Fatalf("created session response %s (err %v)", created, err) - } - sid := session.Data.ID - defer conn.Call(context.Background(), "delete", "/api/session/"+sid, nil) - t.Logf("scratch session %s on %s/%s", sid, provider, model) + defer store.Close() - options := Options{ - Chat: opencode.NewChat(conn), - OwnedSessions: func(context.Context) ([]pipeline.SessionOwner, error) { - return []pipeline.SessionOwner{{ID: sid, Directory: dir}}, nil - }, - } - srv := httptest.NewServer(HandlerWithOptions(ctx, options)) + srv := httptest.NewServer(HandlerWithOptions(ctx, Options{Chat: opencode.NewChat(conn), OperatorRegistry: store})) defer srv.Close() ws, _, err := websocket.Dial(ctx, "ws"+strings.TrimPrefix(srv.URL, "http")+"/connect", nil) if err != nil { @@ -80,18 +55,60 @@ func TestChatLiveEndToEnd(t *testing.T) { } defer ws.CloseNow() - // chat_sessions must list exactly the owned scratch session. - if err := wsjson.Write(ctx, ws, protocol.Message{Type: protocol.ChatSessions, ID: "s1"}); err != nil { + // chat_directories returns the operator's home first. + home, err := os.UserHomeDir() + if err != nil { + t.Fatal(err) + } + if err := wsjson.Write(ctx, ws, protocol.Message{Type: protocol.ChatDirectories, ID: "d1"}); err != nil { t.Fatal(err) } _, resp := readChatResponse(t, ctx, ws) - if resp.Type != protocol.ChatSessions || resp.ID != "s1" { - t.Fatalf("chat_sessions response = %+v", resp) + if resp.Type != protocol.ChatDirectories || len(resp.ChatDirectories) == 0 || resp.ChatDirectories[0] != home { + t.Fatalf("chat_directories = %+v, want home %q first", resp, home) } - if len(resp.ChatSessions) != 1 || resp.ChatSessions[0].ID != sid { - t.Fatalf("chat_sessions = %+v, want the owned session %s", resp.ChatSessions, sid) + t.Logf("chat_directories = %+v", resp.ChatDirectories) + + // chat_create records the operator session in the chosen directory with the + // operator tag. + if err := wsjson.Write(ctx, ws, protocol.Message{Type: protocol.ChatCreate, ID: "c1", ChatCreate: &protocol.ChatCreateRequest{Title: "pipelines chat live check", Directory: dir}}); err != nil { + t.Fatal(err) } - t.Logf("chat_sessions listed %d owned session(s): %+v", len(resp.ChatSessions), resp.ChatSessions) + _, resp = readChatResponse(t, ctx, ws) + if resp.Type != protocol.ChatCreate || resp.ChatSession == nil { + t.Fatalf("chat_create response = %+v", resp) + } + sid := resp.ChatSession.ID + if sid == "" || resp.ChatSession.Directory != dir || resp.ChatSession.Tag != protocol.ChatSessionTagOperator { + t.Fatalf("created operator session = %+v, want directory %q and tag operator", resp.ChatSession, dir) + } + defer conn.Call(context.Background(), "delete", "/api/session/"+sid, nil) + t.Logf("chat_create created operator session %s in %s (tag %s)", sid, resp.ChatSession.Directory, resp.ChatSession.Tag) + + // chat_sessions lists exactly the created operator session, with its registry + // directory and tag. + sessions := listLiveSessions(t, ctx, ws) + if len(sessions) != 1 || sessions[0].ID != sid || sessions[0].Tag != protocol.ChatSessionTagOperator || sessions[0].Directory != dir { + t.Fatalf("chat_sessions = %+v, want the created operator session %s", sessions, sid) + } + t.Logf("chat_sessions listed %d operator session(s): %+v", len(sessions), sessions) + + // A genuine pipeline stage session is created as a raw OpenCode session and + // recorded in run_steps/run_session_owners exactly as a run does; chat_sessions + // must never list it. + stageID := createRawLiveSession(t, ctx, conn, dir) + defer conn.Call(context.Background(), "delete", "/api/session/"+stageID, nil) + recordLiveStageSession(t, ctx, store, stageID, dir) + sessions = listLiveSessions(t, ctx, ws) + for _, session := range sessions { + if session.ID == stageID { + t.Fatalf("pipeline stage session %s was listed: %+v", stageID, sessions) + } + } + if len(sessions) != 1 || sessions[0].ID != sid { + t.Fatalf("chat_sessions = %+v, want only the operator session %s", sessions, sid) + } + t.Logf("chat_sessions still listed only the operator session after recording stage session %s", stageID) // chat_messages resumes retained/readback history without error. if err := wsjson.Write(ctx, ws, protocol.Message{Type: protocol.ChatMessages, ID: "m1", ChatQuery: &protocol.ChatQuery{SessionID: sid}}); err != nil { @@ -115,50 +132,72 @@ func TestChatLiveEndToEnd(t *testing.T) { completed := collectUntilStepEnded(t, ctx, ws, frames) assertLiveFrames(t, sid, completed) t.Logf("completed turn: %d chat_event frame(s) [%s]; first text delta %q", len(completed), frameKinds(completed), firstDelta(completed)) +} - // An interrupted turn: post a long prompt, wait for its ack, then answer it - // with chat_interrupt and confirm the ack. - if err := wsjson.Write(ctx, ws, protocol.Message{Type: protocol.ChatPrompt, ID: "p2", ChatPrompt: &protocol.ChatPromptRequest{SessionID: sid, Text: "Write a 400 line epic poem about the sea. Output every line as it comes."}}); err != nil { +// listLiveSessions issues one chat_sessions request and returns the listed +// sessions. +func listLiveSessions(t *testing.T, ctx context.Context, ws *websocket.Conn) []protocol.ChatSession { + t.Helper() + if err := wsjson.Write(ctx, ws, protocol.Message{Type: protocol.ChatSessions, ID: "s1"}); err != nil { t.Fatal(err) } - if _, ack = readChatResponse(t, ctx, ws); ack.Type != protocol.ChatPrompt || ack.ID != "p2" { - t.Fatalf("second prompt ack = %+v", ack) + _, resp := readChatResponse(t, ctx, ws) + if resp.Type != protocol.ChatSessions { + t.Fatalf("chat_sessions response = %+v", resp) } - if err := wsjson.Write(ctx, ws, protocol.Message{Type: protocol.ChatInterrupt, ID: "i1", ChatQuery: &protocol.ChatQuery{SessionID: sid}}); err != nil { + return resp.ChatSessions +} + +// createRawLiveSession creates a bare OpenCode session in dir through the shared +// connection, mirroring how a pipeline run creates the session a stage drives. +func createRawLiveSession(t *testing.T, ctx context.Context, conn *opencode.Connection, dir string) string { + t.Helper() + created, err := conn.Call(ctx, "post", "/api/session", map[string]any{ + "title": "pipelines stage session live check", + "location": map[string]string{"directory": dir}, + "permissions": []map[string]string{{"action": "*", "resource": "*", "effect": "deny"}}, + }) + if err != nil { + t.Fatalf("create raw session: %v", err) + } + var session struct { + Data struct { + ID string `json:"id"` + } `json:"data"` + } + if err := json.Unmarshal(created, &session); err != nil || session.Data.ID == "" { + t.Fatalf("raw session response %s (err %v)", created, err) + } + return session.Data.ID +} + +// recordLiveStageSession records sessionID as a genuine pipeline stage session +// through the same store calls a run uses (CreateRun/BeginStep/RunSession), so it +// is present in run_steps and run_session_owners and proven to be excluded from +// chat_sessions by the operator filter, not by being unrecorded. +func recordLiveStageSession(t *testing.T, ctx context.Context, store *pipeline.Store, sessionID, dir string) { + t.Helper() + if _, err := store.Submit(ctx, "chat-live-stage", pipeline.Template([]string{"one"}, true)); err != nil { t.Fatal(err) } - for { - message := readChatMessage(t, ctx, ws) - if message.Type == protocol.ChatInterrupt { - if message.ID != "i1" { - t.Fatalf("interrupt ack = %+v, want i1", message) - } - break - } + items, err := store.List(ctx) + if err != nil { + t.Fatal(err) } - // The interrupt must actually end the running turn: the session leaves the - // V2 active set. This is the observable proof the ack alone is not. - deadline := time.Now().Add(30 * time.Second) - for { - active, err := conn.Call(ctx, "get", "/api/session/active", nil) - if err != nil { - t.Fatalf("active check: %v", err) - } - var state struct { - Data map[string]json.RawMessage `json:"data"` - } - if err := json.Unmarshal(active, &state); err != nil { - t.Fatalf("active response %s (err %v)", active, err) - } - if _, running := state.Data[sid]; !running { - break - } - if time.Now().After(deadline) { - t.Fatalf("session %s is still active after chat_interrupt", sid) - } - time.Sleep(500 * time.Millisecond) + definition, err := store.Get(ctx, items[0].ID, 1) + if err != nil { + t.Fatal(err) + } + run, _, err := store.CreateRun(ctx, definition, "chat-live-stage-run", dir, false, nil, map[string]any{"prompt": "task"}) + if err != nil { + t.Fatal(err) + } + if err := store.BeginStep(ctx, run, 1, "one", map[string]any{"prompt": "task"}); err != nil { + t.Fatal(err) + } + if err := store.RunSession(ctx, run, 1, sessionID, true, "v2", dir); err != nil { + t.Fatal(err) } - t.Logf("chat_interrupt acked and the interrupted turn left the active set") } // readChatResponse reads until a non-event response message arrives, returning diff --git a/internal/server/chat_test.go b/internal/server/chat_test.go index e4c58fbb..8ca2a728 100644 --- a/internal/server/chat_test.go +++ b/internal/server/chat_test.go @@ -6,6 +6,8 @@ import ( "fmt" "net/http" "net/http/httptest" + "os" + "path/filepath" "strings" "sync" "sync/atomic" @@ -20,6 +22,19 @@ import ( "git.a-wan.net/alan/pipelines/internal/protocol" ) +// newOperatorStore opens a scratch store for the operator-session registry, so +// the chat tests exercise the real SQL-backed registry (record, list, delete) +// rather than a second fake of it. +func newOperatorStore(t *testing.T) *pipeline.Store { + t.Helper() + store, err := pipeline.Open(filepath.Join(t.TempDir(), "operator.db")) + if err != nil { + t.Fatal(err) + } + t.Cleanup(func() { store.Close() }) + return store +} + // fakeChat is a scripted chatBroker. It counts calls and either emits a fixed // frame sequence or blocks until the caller's context is canceled. type fakeChat struct { @@ -51,6 +66,11 @@ type fakeChat struct { subscribed bool promptBeforeSubscribe bool interruptErr error + createCalls int + createTitle string + createDirectory string + created protocol.ChatSession + createErr error } func (f *fakeChat) Prompt(context.Context, string, string) error { @@ -168,6 +188,32 @@ func (f *fakeChat) sessionQuery() int { return f.sessionCalls } +// Create records the title and directory the handler forwarded and returns the +// seeded created session. A blank created id defaults to "ses_created" so a test +// only asserts what it cares about. +func (f *fakeChat) Create(_ context.Context, title, directory string) (protocol.ChatSession, error) { + f.mu.Lock() + defer f.mu.Unlock() + f.createCalls++ + f.createTitle = title + f.createDirectory = directory + if f.createErr != nil { + return protocol.ChatSession{}, f.createErr + } + session := f.created + if session.ID == "" { + session.ID = "ses_created" + } + return session, nil +} + +// createQuery reports the recorded chat_create call count, title and directory. +func (f *fakeChat) createQuery() (int, string, string) { + f.mu.Lock() + defer f.mu.Unlock() + return f.createCalls, f.createTitle, f.createDirectory +} + // replyQuery reports the recorded chat_reply count and the last forwarded // request, so a test can assert the exact session/request/decision. func (f *fakeChat) replyQuery() (int, protocol.ChatReplyRequest) { @@ -965,38 +1011,214 @@ func TestChatPromptRejectsEmptyText(t *testing.T) { } } -// TestChatCreateAnswersExplicitly pins the declared-but-unbrokered boundary: -// chat_create is answered with a protocol error rather than falling through to -// the generic Pong. chat_sessions is now brokered and covered by -// TestChatSessionsListsOnlyOwned and TestChatSessionsBusyRejectsSecondClient. -func TestChatCreateAnswersExplicitly(t *testing.T) { +// TestChatCreateRecordsOperatorSession is the chat_create acceptance test: the +// broker creates the session in the resolved directory, the handler records it in +// the operator registry with the operator tag, and the response carries the +// created session and the registry row (directory, tag). The registry can then +// list it. +func TestChatCreateRecordsOperatorSession(t *testing.T) { + store := newOperatorStore(t) broker := scriptedChat() - ctx, _, conn := dialChat(t, broker) - if err := wsjson.Write(ctx, conn, protocol.Message{Type: protocol.ChatCreate, ID: "c1"}); err != nil { + broker.created = protocol.ChatSession{ID: "ses_new", Title: "demo"} + dir := t.TempDir() + ctx, _, conn := dialChatOptions(t, Options{Chat: broker, OperatorRegistry: store}) + if err := wsjson.Write(ctx, conn, protocol.Message{Type: protocol.ChatCreate, ID: "c1", ChatCreate: &protocol.ChatCreateRequest{Title: "demo", Directory: dir}}); err != nil { t.Fatal(err) } var response protocol.Message if err := wsjson.Read(ctx, conn, &response); err != nil { t.Fatal(err) } - if response.Type != protocol.Error || response.ID != "c1" { - t.Fatalf("chat_create did not answer with an explicit error: %+v", response) + if response.Type != protocol.ChatCreate || response.ID != "c1" || response.ChatSession == nil { + t.Fatalf("chat_create response = %+v", response) + } + if response.ChatSession.ID != "ses_new" || response.ChatSession.Directory != dir || response.ChatSession.Tag != protocol.ChatSessionTagOperator { + t.Fatalf("created session = %+v", response.ChatSession) + } + if len(response.ChatSessions) != 1 || response.ChatSessions[0].ID != "ses_new" || response.ChatSessions[0].Tag != protocol.ChatSessionTagOperator { + t.Fatalf("created session not echoed as a registry row: %+v", response.ChatSessions) + } + if calls, title, directory := broker.createQuery(); calls != 1 || title != "demo" || directory != dir { + t.Fatalf("broker.Create = %d/%q/%q, want 1/demo/%q", calls, title, directory, dir) + } + recorded, err := store.OperatorSessions(ctx) + if err != nil { + t.Fatal(err) + } + if len(recorded) != 1 || recorded[0].ID != "ses_new" || recorded[0].Directory != dir || recorded[0].Tag != protocol.ChatSessionTagOperator || recorded[0].Title != "demo" { + t.Fatalf("registry row = %+v", recorded) } } -// TestChatSessionsListsOnlyOwned is the task evidence for ownership: the broker -// lists two OpenCode sessions (one owned by this server, one foreign) and -// chat_sessions returns exactly the owned one, asking the broker once. -func TestChatSessionsListsOnlyOwned(t *testing.T) { +// TestChatCreateDirectoryResolution pins directory defaulting and rejection: an +// omitted/empty/"~"/"~/..." directory resolves to the operator's home (never the +// server's working directory), an explicit existing directory is recorded +// unchanged, and a relative or missing directory is rejected before any OpenCode +// call. +func TestChatCreateDirectoryResolution(t *testing.T) { + home, err := os.UserHomeDir() + if err != nil { + t.Fatal(err) + } + explicit := t.TempDir() + cases := []struct { + name string + omitted bool + directory string + wantDirectory string + wantErr string + }{ + {name: "omitted", omitted: true, wantDirectory: home}, + {name: "empty", directory: "", wantDirectory: home}, + {name: "tilde", directory: "~", wantDirectory: home}, + {name: "tilde path", directory: "~/project", wantDirectory: home}, + {name: "explicit", directory: explicit, wantDirectory: explicit}, + {name: "relative", directory: "relative/dir", wantErr: "absolute"}, + {name: "missing", directory: filepath.Join(t.TempDir(), "missing"), wantErr: "not available"}, + } + for _, tc := range cases { + t.Run(tc.name, func(t *testing.T) { + store := newOperatorStore(t) + broker := scriptedChat() + ctx, _, conn := dialChatOptions(t, Options{Chat: broker, OperatorRegistry: store}) + request := protocol.Message{Type: protocol.ChatCreate, ID: "c1"} + if !tc.omitted { + request.ChatCreate = &protocol.ChatCreateRequest{Title: "demo", Directory: tc.directory} + } + if err := wsjson.Write(ctx, conn, request); err != nil { + t.Fatal(err) + } + var response protocol.Message + if err := wsjson.Read(ctx, conn, &response); err != nil { + t.Fatal(err) + } + if tc.wantErr != "" { + if response.Type != protocol.Error || !strings.Contains(response.Error, tc.wantErr) { + t.Fatalf("directory %q not rejected: %+v", tc.directory, response) + } + if calls, _, _ := broker.createQuery(); calls != 0 { + t.Fatalf("rejected directory still reached OpenCode: %d calls", calls) + } + if recorded, err := store.OperatorSessions(ctx); err != nil || len(recorded) != 0 { + t.Fatalf("rejected directory recorded a session: %+v %v", recorded, err) + } + return + } + if response.Type != protocol.ChatCreate || response.ChatSession == nil || response.ChatSession.Directory != tc.wantDirectory { + t.Fatalf("directory %q resolved wrong: %+v", tc.directory, response) + } + if calls, _, directory := broker.createQuery(); calls != 1 || directory != tc.wantDirectory { + t.Fatalf("broker.Create = %d/%q, want 1/%q", calls, directory, tc.wantDirectory) + } + }) + } +} + +// TestChatDirectoriesHomeThenBoundedRecents pins chat_directories: the operator's +// home first, then the directories of previous operator sessions +// most-recently-used first, deduplicated and capped at the fixed bound even with +// more directory history seeded than the cap. +func TestChatDirectoriesHomeThenBoundedRecents(t *testing.T) { + home, err := os.UserHomeDir() + if err != nil { + t.Fatal(err) + } + store := newOperatorStore(t) + ctx, _, conn := dialChatOptions(t, Options{OperatorRegistry: store}) + // Seed more directories than the bound, oldest first. + seeded := make([]string, 0, operatorDirectoryLimit+4) + for i := 0; i < operatorDirectoryLimit+4; i++ { + directory := filepath.Join(t.TempDir(), fmt.Sprintf("d%02d", i)) + seeded = append(seeded, directory) + if err := store.RecordOperatorSession(ctx, fmt.Sprintf("ses_%02d", i), directory, "s", protocol.ChatSessionTagOperator); err != nil { + t.Fatal(err) + } + time.Sleep(2 * time.Millisecond) + } + if err := wsjson.Write(ctx, conn, protocol.Message{Type: protocol.ChatDirectories, ID: "d1"}); err != nil { + t.Fatal(err) + } + var response protocol.Message + if err := wsjson.Read(ctx, conn, &response); err != nil { + t.Fatal(err) + } + if response.Type != protocol.ChatDirectories || response.ID != "d1" { + t.Fatalf("chat_directories response = %+v", response) + } + if len(response.ChatDirectories) != operatorDirectoryLimit { + t.Fatalf("directories = %+v, want the bound of %d", response.ChatDirectories, operatorDirectoryLimit) + } + if response.ChatDirectories[0] != home { + t.Fatalf("home not first: %+v", response.ChatDirectories) + } + // The remainder are the most recently recorded directories, MRU first. + for i := 1; i < len(response.ChatDirectories); i++ { + want := seeded[len(seeded)-i] + if response.ChatDirectories[i] != want { + t.Fatalf("directory %d = %q, want %q (MRU order): %+v", i, response.ChatDirectories[i], want, response.ChatDirectories) + } + } +} + +// TestChatSessionsListsOperatorSessionsOnly is the task evidence for the +// operator-session filter: the broker lists an operator-registered session, a +// genuine pipeline stage session recorded in run_steps/run_session_owners, and a +// foreign session; chat_sessions returns exactly the operator session, carrying +// its registry directory and operator tag, and asks the broker once. The stage +// session is proven to be genuinely recorded through store.OwnedSessions. +func TestChatSessionsListsOperatorSessionsOnly(t *testing.T) { + ctx := context.Background() + store := newOperatorStore(t) + if err := store.RecordOperatorSession(ctx, "ses_op", "/work/op", "Operator chat", protocol.ChatSessionTagOperator); err != nil { + t.Fatal(err) + } + if _, err := store.Submit(ctx, "chatsrv", pipeline.Template([]string{"one"}, true)); err != nil { + t.Fatal(err) + } + items, err := store.List(ctx) + if err != nil { + t.Fatal(err) + } + definition, err := store.Get(ctx, items[0].ID, 1) + if err != nil { + t.Fatal(err) + } + run, _, err := store.CreateRun(ctx, definition, "stage-run", "/work/stage", false, nil, map[string]any{"prompt": "task"}) + if err != nil { + t.Fatal(err) + } + if err := store.BeginStep(ctx, run, 1, "one", map[string]any{"prompt": "task"}); err != nil { + t.Fatal(err) + } + if err := store.RunSession(ctx, run, 1, "ses_stage", true, "v2", "/work/stage"); err != nil { + t.Fatal(err) + } + // Prove ses_stage is a real owned pipeline session, so its exclusion is the + // operator filter at work, not an unrecorded id. + owned, err := store.OwnedSessions(ctx) + if err != nil { + t.Fatal(err) + } + sawStage := false + for _, owner := range owned { + if owner.ID == "ses_stage" { + sawStage = true + } + if owner.ID == "ses_op" { + t.Fatalf("operator session leaked into pipeline ownership: %+v", owner) + } + } + if !sawStage { + t.Fatalf("stage session was not recorded in run_steps: %+v", owned) + } + broker := scriptedChat() broker.sessions = []protocol.ChatSession{ - {ID: "ses_owned", Title: "ours", Directory: "/work"}, + {ID: "ses_op", Title: "upstream", Directory: "/upstream"}, + {ID: "ses_stage", Title: "pipeline internal", Directory: "/work/stage"}, {ID: "ses_foreign", Title: "someone else's", Directory: "/elsewhere"}, } - owners := func(context.Context) ([]pipeline.SessionOwner, error) { - return []pipeline.SessionOwner{{ID: "ses_owned", Directory: "/work"}}, nil - } - ctx, _, conn := dialChatOptions(t, Options{Chat: broker, OwnedSessions: owners}) + _, _, conn := dialChatOptions(t, Options{Chat: broker, OperatorRegistry: store}) if err := wsjson.Write(ctx, conn, protocol.Message{Type: protocol.ChatSessions, ID: "s1"}); err != nil { t.Fatal(err) } @@ -1007,20 +1229,86 @@ func TestChatSessionsListsOnlyOwned(t *testing.T) { if response.Type != protocol.ChatSessions || response.ID != "s1" { t.Fatalf("chat_sessions response = %+v", response) } - if len(response.ChatSessions) != 1 || response.ChatSessions[0].ID != "ses_owned" { - t.Fatalf("foreign session leaked into the list: %+v", response.ChatSessions) + if len(response.ChatSessions) != 1 || response.ChatSessions[0].ID != "ses_op" { + t.Fatalf("non-operator session leaked into the list: %+v", response.ChatSessions) } - if response.ChatSessions[0].Busy { - t.Fatalf("inactive owned session marked busy: %+v", response.ChatSessions[0]) + got := response.ChatSessions[0] + if got.Directory != "/work/op" || got.Tag != protocol.ChatSessionTagOperator { + t.Fatalf("operator session shape = %+v", got) + } + if got.Busy { + t.Fatalf("inactive operator session marked busy: %+v", got) } if calls := broker.sessionQuery(); calls != 1 { t.Fatalf("broker.Sessions called %d times, want 1", calls) } } -// TestChatSessionsFailsClosedWithoutOwnership pins the default when no ownership -// source is available: chat_sessions returns an empty list, never the full -// OpenCode machine. +// TestChatSessionsNeverListsUntagged pins that a row with no recorded tag is not +// an operator session and is never listed, even when the broker still reports it. +func TestChatSessionsNeverListsUntagged(t *testing.T) { + ctx := context.Background() + store := newOperatorStore(t) + if err := store.RecordOperatorSession(ctx, "ses_untagged", "/work/untagged", "no tag", ""); err != nil { + t.Fatal(err) + } + broker := scriptedChat() + broker.sessions = []protocol.ChatSession{{ID: "ses_untagged"}} + _, _, conn := dialChatOptions(t, Options{Chat: broker, OperatorRegistry: store}) + if err := wsjson.Write(ctx, conn, protocol.Message{Type: protocol.ChatSessions, ID: "s1"}); err != nil { + t.Fatal(err) + } + var response protocol.Message + if err := wsjson.Read(ctx, conn, &response); err != nil { + t.Fatal(err) + } + if response.Type != protocol.ChatSessions || len(response.ChatSessions) != 0 { + t.Fatalf("untagged session was listed: %+v", response) + } +} + +// TestChatSessionsMostRecentlyUsedFirst pins the list order: sessions come back +// most-recently-used first by registry recency (later creation wins), with the +// directory and tag from the registry. +func TestChatSessionsMostRecentlyUsedFirst(t *testing.T) { + ctx := context.Background() + store := newOperatorStore(t) + if err := store.RecordOperatorSession(ctx, "ses_old", "/work/old", "old", protocol.ChatSessionTagOperator); err != nil { + t.Fatal(err) + } + time.Sleep(3 * time.Millisecond) + if err := store.RecordOperatorSession(ctx, "ses_new", "/work/new", "new", protocol.ChatSessionTagOperator); err != nil { + t.Fatal(err) + } + broker := scriptedChat() + // The broker lists them oldest-updated-first, so the handler's registry order + // is what decides the result. + broker.sessions = []protocol.ChatSession{ + {ID: "ses_old", UpdatedAt: 100}, + {ID: "ses_new", UpdatedAt: 50}, + } + _, _, conn := dialChatOptions(t, Options{Chat: broker, OperatorRegistry: store}) + if err := wsjson.Write(ctx, conn, protocol.Message{Type: protocol.ChatSessions, ID: "s1"}); err != nil { + t.Fatal(err) + } + var response protocol.Message + if err := wsjson.Read(ctx, conn, &response); err != nil { + t.Fatal(err) + } + if len(response.ChatSessions) != 2 { + t.Fatalf("chat_sessions = %+v, want 2", response.ChatSessions) + } + if response.ChatSessions[0].ID != "ses_new" || response.ChatSessions[1].ID != "ses_old" { + t.Fatalf("not most-recently-used first: %+v", response.ChatSessions) + } + if response.ChatSessions[0].Directory != "/work/new" || response.ChatSessions[0].Tag != protocol.ChatSessionTagOperator { + t.Fatalf("registry fields not applied: %+v", response.ChatSessions[0]) + } +} + +// TestChatSessionsFailsClosedWithoutOwnership pins the default when no operator +// registry (store or injection) is available: chat_sessions returns an empty list +// without consulting the broker, never the full OpenCode machine. func TestChatSessionsFailsClosedWithoutOwnership(t *testing.T) { broker := scriptedChat() broker.sessions = []protocol.ChatSession{{ID: "ses_1"}, {ID: "ses_2"}} @@ -1033,7 +1321,10 @@ func TestChatSessionsFailsClosedWithoutOwnership(t *testing.T) { t.Fatal(err) } if response.Type != protocol.ChatSessions || len(response.ChatSessions) != 0 { - t.Fatalf("unowned sessions were exposed: %+v", response) + t.Fatalf("unregistered sessions were exposed: %+v", response) + } + if calls := broker.sessionQuery(); calls != 0 { + t.Fatalf("fail-closed list consulted the broker %d times, want 0", calls) } } @@ -1043,14 +1334,16 @@ func TestChatSessionsFailsClosedWithoutOwnership(t *testing.T) { // broker.Prompt call; after A disconnects the claim is released and a later list // is no longer busy. func TestChatSessionsBusyRejectsSecondClient(t *testing.T) { + ctx := context.Background() + store := newOperatorStore(t) + if err := store.RecordOperatorSession(ctx, "ses_1", "/work", "operator chat", protocol.ChatSessionTagOperator); err != nil { + t.Fatal(err) + } broker := scriptedChat() broker.block = true broker.done = make(chan struct{}) broker.sessions = []protocol.ChatSession{{ID: "ses_1"}} - owners := func(context.Context) ([]pipeline.SessionOwner, error) { - return []pipeline.SessionOwner{{ID: "ses_1"}}, nil - } - ctx, _, conns := dialChatConns(t, Options{Chat: broker, OwnedSessions: owners}, 2) + ctx, _, conns := dialChatConns(t, Options{Chat: broker, OperatorRegistry: store}, 2) connA, connB := conns[0], conns[1] if err := wsjson.Write(ctx, connA, protocol.Message{Type: protocol.ChatPrompt, ID: "a1", ChatPrompt: &protocol.ChatPromptRequest{SessionID: "ses_1", Text: "hi"}}); err != nil { diff --git a/internal/server/websocket.go b/internal/server/websocket.go index b7b72073..9d3d076a 100644 --- a/internal/server/websocket.go +++ b/internal/server/websocket.go @@ -27,11 +27,12 @@ type Options struct { // chat_* request with a protocol error; a configured server passes an // *opencode.Chat bound to the owned endpoint. Chat chatBroker - // OwnedSessions reports the OpenCode sessions this server owns so - // chat_sessions is restricted to them. When nil, HandlerWithOptions derives - // it from the first store; when neither is available chat_sessions returns an - // empty list rather than the endpoint's whole session list. - OwnedSessions func(context.Context) ([]pipeline.SessionOwner, error) + // OperatorRegistry is the operator-session registry chat_sessions lists and + // chat_create/chat_directories read. When nil, HandlerWithOptions derives it + // from the first store; when neither is available chat_sessions returns an + // empty list (never the endpoint's whole session list) and chat_create is + // refused. Purely pipeline stage ownership is unaffected. + OperatorRegistry operatorRegistry // RunTitles generates the operator-facing title stored with each new run. // When nil, run creation stores the prompt-derived fallback without a model // call, which keeps tests and unconfigured servers deterministic. @@ -78,12 +79,12 @@ func HandlerWithOptions(ctx context.Context, options Options, stores ...*pipelin go runs.scheduleLoop() } } - // chat_sessions is restricted to the sessions this server owns. Prefer an - // injected source; otherwise derive it from the store. With neither, the + // chat_sessions lists the operator's own recorded sessions. Prefer an + // injected registry; otherwise derive it from the store. With neither, the // handler fails closed to an empty list. - owned := options.OwnedSessions - if owned == nil && len(stores) > 0 { - owned = stores[0].OwnedSessions + registry := options.OperatorRegistry + if registry == nil && len(stores) > 0 { + registry = stores[0] } mux.HandleFunc("GET /artifacts/{run}/{step}/{name...}", func(w http.ResponseWriter, r *http.Request) { if runs == nil { @@ -154,7 +155,7 @@ func HandlerWithOptions(ctx context.Context, options Options, stores ...*pipelin return } log.Printf("command received: client=%s type=%q id=%q pipeline=%d version=%d", r.RemoteAddr, request.Type, request.ID, request.PipelineID, request.Version) - if handleChat(connCtx, request, options.Chat, hub, owned, clientID, write) { + if handleChat(connCtx, request, options.Chat, hub, registry, clientID, write) { continue } if handleRunEvents(request, events, runs, clientID, write) { @@ -243,7 +244,7 @@ func HandlerWithOptions(ctx context.Context, options Options, stores ...*pipelin response.Error = err.Error() } } - } else if runs != nil && (request.Type == protocol.RunPipeline || request.Type == protocol.RetryRun || request.Type == protocol.ListRuns || request.Type == protocol.GetRun || request.Type == protocol.CancelRun || request.Type == protocol.DecideRun || request.Type == protocol.SetRunTitle || request.Type == protocol.GetRunEvidence) { + } else if runs != nil && (request.Type == protocol.RunPipeline || request.Type == protocol.RetryRun || request.Type == protocol.ListRuns || request.Type == protocol.GetRun || request.Type == protocol.CancelRun || request.Type == protocol.DecideRun || request.Type == protocol.SetRunTitle || request.Type == protocol.GetRunEvidence) { var err error switch request.Type { case protocol.GetRunEvidence: